jinx 2.1.2 → 2.1.3

data/History.md

@@ -1,6 +1,10 @@
 This history lists major release themes. See the GitHub commits (https://github.com/jinx/core)
 for change details.
 
+2.1.3 / 2012-08-18
+------------------
+* Pull UID out of uniquifier.
+
 2.1.2 / 2012-06-12
 ------------------
 * Fine-tune introspection.

data/LEGAL

@@ -1,5 +1,4 @@
 LEGAL NOTICE INFORMATION
 ------------------------
-
 All the files in this distribution are covered under either the MIT
 license (see the file LICENSE).

data/README.md

@@ -1,6 +1,5 @@
 JINX: JRuby Java introspector
 =============================
-
 **Home**:         [http://github.com/jinx/core](http://github.com/jinx/core)    
 **Git**:          [http://github.com/jinx/core](http://github.com/jinx/core)       
 **Author**:       OHSU Knight Cancer Institute    
@@ -9,12 +8,10 @@ JINX: JRuby Java introspector
 
 Synopsis
 --------
-
 Jinx introspects a Java application domain package.
 
 Feature List
 ------------
-
 1. Introspects Java properties.
 
 2. Annotates the introspected object model with additional meta-data.
@@ -39,6 +36,5 @@ See the [example](http://github.com/jinx/core/tree/master/examples/family) for a
 
 Copyright
 ---------
-
 Jinx © 2012 by [Oregon Health & Science University](http://www.ohsu.edu/xd/health/services/cancer/index.cfm).
 Jinx is licensed under the MIT license. Please see the LICENSE and LEGAL files for more information.

data/lib/jinx/helpers/log.rb

@@ -66,7 +66,9 @@ module Jinx
     # @option opts [Boolean] :debug whether to include debug messages in the log file
     # @return [MultilineLogger] the global logger
     def open(dev=nil, opts=nil)
-      raise RuntimeError.new("Log already open") if open?
+      if open? then
+        raise RuntimeError.new("The logger has already opened the log#{' file ' + @dev if String === @dev}")
+      end
       dev, opts = nil, dev if Hash === dev
       dev ||= default_log_file(Options.get(:app, opts)) 
       FileUtils.mkdir_p(File.dirname(dev)) if String === dev

data/lib/jinx/helpers/string_uniquifier.rb

@@ -0,0 +1,39 @@
+require 'jinx/helpers/uid'
+
+module Jinx
+  # A mix-in to convert a String to a unique value.
+  module StringUniquifier
+    # Returns a relatively unique String for the given base String. Each call returns
+    # a distinct value.
+    #
+    # This method is useful to transform a String object key to a unique value for
+    # testing purposes.
+    #
+    # The unique value is comprised of a prefix and suffix. The prefix is the base value
+    # with spaces replaced by an underscore. The suffix is given by a {Jinx::UID.generate}
+    # qualifier converted to digits and lower-case letters, excluding the digits 0, 1 and
+    # the characters l, o to avoid confusion.
+    #
+    # @example
+    #   Jinx::StringUniquifier.uniquify('Groucho') #=> Groucho_wiafye6e
+    #
+    # @param value [String] the value to make unique
+    # @return [String, nil] the new unique value
+    # @raise [ArgumentError] if value is not a String
+    def self.uniquify(value)
+      raise ArgumentError.new("#{value.qp} is not a String") unless String === value
+      s = ''
+      n = UID.generate
+      while n > 0 do
+        n, m = n.divmod(32)
+        s << CHARS[m]
+      end
+      [value.gsub(' ', '_'), s].join('_')
+    end
+    
+    private
+
+    # The qualifier character range.
+    CHARS = 'abcdefghijkmnpqrstuvwxyz23456789'
+  end
+end

data/lib/jinx/helpers/transitive_closure.rb

@@ -22,8 +22,6 @@ class Object
   #       @children = []
   #       parent.children << self if parent
   #     end
-  #
-  #     def to_s;
   #   end
   #   a = Node.new('a'); b = Node.new('b', a), c = Node.new('c', a); d = Node.new('d', c)
   #   a.transitive_closure { |node| node.children }.to_a.join(", ") #=> a, b, c, d

data/lib/jinx/helpers/uid.rb

@@ -0,0 +1,19 @@
+module Jinx
+  # A unique identifier generator.
+  module UID
+    # Returns a relatively unique integer. Successive calls to this method
+    # within the same time zone spaced more than a millisecond apart return different
+    # integers. Each generated qualifier is greater than the previous by an unspecified
+    # amount.
+    def self.generate
+      # the first date that this method could be called
+      @first ||= Date.new(2011, 12, 01)
+      # days as integer + milliseconds as fraction since the first date
+      diff = DateTime.now - @first
+      # shift a tenth of a milli up into the integer portion
+      decimillis = diff * 24 * 60 * 60 * 10000
+      # truncate the fraction
+      decimillis.truncate
+    end
+  end
+end

data/lib/jinx/helpers/visitor.rb

@@ -193,7 +193,7 @@ module Jinx
     # @return [Visitor] the filter visitor
     # @yield [parent, children] the filter to select which of the children to visit next
     # @yieldparam parent the currently visited node
-    # @yieldparam children the nodes slated by this Visitor to visit next
+    # @yieldparam [Array] children the nodes slated by this visitor to visit next
     # @raise [ArgumentError] if a block is not given to this method
     def filter
       raise ArgumentError.new("A filter block is not given to the visitor filter method") unless block_given?
@@ -229,20 +229,28 @@ module Jinx
     # Visits the root node and all descendants.
     def visit_root(node, &operator)
       clear
-      prune_cycle_nodes(node) if @prune_cycle_flag
-      # visit the root node
-      visit_recursive(node, &operator)
+      # Exclude cycles if the prune cycles flag is set. 
+      @exclude.merge!(cyclic_nodes(node)) if @prune_cycle_flag 
+      # Visit the root node.
+      result = visit_recursive(node, &operator)
+      # Reset the exclusions if the prune cycles flag is set.
+      @exclude.clear if @prune_cycle_flag 
+      result
     end
-  
-    # Excludes the internal nodes in cycles starting and ending at the given root.
-    def prune_cycle_nodes(root)
-      @exclude.clear
-      # visit the root, which will detect cycles, and remove the visited nodes afterwords
-      @prune_cycle_flag = false
-      to_enum(root).collect.each { |node| @visited.delete(node) }
-      @prune_cycle_flag = true
-      # add each cyclic internal node to the exclude list
-      @cycles.each { |cycle| cycle[1...-1].each { |node| @exclude << node } if cycle.first == root }
+    
+    # @example
+    #   visitor.visit(a)
+    #   visit.to_enum #=> [a, b, c, u, v, x, y, z]
+    #   visit.cycles #=> [[a, b, u, x, a], [c, z, c]]
+    #   visit.cyclic_nodes #=> [b, u, x, c, z]
+    # @return [Array] the non-root nodes in visit cycles
+    def cyclic_nodes(root)
+      copts = @options.reject { |k, v| k == :prune_cycle }
+      cycler = Visitor.new(copts, &@navigator)
+      cycler.visit(root)
+      cyclic = cycler.cycles.flatten.uniq
+      cyclic.delete(root)
+      cyclic
     end
   
     def visit_recursive(node, &operator)
@@ -298,7 +306,9 @@ module Jinx
         @visitor = visitor
         @root = node
       end
-  
+      
+      # @yield [node] operates on the visited node
+      # @yieldparam node the visited node 
       def each
         @visitor.visit(@root) { |node| yield(node) }
       end
@@ -314,8 +324,8 @@ module Jinx
   
       # Visits the given pair of nodes.
       #
-      # Raises ArgumentError if nodes does not consist of either two node arguments or one two-item Array
-      # argument.
+      # @param [(Object, Object), <(Object, Object)>] nodes the node pair
+      # @raise [ArgumentError] if the arguments do not consist of either two nodes or one two-item array
       def visit(*nodes)
         if nodes.size == 1 then
           nodes = nodes.first
@@ -324,10 +334,10 @@ module Jinx
         super(nodes)
       end
   
-      # Returns an Enumerable which applies the given block to each matched node starting at the given nodes.
-      #
-      # Raises ArgumentError if nodes does not consist of either two node arguments or one two-item Array
-      # argument.
+      # @param (see #visit)
+      # @param [(Object, Object), <(Object, Object)>] nodes
+      # @return [Enumerable] the result of applying the given block to each matched node starting at the given root nodes
+      # @raise [ArgumentError] if the arguments do not consist of either two nodes or one two-item array
       def to_enum(*nodes)
         if nodes.size == 1 then
           nodes = nodes.first

data/lib/jinx/metadata/introspector.rb

@@ -17,9 +17,9 @@ module Jinx
     # Adds an optional {attribute=>value} constructor parameter to this class.
     def add_attribute_value_initializer
       class << self
-        def new(opts=nil)
+        def new(params=nil)
           obj = super()
-          obj.merge_attributes(opts) if opts
+          obj.merge_attributes(params) if params
           obj
         end
       end

data/lib/jinx/metadata/propertied.rb

@@ -246,7 +246,7 @@ module Jinx
       @local_prop_hash = {}
       @prop_hash = append_ancestor_enum(@local_prop_hash) { |par| par.property_hash }
       @attributes = Enumerable::Enumerator.new(@prop_hash, :each_key)
-      @local_mndty_flt = Set.new
+      @local_mndty_attrs = Set.new
       @local_defaults = {}
       @defaults = append_ancestor_enum(@local_defaults) { |par| par.defaults }
     end
@@ -393,7 +393,7 @@ module Jinx
 
     # @param [Symbol] attribute the mandatory attribute
     def add_mandatory_attribute(attribute)
-      @local_mndty_flt << standard_attribute(attribute)
+      @local_mndty_attrs << standard_attribute(attribute)
     end
 
     # Marks the given attribute with flags supported by {Property#qualify}.
@@ -414,16 +414,16 @@ module Jinx
     # An attribute declared in a superclass Resource is hidden from this Resource but retained in
     # the declaring Resource.
     def remove_attribute(attribute)
-      std_prop = standard_attribute(attribute)
+      sa = standard_attribute(attribute)
       # if the attribute is local, then delete it, otherwise filter out the superclass attribute
-      prop = @local_prop_hash.delete(std_prop)
-      if prop then
+      sp = @local_prop_hash.delete(sa)
+      if sp then
         # clear the inverse, if any
-        clear_inverse(prop)
+        clear_inverse(sp)
         # remove from the mandatory attributes, if necessary
-        @local_mndty_flt.delete(std_prop)
+        @local_mndty_attrs.delete(sa)
         # remove from the attribute => metadata hash
-        @local_std_prop_hash.delete_if { |aliaz, pa| pa == std_prop }
+        @local_std_prop_hash.delete_if { |aliaz, pa| pa == sa }
       else
         # Filter the superclass hashes.
         anc_prop_hash = @prop_hash.components[1]
@@ -478,8 +478,8 @@ module Jinx
     #
     # @see #mandatory_attributes
     def collect_mandatory_attributes
-      @local_mndty_flt.merge!(default_mandatory_local_attributes)
-      append_ancestor_enum(@local_mndty_flt) { |par| par.mandatory_attributes }
+      @local_mndty_attrs.merge!(default_mandatory_local_attributes)
+      append_ancestor_enum(@local_mndty_attrs) { |par| par.mandatory_attributes }
     end
     
     def default_mandatory_local_attributes

data/lib/jinx/metadata/property.rb

@@ -77,15 +77,6 @@ module Jinx
       @inv_prop.attribute if @inv_prop
     end
     
-    # An attribute is unidirectional if both of the following is true:
-    # * there is no distinct {#inverse} attribute
-    # * the attribute is not a {#dependent?} with more than one owner
-    #
-    # @return [Boolean] whether this attribute does not have an inverse
-    def unidirectional?
-      inverse.nil? and not (dependent? and type.owner_attributes.size > 1)
-    end
-    
     # @param [Class] the attribute return type
     def type=(klass)
       return if klass == @type
@@ -135,11 +126,6 @@ module Jinx
       @inv_prop.qualify(:disjoint) if disjoint?
       logger.debug { "Assigned #{@declarer.qp}.#{self} attribute inverse to #{type.qp}.#{attribute}." }
     end
-    
-    # @return [Boolean] whether this property has an inverse
-    def bidirectional?
-      !!@inv_prop
-    end
 
     # @return [Property, nil] the property for the {#inverse} attribute, if any
     def inverse_property
@@ -156,91 +142,10 @@ module Jinx
       if @restrictions then @restrictions.each { |prop| prop.qualify(*flags) } end
     end
 
-    # @return [Boolean] whether the subject attribute encapsulates a Java attribute
-    def java_property?
-      JavaProperty === self
-    end
-
-    # @return [Boolean] whether the subject attribute returns a domain object or collection of domain objects
-    def domain?
-      # the type must be a Ruby class rather than a Java Class, and include the Domain mix-in
-      Class === type and type < Resource
-    end
-
-    # @return [Boolean] whether the subject attribute is not a domain object attribute
-    def nondomain?
-      not domain?
-    end
-
-    # @return [Boolean] whether the subject attribute return type is a collection
-    def collection?
-      @flags.include?(:collection)
-    end
-
-    # Returns whether the subject attribute is a dependent on a parent. See the Jinx configuration
-    # documentation for a dependency description.
-    #
-    # @return [Boolean] whether the attribute references a dependent
-    def dependent?
-      @flags.include?(:dependent)
-    end
-
-    # Returns whether the subject attribute must have a value when it is saved
-    #
-    # @return [Boolean] whether the attribute is mandatory
-    def mandatory?
-      @declarer.mandatory_attributes.include?(attribute)
-    end
-
-    # An attribute is derived if the attribute value is set by setting another attribute, e.g. if this
-    # attribute is the inverse of a dependent owner attribute.
-    #
-    # @return [Boolean] whether this attribute is derived from another attribute
-    def derived?
-      dependent? and !!inverse
-    end
-
     # @return [Boolean] this attribute's inverse attribute if the inverse is a derived attribute, or nil otherwise
     def derived_inverse
       @inv_prop.attribute if @inv_prop and @inv_prop.derived?
     end
-
-    # An independent attribute is a reference to one or more non-dependent Resource objects.
-    # An {#owner?} attribute is independent.
-    #
-    # @return [Boolean] whether the subject attribute is a non-dependent domain attribute
-    def independent?
-      domain? and not dependent?
-    end
-
-    # @return [Boolean] whether this attribute is a collection with a collection inverse
-    def many_to_many?
-      return false unless collection?
-      inv_prop = inverse_property
-      inv_prop and inv_prop.collection?
-    end
-
-    # @return [Boolean] whether the subject attribute is a dependency owner
-    def owner?
-      @flags.include?(:owner)
-    end
-
-    # @return [Boolean] whether this is a dependent attribute which has exactly one owner value
-    #   chosen from several owner attributes
-    def disjoint?
-      @flags.include?(:disjoint)
-    end
-    
-    # @return [Boolean] whether this attribute is a dependent which does not have a Java
-    #   inverse owner attribute
-    def unidirectional_java_dependent?
-      dependent? and java_property? and not bidirectional_java_association?
-    end
-
-    # @return [Boolean] whether this is a Java attribute which has a Java inverse
-    def bidirectional_java_association?
-      inverse and java_property? and inverse_property.java_property?
-    end
     
     # Creates a new declarer attribute which restricts this attribute.
     # This method should only be called by a {Resource} class, since the class is responsible

data/lib/jinx/metadata/property_characteristics.rb

@@ -27,7 +27,8 @@ module Jinx
       JavaProperty === self
     end
 
-    # @return [Boolean] whether the subject attribute returns a domain object or collection of domain objects
+    # @return [Boolean] whether the subject attribute returns a domain object or a collection
+    #   of domain objects
     def domain?
       # the type must be a Ruby class rather than a Java Class, and include the Domain mix-in
       Class === type and type < Resource

data/lib/jinx/resource/match_visitor.rb

@@ -27,8 +27,12 @@ module Jinx
       @copier = opts.delete(:copier)
       # the source => target matches
       @matches = {}
-      # Apply a filter to the selected references so that only a matched reference is visited.
-      opts[:filter] = Proc.new { |src| @matches[src] }
+      # Apply a filter to the visited reference so that only a matched reference is visited.
+      # the reference filter
+      flt = opts[:filter]
+      opts[:filter] = Proc.new do |src|
+        (flt.nil? or flt.call(src)) and !!@matches[src]
+      end
       # the class => {id => target} hash
       @id_mtchs = LazyHash.new { Hash.new }
       # Match the source references before navigating from the source to its references, since

data/lib/jinx/resource/merge_visitor.rb

@@ -60,7 +60,7 @@ module Jinx
       # merge the non-domain attributes
       target.merge_attributes(source)
       # merge the source domain attributes into the target
-      target.merge(source, mas, @matches)
+      target.merge_attributes(source, mas, @matches, &@filter)
     end
   end
 end

data/lib/jinx/resource/mergeable.rb

@@ -23,21 +23,19 @@ module Jinx
     # {Propertied#mergeable_attributes}.
     #
     # The merge is performed by calling {#merge_attribute} on each attribute with the matches
-    # and merger block given to this method.
+    # and filter block given to this method.
     #
     # @param [Mergeable, {Symbol => Object}] other the source domain object or value hash to merge from
     # @param [<Symbol>, nil] attributes the attributes to merge (default {Propertied#nondomain_attributes})
     # @param [{Resource => Resource}, nil] the optional merge source => target reference matches
-    # @yield [attribute, oldval, newval] the optional merger block
-    # @yieldparam [Symbol] attribute the merge target attribute
-    # @yieldparam oldval the current merge attribute value
-    # @yieldparam newval the new merge attribute value
+    # @yield [value] the optional filter block
+    # @yieldparam value the source merge attribute value
     # @return [Mergeable] self
     # @raise [ArgumentError] if none of the following are true:
     #   * other is a Hash
     #   * attributes is non-nil
     #   * the other class responds to +mergeable_attributes+
-    def merge_attributes(other, attributes=nil, matches=nil, &merger)
+    def merge_attributes(other, attributes=nil, matches=nil, &filter)
       return self if other.nil? or other.equal?(self)
       attributes = [attributes] if Symbol === attributes
       attributes ||= self.class.mergeable_attributes
@@ -45,11 +43,13 @@ module Jinx
       # if the source object is not a hash, then convert it to an attribute => value hash
       vh = Hashable === other ? other : other.value_hash(attributes)
       # merge the value hash
-      vh.each { |pa, value| merge_attribute(pa, value, matches, &merger) }
+      vh.each { |pa, value| merge_attribute(pa, value, matches, &filter) }
       self
     end
 
-    alias :merge :merge_attributes
+    def merge(*args, &filter)
+      merge_attributes(*args, &filter)
+    end
 
     alias :merge! :merge
     
@@ -77,19 +77,26 @@ module Jinx
     def merge_attribute(attribute, newval, matches=nil)
       # the previous value
       oldval = send(attribute)
-      # If nothing to merge or a block can take over, then bail. 
-      if newval.nil? or mergeable__equal?(oldval, newval) then
-        return oldval
-      elsif block_given? then
-        return yield(attribute, oldval, value)
+      # Filter the newval into the srcval.
+      srcval = if newval and block_given? then
+        if newval.collection? then
+          newval.select { |v| yield(v) }
+        elsif yield(newval) then
+          newval
+        end
+      else
+        newval
       end
       
+      # If there is no point in merging, then bail. 
+      return oldval if srcval.nil_or_empty? or mergeable__equal?(oldval, newval)
+      
       # Discriminate between a domain and non-domain attribute.
       prop = self.class.property(attribute)
       if prop.domain? then
-        merge_domain_property_value(prop, oldval, newval, matches)
+        merge_domain_property_value(prop, oldval, srcval, matches)
       else
-        merge_nondomain_property_value(prop, oldval, newval)
+        merge_nondomain_property_value(prop, oldval, srcval)
       end
     end
 

data/lib/jinx/resource/reference_visitor.rb

@@ -14,31 +14,31 @@ module Jinx
     # The required selector block given to this initializer determines which attributes to
     # visit. The references to visit next thus consist of the current domain object's selector
     # attributes' values. If the :filter option is set, then the given filter block is applied
-    # to the selected attribute references to restrict which domain objects will be visited.
+    # to each selected attribute reference to determine which domain objects will be visited.
     #
     # @param opts (see Visitor#initialize)
-    # @option opts [Proc] :filter an optional filter on the references to visit
+    # @option opts [Proc] :filter an optional filter on the reference to visit
     # @yield [obj] returns the {AttributeEnumerator} of attributes to visit next from the
     #   current domain object
     # @yieldparam [Resource] obj the current domain object
     def initialize(opts=nil, &selector)
       raise ArgumentError.new("Reference visitor missing domain reference selector") unless block_given?
       # the property selector
-      @flt_sel = selector
+      @selector = selector
       # the reference filter
-      flt = Options.get(:filter, opts)
+      @filter = Options.get(:filter, opts)
       # Initialize the Visitor with a reference enumerator which selects the reference
       # attributes and applies the optional filter if necessary.
       @ref_enums = {}
-      super do |ref|
+      super do |obj|
         # the reference property filter
-        ras = attributes_to_visit(ref)
+        ras = attributes_to_visit(obj)
         if ras then
-          logger.debug { "#{qp} visiting #{ref} attributes #{ras.pp_s(:single_line)}..." } if @verbose
+          logger.debug { "#{qp} visiting #{obj} attributes #{ras.pp_s(:single_line)}..." } if @verbose
           # an enumerator on the reference properties
-          enum = ReferenceEnumerator.new(ref, ras.properties)
+          enum = ReferenceEnumerator.new(obj, ras.properties)
           # If there is a reference filter, then apply it to the enum references.
-          flt ? enum.filter(&flt) : enum
+          @filter ? enum.filter(&@filter) : enum
         end
       end
     end
@@ -48,7 +48,7 @@ module Jinx
     # @param [Resource] obj the visiting object
     # @return [Propertied::Filter] the attributes to visit
     def attributes_to_visit(obj)
-      @flt_sel.call(obj)
+      @selector.call(obj)
     end
   end
 end

data/lib/jinx/resource/unique.rb

@@ -1,32 +1,29 @@
-require 'jinx/helpers/uniquifier'
+require 'jinx/resource/uniquifier_cache'
 
 module Jinx
   # The Unique mix-in makes values unique within the scope of a Resource class.
   module Unique
-    # Makes the given String value unique in the context of this object's class.
-    # @return nil if value is nil
-    # Raises TypeError if value is neither nil nor a String.
-    def uniquify_value(value)
-      unless String === value or value.nil? then
-        raise TypeError.new("Cannot uniquify #{qp} non-String value #{value}")
-      end
-      Uniquifier.instance.uniquify(self, value)
-    end
-    
-    # Makes the secondary key unique by replacing each String key attribute value
-    # with a unique value.
+    # Replaces each String secondary and alternate key property with a unique
+    # value. Successive calls to this method for domain objects of the same class
+    # replace the same String key property values with the same unique value. 
+    #
+    # @return [Resource] self
     def uniquify
       uniquify_attributes(self.class.secondary_key_attributes)
       uniquify_attributes(self.class.alternate_key_attributes)
+      self
     end
-    
-    # Makes the given attribute values unique by replacing each String value
-    # with a unique value.
+
+    private
+
+    # Makes this domain object's String values for the given attributes unique.
+    #
+    # @param [<Symbol>] the key attributes to uniquify
     def uniquify_attributes(attributes)
       attributes.each do |ka|
         oldval = send(ka)
         next unless String === oldval
-        newval = uniquify_value(oldval)
+        newval = UniquifierCache.instance.get(self, oldval)
         set_property_value(ka, newval)
         logger.debug { "Reset #{qp} #{ka} from #{oldval} to unique value #{newval}." }
       end

data/lib/jinx/resource/uniquifier_cache.rb

@@ -0,0 +1,34 @@
+require 'singleton'
+require 'jinx/helpers/lazy_hash'
+require 'jinx/helpers/string_uniquifier'
+
+module Jinx
+  # A utility class to cache key value qualifiers.
+  class UniquifierCache
+    include Singleton
+
+    def initialize
+      @cache = Jinx::LazyHash.new { Hash.new }
+    end
+    
+    # Returns the unique value generated for the given object and value.
+    # Successive calls to this method for domain objects of the same class
+    # and a given value return the same result. 
+    #
+    # @example
+    #   Jinx::UniquifierCache.instance.get(person, 'Groucho') #=> Groucho_wy874e6e
+    #   Jinx::UniquifierCache.instance.get(person.copy, 'Groucho') #=> Groucho_wy87ye6e
+    #
+    # @param [Resource] obj the domain object containing the value
+    # @param [String] value the value to make unique
+    # @return [String] the unique value
+    def get(obj, value)
+      @cache[obj.class][value] ||= StringUniquifier.uniquify(value)
+    end
+    
+    # Clears all cache entries.
+    def clear
+      @cache.clear
+    end
+  end
+end

data/lib/jinx/version.rb

@@ -1,3 +1,3 @@
 module Jinx
-  VERSION = '2.1.2'
+  VERSION = '2.1.3'
 end

data/test/lib/jinx/helpers/string_uniquifier_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require 'test/unit'
+require 'jinx/helpers/string_uniquifier'
+
+class StringUniquifierTest < Test::Unit::TestCase
+  def test_uniquify
+    u1 = Jinx::StringUniquifier.uniquify('Groucho')
+    u2 = Jinx::StringUniquifier.uniquify('Groucho')
+    assert_not_equal(u1, u2, "Consecutive uniquifier calls not unique")
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: jinx
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.1.2
+  version: 2.1.3
 platform: ruby
 authors: 
   - OHSU
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-12 00:00:00 Z
+date: 2012-07-17 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: bundler
@@ -142,9 +142,10 @@ files:
   - lib/jinx/helpers/pretty_print.rb
   - lib/jinx/helpers/set.rb
   - lib/jinx/helpers/stopwatch.rb
+  - lib/jinx/helpers/string_uniquifier.rb
   - lib/jinx/helpers/transformer.rb
   - lib/jinx/helpers/transitive_closure.rb
-  - lib/jinx/helpers/uniquifier.rb
+  - lib/jinx/helpers/uid.rb
   - lib/jinx/helpers/validation.rb
   - lib/jinx/helpers/visitor.rb
   - lib/jinx/import/class_path_modifier.rb
@@ -171,6 +172,7 @@ files:
   - lib/jinx/resource/reference_path_visitor.rb
   - lib/jinx/resource/reference_visitor.rb
   - lib/jinx/resource/unique.rb
+  - lib/jinx/resource/uniquifier_cache.rb
   - lib/jinx/version.rb
   - spec/defaults_spec.rb
   - spec/definitions/model/alias/child.rb
@@ -212,8 +214,8 @@ files:
   - test/lib/jinx/helpers/partial_order_test.rb
   - test/lib/jinx/helpers/pretty_print_test.rb
   - test/lib/jinx/helpers/stopwatch_test.rb
+  - test/lib/jinx/helpers/string_uniquifier_test.rb
   - test/lib/jinx/helpers/transitive_closure_test.rb
-  - test/lib/jinx/helpers/uniquifier_test.rb
   - test/lib/jinx/helpers/visitor_test.rb
   - test/lib/jinx/import/java_test.rb
   - test/lib/jinx/import/mixed_case_test.rb
@@ -265,8 +267,8 @@ test_files:
   - test/lib/jinx/helpers/partial_order_test.rb
   - test/lib/jinx/helpers/pretty_print_test.rb
   - test/lib/jinx/helpers/stopwatch_test.rb
+  - test/lib/jinx/helpers/string_uniquifier_test.rb
   - test/lib/jinx/helpers/transitive_closure_test.rb
-  - test/lib/jinx/helpers/uniquifier_test.rb
   - test/lib/jinx/helpers/visitor_test.rb
   - test/lib/jinx/import/java_test.rb
   - test/lib/jinx/import/mixed_case_test.rb

data/lib/jinx/helpers/uniquifier.rb

@@ -1,83 +0,0 @@
-require 'singleton'
-require 'jinx/helpers/lazy_hash'
-
-module Jinx
-  # A utility class to generate value qualifiers.
-  class Uniquifier
-    include Singleton
-
-    # Returns a relatively unique integral qualifier. Successive calls to this method
-    # within the same time zone spaced more than a millisecond apart return different
-    # integers. Each generated qualifier is greater than the previous by an unspecified
-    # amount.
-    def self.qualifier
-      # the first date that this method could be called
-      @first ||= Date.new(2011, 12, 01)
-      # days as integer + milliseconds as fraction since the first date
-      diff = DateTime.now - @first
-      # shift a tenth of a milli up into the integer portion
-      decimillis = diff * 24 * 60 * 60 * 10000
-      # truncate the fraction
-      decimillis.truncate
-    end
-
-    def initialize
-      @cache = Jinx::LazyHash.new { Hash.new }
-    end
-    
-    # Returns a relatively unique String for the given base String object or
-    # (object, String value) pair. In the former case, each call returns a distinct value.
-    # In the latter case, successive calls of the same String value for the same object
-    # class return the same unique value.
-    #
-    # This method is useful to transform a String object key to a unique value for testing
-    # purposes.
-    #
-    # The unique value is comprised of a prefix and suffix. The prefix is the base value
-    # with spaces replaced by an underscore. The suffix is a {Jinx::Uniquifier.qualifier}
-    # converted to digits and lower-case letters, excluding the digits 0, 1 and characters
-    # l, o to avoid confusion.
-    #
-    # @example
-    #   Jinx::Uniquifier.instance.uniquify('Groucho') #=> Groucho_wiafye6e
-    #   Jinx::Uniquifier.instance.uniquify('Groucho') #=> Groucho_uqafye6e
-    #   Jinx::Uniquifier.instance.uniquify('Groucho Marx') #=> Groucho_ay23ye6e
-    #   Jinx::Uniquifier.instance.uniquify(person, 'Groucho') #=> Groucho_wy874e6e
-    #   Jinx::Uniquifier.instance.uniquify(person, 'Groucho') #=> Groucho_wy87ye6e
-    #
-    # @param obj the object containing the value to uniquify
-    # @param value [String, nil] the value to make unique, or nil if the containing object is a String
-    # @return [String, nil] the new unique value, or nil if the containing object is a String
-    #   and the given value is nil
-    def uniquify(obj, value=nil)
-      if String === obj then
-        to_unique(obj)
-      elsif value then
-        @cache[obj.class][value] ||= to_unique(value)
-      end
-    end
-
-    def clear
-      @cache.clear
-    end
-    
-    private
-    
-    CHARS = 'abcdefghijkmnpqrstuvwxyz23456789'
-    
-    # @param value [String, nil] the value to make unique
-    # @return [String] the new unique value, or nil if the given value is nil
-    # @raise [ArgumentError] if value is neither a String nor nil
-    def to_unique(value)
-      return if value.nil?
-      raise ArgumentError.new("#{value.qp} is not a String") unless String === value
-      s = ''
-      n = Jinx::Uniquifier.qualifier
-      while n > 0 do
-        n, m = n.divmod(32)
-        s << CHARS[m]
-      end
-      [value.gsub(' ', '_'), s].join('_')
-    end
-  end
-end

data/test/lib/jinx/helpers/uniquifier_test.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/../../../helper'
-require 'test/unit'
-require 'jinx/helpers/uniquifier'
-
-class UniquifierTest < Test::Unit::TestCase
-  def test_uniquify
-    u1 = Jinx::Uniquifier.instance.uniquify('Groucho')
-    u2 = Jinx::Uniquifier.instance.uniquify('Groucho')
-    assert_not_equal(u1, u2, "Consequetive uniquifier calls not unique")
-  end
-end