codemodels-java 0.2.0-java

data/lib/codemodels/java/model_building.rb

@@ -0,0 +1,42 @@
+require 'codemodels'
+require 'codemodels/java/parser'
+
+module CodeModels
+
+module Java
+
+SRC_EXTENSION = 'java'
+
+MODEL_EXTENSION = "#{SRC_EXTENSION}.lm"
+
+MODEL_PRODUCER = Proc.new do |src|
+	root = CodeModels::Java.parse_file(src)	
+end
+
+SERIALIZED_MODEL_PRODUCER = Proc.new do |src|
+	root = CodeModels::Java.parse_file(src)	
+	CodeModels::Serialization.rgenobject_to_model(root)
+end
+
+def self.generate_models_in_dir(src,dest,model_ext=MODEL_EXTENSION,max_nesting=500)
+	CodeModels::ModelBuilding.generate_models_in_dir(src,dest,SRC_EXTENSION,model_ext,max_nesting) do |src|
+		SERIALIZED_MODEL_PRODUCER.call(src)
+	end
+end
+
+def self.generate_model_per_file(src,dest,model_ext=MODEL_EXTENSION,max_nesting=500)
+	CodeModels::ModelBuilding.generate_model_per_file(src,dest) do |src|
+		SERIALIZED_MODEL_PRODUCER.call(src)
+	end
+end
+
+def self.handle_models_in_dir(src,error_handler=nil,model_handler)
+	raise "Unexisting dir given: #{src}" unless File.exist?(src)
+	CodeModels::ModelBuilding.handle_models_in_dir(src,SRC_EXTENSION,error_handler,model_handler) do |src|
+		MODEL_PRODUCER.call(src)
+	end
+end
+
+end
+
+end

data/lib/codemodels/java/parser.rb

@@ -0,0 +1,83 @@
+require 'codemodels'
+
+module CodeModels
+module Java
+
+class << self
+	include ParserWrapper
+end
+
+java_import 'japa.parser.JavaParser'
+java_import 'java.io.FileInputStream'
+java_import 'java.io.ByteArrayInputStream'
+
+def self.containment_pos(node)
+	container = node.eContainer
+	children  = node.eContainer.send(node.eContainingFeature)
+	if children.respond_to?(:each)
+		children.each_with_index do |c,i|
+			return i if c==node
+		end
+		raise "Not found"
+	else
+		raise "Not found" unless children==node
+		0
+	end
+end
+
+# node tree contains the original 
+def self.corresponding_node(model_element,node_tree)
+	return node_tree unless model_element.eContainer
+	corresponding_parent_node = corresponding_node(model_element.eContainer,node_tree)
+	containment_pos = containment_pos(model_element)
+	containing_feat = model_element.eContainingFeature
+
+	children = corresponding_parent_node.send(containing_feat)
+	if children.respond_to?(:each)
+		children[containment_pos]
+	else
+		children
+	end
+end
+
+def self.node_tree_from_code(code)
+	sis = ByteArrayInputStream.new(code.to_java_bytes)
+	node_tree = JavaParser.parse(sis)
+	sis.close
+	node_tree
+end
+
+def self.corresponding_node_from_code(model_element,code)
+	sis = ByteArrayInputStream.new(code.to_java_bytes)
+	node_tree = JavaParser.parse(sis)
+	sis.close
+	corresponding_node(model_element,node_tree)
+end
+
+def self.parse_code(code)	
+	node_to_model(node_tree_from_code(code))
+end
+
+class Parser < CodeModels::Parser
+
+	def parse_code(code)
+		CodeModels::Java.parse_code(code)
+	end
+
+end
+
+DefaultParser = Parser.new
+
+def self.parse_file(path)	
+	DefaultParser.parse_file(path)
+end
+
+private
+
+def self.adapter_specific_class(model_class,ref)
+	return nil unless CodeModels::Java::PROP_ADAPTERS[model_class]
+	CodeModels::Java::PROP_ADAPTERS[model_class][ref.name]
+end
+
+end
+end

data/lib/codemodels/java.rb

