veritas 0.0.5 → 0.0.6

data/lib/veritas/relation/operation/order/direction_set.rb

@@ -7,9 +7,11 @@ module Veritas
 
         # A class that represents a tuple sort order for a set of attributes
         class DirectionSet
-          extend Aliasable
+          extend Aliasable, Comparator
           include Enumerable, Immutable
 
+          compare :to_ary
+
           inheritable_alias(:| => :union)
 
           # Instantiate a DirectionSet
@@ -24,7 +26,7 @@ module Veritas
           #
           # @api public
           def self.new(directions)
-            directions = coerce_directions(directions.to_ary)
+            directions = coerce_directions(directions)
             assert_unique_attributes(directions.map { |direction| direction.attribute })
             super
           end
@@ -37,7 +39,7 @@ module Veritas
           #
           # @api private
           def self.coerce_directions(directions)
-            directions.map { |direction| Ascending.coerce(direction) }
+            Array(directions).map { |direction| Ascending.coerce(direction) }
           end
 
           # Assert the attributes are unique
@@ -212,36 +214,7 @@ module Veritas
           #
           # @api public
           def ==(other)
-            other = self.class.coerce(other)
-            to_ary == other.to_ary
-          end
-
-          # Compare the directions with other directions for equality
-          #
-          # @example
-          #   directions.eql?(other)  # => true or false
-          #
-          # @param [DirectionSet] other
-          #   the other directions to compare with
-          #
-          # @return [Boolean]
-          #
-          # @api public
-          def eql?(other)
-            instance_of?(other.class) &&
-            to_ary.eql?(other.to_ary)
-          end
-
-          # Return the hash of the aliases
-          #
-          # @example
-          #   hash = directions.hash
-          #
-          # @return [Fixnum]
-          #
-          # @api public
-          def hash
-            self.class.hash ^ to_ary.hash
+            cmp?(__method__, coerce(other))
           end
 
           # Test if there are no directions
@@ -291,6 +264,17 @@ module Veritas
             end
           end
 
+          # Coerce directions into a DirectionSet
+          #
+          # @param [DirectionSet, Array<Direction, Attribute>]
+          #
+          # @return [DirectionSet]
+          #
+          # @api private
+          def coerce(object)
+            self.class.coerce(object)
+          end
+
           # Coerce directions into a DirectionSet
           #
           # @param [DirectionSet, Array<Direction, Attribute>]
@@ -302,7 +286,7 @@ module Veritas
             object.kind_of?(DirectionSet) ? object : new(object)
           end
 
-          memoize :hash, :reverse
+          memoize :reverse
 
         end # class DirectionSet
       end # class Order

data/lib/veritas/relation/operation/order.rb

@@ -8,6 +8,8 @@ module Veritas
       class Order < Relation
         include Unary
 
+        compare :operand, :directions
+
         # The relation sort order
         #
         # @return [Operation::Order::DirectionSet]
@@ -91,33 +93,6 @@ module Veritas
           self
         end
 
-        # Compare the Order with other relation for equality
-        #
-        # @example
-        #   order.eql?(other)  # => true or false
-        #
-        # @param [Relation] other
-        #   the other relation to compare with
-        #
-        # @return [Boolean]
-        #
-        # @api public
-        def eql?(other)
-          super && directions.eql?(other.directions)
-        end
-
-        # Return the hash of the order
-        #
-        # @example
-        #   hash = order.hash
-        #
-        # @return [Fixnum]
-        #
-        # @api public
-        def hash
-          super ^ directions.hash
-        end
-
         module Methods
 
           # Return an ordered relation
@@ -130,47 +105,20 @@ module Veritas
           #
           # @yieldparam [Relation] relation
           #
-          # @yieldreturn [Array<Direction>, Header]
+          # @yieldreturn [DirectionSet, Array<Direction>, Header]
           #
           # @return [Order]
           #
           # @api public
           def sort_by
             context = Evaluator::Context.new(header) { |context| yield context }
