jinx 2.1.1

data/lib/jinx/resource/reference_enumerator.rb

@@ -0,0 +1,49 @@
+require 'enumerator'
+require 'generator'
+require 'jinx/helpers/options'
+require 'jinx/helpers/collections'
+
+require 'jinx/helpers/validation'
+require 'jinx/helpers/visitor'
+require 'jinx/helpers/math'
+
+module Jinx
+  # A ReferenceEnumerator iterates over domain property references.
+  class ReferenceEnumerator
+    include Enumerable
+    
+    # @return [Resource] the domain object containing the references
+    attr_reader :subject
+    
+    alias :on :subject
+    
+    alias :from :subject
+    
+    # @return [<Property>] the current property
+    attr_reader :property
+  
+    # @param [Resource, nil] on the object containing the references
+    # @param [<Property>, Property, nil] properties the property or properties to dereference
+    def initialize(on=nil, properties=nil)
+      @subject = on
+      @properties = properties
+    end
+    
+    # @param [Resource] obj the visiting domain object
+    # @return [(Resource, Resource, Property)] the (visited, visiting, property) tuples
+    # @yield [obj, from, property] operates on the visited domain object
+    # @yieldparam [Resource] obj the visited domain object
+    # @yieldparam [Resource] from the visiting domain object
+    # @yieldparam [Property] property the visiting property
+    def each
+      return if @subject.nil?
+      @properties.enumerate do |prop|
+        @property = prop
+        # the reference(s) to visit
+        refs = @subject.send(prop.attribute)
+        # associate each reference to visit with the current visited attribute
+        refs.enumerate { |ref| yield(ref) }
+      end
+    end
+  end
+end

data/lib/jinx/resource/reference_path_visitor.rb

@@ -0,0 +1,38 @@
+require 'jinx/helpers/collections'
+
+require 'jinx/helpers/validation'
+require 'jinx/helpers/visitor'
+require 'jinx/helpers/math'
+
+module Jinx
+  # A ReferencePathVisitor traverses an attribute path.
+  #
+  # For example, given the attributes:
+  #   favorites : Person -> Book
+  #   authors : Book -> Author
+  #   publications : Author -> Book
+  # then a path visitor given by:
+  #   ReferencePathVisitor.new(Person, [:favorites, :authors, :publications])
+  # visits the transitive closure of books published by the authors of a person's favorite books.
+  class ReferencePathVisitor < ReferenceVisitor
+    # @return [ReferenceVisitor] a visitor which traverses the given path attributes starting at
+    #   an instance of the given type
+    #
+    # @param [Class] the type of object to begin the traversal
+    # @param [<Symbol>] the attributes to traverse
+    # @param opts (see ReferenceVisitor#initialize)
+    def initialize(klass, attributes, opts=nil)
+      # augment the attributes path as a [class, attribute] path
+      path = klass.property_path(*attributes)
+      # make the visitor
+      super(opts) do |ref|
+        # Collect the path attributes whose type is the ref type up to the
+        # next position in the path.
+        max = lineage.size.min(path.size)
+        pas = (0...max).map { |i| path[i].attribute if path[i].declarer === ref }
+        pas.compact!
+        ref.class.attribute_filter(pas)
+      end
+    end
+  end
+end

data/lib/jinx/resource/reference_visitor.rb

@@ -0,0 +1,55 @@
+require 'enumerator'
+require 'generator'
+require 'jinx/helpers/options'
+require 'jinx/helpers/collections'
+
+require 'jinx/helpers/validation'
+require 'jinx/helpers/visitor'
+require 'jinx/helpers/math'
+
+module Jinx
+  # A ReferenceVisitor traverses reference attributes.
+  class ReferenceVisitor < Visitor
+    # Creates a new ReferenceVisitor on domain reference attributes.
+    #
+    # 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.
+    #
+    # @param opts (see Visitor#initialize)
+    # @option opts [Proc] :filter an optional filter on the references 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)
+      Jinx.fail(ArgumentError, "Reference visitor missing domain reference selector") unless block_given?
+      # the property selector
+      @flt_sel = selector
+      # the reference filter
+      flt = 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|
+        # the reference property filter
+        attrs = attributes_to_visit(ref)
+        if attrs then
+          logger.debug { "#{qp} visiting #{ref} attributes #{attrs.pp_s(:single_line)}..." } if @verbose
+          # an enumerator on the reference properties
+          enum = ReferenceEnumerator.new(ref, attrs.properties)
+          # If there is a reference filter, then apply it to the enum references.
+          flt ? enum.filter(&flt) : enum
+        end
+      end
+    end
+    
+    private
+    
+    # @param [Resource] obj the visiting object
+    # @return [Propertied::Filter] the attributes to visit
+    def attributes_to_visit(obj)
+      @flt_sel.call(obj)
+    end
+  end
+end