@@ -0,0 +1,10 @@
+curr_dir = File.dirname(__FILE__)
+Dir[curr_dir+"/../jars/*.jar"].each do |jar|
+	require jar
+end
+
+require 'codemodels/java/metamodel'
+require 'codemodels/java/parser'
+require 'codemodels/java/model_building'
+require 'codemodels/java/info_extraction'
+require 'codemodels/java/language'

data/test/data/ActionButtonsColumnTag.java

@@ -0,0 +1,100 @@
+package com.technoetic.xplanner.tags.displaytag;
+
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.PageContext;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.displaytag.properties.MediaTypeEnum;
+import org.displaytag.util.TagConstants;
+
+import com.technoetic.xplanner.tags.WritableTag;
+
+
+public class ActionButtonsColumnTag extends org.displaytag.tags.ColumnTag {
+   // TODO: why not use our ColumnTag instead for consistency?
+//public class ActionButtonsColumnTag extends com.technoetic.xplanner.tags.displaytag.ColumnTag 
+   private static Log log = LogFactory.getLog(ActionButtonsColumnTag.class);
+   ActionButtonsTag actionButtonsTag;
+
+   public void setActionButtonsTag(ActionButtonsTag actionButtonsTag)
+   {
+      this.actionButtonsTag = actionButtonsTag;
+   }
+
+    public ActionButtonsColumnTag() {
+        setMedia(MediaTypeEnum.HTML.getName());
+        actionButtonsTag = new ActionButtonsTag();
+        actionButtonsTag.showOnlyActionWithIcon();
+    }
+
+   public void setPageContext(PageContext context)
+   {
+      super.setPageContext(context);
+      actionButtonsTag.setPageContext(context);
+   }
+
+    public void setId(String s)
+    {
+        this.id = s;
+        actionButtonsTag.setId(s);
+    }
+
+   public String getName() {
+        return actionButtonsTag.getName();
+    }
+
+    public void setName(String name) {
+       actionButtonsTag.setName(name);
+    }
+
+    public String getScope() {
+        return actionButtonsTag.getScope();
+    }
+
+    public void setScope(String scope) {
+       actionButtonsTag.setScope(scope);
+    }
+
+    public int doStartTag() throws JspException {
+        try {
+            WritableTag parentTable = (WritableTag) this.getParent();
+            if (!parentTable.isWritable()) {
+                return SKIP_BODY;
+            }
+            if (!getAttributeMap().containsKey(TagConstants.ATTRIBUTE_NOWRAP))
+                getAttributeMap().put(TagConstants.ATTRIBUTE_NOWRAP, "true");
+
+            int status = super.doStartTag();
+            if (status != SKIP_BODY) {
+               return actionButtonsTag.doStartTag();
+            }
+            return status;
+        } catch (Exception e) {
+            throw new JspException(e);
+        }
+    }
+
+
+   public int doAfterBody() throws JspException {
+       return actionButtonsTag.doAfterBody();
+    }
+
+    public int doEndTag() throws JspException {
+        actionButtonsTag.doEndTag();
+        try {
+            WritableTag parentTable = (WritableTag) this.getParent();
+            if (!parentTable.isWritable()) {
+                return SKIP_BODY;
+            } else {
+                return super.doEndTag();
+            }
+        } catch (Exception e) {
+            throw new JspException(e);
+        }
+    }
+
+    public void release() {
+      actionButtonsTag.release();
+    }
+}

data/test/data/AuthConstraint.java

@@ -0,0 +1,17 @@
+package com.technoetic.xplanner.security.config;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class AuthConstraint {
+    private List<String> roleNames = new ArrayList<String>();
+
+    public void addRoleName(String roleName) {
+        roleNames.add(roleName);
+    }
+
+    public Collection<String> getRoleNames() {
+        return roleNames;
+    }
+}

data/test/data/CsvExporter.java