-            Order.new(self, Array(context.yield))
-          end
-
-          # Return an ordered relation (Deprecated)
-          #
-          # @deprecated Use #sort_by instead
-          #
-          # @example with no directions
-          #   order = relation.order  # sort by the header
-          #
-          # @example with a block
-          #   order = relation.order { |r| [ r.a.desc, r.b ] }
-          #
-          # @yield [relation]
-          #   optional block to evaluate for directions
-          #
-          # @yieldparam [Relation] relation
-          #
-          # @yieldreturn [Array<Direction>, Header]
-          #
-          # @return [Order]
-          #
-          # @api public
-          def order
-            warn "#{self.class}#order is deprecated and will be removed from Veritas 0.0.6"
-            sort_by { |context| block_given? ? yield(context) : header }
+            Order.new(self, context.yield)
           end
 
         end # module Methods
 
         Relation.class_eval { include Methods }
 
-        memoize :hash
-
       end # class Order
     end # module Operation
   end # class Relation

data/lib/veritas/relation.rb

@@ -4,8 +4,11 @@ module Veritas
 
   # Abstract base class for Relation operations
   class Relation
+    extend Comparator
     include Immutable, Enumerable, Visitable
 
+    compare :header, :to_set
+
     # The relation header
     #
     # @return [Header]
@@ -152,36 +155,7 @@ module Veritas
     def ==(other)
       other = coerce(other)
       header == other.header &&
-      to_set == project_relation(other).to_set
-    end
-
-    # Compare the relation with other relation for equality
-    #
-    # @example
-    #   relation.eql?(other)  # => true or false
-    #
-    # @param [Relation] other
-    #   the other relation to compare with
-    #
-    # @return [Boolean]
-    #
-    # @api public
-    def eql?(other)
-      instance_of?(other.class) &&
-      header.eql?(other.header) &&
-      to_set.eql?(project_relation(other).to_set)
-    end
-
-    # Return the hash of the relation
-    #
-    # @example
-    #   hash = relation.hash
-    #
-    # @return [Fixnum]
-    #
-    # @api public
-    def hash
-      self.class.hash ^ header.hash ^ to_set.hash
+      to_set == other.to_set
     end
 
     # Test if there are no tuples
@@ -200,17 +174,15 @@ module Veritas
 
     # Coerce an Enumerable into a Relation
     #
-    # @param [Enumerable] tuples
-    #   the tuples to coerce
+    # @param [Enumerable] object
+    #   the object to coerce
     #
     # @return [Relation]
     #
     # @api private
-    def coerce(tuples)
-      Relation.new(header, tuples)
+    def coerce(object)
+      project_relation(Relation.new(header, object))
     end
 
-    memoize :hash
-
   end # class Relation
 end # module Veritas

data/lib/veritas/support/aliasable.rb

@@ -17,15 +17,28 @@ module Veritas
     #
     # @api public
     def inheritable_alias(aliases)
-      aliases.each do |new_method, original_method|
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{new_method}(*args, &block)          # def |(*args, &block)
-            self.#{original_method}(*args, &block)  #   self.union(*args, &block)
-          end                                       # end
-        RUBY
-      end
+      aliases.each { |methods| define_inheritable_alias_method(*methods) }
       self
     end
 
+  private
+
+    # Create a new method alias for the original method
+    #
+    # @param [Symbol] new_method
+    #
+    # @param [Symbol] original_method
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_inheritable_alias_method(new_method, original_method)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{new_method}(*args, &block)          # def |(*args, &block)
+          self.#{original_method}(*args, &block)  #   self.union(*args, &block)
+        end                                       # end
+      RUBY
+    end
+
   end # module Aliasable
 end # module Veritas

data/lib/veritas/support/comparator.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module Veritas
+
+  # Allows objects to be compared
+  module Comparator
+
+    # Setup default comparison methods for the object
+    #
+    # @example
+    #   compare :left, :right
+    #
+    # @param [Array<Symbol>] *methods
+    #
+    # @return [self]
+    #
+    # @api public
+    def compare(*methods)
+      include Methods
+      define_hash_method(methods)
+      define_comparison_method(methods)
+      memoize :hash
+      private :cmp?
+      self
+    end
+
+  private
+
+    # Define a #hash method on the object
+    #
+    # The list of methods specify which methods' return values should be hashed
+    # and XOR'd together with the class's hash.
+    #
+    # @param [Array<#to_s>] methods
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_hash_method(methods)
+      define_method(:hash) do
+        self.class.hash ^ methods.map { |method| send(method).hash }.inject(:^)
+      end
+    end
+
+    # Define a private comparison method on the object
+    #
+    # The list of methods specify which methods' return values should be
+    # compared together using #== or #eql?
+    #
+    # @param [Array<#to_s>] methods
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_comparison_method(methods)
+      define_method(:cmp?) do |comparator, other|
+        methods.all? { |method| send(method).send(comparator, other.send(method)) }
+      end
+    end
+
+    # The comparison methods
+    module Methods
+
+      # Compare the object with other object for equality
+      #
+      # @example
+      #   object.eql?(other)  # => true or false
+      #
+      # @param [Object] other
+      #   the other object to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class) && cmp?(__method__, other)
+      end
+
+    end # module Methods
+  end # module Comparator
+end # module Veritas

