cadove 0.1

data/CHANGELOG

@@ -0,0 +1,3 @@
+0.0.0
+=====
+Original release.

data/README

@@ -0,0 +1,34 @@
+caDOVe (Domain Object Verifier)
+===============================
+
+About
+-----
+caDOVe helps with checking if a Java code base and a UML model
+of the domain objects are in sync.  This is especially useful for
+verifying the silver level compatibility requirement,
+"bla bla bla bla bla".
+
+Currently...
+  - only Hibernate annotated Java classes.
+  - only XMI representations of UML are supported.
+
+Installation
+------------
+  1. Install the RJB rubygem (http://rjb.rubyforge.org/)
+  2. Set JAVA_HOME in your environment
+
+Usage Example
+-------------
+require 'cadove'
+
+CaDOVe.configure do
+  left 'nbia.xmi'
+  right 'nbia/domain'
+  
+  ignore_classes %w(Boolean Date Double Integer Long String)
+  
+  matching_classes(
+    :Image => :CTImage
+  )
+end.class_comparison.attribute_comparison
+

data/lib/cadove.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/cadove/models'
+
+module CaDOVe
+  class << self
+    attr_writer :left, :right, :ignore_classes, :matching_classes
+    
+    def configure(&block)
+      Configurator.module_eval &block
+      self
+    end
+    
+    ###### CONFIGURATION PROPERTY ACCESSORS
+    %w(left right).each do |attribute|
+      required_accessor = <<-EOS
+        def #{attribute}
+          raise ConfigurationError.new("Bcsec::#{attribute} not set") unless @#{attribute}
+          @#{attribute}
+        end
+      EOS
+      class_eval(required_accessor)
+    end
+    
+    def ignore_classes
+      @ignore_classes ||= []
+    end
+    
+    def matching_classes
+      @matching_clases ||= {}
+    end
+    
+    def class_comparison
+      Reports::ClassReport.new(comparison, left_type, right_type).display
+      self
+    end
+    
+    def attribute_comparison
+      Reports::AttributeReport.new(comparison, left_type, right_type).display
+      self
+    end
+    
+    protected
+    def left_representation
+      @left_representation ||= xmi?(left) ? XMI::XMIDocument.new(left) : Java::JavaSourceTree.new(left)
+    end
+    
+    def right_representation
+      @right_representation ||= xmi?(right) ? XMI::XMIDocument.new(right) : Java::JavaSourceTree.new(right)
+    end
+    
+    def comparison
+      @comparison ||= Analytics::Comparison.new(
+        left_representation.hashify, 
+        right_representation.hashify, 
+        :ignore_classes => @ignore_classes, 
+        :matching_classes => @matching_classes
+      )
+    end
+    
+    def xmi?(path)
+      path =~ /.*\.xmi$/i
+    end
+    
+    %w(left right).each do |side|
+      type_accessor = <<-EOS
+        def #{side}_type
+          xmi?(#{side}) ? :xmi : :java
+        end
+      EOS
+      class_eval(type_accessor)
+    end
+  end
+    
+  module Configurator
+    class << self
+      #########
+      protected
+
+      SIMPLE_TERMS = %w(left right ignore_classes matching_classes)
+
+      # DSL terms for simple top-level attributes
+      SIMPLE_TERMS.each do |attribute|
+        simple_setter = <<-EOS
+          def #{attribute}(value)
+            CaDOVe.#{attribute} = value
+          end
+        EOS
+        class_eval(simple_setter)
+      end
+    end
+  end
+  class ConfigurationError < Exception; end
+end

data/lib/cadove/models.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+
+Dir[File.dirname(__FILE__) + "/models/**/*.rb"].each do |model_file|
+  require model_file
+end

data/lib/cadove/models/XMI/document.rb

@@ -0,0 +1,143 @@
+require 'rexml/document'
+require File.dirname(__FILE__) + '/../helpers'
+
+module CaDOVe
+  module XMI
+    class XMIDocument
+      def initialize(input, opts = {})
+        opts[:input_type] ||= :file_path
+        val = 
+          if opts[:input_type] == :text
+            input
+          elsif opts[:input_type] == :file_path
+            File.new(input)
+          end
+        
+        @xml_doc = REXML::Document.new(val)
+      end
+    
+      def classes
+        package = UMLPackage.logical_model(@xml_doc) || UMLPackage.all(@xml_doc).first
+        raise "No packages found in the XMI document" unless package
+        @classes ||= package.classes
+      end
+      
+      def hashify
+        all = {}
+        classes.each do |clazz|
+          all.merge!(clazz.hashify)
+        end
+        all
+      end
+    end
+  
+    class UMLPackage
+      def initialize(xml)
+        @xml = xml
+        @name = name
+      end
+    
+      # def self.logical_model(xml)
+      #   packages = all(xml)
+      #   logical = packages.size == 1 ? packages : packages.select{|p| p.name =~ /Logical Model/i}
+      #   logical.first
+      # end
+    
+      def self.all(xml)
+        xml.elements.collect('.//UML:Package') do |p|
+          new(p)
+        end
+      end
+    
+      def self.method_missing(name, *args)
+        package_name = name.to_s.gsub(/_/, ' ')
+        all(args[0]).select{|p| p.name =~ /#{package_name}/i}.first      
+      end
+    
+      def name
+        @name ||= @xml.attributes['name']
+      end
+    
+      def classes
+        UMLClass.all(@xml)
+      end
+    end
+  
+    class UMLClass
+      def initialize(xml)
+        @xml = xml
+      end
+    
+      def self.all(xml)
+        xml.elements.collect('.//UML:Class') do |c|
+          new(c)
+        end
+      end
+
+      def name
+        @name ||= @xml.attributes['name']
+      end
+      
+      def hashify
+        field_and_type = attributes.collect{|f| [f.name, f.type] }
+        {"#{name}" => field_and_type}
+      end
+    
+      def attributes
+        @attributes ||= UMLAttribute.all(@xml)
+      end
+    
+      def associations
+        @associations ||= UMLAssociation.all(@xml, name)
+      end
+    end
+  
+    class UMLAttribute
+      include CaDOVe::Helpers
+    
+      def initialize(xml)
+        @xml = xml
+      end
+    
+      def self.all(class_element)
+        class_element.elements.collect('.//UML:Attribute') do |a|
+          new(a)
+        end
+      end
+    
+      def name
+        @name ||= @xml.attributes['name']
+      end
+    
+      def type
+        @type ||= remove_package_name(REXML::XPath.first(@xml, ".//UML:TaggedValue[@tag='type']").attributes['value'])
+      end
+    
+      def key
+        "#{name} (#{type})"
+      end
+    end
+  
+    class UMLAssociation
+      def initialize(xml)
+        @xml = xml
+      end
+    
+      def self.all(class_element, class_name)
+        class_element.root.elements.collect("//UML:Association") do |a|
+          if REXML::XPath.first(a, ".//UML:TaggedValue[@tag='ea_sourceName']") && REXML::XPath.first(a, ".//UML:TaggedValue[@tag='ea_sourceName']").attributes['value'] == class_name
+            new(a)
+          end
+        end.compact
+      end
+    
+      def name
+        REXML::XPath.first(@xml, ".//UML:TaggedValue[@tag='ea_targetName']").attributes['value']
+      end
+    
+      def key
+        "#{name} (#{type})"
+      end
+    end
+  end
+end

data/lib/cadove/models/analytics/comparison.rb

@@ -0,0 +1,155 @@
+module CaDOVe
+  module Analytics
+    class Comparison
+      def initialize(left, right, opts={})
+        @left = left
+        @right = right
+        @opts = opts
+      end
+    
+      def classes
+        @classes ||= ClassMatch.all(@left, @right, @opts)
+      end
+      
+      def intersecting_classes
+        @intersecting_classes ||= classes.select{|c| c.intersecting_class? }
+      end
+    end
+  
+    class ClassMatch
+      def initialize(key, left_attributes, right_attributes)
+        @key = key
+        @left_attributes = left_attributes
+        @right_attributes = right_attributes
+      end
+      attr_reader :key
+      
+      # TODO: Clean this mess up
+      def self.all(left, right, opts={})
+        opts ||= {}
+        ignore_classes = opts[:ignore_classes] || []
+        matching_classes = opts[:matching_classes] || {}
+        
+        left_keys = left.keys.reject{|k| ignore_classes.include?(k)}
+        right_keys = right.keys.reject{|k| ignore_classes.include?(k)}
+        ClassMatchKey.align(left_keys, right_keys, matching_classes).collect do |key|
+          ClassMatch.new(
+            key,
+            left["#{key.left}"],
+            right["#{key.right}"]
+          )
+        end
+      end
+        
+      def attributes
+        @attributes ||= AttributeMatch.all(@left_attributes, @right_attributes)
+      end
+      
+      def left_match?
+        !@left_attributes.nil?
+      end
+      
+      def right_match?
+        !@right_attributes.nil?
+      end
+      
+      def intersecting_class?
+        left_match? && right_match?
+      end
+    end
+    
+    class ClassMatchKey
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+      attr_reader :left, :right
+      
+      def self.align(left_keys, right_keys, override={})
+        override = override.with_indifferent_access
+
+        matches = []
+        left_keys.each do |left_key|
+          found =
+            if m = override_match(left_key, right_keys, override)
+              right_keys.delete(m)
+            elsif right_keys.include?(left_key)
+              right_keys.delete(left_key)
+            end
+
+            matches << new(left_key, found)
+        end
+        
+        right_keys.each do |right_key|
+          matches << new(nil, right_key)
+        end
+        
+        matches.sort
+      end
+      
+      def self.override_match(left_key, right_keys, override={})
+        if override.has_key?(left_key) && right_keys.include?(override[left_key].to_s)
+          override[left_key].to_s
+        elsif override.invert.has_key?(left_key) && right_keys.include?(override.invert[left_key].to_s)
+          override.invert[left_key].to_s
+        end
+      end
+      
+      def <=>(other)
+        display <=> other.display
+      end
+      
+      def display
+        return if left.nil? && right.nil?
+        
+        if left && right.nil?
+          left
+        elsif right && left.nil?
+          right
+        elsif left == right
+          left
+        elsif left != right
+          "#{left} => #{right}"
+        end
+      end
+    end
+    
+    class AttributeMatch
+      def initialize(name, type, left_match, right_match)
+        @name = name
+        @type = type
+        @left_match = left_match
+        @right_match = right_match
+      end
+      
+      def self.all(left_attributes, right_attributes)
+        combined = (left_attributes | right_attributes).sort{|a,b|a[0] <=> b[0]} # Sort by name
+
+        combined.collect do |name, type|
+          AttributeMatch.new( 
+            name, 
+            type,
+            left_attributes.include?( [name, type] ),
+            right_attributes.include?( [name, type] )
+          )
+        end
+      end
+      
+      def key
+        [@name, @type]
+      end
+      
+      def left_match?
+        @left_match
+      end
+      
+      def right_match?
+        @right_match
+      end
+      
+      def display
+        "#{@name} (#{@type})"
+      end
+    end
+  end
+end

data/lib/cadove/models/helpers.rb

@@ -0,0 +1,7 @@
+module CaDOVe
+  module Helpers
+    def remove_package_name(fully_qualified)
+      fully_qualified.sub(/.*\./ , '')
+    end
+  end
+end

data/lib/cadove/models/indifferent_access.rb

@@ -0,0 +1,149 @@
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+
+class HashWithIndifferentAccess < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # Assigns a new value to the hash:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:key] = "value"
+  #
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # Updates the instantized hash with values from the second:
+  # 
+  #   hash_1 = HashWithIndifferentAccess.new
+  #   hash_1[:key] = "value"
+  # 
+  #   hash_2 = HashWithIndifferentAccess.new
+  #   hash_2[:key] = "New Value!"
+  # 
+  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+  # 
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # Checks the hash for a key matching the argument passed in:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash["key"] = "value"
+  #   hash.key? :key  # => true
+  #   hash.key? "key" # => true
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # Fetches the value for the specified key, same as doing hash[key]
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # Returns an exact copy of the hash.
+  def dup
+    HashWithIndifferentAccess.new(self)
+  end
+
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+  # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+  def reverse_merge(other_hash)
+    super other_hash.with_indifferent_access
+  end
+  
+  def invert
+    super.with_indifferent_access
+  end
+
+  # Removes a specified key from the hash.
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+  def to_options!; self end
+
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        value.with_indifferent_access
+      when Array
+        value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+      else
+        value
+      end
+    end
+end
+
+module CaDOVe #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module IndifferentAccess #:nodoc:
+        def with_indifferent_access
+          hash = HashWithIndifferentAccess.new(self)
+          hash.default = self.default
+          hash
+        end
+      end
+    end
+  end
+end
+
+Hash.send(:include, CaDOVe::CoreExtensions::Hash::IndifferentAccess)

data/lib/cadove/models/java/code.rb

@@ -0,0 +1,108 @@
+require 'rjb'
+require File.dirname(__FILE__) + '/../helpers'
+
+module CaDOVe
+  module Java
+    Rjb::load(File.dirname(__FILE__) + '/javalib/qdox-1.10.jar')
+    
+    class JavaSourceTree
+      def initialize(directory)
+        file = Rjb::import('java.io.File').
+                 new_with_sig('Ljava.lang.String;', directory)
+
+        builder = Rjb::import('com.thoughtworks.qdox.JavaDocBuilder').new
+        builder._invoke('addSourceTree', 'Ljava.io.File;', file)
+      
+        @sources = builder.getSources
+      end
+    
+      def classes      
+        JavaClass.all(@sources)
+      end
+      
+      def hashify
+        all = {}
+        classes.each do |clazz|
+          all.merge!(clazz.hashify)
+        end
+        all
+      end
+    end
+  
+    class JavaClass
+      def initialize(clazz)
+        @clazz = clazz
+      end
+    
+      def self.all(sources, including_abstract=false)
+        classes = sources.collect { |s| s.getClasses }.flatten
+        results = classes.collect { |c| new(c) }
+      end
+    
+      def name
+        @name ||= @clazz.getName
+      end
+    
+      def hashify
+        field_and_type = fields.collect{|f| [f.name, f.type] }
+        {"#{name}" => field_and_type}
+      end
+    
+      def fields
+        JavaField.all_non_associated(@clazz)
+      end
+      alias_method :attributes, :fields
+    end
+
+
+    class JavaField
+      include CaDOVe::Helpers
+      def initialize(field)
+        @field = field
+      end
+
+      def self.all(clazz)
+        clazz.getFields.collect do |field|
+          new(field)
+        end.reject{|f| is_constant?(f.name) }
+      end
+    
+      def self.all_non_associated(clazz)
+        all(clazz).select{|f| is_simple_type(f.type) }
+      end
+    
+      def self.is_simple_type(class_name)
+        java_lang_and_other = %w(Boolean Byte Character Double Float Integer Long Math Number Short String Date Timestamp)
+        primitives = %w(boolean byte char double float integer long short)
+        result |= java_lang_and_other.include?(class_name)
+        result |= primitives.include?(class_name)
+        result
+      end
+      
+      def self.is_constant?(name)
+        name =~ /^([A-Z]|_)+$/
+      end
+    
+      def name
+        @name ||= @field.getName
+      end
+    
+      def type
+       @type ||= remove_package_name(@field.getType.getValue)
+      end
+    
+      def ==(other)
+        return true if self.equal?(other)
+        return false if self.class != Java::JavaMethod
+      
+        if (self.name != other.name)
+          return false
+        elsif (self.type != other.type)
+          return false
+        end
+      
+        true
+      end
+    end
+  end
+end

data/lib/cadove/models/reports/reports.rb

@@ -0,0 +1,60 @@
+# TODO: Move these into a plain text file
+module CaDOVe
+  module Reports
+    class ClassReport
+      def initialize(comparison, left_type, right_type)
+        @comparison = comparison
+        @left_type = left_type
+        @right_type = right_type
+      end
+      
+      def display
+        puts Time.new.strftime('%b %d, %Y %H:%M:%S %Z')
+        puts "\n"
+        puts "  #{header(@left_type)}   |   #{header(@right_type)}  | Class Name"
+        puts "--------------------------------"
+        @comparison.classes.each do |clazz|
+          puts "   #{clazz.left_match? ? 'X' : ' '}    |    #{clazz.right_match? ? 'X' : ' '}    | #{clazz.key.display}"
+        end
+      end
+      
+      def header(name)
+        name.to_s.upcase
+      end
+    end
+    
+    class AttributeReport
+      def initialize(comparison, left_type, right_type)
+        @comparison = comparison
+        @left_type = left_type
+        @right_type = right_type
+      end
+      
+      def display
+        puts Time.new.strftime('%b %d, %Y %H:%M:%S %Z')
+        puts "\n"
+
+        puts "########################"
+        @comparison.intersecting_classes.each do |clazz|
+          unless clazz.attributes.empty?
+            puts ""
+            puts "#{clazz.key.display}"
+            puts ""
+            puts "  #{header(@left_type)}   |   #{header(@right_type)}   | Attributes"
+            puts "--------------------------------------"
+
+            clazz.attributes.each do |a|
+              puts "   #{a.left_match? ? 'X' : ' '}    |    #{a.right_match? ? 'X' : ' '}     | #{a.display}"  
+            end
+            puts ""
+            puts "########################"  
+          end
+        end
+      end
+      
+      def header(name)
+        name.to_s.upcase
+      end
+    end
+  end
+end

data/spec/cadove_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe CaDOVe do
+  it "should configure the left and right properties" do
+    CaDOVe.configure do
+      left 'hello'
+      right 'world'
+    end
+      
+    CaDOVe.left.should == 'hello'
+    CaDOVe.right.should == 'world'
+  end
+  
+  it "should throws an exception if a required configuration option is accessed without being set" do
+    CaDOVe.left = nil
+    lambda { CaDOVe.left }.should raise_error(CaDOVe::ConfigurationError)
+  end
+end

data/spec/java_stubs/org/foo/Animal.java

@@ -0,0 +1,3 @@
+package org.foo;
+
+abstract class Animal {}

data/spec/java_stubs/org/foo/Cat.java

@@ -0,0 +1,3 @@
+package org.foo;
+
+class Cat { }

data/spec/java_stubs/org/foo/Dog.java

@@ -0,0 +1,18 @@
+package org.foo;
+
+class Dog {
+  String color;
+  boolean rabid;
+  Father father;
+  List<Enemies> enemies;
+  
+  public String getColor(){}
+  public boolean isRabid(){}
+    
+  public Father getFather() {}
+  public List<Enemies> getEnemies() {}
+  
+  public String setIgnoreSetters(){}
+  private String getIgnorePrivateMethods(){}
+  protected String getIgnoreProtectedMethods(){}
+}

data/spec/models/XMI/document_spec.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module CaDOVe::XMI
+  describe UMLClass do
+    before(:each) do
+      @xmi =
+        xmi_document do
+          uml_package('Data Model') do
+            uml_class('DontFindMe')
+          end +
+          uml_package('Logical Model') do
+            uml_class('Dog') do
+              uml_attribute('color', 'String') +
+              uml_attribute('rabid', 'boolean')
+            end +
+            uml_class('Cat')
+          end +
+          
+          uml_association('Dog', 'Friend') +
+          uml_association('Dog', 'Enemy')
+        end
+      
+      @doc = XMIDocument.new(@xmi, :input_type => :text)
+      @dog = @doc.classes.select{ |c| c.name == 'Dog' }.first
+    end
+    
+    it "should have two classes in the document" do
+      classes = @doc.classes
+      @doc.should have(2).classes
+    end
+    
+    it "should include the class Cat and Dog" do
+      names = @doc.classes.collect { |c| c.name }
+      names.should include("Cat")
+      names.should include("Dog")      
+    end
+    
+    it "should have the correct attributes for Dog" do
+      @dog.should have(2).attributes
+      names = @dog.attributes.collect { |c| [c.name, c.type] }
+      names.should include( %w(color String) )
+      names.should include( %w(rabid boolean) )
+    end
+    
+    it "should have the correct correct associations for Dog" do
+      @dog.should have(2).associations
+      names = @dog.associations.collect { |c| c.name }
+      names.should include('Friend')
+      names.should include('Enemy')      
+    end
+    
+    it "should return the only model available if only one exists" do
+      single_pkg_xmi = 
+        xmi_document do
+          uml_package('My Package') do
+            uml_class('Foo')
+          end
+        end
+      
+      single_pkg_doc = XMIDocument.new(single_pkg_xmi, :input_type => :text)
+      single_pkg_doc.should have(1).classes
+    end
+    
+    it "should hashify dog" do
+      doggy_hash = @dog.hashify
+      doggy_hash['Dog'].should include( %w(color String) )
+      doggy_hash['Dog'].should include( %w(rabid boolean) )
+    end
+    
+    it "should hashify the document tree" do
+      @doc.hashify.keys.should include('Cat')
+      @doc.hashify.keys.should include('Dog')
+
+      @doc.hashify['Dog'].should include( %w(color String) )
+      @doc.hashify['Dog'].should include( %w(rabid boolean) )
+    end
+    
+    private
+    def xmi_document(&block)
+      <<-XMI
+        <xmi:XMI xmlns:UML="http://schema.omg.org/spec/UML/2.0" xmlns:xmi="http://schema.omg.org/spec/XMI/2.1">
+          #{yield if block_given?}
+        </xmi:XMI>
+      XMI
+    end
+    
+    def uml_package(name, &block)
+      <<-XMI 
+        <UML:Package name="#{name}">
+          #{yield if block_given?}
+        </UML:Package>
+      XMI
+    end
+    
+    def uml_class(name, &block)
+      <<-XMI 
+        <UML:Class name='#{name}'>
+          #{yield if block_given?}
+        </UML:Class>
+      XMI
+    end
+    
+    def uml_attribute(name, type)
+      <<-XMI
+        <UML:Attribute name='#{name}' visibility='private'>
+          <UML:ModelElement.taggedValue>
+            <UML:TaggedValue tag='foo' value='bar'/>
+            <UML:TaggedValue tag='type' value='#{type}'/>
+            <UML:TaggedValue tag='derived' value='0'/>
+          </UML:ModelElement.taggedValue>
+        </UML:Attribute>
+      XMI
+    end
+    
+    def uml_association(src, dst)
+      <<-XMI
+        <UML:Association visibility='public'>
+          <UML:ModelElement.taggedValue>
+            <UML:TaggedValue tag='style' value='3'/>
+            <UML:TaggedValue tag='ea_sourceName' value='#{src}'/>
+            <UML:TaggedValue tag='ea_targetName' value='#{dst}'/>
+          </UML:ModelElement.taggedValue>
+        </UML:Association>
+      XMI
+    end
+  end
+end

data/spec/models/analytics/comparison_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module CaDOVe::Analytics
+  describe Comparison do
+    before(:each) do
+      @left = {
+        'Dog' => [
+          %w(name String),
+          %w(rabid boolean)
+        ]
+      }
+      
+      @right = {
+        'Dog' => [
+          %w(name String),
+          %w(color String)
+        ],
+        'Rabbit' => [ %w(color String) ]
+      }
+      
+      @comparison = Comparison.new(@left, @right)
+      @dog = @comparison.classes.select{|c| c.key.left == 'Dog' }.first
+    end
+    
+    it "should have two class" do
+      @comparison.should have(2).classes
+      @comparison.classes.collect{|c| [c.key.left, c.key.right]}.should == [
+        ['Dog', 'Dog'],
+        [nil, 'Rabbit']
+      ]
+    end
+
+    it "should have a left and right match" do
+      @dog.should be_left_match
+      @dog.should be_right_match
+    end
+
+    
+    it "should have one intersecting class" do
+      @comparison.should have(1).intersecting_classes
+      @comparison.intersecting_classes.collect{|c| [c.key.left, c.key.right]}.should == [['Dog', 'Dog']]
+    end
+    
+    it "should have a dog match with 3 attributes" do
+      keys = @dog.attributes.collect{|a| a.key}
+      keys.should include( %w(name String)  )
+      keys.should include( %w(rabid boolean))
+      keys.should include( %w(color String) )
+    end
+    
+    it "should have a dog match having an 'name' attribute having a left and right match" do
+      name = @dog.attributes.select{|a| a.key[0] == 'name'}.first
+      name.should be_left_match
+      name.should be_right_match
+    end
+    
+    it "should have a dog match having an 'rabid' attribute having only a left match" do
+      name = @dog.attributes.select{|a| a.key[0] == 'rabid'}.first
+      name.should be_left_match
+      name.should_not be_right_match
+    end
+    
+    it "should ignore the Rabbit class" do
+      ignore_on = Comparison.new(@left, @right, :ignore_classes => %w(Rabbit) )
+      ignore_on.should have(1).classes
+    end
+    
+    it "should manually match 'Rabbit' to 'Hare'" do
+      @left['Hare'] = [
+        %w(color String)
+      ]
+      
+      manual_matching = Comparison.new(@left, @right, :matching_classes => {:Hare => :Rabbit})
+      manual_matching.should have(2).intersecting_classes
+      names = manual_matching.intersecting_classes.collect{|c| [c.key.left, c.key.right]}
+      names.should include(['Hare', 'Rabbit'])
+      names.should include(['Dog', 'Dog'])
+    end
+    
+    it "should manually match 'Rabbit' to 'Hare' with inverse matching class" do
+      @left['Hare'] = [
+        %w(color String)
+      ]
+      
+      manual_matching = Comparison.new(@left, @right, :matching_classes => {:Rabbit => :Hare})
+      manual_matching.should have(2).intersecting_classes
+      names = manual_matching.intersecting_classes.collect{|c| [c.key.left, c.key.right]}
+      names.should include(['Hare', 'Rabbit'])
+      names.should include(['Dog', 'Dog'])
+    end
+    
+    it "should align keys" do
+      aligned = ClassMatchKey.align(['a', 'b'], ['b', 'c'], :a => :c).collect{|k| [k.left, k.right]}
+      aligned.size.should be(2)
+      aligned.should include(['b', 'b'])
+      aligned.should include(['a', 'c'])
+    end
+    
+    it "should sort keys" do
+      keys = [ClassMatchKey.new('b', 'b'), ClassMatchKey.new('a', 'a')].sort
+      keys[0].left.should == 'a'
+      keys[1].left.should == 'b'
+    end
+  end
+end

data/spec/models/java/code_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module CaDOVe::Java
+  describe JavaSourceTree do
+    before(:each) do
+      @code = JavaSourceTree.new(
+        File.dirname(__FILE__) + '/../../java_stubs'
+      )
+      
+      @dog =  @code.classes.select { |c| c.name == "Dog" }.first
+    end
+        
+    it "should have three classes in the document" do
+      @code.should have(3).classes
+    end
+    
+    it "should include only classes Animal, Cat and Dog" do
+      names = @code.classes.collect { |c| c.name }
+      names.should include("Animal")
+      names.should include("Cat")
+      names.should include("Dog")
+    end
+    
+    it "should have the two fields" do
+      @dog.should have(2).fields
+      fields = @dog.fields.collect{ |f| [f.name, f.type] }
+      fields.should include( %w(color String) )
+      fields.should include( %w(rabid boolean) )
+    end
+    
+    
+    it "should hashify Dog" do
+      doggy_hash = @dog.hashify
+      doggy_hash['Dog'].should include( %w(color String) )
+      doggy_hash['Dog'].should include( %w(rabid boolean) )
+    end
+    
+    it "should hashify the source tree" do
+      @code.hashify.keys.should include('Cat')
+      @code.hashify.keys.should include('Dog')
+      
+      @code.hashify['Dog'].should include( %w(color String) )
+      @code.hashify['Dog'].should include( %w(rabid boolean) )
+    end
+    
+    it "should have only associations"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/cadove'

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: cadove
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- John Dzak
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-11 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rjb
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/cadove/models/analytics/comparison.rb
+- lib/cadove/models/helpers.rb
+- lib/cadove/models/indifferent_access.rb
+- lib/cadove/models/java/code.rb
+- lib/cadove/models/java/javalib/qdox-1.10.jar
+- lib/cadove/models/reports/reports.rb
+- lib/cadove/models/XMI/document.rb
+- lib/cadove/models.rb
+- lib/cadove.rb
+- CHANGELOG
+- README
+- spec/cadove_spec.rb
+- spec/java_stubs/org/foo/Animal.java
+- spec/java_stubs/org/foo/Cat.java
+- spec/java_stubs/org/foo/Dog.java
+- spec/models/analytics/comparison_spec.rb
+- spec/models/java/code_spec.rb
+- spec/models/XMI/document_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Domain Object Verifier compares Java domain objects to their corresponding XMI representations.
+test_files: []
+