data/lib/jinx/resource/unique.rb

@@ -0,0 +1,35 @@
+require 'jinx/helpers/uniquifier'
+
+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
+        Jinx.fail(TypeError, "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.
+    def uniquify
+      uniquify_attributes(self.class.secondary_key_attributes)
+      uniquify_attributes(self.class.alternate_key_attributes)
+    end
+    
+    # Makes the given attribute values unique by replacing each String value
+    # with a unique value.
+    def uniquify_attributes(attributes)
+      attributes.each do |ka|
+        oldval = send(ka)
+        next unless String === oldval
+        newval = uniquify_value(oldval)
+        set_property_value(ka, newval)
+        logger.debug { "Reset #{qp} #{ka} from #{oldval} to unique value #{newval}." }
+      end
+    end
+  end
+end

data/lib/jinx/version.rb

@@ -0,0 +1,3 @@
+module Jinx
+  VERSION = "2.1.1"
+end

data/spec/defaults_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module Model
+  describe 'Defaults' do
+    before(:all) do
+      Model.definitions BASE, DEFAULTS
+    end
+
+    it "should recognize the property default" do
+      Child.defaults[:cardinal].should be 1
+    end
+
+    it "should set the default property value" do
+      c = Child.new
+      c.add_defaults
+      c.cardinal.should be 1
+    end
+
+    it "should not reset a property value to the default" do
+      c = Child.new(:cardinal => 2)
+      c.add_defaults
+      c.cardinal.should be 2
+    end
+  
+    private
+
+    # The defaults fixture model definitions.
+    DEFAULTS = File.dirname(__FILE__) + '/definitions/model/defaults'
+  end
+end

data/spec/definitions/model/alias/child.rb

@@ -0,0 +1,5 @@
+module Model
+  class Child
+    property :friends, :alias => :pals
+  end
+end

data/spec/definitions/model/base/child.rb

@@ -0,0 +1,5 @@
+module Model
+  class Child
+    property :name, :secondary_key
+  end
+end

data/spec/definitions/model/base/domain_object.rb

@@ -0,0 +1,5 @@
+module Model
+  class DomainObject
+    property :identifier, :primary_key
+  end
+end

data/spec/definitions/model/base/independent.rb

@@ -0,0 +1,5 @@
+module Model
+  class Independent
+    property :others, :type => self
+  end
+end

data/spec/definitions/model/defaults/child.rb

@@ -0,0 +1,5 @@
+module Model
+  class Child
+    property :cardinal, :default => 1
+  end
+end

data/spec/definitions/model/dependency/child.rb

@@ -0,0 +1,5 @@
+module Model
+  class Child
+    property :dependent, :dependent
+  end
+end

data/spec/definitions/model/dependency/parent.rb

@@ -0,0 +1,6 @@
+module Model
+  class Parent
+    property :children, :dependent
+    property :dependent, :dependent
+  end
+end

data/spec/definitions/model/inverse/child.rb

@@ -0,0 +1,5 @@
+module Model
+  class Child
+    property :parent, :inverse => :children
+  end
+end

data/spec/definitions/model/inverse/independent.rb

@@ -0,0 +1,5 @@
+module Model
+  class Independent
+    property :others, :inverse => :others
+  end
+end

data/spec/definitions/model/inverse/parent.rb

@@ -0,0 +1,5 @@
+module Model
+  class Parent
+    property :spouse, :inverse => :spouse
+  end
+end

data/spec/definitions/model/mandatory/child.rb

@@ -0,0 +1,6 @@
+module Model
+  class Child
+    property :flag, :mandatory
+    property :dependent, :autogenerated
+  end
+end

data/spec/dependency_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module Model
+  describe 'Dependency' do
+    before(:all) do
+      Model.definitions BASE, DEPENDENCY
+    end
+    
+    context '1:1' do
+      it "should capture the dependents" do
+        d = Dependent.new
+        c = Child.new(:dependent => d)
+        c.dependents.should include d
+      end
+    end
+    
+    context '1:N' do
+      it "should set the inverses" do
+        Child.property(:parent).inverse.should be :children
+        Parent.property(:children).inverse.should be :parent
+      end
+
+      it "should capture the dependents" do
+        p = Parent.new
+        c = Child.new(:parent => p)
+        p.dependents.should include c
+      end
+
+      it "should fail to validate a missing owner" do
+        c = Child.new
+        expect { c.validate }.to raise_error(Jinx::ValidationError)
+      end
+
+      it "should validate an existing owner" do
+        p = Parent.new
+        c = Child.new(:parent => p, :name => 'Sam')
+        expect { c.validate }.to_not raise_error
+      end
+    end
+  
+    private
+  
+    # The dependency fixture model definitions.
+    # @private
+    DEPENDENCY = File.dirname(__FILE__) + '/definitions/model/dependency'
+  end
+end

data/spec/family_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+require File.dirname(__FILE__) + '/../examples/family/lib/family'
+
+module Family
+  describe DomainObject do
+    it "should set the primary key attribute" do
+      DomainObject.primary_key_attributes.should == [:identifier]
+    end
+  end
+  
+  describe Address do
+    it "should have an attribute => value constructor" do
+      Address.new(:state => 'OR').state.should == 'OR'
+    end
+    
+    it "should recognize an alias" do
+      a = Address.new(:postal_code => '95111')
+      a.zip.should == a.postal_code
+    end
+  end
+  
+  describe Parent do
+    it "should inherit the primary key" do
+      Parent.primary_key_attributes.should be DomainObject.primary_key_attributes
+    end
+    
+    it "should have a secondary key" do
+      Parent.secondary_key_attributes.should == [:ssn]
+    end
+    
+    it "should have a name property" do
+      Parent.property_defined?(:name).should be true
+    end
+    
+    it "should have a children dependent" do
+      Parent.property(:children).dependent?.should be true
+    end
+  end
+  
+  describe Child do
+    it "should have a parents owner" do
+      Child.property(:parents).owner?.should be true
+    end
+    
+    it "should add itself to the household inverse" do
+      h = Household.new
+      c = Child.new(:household => h)
+      h.members.should include c
+    end
+    
+    it "should not add itself to the parents inverse" do
+      p = Parent.new
+      c = Child.new(:parents => [p])
+      p.children.should_not include c
+    end
+  end
+  
+  describe Household do
+    it "should have a dependent address" do
+      a = Address.new
+      Household.new(:address => a).dependents.should include a
+    end
+  end
+end

data/spec/inverse_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module Model
+  describe 'Inverse' do
+    before(:all) do
+      Model.definitions BASE, INVERSE
+    end
+    
+    context '1:1' do
+      it "should set the inverse" do
+        Parent.property(:spouse).inverse.should == :spouse
+      end
+    
+      it "should set the target inverse type back to self" do
+        Parent.property(:spouse).inverse.should == :spouse
+      end
+    
+      it "should enforce inverse integrity" do
+        m = Parent.new
+        f = Parent.new(:spouse => m)
+        m.spouse.should be f
+      end
+    end
+    
+    context '1:N' do
+      it "should set the inverse" do
+        Child.property(:parent).inverse.should == :children
+      end
+
+      it "should set the target inverse type back to self" do
+        Parent.property(:children).inverse.should == :parent
+      end
+
+      it "should enforce inverse integrity" do
+        p = Parent.new
+        c = Child.new(:parent => p)
+        p.children.should include c
+      end
+    end
+    
+    context 'M:N' do
+      it "should set the inverse" do
+        Independent.property(:others).inverse.should == :others
+      end
+    end
+  
+    private
+  
+    # The inverse fixture model definitions.
+    # @private
+    INVERSE = File.dirname(__FILE__) + '/definitions/model/inverse'
+  end
+end