Expertiza_Wiki - User contributions [en]

CSC/ECE 517/M601 Design Document

2013-04-27T12:43:20Z

Japlemmo: /* Specific Changes */

<h1>Add ability to update css through webapp</h1>
== Example Video ==
A video example of this module can be seen here [http://youtu.be/2dQeFYjcsnU]
==Team==
Yuri Kolesnikov 
Jonathan Wills 
Jeffrey Plemmons 
Roshna Agarwal

==Our Work==
Link to the OpenMRS ticket: https://tickets.openmrs.org/browse/TRUNK-3415 
Link to our code in GitHub: https://github.com/ykolesn/openmrs-module-m601 
Link to application: http://152.46.17.228:8081/openmrs-standalone

==Purpose==
The purpose of this module is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file.
This would be best as a new module in openmrs or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin.

==Design Requirements==

1. The admin should be able to customize the openmrs css file through an admin page. 
2. The admin should see a page with a large text box. 
3. The text box content should be stored in the database. 
4. The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin. 
5. Need to use Eclipse and Maven as development tools for the module. 

==Tasks==
'''Week 1'''

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
'''Week 2'''

*Create object for storing css in db
*Create service layer and dao layer methods to save object
*Connect controller to db object for saving + retrieving
*Add unit tests for saving/retrieving
'''Week 3'''

*Create settings page to allow admin to choose where tomcat is running
*Add some magic so that module tries to guess where tomcat is running
*Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Development Tools==
1. '''Eclipse'''<ref>http://en.wikipedia.org/wiki/Integrated_development_environment</ref>: Eclipse is the Integrated Development Environment used to develop, modify, and compile the code for our module. 
2. '''Maven'''<ref>http://en.wikipedia.org/wiki/Apache_Maven</ref>: Maven is used through a plug-in in Eclipse to compile, run unit tests, and package all of the Java files in the module. 
3. '''Tomcat'''<ref>http://en.wikipedia.org/wiki/Apache_Tomcat</ref>: Tomcat is the web-server used to run the application. 
4. '''Hibernate'''<ref>http://en.wikipedia.org/wiki/Hibernate_(Java)</ref>: Hibernate is a built-in utility in the OpenMRS module, that is used to connect the Java classes to the database tables in the application. It configured the database table through an xml file: UpdateCSS.hbm.xml 
<pre>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>
</hibernate-mapping>
</pre>
''Here in the UpdateCSS.hbm.xml we specify the table name and columns. Hibernate generates the table with the fields specified and handles all the necessary SQL calls and queries.'' 
5. '''MySQL''': MySQL<ref>http://en.wikipedia.org/wiki/Mysql</ref> is the RDBMS that is used to store the CSS data for the application.

==Use Case==
[[File:Openmrsui.png|800px|alt=OpenMRS UI]] 
''This is the user interface for the UpdateCSS module. The initial start screen provides a default location for the css style sheet and default css code. Here the navigation bar is changed to "orange". '' 
 
1. Log in to the Admin page with user "Admin" and password "Admin123" 
2. Once logged in, click on "Administration" on the right-hand side of the navigation bar. 
3. Under "Update CSS Module", click on "Manage module" 
4. Here the user can enter their desired CSS preferences for customization. 

==Application Overview==
[[File:Overview.png]]

<h1>Code Changes</h1>
==Classes and Files Worked On==
* UpdateCSSActivator.java 
* UpdateCSS.java 
* UpdateCSSService.java 
* UpdateCSSServiceImpl.java 
* UpdateCSSDAO.java 
* HibernateUpdateCSSDAO.java 
* UpdateCSS.hbm.xml 
* liquibase.xml 
* moduleApplicationContext.xml 
* UpdateCSSServiceTest.java 
* manage.jsp 
* UpdateCSSManageController.java 

==Specific Changes==
'''UpdateCSSActivator.java:''' 
The activator class is an OpenMRS standard module class for initializing necessary components 
when the module is in a certain state of activity. In our case, we needed to have the CSS 
file overridden at module startup so the following function was added. 
<pre>
/**
* @see ModuleActivator#started()
*/
public void started() {
log.info("Update CSS Module started");

// When the module loads, copy the css data
// to the tomcat directory CSS file
UpdateCSSService cssService = Context.getService(UpdateCSSService.class);
cssService.copyCssDataToTomcatDirectory();
}
</pre>
'''UpdateCSSServiceImpl.java:''' 
Added below methods to UpdateCSSServiceImpl class: 
<pre>
/**
+ * Replaces the text of the specified CSS file in the
+ * specified directory with the specified text
+ */ + public void copyCssDataToTomcatDirectory(String directory, String cssText) {
+ File cssFile = new File(directory);
+ if (cssFile.exists()) {
+ writeDataToFile(cssFile, cssText);
+ }
+ }
+
+ /**
+ * Copies the data stored in the DB into the CSS file that is saved in the
+ * directory column of the css_properties table
+ */
+ public void copyCssDataToTomcatDirectory() {
+ UpdateCSS updateCSS = getData();
+ String cssDirectory = updateCSS.getHomeDirectory();
+ String cssText = updateCSS.getCssData();
+ copyCssDataToTomcatDirectory(cssDirectory, cssText);
+ }
+
+ /**
+ * Writes the specified text to the specified CSS file
+ */
+ public void writeDataToFile(File cssFile, String cssText) {
+ try {
+ if (cssFile.exists()) {
+ PrintWriter writer = new PrintWriter(cssFile);
+ writer.print(cssText);
+ writer.close();
+ }
+ } catch (FileNotFoundException ex) {
+
+ }
+ }
+
+ /**
+ * Reads the data in the file at the specified path and returns
+ * a String with the contents. If the file doesn't exist
+ * then it returns an empty string
+ */
+ public String getCssTextFromFile(String filePath) {
+ String cssText = "";
+ try {
+ File cssFile = new File(filePath);
+ if (cssFile.exists()) {
+ cssText = FileUtils.readFileToString(cssFile);
+ }
+ } catch (IOException ex) {
+
+ }
+ return cssText;
+ }
+
</pre>
'''UpdateCSS.java:''' 
Our model portion of the MVC pattern. This Java POJO represents the database record we are storing 
to update/get CSS configuration setting. 
<pre>
/**
* The contents of this file are subject to the OpenMRS Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://license.openmrs.org
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
* License for the specific language governing rights and limitations
* under the License.
*
* Copyright (C) OpenMRS, LLC. All Rights Reserved.
*/
package org.openmrs.module.updatecss;

import java.io.Serializable;
import org.openmrs.BaseOpenmrsObject;
import org.openmrs.BaseOpenmrsMetadata;

/**
* It is a model class. It should extend either {@link BaseOpenmrsObject} or {@link BaseOpenmrsMetadata}.
*/
public class UpdateCSS extends BaseOpenmrsObject implements Serializable {

private static final long serialVersionUID = 1L;

private Integer id;
private String homeDirectory;
private String cssData;

@Override
public Integer getId() {
return id;
}

@Override
public void setId(Integer id) {
this.id = id;
}

public String getHomeDirectory() {
return homeDirectory;
}

public void setHomeDirectory(String homeDirectory) {
this.homeDirectory = homeDirectory;
}

public String getCssData() {
return cssData;
}

public void setCssData(String cssData) {
this.cssData = cssData;
}
}
</pre>
'''UpdateCSSDAO.java/HibernateUpdateCSSDAO.java'''
The DAO files carry the primary responsibility of interaction with the DB layer in the MVC architecture. 
The data layer changes involved 3 separate components: 
1. liquibase.xml file to configure our new table: css_properties 
2. UpdateCSSDAO.java/HibernateUpdateCSSDAO.java - Interface/Implementation for DAO getter/setter. 
3. UpdateCSS.hbm.xml - Hibernate configuration file for mapping DAO to new properties table. 

''liquibase.xml'' 
Liquibase<ref>http://www.liquibase.org/documentation/</ref> is a method for automatically generating database changes at module startup. We used this to add 
our new css_properties table. 
<pre>
<changeSet id="updatecss-2013-04-22-26:00" author="yurijeffroshnajon" runOnChange="true">
<preConditions onFail="MARK_RAN">
<not><tableExists tableName="css_properties"/></not>
</preConditions>
<comment>
Create the css_properties table
</comment>
<createTable tableName="css_properties">
<column name="id" type="int" autoIncrement="true">
<constraints primaryKey="true" nullable="false"/>
</column>
<column name="css_location" type="longtext">
<constraints nullable="false"/>
</column>
<column name="tomcat_home" type="varchar(255)">
<constraints nullable="false"/>
</column>
</createTable>
</changeSet>
</pre>
''Hibernate'' 
Hibernate<ref>http://www.hibernate.org/</ref> is a POJO-based implementation used for database interaction without the need for SQL queries. Instead, by using some XML-based configuration files provided by the Hibernate framework, you can manipulate the 
database using only Java objects. This is the mechanism we used for our database interaction. Our sample config file: 
<pre>
<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>

</hibernate-mapping>
</pre>
'''UpdateCSSService.java:''' 
The interface for the UpdateCSSServiceImpl file described above. 
'''UpdateCSSManageController.java:''' 
Our controller utilized in the MVC pattern. We modified this file to initialize our main web page and populate it 
with our existing configuration record. 
<pre>
//this method creates an UpdateCSS object the first time this controller is loaded
@ModelAttribute("updateCSS")
public UpdateCSS getPatientSearchObject(){
UpdateCSSService cssService = Context.getService(UpdateCSSService.class);
UpdateCSS currCSS = cssService.getData();

if (currCSS == null) {
UpdateCSS newCSS = new UpdateCSS();
newCSS.setHomeDirectory(System.getProperty("catalina.base") + "\\webapps\\openmrs-standalone\\style.css");
newCSS.setCssData(cssService.getCssTextFromFile(newCSS.getHomeDirectory()));
return newCSS;
} else {
return currCSS;
}
}
</pre>

==References==

<references />

CSC/ECE 517/M601 Design Document

2013-04-27T12:40:52Z

Japlemmo: /* Specific Changes */

<h1>Add ability to update css through webapp</h1>
== Example Video ==
A video example of this module can be seen here [http://youtu.be/2dQeFYjcsnU]
==Team==
Yuri Kolesnikov 
Jonathan Wills 
Jeffrey Plemmons 
Roshna Agarwal

==Our Work==
Link to the OpenMRS ticket: https://tickets.openmrs.org/browse/TRUNK-3415 
Link to our code in GitHub: https://github.com/ykolesn/openmrs-module-m601 
Link to application: http://152.46.17.228:8081/openmrs-standalone

==Purpose==
The purpose of this module is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file.
This would be best as a new module in openmrs or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin.

==Design Requirements==

1. The admin should be able to customize the openmrs css file through an admin page. 
2. The admin should see a page with a large text box. 
3. The text box content should be stored in the database. 
4. The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin. 
5. Need to use Eclipse and Maven as development tools for the module. 

==Tasks==
'''Week 1'''

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
'''Week 2'''

*Create object for storing css in db
*Create service layer and dao layer methods to save object
*Connect controller to db object for saving + retrieving
*Add unit tests for saving/retrieving
'''Week 3'''

*Create settings page to allow admin to choose where tomcat is running
*Add some magic so that module tries to guess where tomcat is running
*Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Development Tools==
1. '''Eclipse'''<ref>http://en.wikipedia.org/wiki/Integrated_development_environment</ref>: Eclipse is the Integrated Development Environment used to develop, modify, and compile the code for our module. 
2. '''Maven'''<ref>http://en.wikipedia.org/wiki/Apache_Maven</ref>: Maven is used through a plug-in in Eclipse to compile, run unit tests, and package all of the Java files in the module. 
3. '''Tomcat'''<ref>http://en.wikipedia.org/wiki/Apache_Tomcat</ref>: Tomcat is the web-server used to run the application. 
4. '''Hibernate'''<ref>http://en.wikipedia.org/wiki/Hibernate_(Java)</ref>: Hibernate is a built-in utility in the OpenMRS module, that is used to connect the Java classes to the database tables in the application. It configured the database table through an xml file: UpdateCSS.hbm.xml 
<pre>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>
</hibernate-mapping>
</pre>
''Here in the UpdateCSS.hbm.xml we specify the table name and columns. Hibernate generates the table with the fields specified and handles all the necessary SQL calls and queries.'' 
5. '''MySQL''': MySQL<ref>http://en.wikipedia.org/wiki/Mysql</ref> is the RDBMS that is used to store the CSS data for the application.

==Use Case==
[[File:Openmrsui.png|800px|alt=OpenMRS UI]] 
''This is the user interface for the UpdateCSS module. The initial start screen provides a default location for the css style sheet and default css code. Here the navigation bar is changed to "orange". '' 
 
1. Log in to the Admin page with user "Admin" and password "Admin123" 
2. Once logged in, click on "Administration" on the right-hand side of the navigation bar. 
3. Under "Update CSS Module", click on "Manage module" 
4. Here the user can enter their desired CSS preferences for customization. 

==Application Overview==
[[File:Overview.png]]

<h1>Code Changes</h1>
==Classes and Files Worked On==
* UpdateCSSActivator.java 
* UpdateCSS.java 
* UpdateCSSService.java 
* UpdateCSSServiceImpl.java 
* UpdateCSSDAO.java 
* HibernateUpdateCSSDAO.java 
* UpdateCSS.hbm.xml 
* liquibase.xml 
* moduleApplicationContext.xml 
* UpdateCSSServiceTest.java 
* manage.jsp 
* UpdateCSSManageController.java 

==Specific Changes==
'''UpdateCSSActivator.java:''' 
'''UpdateCSSServiceImpl.java:''' 
Added below methods to UpdateCSSServiceImpl class: 
<pre>
/**
+ * Replaces the text of the specified CSS file in the
+ * specified directory with the specified text
+ */ + public void copyCssDataToTomcatDirectory(String directory, String cssText) {
+ File cssFile = new File(directory);
+ if (cssFile.exists()) {
+ writeDataToFile(cssFile, cssText);
+ }
+ }
+
+ /**
+ * Copies the data stored in the DB into the CSS file that is saved in the
+ * directory column of the css_properties table
+ */
+ public void copyCssDataToTomcatDirectory() {
+ UpdateCSS updateCSS = getData();
+ String cssDirectory = updateCSS.getHomeDirectory();
+ String cssText = updateCSS.getCssData();
+ copyCssDataToTomcatDirectory(cssDirectory, cssText);
+ }
+
+ /**
+ * Writes the specified text to the specified CSS file
+ */
+ public void writeDataToFile(File cssFile, String cssText) {
+ try {
+ if (cssFile.exists()) {
+ PrintWriter writer = new PrintWriter(cssFile);
+ writer.print(cssText);
+ writer.close();
+ }
+ } catch (FileNotFoundException ex) {
+
+ }
+ }
+
+ /**
+ * Reads the data in the file at the specified path and returns
+ * a String with the contents. If the file doesn't exist
+ * then it returns an empty string
+ */
+ public String getCssTextFromFile(String filePath) {
+ String cssText = "";
+ try {
+ File cssFile = new File(filePath);
+ if (cssFile.exists()) {
+ cssText = FileUtils.readFileToString(cssFile);
+ }
+ } catch (IOException ex) {
+
+ }
+ return cssText;
+ }
+
</pre>
'''UpdateCSS.java:''' 
Our model portion of the MVC pattern. This Java POJO represents the database record we are storing 
to update/get CSS configuration setting. 
<pre>
/**
* The contents of this file are subject to the OpenMRS Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://license.openmrs.org
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
* License for the specific language governing rights and limitations
* under the License.
*
* Copyright (C) OpenMRS, LLC. All Rights Reserved.
*/
package org.openmrs.module.updatecss;

import java.io.Serializable;
import org.openmrs.BaseOpenmrsObject;
import org.openmrs.BaseOpenmrsMetadata;

/**
* It is a model class. It should extend either {@link BaseOpenmrsObject} or {@link BaseOpenmrsMetadata}.
*/
public class UpdateCSS extends BaseOpenmrsObject implements Serializable {

private static final long serialVersionUID = 1L;

private Integer id;
private String homeDirectory;
private String cssData;

@Override
public Integer getId() {
return id;
}

@Override
public void setId(Integer id) {
this.id = id;
}

public String getHomeDirectory() {
return homeDirectory;
}

public void setHomeDirectory(String homeDirectory) {
this.homeDirectory = homeDirectory;
}

public String getCssData() {
return cssData;
}

public void setCssData(String cssData) {
this.cssData = cssData;
}
}
</pre>
'''UpdateCSSDAO.java/HibernateUpdateCSSDAO.java'''
The DAO files carry the primary responsibility of interaction with the DB layer in the MVC architecture. 
The data layer changes involved 3 separate components: 
1. liquibase.xml file to configure our new table: css_properties 
2. UpdateCSSDAO.java/HibernateUpdateCSSDAO.java - Interface/Implementation for DAO getter/setter. 
3. UpdateCSS.hbm.xml - Hibernate configuration file for mapping DAO to new properties table. 

''liquibase.xml'' 
Liquibase<ref>http://www.liquibase.org/documentation/</ref> is a method for automatically generating database changes at module startup. We used this to add 
our new css_properties table. 
<pre>
<changeSet id="updatecss-2013-04-22-26:00" author="yurijeffroshnajon" runOnChange="true">
<preConditions onFail="MARK_RAN">
<not><tableExists tableName="css_properties"/></not>
</preConditions>
<comment>
Create the css_properties table
</comment>
<createTable tableName="css_properties">
<column name="id" type="int" autoIncrement="true">
<constraints primaryKey="true" nullable="false"/>
</column>
<column name="css_location" type="longtext">
<constraints nullable="false"/>
</column>
<column name="tomcat_home" type="varchar(255)">
<constraints nullable="false"/>
</column>
</createTable>
</changeSet>
</pre>
''Hibernate'' 
Hibernate<ref>http://www.hibernate.org/</ref> is a POJO-based implementation used for database interaction without the need for SQL queries. Instead, by using some XML-based configuration files provided by the Hibernate framework, you can manipulate the 
database using only Java objects. This is the mechanism we used for our database interaction. Our sample config file: 
<pre>
<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>

</hibernate-mapping>
</pre>
'''UpdateCSSService.java:''' 
The interface for the UpdateCSSServiceImpl file described above. 
'''UpdateCSSManageController.java:''' 
Our controller utilized in the MVC pattern. We modified this file to initialize our main web page and populate it 
with our existing configuration record. 
<pre>
//this method creates an UpdateCSS object the first time this controller is loaded
@ModelAttribute("updateCSS")
public UpdateCSS getPatientSearchObject(){
UpdateCSSService cssService = Context.getService(UpdateCSSService.class);
UpdateCSS currCSS = cssService.getData();

if (currCSS == null) {
UpdateCSS newCSS = new UpdateCSS();
newCSS.setHomeDirectory(System.getProperty("catalina.base") + "\\webapps\\openmrs-standalone\\style.css");
newCSS.setCssData(cssService.getCssTextFromFile(newCSS.getHomeDirectory()));
return newCSS;
} else {
return currCSS;
}
}
</pre>

==References==

<references />

CSC/ECE 517/M601 Design Document

2013-04-27T12:38:33Z

Japlemmo: /* Specific Changes */

<h1>Add ability to update css through webapp</h1>
== Example Video ==
A video example of this module can be seen here [http://youtu.be/2dQeFYjcsnU]
==Team==
Yuri Kolesnikov 
Jonathan Wills 
Jeffrey Plemmons 
Roshna Agarwal

==Our Work==
Link to the OpenMRS ticket: https://tickets.openmrs.org/browse/TRUNK-3415 
Link to our code in GitHub: https://github.com/ykolesn/openmrs-module-m601 
Link to application: http://152.46.17.228:8081/openmrs-standalone

==Purpose==
The purpose of this module is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file.
This would be best as a new module in openmrs or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin.

==Design Requirements==

1. The admin should be able to customize the openmrs css file through an admin page. 
2. The admin should see a page with a large text box. 
3. The text box content should be stored in the database. 
4. The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin. 
5. Need to use Eclipse and Maven as development tools for the module. 

==Tasks==
'''Week 1'''

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
'''Week 2'''

*Create object for storing css in db
*Create service layer and dao layer methods to save object
*Connect controller to db object for saving + retrieving
*Add unit tests for saving/retrieving
'''Week 3'''

*Create settings page to allow admin to choose where tomcat is running
*Add some magic so that module tries to guess where tomcat is running
*Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Development Tools==
1. '''Eclipse'''<ref>http://en.wikipedia.org/wiki/Integrated_development_environment</ref>: Eclipse is the Integrated Development Environment used to develop, modify, and compile the code for our module. 
2. '''Maven'''<ref>http://en.wikipedia.org/wiki/Apache_Maven</ref>: Maven is used through a plug-in in Eclipse to compile, run unit tests, and package all of the Java files in the module. 
3. '''Tomcat'''<ref>http://en.wikipedia.org/wiki/Apache_Tomcat</ref>: Tomcat is the web-server used to run the application. 
4. '''Hibernate'''<ref>http://en.wikipedia.org/wiki/Hibernate_(Java)</ref>: Hibernate is a built-in utility in the OpenMRS module, that is used to connect the Java classes to the database tables in the application. It configured the database table through an xml file: UpdateCSS.hbm.xml 
<pre>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>
</hibernate-mapping>
</pre>
''Here in the UpdateCSS.hbm.xml we specify the table name and columns. Hibernate generates the table with the fields specified and handles all the necessary SQL calls and queries.'' 
5. '''MySQL''': MySQL<ref>http://en.wikipedia.org/wiki/Mysql</ref> is the RDBMS that is used to store the CSS data for the application.

==Use Case==
[[File:Openmrsui.png|800px|alt=OpenMRS UI]] 
''This is the user interface for the UpdateCSS module. The initial start screen provides a default location for the css style sheet and default css code. Here the navigation bar is changed to "orange". '' 
 
1. Log in to the Admin page with user "Admin" and password "Admin123" 
2. Once logged in, click on "Administration" on the right-hand side of the navigation bar. 
3. Under "Update CSS Module", click on "Manage module" 
4. Here the user can enter their desired CSS preferences for customization. 

==Application Overview==
[[File:Overview.png]]

<h1>Code Changes</h1>
==Classes and Files Worked On==
* UpdateCSSActivator.java 
* UpdateCSS.java 
* UpdateCSSService.java 
* UpdateCSSServiceImpl.java 
* UpdateCSSDAO.java 
* HibernateUpdateCSSDAO.java 
* UpdateCSS.hbm.xml 
* liquibase.xml 
* moduleApplicationContext.xml 
* UpdateCSSServiceTest.java 
* manage.jsp 
* UpdateCSSManageController.java 

==Specific Changes==
'''UpdateCSSActivator.java:''' 
'''UpdateCSSServiceImpl.java:''' 
Added below methods to UpdateCSSServiceImpl class: 
<pre>
/**
+ * Replaces the text of the specified CSS file in the
+ * specified directory with the specified text
+ */ + public void copyCssDataToTomcatDirectory(String directory, String cssText) {
+ File cssFile = new File(directory);
+ if (cssFile.exists()) {
+ writeDataToFile(cssFile, cssText);
+ }
+ }
+
+ /**
+ * Copies the data stored in the DB into the CSS file that is saved in the
+ * directory column of the css_properties table
+ */
+ public void copyCssDataToTomcatDirectory() {
+ UpdateCSS updateCSS = getData();
+ String cssDirectory = updateCSS.getHomeDirectory();
+ String cssText = updateCSS.getCssData();
+ copyCssDataToTomcatDirectory(cssDirectory, cssText);
+ }
+
+ /**
+ * Writes the specified text to the specified CSS file
+ */
+ public void writeDataToFile(File cssFile, String cssText) {
+ try {
+ if (cssFile.exists()) {
+ PrintWriter writer = new PrintWriter(cssFile);
+ writer.print(cssText);
+ writer.close();
+ }
+ } catch (FileNotFoundException ex) {
+
+ }
+ }
+
+ /**
+ * Reads the data in the file at the specified path and returns
+ * a String with the contents. If the file doesn't exist
+ * then it returns an empty string
+ */
+ public String getCssTextFromFile(String filePath) {
+ String cssText = "";
+ try {
+ File cssFile = new File(filePath);
+ if (cssFile.exists()) {
+ cssText = FileUtils.readFileToString(cssFile);
+ }
+ } catch (IOException ex) {
+
+ }
+ return cssText;
+ }
+
</pre>
'''UpdateCSS.java:''' 
'''UpdateCSSDAO.java/HibernateUpdateCSSDAO.java'''
The DAO files carry the primary responsibility of interaction with the DB layer in the MVC architecture. 
The data layer changes involved 3 separate components: 
1. liquibase.xml file to configure our new table: css_properties 
2. UpdateCSSDAO.java/HibernateUpdateCSSDAO.java - Interface/Implementation for DAO getter/setter. 
3. UpdateCSS.hbm.xml - Hibernate configuration file for mapping DAO to new properties table. 

''liquibase.xml'' 
Liquibase<ref>http://www.liquibase.org/documentation/</ref> is a method for automatically generating database changes at module startup. We used this to add 
our new css_properties table. 
<pre>
<changeSet id="updatecss-2013-04-22-26:00" author="yurijeffroshnajon" runOnChange="true">
<preConditions onFail="MARK_RAN">
<not><tableExists tableName="css_properties"/></not>
</preConditions>
<comment>
Create the css_properties table
</comment>
<createTable tableName="css_properties">
<column name="id" type="int" autoIncrement="true">
<constraints primaryKey="true" nullable="false"/>
</column>
<column name="css_location" type="longtext">
<constraints nullable="false"/>
</column>
<column name="tomcat_home" type="varchar(255)">
<constraints nullable="false"/>
</column>
</createTable>
</changeSet>
</pre>
''Hibernate'' 
Hibernate<ref>http://www.hibernate.org/</ref> is a POJO-based implementation used for database interaction without the need for SQL queries. Instead, by using some XML-based configuration files provided by the Hibernate framework, you can manipulate the 
database using only Java objects. This is the mechanism we used for our database interaction. Our sample config file: 
<pre>
<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>

</hibernate-mapping>
</pre>
'''UpdateCSSService.java:''' 
The interface for the UpdateCSSServiceImpl file described above. 
'''UpdateCSSManageController.java:''' 
Our controller utilized in the MVC pattern. We modified this file to initialize our main web page and populate it 
with our existing configuration record. 
<pre>
//this method creates an UpdateCSS object the first time this controller is loaded
@ModelAttribute("updateCSS")
public UpdateCSS getPatientSearchObject(){
UpdateCSSService cssService = Context.getService(UpdateCSSService.class);
UpdateCSS currCSS = cssService.getData();

if (currCSS == null) {
UpdateCSS newCSS = new UpdateCSS();
newCSS.setHomeDirectory(System.getProperty("catalina.base") + "\\webapps\\openmrs-standalone\\style.css");
newCSS.setCssData(cssService.getCssTextFromFile(newCSS.getHomeDirectory()));
return newCSS;
} else {
return currCSS;
}
}
</pre>

==References==

<references />

CSC/ECE 517/M601 Design Document

2013-04-27T12:35:28Z

Japlemmo: /* Specific Changes */

<h1>Add ability to update css through webapp</h1>
== Example Video ==
A video example of this module can be seen here [http://youtu.be/2dQeFYjcsnU]
==Team==
Yuri Kolesnikov 
Jonathan Wills 
Jeffrey Plemmons 
Roshna Agarwal

==Our Work==
Link to the OpenMRS ticket: https://tickets.openmrs.org/browse/TRUNK-3415 
Link to our code in GitHub: https://github.com/ykolesn/openmrs-module-m601 
Link to application: http://152.46.17.228:8081/openmrs-standalone

==Purpose==
The purpose of this module is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file.
This would be best as a new module in openmrs or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin.

==Design Requirements==

1. The admin should be able to customize the openmrs css file through an admin page. 
2. The admin should see a page with a large text box. 
3. The text box content should be stored in the database. 
4. The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin. 
5. Need to use Eclipse and Maven as development tools for the module. 

==Tasks==
'''Week 1'''

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
'''Week 2'''

*Create object for storing css in db
*Create service layer and dao layer methods to save object
*Connect controller to db object for saving + retrieving
*Add unit tests for saving/retrieving
'''Week 3'''

*Create settings page to allow admin to choose where tomcat is running
*Add some magic so that module tries to guess where tomcat is running
*Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Development Tools==
1. '''Eclipse'''<ref>http://en.wikipedia.org/wiki/Integrated_development_environment</ref>: Eclipse is the Integrated Development Environment used to develop, modify, and compile the code for our module. 
2. '''Maven'''<ref>http://en.wikipedia.org/wiki/Apache_Maven</ref>: Maven is used through a plug-in in Eclipse to compile, run unit tests, and package all of the Java files in the module. 
3. '''Tomcat'''<ref>http://en.wikipedia.org/wiki/Apache_Tomcat</ref>: Tomcat is the web-server used to run the application. 
4. '''Hibernate'''<ref>http://en.wikipedia.org/wiki/Hibernate_(Java)</ref>: Hibernate is a built-in utility in the OpenMRS module, that is used to connect the Java classes to the database tables in the application. It configured the database table through an xml file: UpdateCSS.hbm.xml 
<pre>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>
</hibernate-mapping>
</pre>
''Here in the UpdateCSS.hbm.xml we specify the table name and columns. Hibernate generates the table with the fields specified and handles all the necessary SQL calls and queries.'' 
5. '''MySQL''': MySQL<ref>http://en.wikipedia.org/wiki/Mysql</ref> is the RDBMS that is used to store the CSS data for the application.

==Use Case==
[[File:Openmrsui.png|800px|alt=OpenMRS UI]] 
''This is the user interface for the UpdateCSS module. The initial start screen provides a default location for the css style sheet and default css code. Here the navigation bar is changed to "orange". '' 
 
1. Log in to the Admin page with user "Admin" and password "Admin123" 
2. Once logged in, click on "Administration" on the right-hand side of the navigation bar. 
3. Under "Update CSS Module", click on "Manage module" 
4. Here the user can enter their desired CSS preferences for customization. 

==Application Overview==
[[File:Overview.png]]

<h1>Code Changes</h1>
==Classes and Files Worked On==
* UpdateCSSActivator.java 
* UpdateCSS.java 
* UpdateCSSService.java 
* UpdateCSSServiceImpl.java 
* UpdateCSSDAO.java 
* HibernateUpdateCSSDAO.java 
* UpdateCSS.hbm.xml 
* liquibase.xml 
* moduleApplicationContext.xml 
* UpdateCSSServiceTest.java 
* manage.jsp 
* UpdateCSSManageController.java 

==Specific Changes==
'''UpdateCSSActivator.java:''' 
'''UpdateCSSServiceImpl.java:''' 
Added below methods to UpdateCSSServiceImpl class: 
<pre>
/**
+ * Replaces the text of the specified CSS file in the
+ * specified directory with the specified text
+ */ + public void copyCssDataToTomcatDirectory(String directory, String cssText) {
+ File cssFile = new File(directory);
+ if (cssFile.exists()) {
+ writeDataToFile(cssFile, cssText);
+ }
+ }
+
+ /**
+ * Copies the data stored in the DB into the CSS file that is saved in the
+ * directory column of the css_properties table
+ */
+ public void copyCssDataToTomcatDirectory() {
+ UpdateCSS updateCSS = getData();
+ String cssDirectory = updateCSS.getHomeDirectory();
+ String cssText = updateCSS.getCssData();
+ copyCssDataToTomcatDirectory(cssDirectory, cssText);
+ }
+
+ /**
+ * Writes the specified text to the specified CSS file
+ */
+ public void writeDataToFile(File cssFile, String cssText) {
+ try {
+ if (cssFile.exists()) {
+ PrintWriter writer = new PrintWriter(cssFile);
+ writer.print(cssText);
+ writer.close();
+ }
+ } catch (FileNotFoundException ex) {
+
+ }
+ }
+
+ /**
+ * Reads the data in the file at the specified path and returns
+ * a String with the contents. If the file doesn't exist
+ * then it returns an empty string
+ */
+ public String getCssTextFromFile(String filePath) {
+ String cssText = "";
+ try {
+ File cssFile = new File(filePath);
+ if (cssFile.exists()) {
+ cssText = FileUtils.readFileToString(cssFile);
+ }
+ } catch (IOException ex) {
+
+ }
+ return cssText;
+ }
+
</pre>
'''UpdateCSS.java:''' 
'''UpdateCSSDAO.java/HibernateUpdateCSSDAO.java'''
The DAO files carry the primary responsibility of interaction with the DB layer in the MVC architecture. 
The data layer changes involved 3 separate components: 
1. liquibase.xml file to configure our new table: css_properties 
2. UpdateCSSDAO.java/HibernateUpdateCSSDAO.java - Interface/Implementation for DAO getter/setter. 
3. UpdateCSS.hbm.xml - Hibernate configuration file for mapping DAO to new properties table. 

''liquibase.xml'' 
Liquibase<ref>http://www.liquibase.org/documentation/</ref> is a method for automatically generating database changes at module startup. We used this to add 
our new css_properties table. 
<pre>
<changeSet id="updatecss-2013-04-22-26:00" author="yurijeffroshnajon" runOnChange="true">
<preConditions onFail="MARK_RAN">
<not><tableExists tableName="css_properties"/></not>
</preConditions>
<comment>
Create the css_properties table
</comment>
<createTable tableName="css_properties">
<column name="id" type="int" autoIncrement="true">
<constraints primaryKey="true" nullable="false"/>
</column>
<column name="css_location" type="longtext">
<constraints nullable="false"/>
</column>
<column name="tomcat_home" type="varchar(255)">
<constraints nullable="false"/>
</column>
</createTable>
</changeSet>
</pre>
''Hibernate'' 
Hibernate<ref>http://www.hibernate.org/</ref> is a POJO-based implementation used for database interaction without the need for SQL queries. Instead, by using some XML-based configuration files provided by the Hibernate framework, you can manipulate the 
database using only Java objects. This is the mechanism we used for our database interaction. Our sample config file: 
<pre>
<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>

</hibernate-mapping>
</pre>
'''UpdateCSSService.java:''' 
The interface for the UpdateCSSServiceImpl file described above. 
'''UpdateCSSManageController.java:''' 

==References==

<references />

CSC/ECE 517/M601 Design Document

2013-04-27T12:33:49Z

Japlemmo: /* Specific Changes */

<h1>Add ability to update css through webapp</h1>
== Example Video ==
A video example of this module can be seen here [http://youtu.be/2dQeFYjcsnU]
==Team==
Yuri Kolesnikov 
Jonathan Wills 
Jeffrey Plemmons 
Roshna Agarwal

==Our Work==
Link to the OpenMRS ticket: https://tickets.openmrs.org/browse/TRUNK-3415 
Link to our code in GitHub: https://github.com/ykolesn/openmrs-module-m601 
Link to application: http://152.46.17.228:8081/openmrs-standalone

==Purpose==
The purpose of this module is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file.
This would be best as a new module in openmrs or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin.

==Design Requirements==

1. The admin should be able to customize the openmrs css file through an admin page. 
2. The admin should see a page with a large text box. 
3. The text box content should be stored in the database. 
4. The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin. 
5. Need to use Eclipse and Maven as development tools for the module. 

==Tasks==
'''Week 1'''

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
'''Week 2'''

*Create object for storing css in db
*Create service layer and dao layer methods to save object
*Connect controller to db object for saving + retrieving
*Add unit tests for saving/retrieving
'''Week 3'''

*Create settings page to allow admin to choose where tomcat is running
*Add some magic so that module tries to guess where tomcat is running
*Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Development Tools==
1. '''Eclipse'''<ref>http://en.wikipedia.org/wiki/Integrated_development_environment</ref>: Eclipse is the Integrated Development Environment used to develop, modify, and compile the code for our module. 
2. '''Maven'''<ref>http://en.wikipedia.org/wiki/Apache_Maven</ref>: Maven is used through a plug-in in Eclipse to compile, run unit tests, and package all of the Java files in the module. 
3. '''Tomcat'''<ref>http://en.wikipedia.org/wiki/Apache_Tomcat</ref>: Tomcat is the web-server used to run the application. 
4. '''Hibernate'''<ref>http://en.wikipedia.org/wiki/Hibernate_(Java)</ref>: Hibernate is a built-in utility in the OpenMRS module, that is used to connect the Java classes to the database tables in the application. It configured the database table through an xml file: UpdateCSS.hbm.xml 
<pre>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>
</hibernate-mapping>
</pre>
''Here in the UpdateCSS.hbm.xml we specify the table name and columns. Hibernate generates the table with the fields specified and handles all the necessary SQL calls and queries.'' 
5. '''MySQL''': MySQL<ref>http://en.wikipedia.org/wiki/Mysql</ref> is the RDBMS that is used to store the CSS data for the application.

==Use Case==
[[File:Openmrsui.png|800px|alt=OpenMRS UI]] 
''This is the user interface for the UpdateCSS module. The initial start screen provides a default location for the css style sheet and default css code. Here the navigation bar is changed to "orange". '' 
 
1. Log in to the Admin page with user "Admin" and password "Admin123" 
2. Once logged in, click on "Administration" on the right-hand side of the navigation bar. 
3. Under "Update CSS Module", click on "Manage module" 
4. Here the user can enter their desired CSS preferences for customization. 

==Application Overview==
[[File:Overview.png]]

<h1>Code Changes</h1>
==Classes and Files Worked On==
* UpdateCSSActivator.java 
* UpdateCSS.java 
* UpdateCSSService.java 
* UpdateCSSServiceImpl.java 
* UpdateCSSDAO.java 
* HibernateUpdateCSSDAO.java 
* UpdateCSS.hbm.xml 
* liquibase.xml 
* moduleApplicationContext.xml 
* UpdateCSSServiceTest.java 
* manage.jsp 
* UpdateCSSManageController.java 

==Specific Changes==
'''UpdateCSSActivator.java:''' 
'''UpdateCSSServiceImpl.java:''' 
Added below methods to UpdateCSSServiceImpl class: 
<pre>
/**
+ * Replaces the text of the specified CSS file in the
+ * specified directory with the specified text
+ */ + public void copyCssDataToTomcatDirectory(String directory, String cssText) {
+ File cssFile = new File(directory);
+ if (cssFile.exists()) {
+ writeDataToFile(cssFile, cssText);
+ }
+ }
+
+ /**
+ * Copies the data stored in the DB into the CSS file that is saved in the
+ * directory column of the css_properties table
+ */
+ public void copyCssDataToTomcatDirectory() {
+ UpdateCSS updateCSS = getData();
+ String cssDirectory = updateCSS.getHomeDirectory();
+ String cssText = updateCSS.getCssData();
+ copyCssDataToTomcatDirectory(cssDirectory, cssText);
+ }
+
+ /**
+ * Writes the specified text to the specified CSS file
+ */
+ public void writeDataToFile(File cssFile, String cssText) {
+ try {
+ if (cssFile.exists()) {
+ PrintWriter writer = new PrintWriter(cssFile);
+ writer.print(cssText);
+ writer.close();
+ }
+ } catch (FileNotFoundException ex) {
+
+ }
+ }
+
+ /**
+ * Reads the data in the file at the specified path and returns
+ * a String with the contents. If the file doesn't exist
+ * then it returns an empty string
+ */
+ public String getCssTextFromFile(String filePath) {
+ String cssText = "";
+ try {
+ File cssFile = new File(filePath);
+ if (cssFile.exists()) {
+ cssText = FileUtils.readFileToString(cssFile);
+ }
+ } catch (IOException ex) {
+
+ }
+ return cssText;
+ }
+
</pre>
'''UpdateCSS.java:''' 
'''UpdateCSSDAO.java/HibernateUpdateCSSDAO.java'''
The DAO files carry the primary responsibility of interaction with the DB layer in the MVC architecture. 
The data layer changes involved 3 separate components: 
1. liquibase.xml file to configure our new table: css_properties 
2. UpdateCSSDAO.java/HibernateUpdateCSSDAO.java - Interface/Implementation for DAO getter/setter. 
3. UpdateCSS.hbm.xml - Hibernate configuration file for mapping DAO to new properties table. 

''liquibase.xml'' 
Liquibase<ref>http://www.liquibase.org/documentation/</ref> is a method for automatically generating database changes at module startup. We used this to add 
our new css_properties table. 
<pre>
<changeSet id="updatecss-2013-04-22-26:00" author="yurijeffroshnajon" runOnChange="true">
<preConditions onFail="MARK_RAN">
<not><tableExists tableName="css_properties"/></not>
</preConditions>
<comment>
Create the css_properties table
</comment>
<createTable tableName="css_properties">
<column name="id" type="int" autoIncrement="true">
<constraints primaryKey="true" nullable="false"/>
</column>
<column name="css_location" type="longtext">
<constraints nullable="false"/>
</column>
<column name="tomcat_home" type="varchar(255)">
<constraints nullable="false"/>
</column>
</createTable>
</changeSet>
</pre>
''Hibernate'' 
Hibernate<ref>http://www.hibernate.org/</ref> is a POJO-based implementation used for database interaction without the need for SQL queries. Instead, by using some XML-based configuration files provided by the Hibernate framework, you can manipulate the 
database using only Java objects. This is the mechanism we used for our database interaction. Our sample config file: 
<pre>
<hibernate-mapping package="org.openmrs.module.updatecss">

<class name="UpdateCSS"
table="css_properties">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="cssData" type="java.lang.String" column="css_location"
length="255" not-null="true" />
<property name="homeDirectory" type="java.lang.String" column="tomcat_home"
length="255" not-null="true"/>
</class>

</hibernate-mapping>
</pre>
'''UpdateCSSService.java:''' 
'''UpdateCSSManageController.java:''' 

==References==

<references />

CSC/ECE 517/M601 Design Document

2013-04-27T12:29:35Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T12:27:54Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T12:26:08Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T12:24:33Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T12:24:06Z

Japlemmo: /* Hibernate */

CSC/ECE 517/M601 Design Document

2013-04-27T12:23:44Z

Japlemmo: /* UpdateCSSDAO.java/HibernateUpdateCSSDAO.java */

CSC/ECE 517/M601 Design Document

2013-04-27T12:23:20Z

Japlemmo: /* liquibase.xml */

CSC/ECE 517/M601 Design Document

2013-04-27T12:22:28Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T12:21:31Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T12:19:45Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T02:29:15Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T02:27:05Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T02:26:38Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T02:25:42Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T02:24:57Z

Japlemmo:

CSC/ECE 517/M601 Design Document

2013-04-27T02:01:22Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T01:48:40Z

Japlemmo: /* Specific Changes */

CSC/ECE 517/M601 Design Document

2013-04-27T01:47:55Z

Japlemmo:

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T01:34:36Z

Japlemmo: /* Perl: AUTOLOAD */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

In the above code, the Test class has variable definitions for 'a' and 'b', but no others. When the print method tries to send in a 'c' or 'd' method call, __getattr__ catches this call and prints the generic '123456' value. Even the hasattr method recognizes non-existent attributes as being valid without there even being an actual method call.

If an attribute is found through a normal mechanism, this function is never actually called. In fact, one difference with Ruby is that Python executes this method in a static fashion, only checking on one run if attributes have been defined somewhere for a relevant class. This code may in fact not perform properly if classes are modified dynamically at runtime.

===Perl: AUTOLOAD===

Lastly, the Perl programming language provides the AUTOLOAD feature for handling this situation. Basically, if a class or any parent classes define an AUTOLOAD method, this method is called in the case where a direct method isn't found. <ref>http://perldoc.perl.org/perlobj.html#AUTOLOAD</ref> Anything that the AUTOLOAD method returns will be the last value returned to the caller (the caller never even needs to know the AUTOLOAD code exists).

The following is a code snippet that can be used to auto-create methods on the fly in Perl using AUTOLOAD: <ref>http://www.perlmonks.org/?node_id=8227</ref>

#!/usr/bin/perl -w
package myClass;
use strict;
use vars qw{$AUTOLOAD $Debug};
$Debug = 1;
sub new {
return bless {
thing => 1,
thang => 2,
thong => 3,
}, shift;
}
sub AUTOLOAD {
my $self = shift or return undef;
# Get the called method name and trim off the fully-qualified part
( my $method = $AUTOLOAD ) =~ s{.*::}{};
# If the data member being accessed exists, build an accessor for it
if ( exists $self->{$method} ) {
### Create a closure that will become the new accessor method
my $accessor = sub {
my $closureSelf = shift;
if ( @_ ) {
return $closureSelf->{$method} = shift;
}
return $closureSelf->{$method}
}
# Assign the closure to the symbol table at the place where the real
# method should be. We need to turn off strict refs, as we'll be mucking
# with the symbol table.
SYMBOL_TABLE_HACQUERY: {
no strict qw{refs};
*$AUTOLOAD = $accessor;
}
# Turn the call back into a method call by sticking the self-reference
# back onto the arglist
unshift @_, $self;
# Jump to the newly-created method with magic goto
goto &$AUTOLOAD;
}
### Handle other autoloaded methods or errors
}
DESTROY {}
### Test program
package main;
my $a = new myClass;
print $a->thing, $a->thang, $a->thong, "\n";

In the above example, new accessor methods are being created dynamically where closures are being added to the symbol table and then the relevant method is loaded for the caller.

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T01:31:26Z

Japlemmo: /* Perl: AUTOLOAD */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T01:28:41Z

Japlemmo: /* Perl: AUTOLOAD */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

In the above code, the Test class has variable definitions for 'a' and 'b', but no others. When the print method tries to send in a 'c' or 'd' method call, __getattr__ catches this call and prints the generic '123456' value. Even the hasattr method recognizes non-existent attributes as being valid without there even being an actual method call.

If an attribute is found through a normal mechanism, this function is never actually called. In fact, one difference with Ruby is that Python executes this method in a static fashion, only checking on one run if attributes have been defined somewhere for a relevant class. This code may in fact not perform properly if classes are modified dynamically at runtime.

===Perl: AUTOLOAD===

Lastly, the Perl programming language provides the AUTOLOAD feature for handling this situation. Basically, if a class or any parent classes define an AUTOLOAD method, this method is called in the case where a direct method isn't found. <ref>http://perldoc.perl.org/perlobj.html#AUTOLOAD</ref> Anything that the AUTOLOAD method returns will be the last value returned to the caller (the caller never even needs to know the AUTOLOAD code exists).

The following is a code snippet that can be used to auto-create methods on the fly in Perl using AUTOLOAD: <ref>http://www.perlmonks.org/?node_id=8227</ref>

#!/usr/bin/perl -w
package myClass;
use strict;
use vars qw{$AUTOLOAD $Debug};
$Debug = 1;
sub new {
return bless {
thing => 1,
thang => 2,
thong => 3,
}, shift;
}
sub AUTOLOAD {
my $self = shift or return undef;
# Get the called method name and trim off the fully-qualified part
( my $method = $AUTOLOAD ) =~ s{.*::}{};
# If the data member being accessed exists, build an accessor for it
if ( exists $self->{$method} ) {
### Create a closure that will become the new accessor method
my $accessor = sub {
my $closureSelf = shift;
if ( @_ ) {
return $closureSelf->{$method} = shift;
}
return $closureSelf->{$method};
};
# Assign the closure to the symbol table at the place where the real
# method should be. We need to turn off strict refs, as we'll be mucking
# with the symbol table.
SYMBOL_TABLE_HACQUERY: {
no strict qw{refs};
*$AUTOLOAD = $accessor;
}
# Turn the call back into a method call by sticking the self-reference
# back onto the arglist
unshift @_, $self;
# Jump to the newly-created method with magic goto
goto &$AUTOLOAD;
}
### Handle other autoloaded methods or errors
}
DESTROY {}
### Test program
package main;
my $a = new myClass;
print $a->thing, $a->thang, $a->thong, "\n";

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T01:27:13Z

Japlemmo: /* Perl: AUTOLOAD */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

In the above code, the Test class has variable definitions for 'a' and 'b', but no others. When the print method tries to send in a 'c' or 'd' method call, __getattr__ catches this call and prints the generic '123456' value. Even the hasattr method recognizes non-existent attributes as being valid without there even being an actual method call.

If an attribute is found through a normal mechanism, this function is never actually called. In fact, one difference with Ruby is that Python executes this method in a static fashion, only checking on one run if attributes have been defined somewhere for a relevant class. This code may in fact not perform properly if classes are modified dynamically at runtime.

===Perl: AUTOLOAD===

Lastly, the Perl programming language provides the AUTOLOAD feature for handling this situation. Basically, if a class or any parent classes define an AUTOLOAD method, this method is called in the case where a direct method isn't found. <ref>http://perldoc.perl.org/perlobj.html#AUTOLOAD</ref> Anything that the AUTOLOAD method returns will be the last value returned to the caller (the caller never even needs to know the AUTOLOAD code exists).

The following is a code snippet that can be used to auto-create methods on the fly in Perl using AUTOLOAD: <ref>http://www.perlmonks.org/?node_id=8227</ref>

#!/usr/bin/perl -w
package myClass;
use strict;
use vars qw{$AUTOLOAD $Debug};
$Debug = 1;
sub new {
return bless {
thing => 1,
thang => 2,
thong => 3,
}, shift;
}
sub AUTOLOAD {
my $self = shift or return undef;
# Get the called method name and trim off the fully-qualified part
( my $method = $AUTOLOAD ) =~ s{.*::}{};
# If the data member being accessed exists, build an accessor for it
if ( exists $self->{$method} ) {
### Create a closure that will become the new accessor method
my $accessor = sub {
my $closureSelf = shift;
if ( @_ ) {
return $closureSelf->{$method} = shift;
}
return $closureSelf->{$method};
};
# Assign the closure to the symbol table at the place where the real
# method should be. We need to turn off strict refs, as we'll be mucking
# with the symbol table.
SYMBOL_TABLE_HACQUERY: {
no strict qw{refs};
*$AUTOLOAD = $accessor;
}
# Turn the call back into a method call by sticking the self-reference
# back onto the arglist
unshift @_, $self;
# Jump to the newly-created method with magic goto
goto &$AUTOLOAD;
}
### Handle other autoloaded methods or errors
}
DESTROY {}
### Test program
package main;
my $a = new myClass;
print $a->thing, $a->thang, $a->thong, "\n";

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T01:26:32Z

Japlemmo: /* Perl: AUTOLOAD */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

In the above code, the Test class has variable definitions for 'a' and 'b', but no others. When the print method tries to send in a 'c' or 'd' method call, __getattr__ catches this call and prints the generic '123456' value. Even the hasattr method recognizes non-existent attributes as being valid without there even being an actual method call.

If an attribute is found through a normal mechanism, this function is never actually called. In fact, one difference with Ruby is that Python executes this method in a static fashion, only checking on one run if attributes have been defined somewhere for a relevant class. This code may in fact not perform properly if classes are modified dynamically at runtime.

===Perl: AUTOLOAD===

Lastly, the Perl programming language provides the AUTOLOAD feature for handling this situation. Basically, if a class or any parent classes define an AUTOLOAD method, this method is called in the case where a direct method isn't found. <ref>http://perldoc.perl.org/perlobj.html#AUTOLOAD</ref> Anything that the AUTOLOAD method returns will be the last value returned to the caller (the caller never even needs to know the AUTOLOAD code exists).

The following is a code snippet that can be used to auto-create methods on the fly in Perl using AUTOLOAD: <ref>http://www.perlmonks.org/?node_id=8227</ref>

#!/usr/bin/perl -w
package myClass;
use strict;
use vars qw{$AUTOLOAD $Debug};
$Debug = 1;
sub new {
return bless {
thing => 1,
thang => 2,
thong => 3,
}, shift;
}
sub AUTOLOAD {
my $self = shift or return undef;
# Get the called method name and trim off the fully-qualified part
( my $method = $AUTOLOAD ) =~ s{.*::}{};
# If the data member being accessed exists, build an accessor for it
if ( exists $self->{$method} ) {
### Create a closure that will become the new accessor method
my $accessor = sub {
my $closureSelf = shift;
if ( @_ ) {
return $closureSelf->{$method} = shift;
}
return $closureSelf->{$method};
};
# Assign the closure to the symbol table at the place where the real
# method should be. We need to turn off strict refs, as we'll be mucking
# with the symbol table.
SYMBOL_TABLE_HACQUERY: {
no strict qw{refs};
*$AUTOLOAD = $accessor;
}
# Turn the call back into a method call by sticking the self-reference
# back onto the arglist
unshift @_, $self;
# Jump to the newly-created method with magic goto
goto &$AUTOLOAD;
}
### Handle other autoloaded methods or errors
}
DESTROY {}
### Test program
package main;
my $a = new myClass;
print $a->thing, $a->thang, $a->thong, "\n";

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T01:25:27Z

Japlemmo: /* Perl: AUTOLOAD */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

In the above code, the Test class has variable definitions for 'a' and 'b', but no others. When the print method tries to send in a 'c' or 'd' method call, __getattr__ catches this call and prints the generic '123456' value. Even the hasattr method recognizes non-existent attributes as being valid without there even being an actual method call.

If an attribute is found through a normal mechanism, this function is never actually called. In fact, one difference with Ruby is that Python executes this method in a static fashion, only checking on one run if attributes have been defined somewhere for a relevant class. This code may in fact not perform properly if classes are modified dynamically at runtime.

===Perl: AUTOLOAD===

Lastly, the Perl programming language provides the AUTOLOAD feature for handling this situation. Basically, if a class or any parent classes define an AUTOLOAD method, this method is called in the case where a direct method isn't found. <ref>http://perldoc.perl.org/perlobj.html#AUTOLOAD</ref> Anything that the AUTOLOAD method returns will be the last value returned to the caller (the caller never even needs to know the AUTOLOAD code exists).

The following is a code snippet that can be used to auto-create methods on the fly in Perl using AUTOLOAD: <ref>http://www.perlmonks.org/?node_id=8227</ref>

#!/usr/bin/perl -w
package myClass;
use strict;
use vars qw{$AUTOLOAD $Debug};

$Debug = 1;

sub new {
return bless {
thing => 1,
thang => 2,
thong => 3,
}, shift;
}

sub AUTOLOAD {
my $self = shift or return undef;

# Get the called method name and trim off the fully-qualified part
( my $method = $AUTOLOAD ) =~ s{.*::}{};

# If the data member being accessed exists, build an accessor for it
if ( exists $self->{$method} ) {

### Create a closure that will become the new accessor method
my $accessor = sub {
my $closureSelf = shift;

if ( @_ ) {
return $closureSelf->{$method} = shift;
}

return $closureSelf->{$method};
};

# Assign the closure to the symbol table at the place where the real
# method should be. We need to turn off strict refs, as we'll be mucking
# with the symbol table.
SYMBOL_TABLE_HACQUERY: {
no strict qw{refs};
*$AUTOLOAD = $accessor;
}

# Turn the call back into a method call by sticking the self-reference
# back onto the arglist
unshift @_, $self;

# Jump to the newly-created method with magic goto
goto &$AUTOLOAD;
}

### Handle other autoloaded methods or errors
}

DESTROY {}

### Test program
package main;

my $a = new myClass;

print $a->thing, $a->thang, $a->thong, "\n";

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T00:58:50Z

Japlemmo: /* Perl: AUTOLOAD */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

In the above code, the Test class has variable definitions for 'a' and 'b', but no others. When the print method tries to send in a 'c' or 'd' method call, __getattr__ catches this call and prints the generic '123456' value. Even the hasattr method recognizes non-existent attributes as being valid without there even being an actual method call.

If an attribute is found through a normal mechanism, this function is never actually called. In fact, one difference with Ruby is that Python executes this method in a static fashion, only checking on one run if attributes have been defined somewhere for a relevant class. This code may in fact not perform properly if classes are modified dynamically at runtime.

===Perl: AUTOLOAD===

Lastly, the Perl programming language provides the AUTOLOAD feature for handling this situation. Basically, if a class or any parent classes define an AUTOLOAD method, this method is called in the case where a direct method isn't found. <ref>http://perldoc.perl.org/perlobj.html#AUTOLOAD</ref> Anything that the AUTOLOAD method returns will be the last value returned to the caller (the caller never even needs to know the AUTOLOAD code exists).

The following is a code snippet that can be used to auto-create methods on the fly in Perl using AUTOLOAD: <ref>http://www.perlmonks.org/?node_id=8227</ref>

sub AUTOLOAD{
my ($self,$value)= @_ ;
return if $AUTOLOAD =~ /::DESTROY$/ ;
my $attname = $AUTOLOAD;
$attname =~ s/.*::// ;
if(! exists $self->{$attname}){
Carp::confess("Attribute $attname does not exists in $self");
}
my $pkg = ref($self ) ;
my $code = qq{
package $pkg ;
sub $attname {
my \$self = shift ;
\@_ ? \$self->{$attname} = shift :
\$self->{$attname} ;
}
};
eval $code ;
if( $@ ){
Carp::confess("Failed to create method $AUTOLOAD : $@");
}
goto &$AUTOLOAD ;
}

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T00:58:06Z

Japlemmo: /* Perl: AUTOLOAD */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

In the above code, the Test class has variable definitions for 'a' and 'b', but no others. When the print method tries to send in a 'c' or 'd' method call, __getattr__ catches this call and prints the generic '123456' value. Even the hasattr method recognizes non-existent attributes as being valid without there even being an actual method call.

If an attribute is found through a normal mechanism, this function is never actually called. In fact, one difference with Ruby is that Python executes this method in a static fashion, only checking on one run if attributes have been defined somewhere for a relevant class. This code may in fact not perform properly if classes are modified dynamically at runtime.

===Perl: AUTOLOAD===

Lastly, the Perl programming language provides the AUTOLOAD feature for handling this situation. Basically, if a class or any parent classes define an AUTOLOAD method, this method is called in the case where a direct method isn't found. <ref>http://perldoc.perl.org/perlobj.html#AUTOLOAD</ref> Anything that the AUTOLOAD method returns will be the last value returned to the caller (the caller never even needs to know the AUTOLOAD code exists).

The following is a code snippet that can be used to auto-create methods on the fly in Perl using AUTOLOAD:

sub AUTOLOAD{
my ($self,$value)= @_ ;
return if $AUTOLOAD =~ /::DESTROY$/ ;
my $attname = $AUTOLOAD;
$attname =~ s/.*::// ;
if(! exists $self->{$attname}){
Carp::confess("Attribute $attname does not exists in $self");
}
my $pkg = ref($self ) ;
my $code = qq{
package $pkg ;
sub $attname {
my \$self = shift ;
\@_ ? \$self->{$attname} = shift :
\$self->{$attname} ;
}
};
eval $code ;
if( $@ ){
Carp::confess("Failed to create method $AUTOLOAD : $@");
}
goto &$AUTOLOAD ;
}

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T00:57:22Z

Japlemmo: /* Perl: AUTOLOAD */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

In the above code, the Test class has variable definitions for 'a' and 'b', but no others. When the print method tries to send in a 'c' or 'd' method call, __getattr__ catches this call and prints the generic '123456' value. Even the hasattr method recognizes non-existent attributes as being valid without there even being an actual method call.

If an attribute is found through a normal mechanism, this function is never actually called. In fact, one difference with Ruby is that Python executes this method in a static fashion, only checking on one run if attributes have been defined somewhere for a relevant class. This code may in fact not perform properly if classes are modified dynamically at runtime.

===Perl: AUTOLOAD===

Lastly, the Perl programming language provides the AUTOLOAD feature for handling this situation. Basically, if a class or any parent classes define an AUTOLOAD method, this method is called in the case where a direct method isn't found. <ref>http://perldoc.perl.org/perlobj.html#AUTOLOAD</ref> Anything that the AUTOLOAD method returns will be the last value returned to the caller (the caller never even needs to know the AUTOLOAD code exists).

The following is a code snippet that can be used to auto-create methods on the fly in Perl using AUTOLOAD:

sub AUTOLOAD{
my ($self,$value)= @_ ;

return if $AUTOLOAD =~ /::DESTROY$/ ;

my $attname = $AUTOLOAD;

$attname =~ s/.*::// ;

if(! exists $self->{$attname}){
Carp::confess("Attribute $attname does not exists in $self");
}

my $pkg = ref($self ) ;

my $code = qq{
package $pkg ;
sub $attname {
my \$self = shift ;
\@_ ? \$self->{$attname} = shift :
\$self->{$attname} ;
}

};

eval $code ;
if( $@ ){
Carp::confess("Failed to create method $AUTOLOAD : $@");
}

goto &$AUTOLOAD ;

}

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-21T00:51:17Z

Japlemmo: /* Perl: AUTOLOAD */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T21:11:43Z

Japlemmo: /* Python: __getattr__ */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:57:29Z

Japlemmo: /* Python: __getattr__ */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def __getattr__(self, name):
return 123456
t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

===Perl: AUTOLOAD===

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:56:54Z

Japlemmo: /* Python: __getattr__ */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

class Test(object):
def __init__(self):
self.a = 'a'
self.b = 'b'

def __getattr__(self, name):
return 123456

t = Test()
print 'object variables: %r' % t.__dict__.keys()
print t.a
print t.b
print t.c
print getattr(t, 'd')
print hasattr(t, 'x')

Expected output:

object variables: ['a', 'b']
a
b
123456
123456
True

===Perl: AUTOLOAD===

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:54:04Z

Japlemmo: /* Python: __getattr__ */

=Ruby's method_missing(): Advantages/Disadvantages and Alternatives =

==Introduction==

One of the distinguishing features of the Ruby programming language is it's ability to easily extend classes in a dynamic fashion to perform a variety of different methods depending upon the needs of the current application. For example, should the developer want to extend a core language class, take String for example, they could easily re-open that class and add new methods dynamically to this existing class, rather than creating an entirely new class.

Even more powerful, Ruby allows for a construct called method_missing(). By overriding this method in your class, method_missing() will attempt to handle any method calls not currently defined by the given class (or class hierarchy). Typically, some sort of regular expression is used to determine if the method call can be redirected to an existing method based on it's naming convention (for example, a method call in a non-existent singular form could be redirected to an existing pluralized form). If the method_missing() definition cannot determine where to redirect the method call, the default is simply to call the parent class via super().

By having the ability to allow a class to dynamically extend itself even if a method definition never truly existed, Ruby allows for a far greater degree of flexibility than does a statically typed language such as Java, where much greater effort is involved in handing method calls that do not currently exist. With method_missing() defined, almost any sort of method call can be handled in the desired manner.

This article will explore the method_missing() construct in greater detail, giving both advantages and disadvantages of having this feature in the Ruby language. We will also examine how other programming languages attempt to handle the same problem.

==Advantages of method_missing()==
1. Allows for dynamically invoked methods.

==Disadvantages of method_missing()==

==Alternatives to method_missing() in other programming languages==

===Smalltalk: doesNotUnderstand===

In many ways the inspiration for Ruby, Smalltalk is often considered one of the original truly Object-Oriented languages. Smalltalk, much like Ruby with method_missing(), sends a message called #doesNotUnderstand<ref>http://c2.com/cgi/wiki?DoesNotUnderstand</ref> to handle methods that are unknown.

Essentially, when an object receives a method that it doesn't recognize, the Smalltalk runtime engine is then responsible for turning this message into an object with all necessary parameters and returning it to the sender as an exception. The sender is, at that point, responsible for handling the message and somehow dealing with the exception. Even though Smalltalk does consider this an exception, this construct is used quite frequently to form proxy objects and can handle a wide variety of different methods and arguments.

Consider the following code: <ref>http://www.iam.unibe.ch/~akuhn/blog/category/smalltalk/</ref>

OrderedCollection subclass: #Group.
Group >> eachRespondsTo: aSelector
self allSatisfy: [ :each | each respondsTo: aSelector ]
Group >> doesNotUnderstand: aMessage
(self eachRespondsTo: aMessage selector)
ifTrue: [ self collect: [ :each | aMessage sendTo: each ] ]
ifFalse: [ super doesNotUnderstand: aMessage ]
Group >> respondsTo: aSelector
^ (super respondsTo: aSelector) or: [ self eachRespondsTo: aSelector ]

In this code snippet, an OrderedCollection object is created. Should this collection class not understand any of the methods being sent to it, the doesUnderstand code will attempt to handle the message itself. Without overriding this method, the default is for Smalltalk to open a debugger to step through the exception (defining it overrides this behavior).

===Java: DynamicProxy===

In Java, the ability to handle undefined methods is a bit more cumbersome, but it can still be done successfully through the use of dynamic proxy classes. By creating this dynamic proxy, all calls will essentially be intercepted prior to invocation. An attempt will be made to invoke the object in question and, if unable to do so, an interface will need to be defined to handle the missing method scenarios. To give an example<ref>http://www.jroller.com/ie/entry/methodmissing_in_java</ref>:

public class Dynamic implements java.lang.reflect.InvocationHandler {
Object delegate;
public Dynamic(Object delegate){
this.delegate=delegate;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
result = method.invoke(delegate, args);
} catch (InvocationTargetException e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} catch (Exception e) {
result =
((MethodMissing)delegate).methodMissing(method,args);
} finally {

}
if(result==delegate)
result = proxy;

return result;
}
public static T newInstance(Object o,Class... interfaces) {
return (T)java.lang.reflect.Proxy.newProxyInstance(
interfaces[0].getClassLoader(),
interfaces,
new Dynamic(o));
}
}

Here, we define our Proxy class. Note, both an Object and Method are passed in as parameters. When attempting to invoke the method of the given Object, an exception is caught and delegated to a MethodMissing interface, which will also need to be defined.

public interface MethodMissing {
public T methodMissing(Method method,E... args);
}

Now, we define an interface whose methods will need to be implemented in order to handle the missing objects.

public class Ruby implements MethodMissing{
public Object methodMissing(Method method, Object... args) {
System.out.println(method.getName());
return this;
}
public static void main(String[] args){
IDynamic dynamic =
Dynamic.newInstance(new Ruby(), IDynamic.class);
dynamic.meow().woof();
dynamic.woof();

}
}
public interface IDynamic extends MethodMissing{
public IDynamic woof();
public IDynamic meow();
}

Lastly, we create a class that attempts to utilize the MethodMissing construct. As you can see, the Ruby class creates an implementation of the methodMissing() method, choosing to simply reflect the name of the method itself. When the IDynamic class is created, it attempts to run several methods which are never actually defined. Nevertheless, all of these method calls are actually intercepted by our proxy class and called as if there were no issue.

The output of running this class would be:

meow
woof
woof

Compared to Ruby, of course, or even Smalltalk, this is a very difficult way to handle missing methods. Instead of having something built into the class itself, additional interfaces and wrappers are required to handle these scenarios, creating far more bulky and complex code. Unfortunately, this is probably the price for having a statically typed language.

===Python: __getattr__===

In Python, much like Ruby, there is also a built-in class mechanism for handling non-existent methods. Built into a class is __getattr__, which can be used to provide a default for all Python attributes that have not otherwise been defined. In the following example: <ref>http://farmdev.com/src/secrets/magicmethod/index.html#introducing-getattr</ref>

===Perl: AUTOLOAD===

==References==

<references />

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:35:31Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:33:32Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:28:37Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:25:58Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:25:39Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:24:31Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:18:02Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:17:44Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:14:49Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:14:37Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:14:24Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:13:43Z

Japlemmo: /* Java: DynamicProxy */

CSC/ECE 517 Spring 2013/ch1b 1n jp

2013-02-20T20:08:55Z