@@ -0,0 +1,58 @@
+package com.technoetic.xplanner.export;
+
+
+import java.io.ByteArrayOutputStream;
+
+import javax.servlet.ServletResponseWrapper;
+import javax.servlet.http.HttpServletResponse;
+
+import org.hibernate.classic.Session;
+
+public class CsvExporter implements Exporter {
+
+	private String encoding = "UTF-8";
+	
+	private String delimiter = ";";
+	
+	public void setEncoding(String encoding) {
+		this.encoding = encoding;
+	}
+
+	public void setDelimiter(String delimiter) {
+		this.delimiter = delimiter;
+	}
+
+	public String getFileExtension() {
+		return "csv";
+	}
+	
+	@Override
+	public byte[] export(Session session, Object object) throws ExportException {
+		ByteArrayOutputStream data = new ByteArrayOutputStream();
+		return data.toByteArray();
+//		for (Object item : items) {
+//			BeanWrapperImpl wrapper = new BeanWrapperImpl(item);
+//			String[] properties = {"", ""};
+//			for (String property : properties ) {
+//				Object value = wrapper.getPropertyValue(property);
+//				if (value instanceof Collection) {
+//					Iterator<?> it = ((Collection<?>) value).iterator();
+//					while (it.hasNext()) {
+//						out.print(it.next());
+//						out.print(' ');
+//					}
+//				}
+//				else if (value != null) {
+//					out.print(value);
+//				}
+//				out.print(delimiter);
+//			}
+//			out.println();
+		}
+
+	@Override
+	public void initializeHeaders(HttpServletResponse response) {
+		response.setContentType("text/csv; charset=" + encoding);
+//		response.setCharacterEncoding(encoding);
+	}
+}

data/test/data/ReorderStoriesForm.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2006 Your Corporation. All Rights Reserved.
+ */
+
+package com.technoetic.xplanner.forms;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.struts.action.ActionErrors;
+import org.apache.struts.action.ActionMapping;
+
+/**
+ * Created by IntelliJ IDEA.
+ * User: SG0897500
+ * Date: Mar 6, 2006
+ * Time: 11:58:37 AM
+ * To change this template use File | Settings | File Templates.
+ */
+public class ReorderStoriesForm extends AbstractEditorForm {
+
+   public static final String INVALID_ORDER_NUMBER = "story.editor.invalid.order.number";
+   private List<String> storyIds = new ArrayList<String>();
+   private List<String> orderNos = new ArrayList<String>();
+   private String iterationId;
+
+   @Override
+public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
+      ActionErrors errors = new ActionErrors();
+      if (orderNos != null) {
+         for (Iterator<String> iterator = orderNos.iterator(); iterator.hasNext();) {
+            String orderValue = iterator.next();
+            try {
+               Double.parseDouble(orderValue);
+            } catch (NumberFormatException e) {
+               error(errors, INVALID_ORDER_NUMBER, new Object[] {orderValue});
+            }
+         }
+      }
+      return errors;
+   }
+
+   public List<String> getStoryIds() {
+      return storyIds;
+   }
+
+   public void setStoryIds(List<String> storyIds) {
+      this.storyIds = storyIds;
+   }
+
+   public void setStoryId(int index, String storyId) {
+       ensureSize(storyIds, index + 1);
+       storyIds.set(index, storyId);
+   }
+
+   public String getStoryId(int index) {
+       return storyIds.get(index);
+   }
+
+   public int getStoryIdAsInt(int index) {
+       return Integer.parseInt(getStoryId(index));
+   }
+
+   public int getStoryCount() {
+       return storyIds.size();
+   }
+
+   public List<String> getOrderNos() {
+      return orderNos;
+   }
+
+   public void setOrderNos(List<String> orderNos) {
+      this.orderNos = orderNos;
+   }
+
+   public void setOrderNo(int index, String orderNo) {
+       ensureSize(orderNos, index + 1);
+       orderNos.set(index, orderNo);
+   }
+
+   public String getOrderNo(int index) {
+       return orderNos.get(index);
+   }
+
+   public int getOrderNoAsInt(int index) {
+       return (int) Double.parseDouble(getOrderNo(index));
+   }
+
+   public String getIterationId() {
+      return iterationId;
+   }
+
+   public void setIterationId(String iterationId) {
+      this.iterationId = iterationId;
+   }
+
+}

data/test/data/TestIteration.java