data/lib/veritas/support/evaluator.rb

@@ -82,7 +82,7 @@ module Veritas
       #
       # @api private
       def respond_to?(name, *)
-        !!self[name]
+        self[name] ? true : false
       end
 
       # Forward a message to the object

data/lib/veritas/support/immutable.rb

@@ -29,7 +29,7 @@ module Veritas
     #
     # @api public
     def freeze
-      @__memory = Memory.new unless frozen?
+      @__memory = {} unless frozen?
       super
     end
 
@@ -38,14 +38,14 @@ module Veritas
     # @example
     #   hash = object.memoized(:hash)
     #
-    # @param [#to_s] name
+    # @param [Symbol] name
     #   the method name
     #
     # @return [Object]
     #
     # @api public
     def memoized(name)
-      @__memory["@#{name}"]
+      @__memory[name]
     end
 
     # Sets a memoized value for a method
@@ -53,7 +53,7 @@ module Veritas
     # @example
     #   object.memoize(:hash, 12345)
     #
-    # @param [#to_s] name
+    # @param [Symbol] name
     #   the method name
     # @param [Object] value
     #   the value to memoize
@@ -62,7 +62,9 @@ module Veritas
     #
     # @api public
     def memoize(name, value)
-      @__memory["@#{name}"] = Immutable.freeze_object(value)
+      unless @__memory.key?(name)
+        @__memory[name] = Immutable.freeze_object(value)
+      end
       self
     end
 
@@ -95,10 +97,10 @@ module Veritas
     # @api public
     def self.freeze_object(object)
       case object
-        when Numeric, TrueClass, FalseClass, NilClass, Symbol
-          object
-        else
-          freeze_value(object)
+      when Numeric, TrueClass, FalseClass, NilClass, Symbol
+        object
+      else
+        freeze_value(object)
       end
     end
 
@@ -161,23 +163,27 @@ module Veritas
       # @api private
       def memoize_method(method)
         visibility = method_visibility(method)
-        create_memoize_method_for(method)
+        define_memoize_method(method)
         send(visibility, method)
       end
 
-      # Create a memoized method that delegates to the original method
+      # Define a memoized method that delegates to the original method
       #
-      # @param [String, Symbol] method
+      # @param [Symbol] method
       #   the name of the method
       #
       # @return [undefined]
       #
       # @api private
-      def create_memoize_method_for(method)
+      def define_memoize_method(method)
         original = instance_method(method)
-        ivar     = "@#{method}"
-        send(:define_method, method) do |*args|
-          @__memory[ivar] ||= Immutable.freeze_object(original.bind(self).call(*args))
+        undef_method(method)
+        define_method(method) do |*args|
+          if @__memory.key?(method)
+            @__memory.fetch(method)
+          else
+            @__memory[method] = Immutable.freeze_object(original.bind(self).call(*args))
+          end
         end
       end
 
@@ -214,38 +220,5 @@ module Veritas
       end
 
     end # module ClassMethods
-
-    # Tracks the values for memoized methods
-    class Memory
-
-      # Get a frozen value from memory
-      #
-      # @example
-      #   value = memory[ivar]
-      #
-      # @param [#to_s] ivar
-      #   the name of the ivar to get the value for
-      #
-      # @return [Object]
-      #
-      # @api public
-      alias [] instance_variable_get
-
-      # Set a frozen value in memory
-      #
-      # @example
-      #   memory[ivar] = value
-      #
-      # @param [#to_s] ivar
-      #   the name of the ivar to set
-      # @param [Object] value
-      #   the value to set
-      #
-      # @return [undefined]
-      #
-      # @api public
-      alias []= instance_variable_set
-
-    end # class Memory
   end # module Immutable
 end # module Veritas

data/lib/veritas/support/operation/binary.rb

@@ -3,8 +3,11 @@
 module Veritas
   module Operation
     module Binary
+      extend Comparator
       include Immutable
 
+      compare :left, :right
+
       # The left operand for the operation
       #
       # @example
@@ -40,36 +43,6 @@ module Veritas
         @right = Immutable.freeze_object(right)
       end
 
-      # Compare the operation with the other operation for equality
-      #
-      # @example
-      #   binary.eql?(other)  # => true or false
-      #
-      # @param [Object] other
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def eql?(other)
-        instance_of?(other.class) &&
-        left.eql?(other.left)     &&
-        right.eql?(other.right)
-      end
-
-      # Return the hash of the left and right operands
-      #
-      # @example
-      #   hash = binary.hash
-      #
-      # @return [Fixnum]
-      #
-      # @api public
-      def hash
-        self.class.hash ^ left.hash ^ right.hash
-      end
-
-      memoize :hash
-
     end # module Binary
   end # module Operation
 end # module Veritas

data/lib/veritas/support/operation/unary.rb

@@ -3,8 +3,11 @@
 module Veritas
   module Operation
     module Unary
+      extend Comparator
       include Immutable
 
+      compare :operand
+
       # The operand to the operation
       #
       # @example
@@ -27,35 +30,6 @@ module Veritas
         @operand = Immutable.freeze_object(operand)
       end
 
-      # Compare the operation with the other operation for equality
-      #
-      # @example
-      #   unary.eql?(other)  # => true or false
-      #
-      # @param [Object] other
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def eql?(other)
-        instance_of?(other.class) &&
-        operand.eql?(other.operand)
-      end
-
-      # Return the hash of the operand
-      #
-      # @example
-      #   hash = unary.hash
-      #
-      # @return [Fixnum]
-      #
-      # @api public
-      def hash
-        self.class.hash ^ operand.hash
-      end
-
-      memoize :hash
-
     end # module Unary
   end # module Operation
 end # module Veritas

data/lib/veritas/tuple.rb

@@ -4,8 +4,11 @@ module Veritas
 
   # A set of objects representing a unique fact in a relation
   class Tuple
+    extend Comparator
     include Immutable
 
+    compare :data
+
     # The tuple header
     #
     # @return [Header]
@@ -136,48 +139,35 @@ module Veritas
     #
     # @api public
     def ==(other)
-      other = self.class.coerce(header, other)
-      data == other.data
+      cmp?(__method__, coerce(other))
     end
 
-    # Compare the tuple with other tuple for equality
+    # Return a string representing the tuple data
     #
     # @example
-    #   tuple == other  # => true or false
-    #
-    # @param [Tuple] other
-    #   the other tuple to compare with
+    #   tuple.inspect  # => "{<Attribute::Integer name: id>=>1}"
     #
-    # @return [Boolean]
+    # @return [String]
     #
     # @api public
-    def eql?(other)
-      instance_of?(other.class) &&
-      data.eql?(other.data)
+    def inspect
+      data.inspect
     end
 
-    # Return the hash of the tuple
-    #
-    # @example
-    #   hash = tuple.hash
-    #
-    # @return [Fixnum]
-    #
-    # @api public
-    def hash
-      self.class.hash ^ data.hash
-    end
+  private
 
-    # Return a string representing the tuple data
+    # Coerce an Array-like object into a Tuple
     #
-    # @example
-    #   tuple.inspect  # => "{<Attribute::Integer name: id>=>1}"
+    # @param [Header] header
+    #   the tuple header
+    # @param [Tuple, #to_ary]
+    #   the tuple or tuple data
     #
-    # @return [String]
+    # @return [Tuple]
     #
-    # @api public
-    def inspect
-      data.inspect
+    # @api private
+    def coerce(object)
+      self.class.coerce(header, object)
     end
 
     # Coerce an Array-like object into a Tuple

data/lib/veritas/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Veritas
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end # module Veritas