@@ -0,0 +1,192 @@
+package com.technoetic.xplanner.domain;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import junit.framework.TestCase;
+import net.sf.xplanner.domain.Iteration;
+import net.sf.xplanner.domain.Task;
+import net.sf.xplanner.domain.TimeEntry;
+import net.sf.xplanner.domain.UserStory;
+
+public class TestIteration extends TestCase {
+    Iteration iteration = new Iteration();
+
+    public void testGetActualHoursWithNoStories() throws Exception {
+        assertEquals(0.0d, iteration.getCachedActualHours(),0.0);
+    }
+
+    public void testGetEstimatedHoursWithNoStories() throws Exception {
+        assertEquals(0.0d, iteration.getEstimatedHours(),0.0);
+    }
+
+    public void testGetAdjustedEstimatedHoursWithNoStories() throws Exception {
+        assertEquals(0.0d, iteration.getAdjustedEstimatedHours(),0.0);
+    }
+
+    public void testGetRemainingHours() throws Exception {
+        assertEquals(0.0d, iteration.getTaskRemainingHours(),0.0);
+    }
+
+    public void testGetEstimatedOriginalHours() throws Exception {
+      assertEquals(0.0d, iteration.getTaskEstimatedOriginalHours(),0.0);
+        List<UserStory> stories = new ArrayList<UserStory>();
+        UserStory story = new UserStory();
+        //start iteration
+        story.setEstimatedOriginalHours(new Double(10.0));
+        stories.add(story);
+        List<Task> tasks = new ArrayList();
+        Task task = new Task();
+        task.setUserStory(story);
+        task.setEstimatedOriginalHours(3);
+        tasks.add(task);
+        story.setTasks(tasks);
+        iteration.setUserStories(stories);
+      assertEquals(3.0d, iteration.getTaskEstimatedOriginalHours(),0.0);
+        task.setDisposition(TaskDisposition.ADDED);
+      assertEquals(0.0d, iteration.getTaskEstimatedOriginalHours(),0.0);
+    }
+
+    public void testGetOverestimatedHours() throws Exception {
+        Iteration iteration = setUpTestIteration();
+        assertEquals(7.0d, iteration.getTaskOverestimatedHours(),0.0);
+    }
+
+    public void testGetOverestimatedOriginalHours() throws Exception {
+        Iteration iteration = setUpTestIteration();
+        assertEquals(4.0d, iteration.getOverestimatedOriginalHours(),0.0);
+    }
+
+    public void testGetUnderestimatedHours() throws Exception {
+        Iteration iteration = setUpTestIteration();
+        assertEquals(1.0d, iteration.getTaskUnderestimatedOriginalHours(),0.0);
+    }
+
+   public void testGetUnderestimatedOriginalHours() throws Exception {
+        Iteration iteration = setUpTestIteration();
+        assertEquals(1.0d, iteration.getUnderestimatedOriginalHours(),0.0);
+    }
+
+   public void testGetAddedHours() throws Exception {
+        Iteration iteration = setUpTestIteration();
+        assertEquals(5.0d, iteration.getEstimatedHoursOfAddedTasks(),0.0);
+    }
+
+   public void testGetAddedOrDiscoveredOriginalHours() throws Exception {
+        Iteration iteration = setUpTestIteration();
+        assertEquals(5.0d, iteration.getAddedOriginalHours(),0.0);
+    }
+
+   public void testGetPostponedHours() throws Exception {
+        Iteration iteration = setUpTestIteration();
+        assertEquals(2.0d, iteration.getPostponedHours(),0.0);
+    }
+
+   public void testIsFuture() throws Exception
+    {
+        Iteration iteration = new Iteration();
+        iteration.setStartDate(new Date(System.currentTimeMillis() - 7200000));
+        assertFalse(iteration.isFuture());
+        iteration.setStartDate(new Date(System.currentTimeMillis() + 7200000));
+        assertTrue(iteration.isFuture());
+    }
+
+   public void testIsActive() throws Exception
+    {
+        Iteration iteration = new Iteration();
+        iteration.setIterationStatus(IterationStatus.INACTIVE);
+        assertFalse(iteration.isActive());
+    }
+
+   public void testIsCurrent() throws Exception
+    {
+        Iteration iteration = new Iteration();
+        iteration.setStartDate(new Date(System.currentTimeMillis() - 2000));
+        iteration.setEndDate(new Date(System.currentTimeMillis() - 1000));
+        assertFalse("Past iteration", iteration.isCurrent());
+        iteration.setStartDate(new Date(System.currentTimeMillis() - 1000));
+        iteration.setEndDate(new Date(System.currentTimeMillis() + 1000));
+        assertTrue("Current iteration", iteration.isCurrent());
+        iteration.setStartDate(new Date(System.currentTimeMillis() + 1000));
+        iteration.setEndDate(new Date(System.currentTimeMillis() + 2000));
+        assertFalse("Future iteration", iteration.isCurrent());
+    }
+
+   public void testGetCompletedOriginalHours() throws Exception {
+      Iteration iteration = setUpTestIteration();
+      assertEquals(9.0, iteration.getCompletedOriginalHours(), 0.0);
+   }
+
+   public void testGetCompletedHours() throws Exception {
+      Iteration iteration = setUpTestIteration();
+      assertEquals(6.0, iteration.getTaskActualCompletedHours(), 0.0);
+   }
+
+   private Iteration setUpTestIteration() throws Exception {
+      Iteration iteration = new Iteration();
+      iteration.setIterationStatus(IterationStatus.INACTIVE);
+
+      List tasks1 = new ArrayList();
+      List tasks2 = new ArrayList();
+      ArrayList twoHourTimeEntry = getTimeEntriesForDurationInHours(2);
+
+      UserStory story1 = new UserStory();
+      story1.setDisposition(StoryDisposition.ADDED);
+      story1.setEstimatedOriginalHours(new Double(10.0));
+
+      UserStory story2 = new UserStory();
+      story2.setDisposition(StoryDisposition.CARRIED_OVER);
+      story2.setPostponedHours(2.0d);
+      story2.setEstimatedOriginalHours(new Double(10.0));
+
+      Task task1 = new Task();
+      task1.setEstimatedHours(1.0);
+      task1.setTimeEntries(twoHourTimeEntry);
+      task1.setUserStory(story1);
+      tasks1.add(task1);
+
+      tasks2.add(createTask(4.0d, twoHourTimeEntry, TaskDisposition.PLANNED, story2));
+      tasks2.add(createTask(4.0d, twoHourTimeEntry, TaskDisposition.DISCOVERED, story2));
+
+      story1.setTasks(tasks1);
+
+      story2.setTasks(tasks2);
+
+      List userStories = new ArrayList();
+      userStories.add(story1);
+      userStories.add(story2);
+      iteration.setUserStories(userStories);
+      iteration.start();
+      task1.setEstimatedHours(5.0);
+      task1.setCompleted(true);
+      task1.setDisposition(TaskDisposition.ADDED);
+      return iteration;
+   }
+
+   private Task createTask(double estimatedHours, ArrayList twoHourTimeEntry, TaskDisposition disposition) {
+      Task task2 = new Task();
+      task2.setEstimatedHours(estimatedHours);
+      task2.setTimeEntries(twoHourTimeEntry);
+      task2.setCompleted(true);
+      task2.setDisposition(disposition);
+      return task2;
+   }
+
+   private Task createTask(double estimatedHours, ArrayList twoHourTimeEntry, TaskDisposition disposition, UserStory story) {
+      Task task2 = createTask(estimatedHours, twoHourTimeEntry, disposition);
+      task2.setUserStory(story);
+      return task2;
+   }
+
+   private ArrayList getTimeEntriesForDurationInHours(int duration) {
+      long now = new Date().getTime();
+      TimeEntry timeEntry = new TimeEntry();
+      timeEntry.setStartTime(new Date(now - 7200000));
+      timeEntry.setEndTime(new Date(now));
+      timeEntry.setDuration(duration);
+      ArrayList timeEntries = new ArrayList();
+      timeEntries.add(timeEntry);
+      return timeEntries;
+   }
+}