veritas 0.0.6 → 0.0.7

data/lib/veritas/function/string/length.rb

@@ -44,7 +44,6 @@ module Veritas
         end
 
         module Methods
-          extend Aliasable
 
           # Return a length function
           #

data/lib/veritas/function/unary.rb

@@ -10,6 +10,41 @@ module Veritas
 
         compare :operand
 
+        # Mixin for adding #call to unary function classes
+        module Callable
+
+          # Hook called when module is included
+          #
+          # @param [Module] descendant
+          #   the module or class including Callable
+          #
+          # @return [self]
+          #
+          # @api private
+          def included(descendant)
+            super
+            descendant.extend(Callable)
+            self
+          end
+
+          # Return the response from the unary operation called on the value
+          #
+          # @example
+          #   callable.call(value)  # => any object
+          #
+          # @param [Object] value
+          #
+          # @return [Object]
+          #
+          # @api public
+          def call(value)
+            value.send(operation)
+          end
+
+        end # module Callable
+
+        extend Callable
+
         # Evaluate the unary connective using the tuple
         #
         # @example
@@ -70,6 +105,18 @@ module Veritas
           cmp?(__method__, other)
         end
 
+        # Return a string representing the unary function
+        #
+        # @example
+        #   unary.inspect  # => "+1"
+        #
+        # @return [String]
+        #
+        # @api public
+        def inspect
+          "#{self.class.operation.to_s.upcase.chomp('@')}(#{operand.inspect})"
+        end
+
         # Mixin for invertable unary functions
         module Invertible
 

data/lib/veritas/relation.rb

@@ -112,7 +112,7 @@ module Veritas
       seen = {}
       tuples.each do |tuple|
         tuple = Tuple.coerce(header, tuple)
-        yield(seen[tuple] = tuple) unless seen.key?(tuple)
+        yield seen[tuple] = tuple unless seen.key?(tuple)
       end
       self
     end
@@ -181,7 +181,21 @@ module Veritas
     #
     # @api private
     def coerce(object)
-      project_relation(Relation.new(header, object))
+      self.class.coerce(header, object)
+    end
+
+    # Coerce an Enumerable into a Relation
+    #
+    # @param [Header] header
+    #   the header to use when initializing a Relation
+    # @param [Enumerable] object
+    #   the object to coerce
+    #
+    # @return [Relation]
+    #
+    # @api private
+    def self.coerce(header, object)
+      object.kind_of?(Relation) ? object : Relation.new(header, object)
     end
 
   end # class Relation

data/lib/veritas/relation/header.rb

@@ -11,9 +11,10 @@ module Veritas
       compare :to_set
 
       inheritable_alias(
-        :& => :intersect,
-        :| => :union,
-        :- => :difference
+        :[] => :call,
+        :&  => :intersect,
+        :|  => :union,
+        :-  => :difference
       )
 
       # Instantiate a Header
@@ -24,12 +25,12 @@ module Veritas
       # @param [#to_ary] attributes
       #   optional attributes
       #
-      # @return [undefined]
+      # @return [Header]
       #
       # @api public
-      def self.new(attributes = [])
-        attributes = coerce_attributes(attributes.to_ary)
-        assert_unique_attributes(attributes)
+      def self.new(attributes = nil)
+        attributes = coerce_attributes(attributes)
+        assert_unique_names(attributes.map { |attribute| attribute.name })
         super
       end
 
@@ -41,44 +42,53 @@ module Veritas
       #
       # @api private
       def self.coerce_attributes(attributes)
-        attributes.map { |attribute| Attribute.coerce(attribute) }
+        Array(attributes).map { |attribute| coerce_attribute(attribute) }
       end
 
-      # Assert the attributes are unique
+      # Coerce the attribute into an Attribute
       #
-      # @param [Array<Attribute>] attributes
+      # @param [Object] attribute
+      #
+      # @return [Attribute]
+      #
+      # @api private
+      def self.coerce_attribute(attribute)
+        Attribute.coerce(attribute)
+      end
+
+      # Assert the names are unique
+      #
+      # @param [Array<Symbol>] names
       #
       # @return [undefined]
       #
-      # @raise [DuplicateAttributeError]
-      #   raised if the attributes are not unique
+      # @raise [DuplicateNameError]
+      #   raised if the names are not unique
       #
       # @api private
-      def self.assert_unique_attributes(attributes)
-        duplicates = duplicate_attributes(attributes)
+      def self.assert_unique_names(names)
+        duplicates = duplicate_names(names)
         if duplicates
-          raise DuplicateAttributeError, "duplicate attributes: #{duplicates.join(', ')}"
+          raise DuplicateNameError, "duplicate names: #{duplicates.join(', ')}"
         end
       end
 
-      # Returns the duplicate attribute names, if any
+      # Returns the duplicate names, if any
       #
-      # @param [Array<Attribute>] attributes
+      # @param [Array<Symbol>] names
       #
       # @return [Array<Symbol>]
-      #   returns an array of duplicate attributes
+      #   returns an array of duplicate names
       #
       # @return [nil]
-      #   returns nil if there are no duplicate attributes
+      #   returns nil if there are no duplicate names
       #
       # @api private
-      def self.duplicate_attributes(attributes)
-        names = attributes.map { |attribute| attribute.name }
-        names.select! { |name| names.count(name) > 1 }
-        names.uniq!
+      def self.duplicate_names(names)
+        names.select { |name| names.count(name) > 1 }.uniq!
       end
 
-      private_class_method :coerce_attributes, :assert_unique_attributes, :duplicate_attributes
+      private_class_method :coerce_attributes, :coerce_attribute, :assert_unique_names, :duplicate_names
 
       # Initialize a Header
       #
@@ -91,8 +101,8 @@ module Veritas
       #
       # @api public
       def initialize(attributes)
-        @names      = attributes.map { |attribute| attribute.name }
-        @attributes = Hash[@names.zip(attributes)]
+        @attributes    = Immutable.freeze_object(attributes)
+        @attribute_for = Hash[@attributes.map { |attribute| attribute.name }.zip(@attributes)]
       end
 
       # Iterate over each attribute in the header
@@ -111,25 +121,25 @@ module Veritas
       # @api public
       def each
         return to_enum unless block_given?
-        @names.each { |name| yield @attributes.fetch(name) }
+        to_ary.each { |attribute| yield attribute }
         self
       end
 
       # Lookup an attribute in the header given a name
       #
       # @example
-      #   attribute = header[:id]
+      #   attribute = header.call(:id)
       #
       # @param [Attribute, #to_ary, #to_sym] name
       #
       # @return [Attribute]
       #   the attribute when the name is known
       # @return [nil]
-      #   nil when the attribute is unknown
+      #   nil when the name is unknown
       #
       # @api public
-      def [](name)
-        @attributes[Attribute.name_from(name)]
+      def call(name)
+        @attribute_for[Attribute.name_from(name)]
       end
 
       # Return a header with only the attributes specified
@@ -142,7 +152,7 @@ module Veritas
       #
       # @return [Header]
       #
-      # @api private
+      # @api public
       def project(attributes)
         new(attributes.map { |attribute| self[attribute] })
       end
@@ -204,7 +214,7 @@ module Veritas
       #
       # @api private
       def to_ary
-        @attributes.values_at(*@names).freeze
+        @attributes
       end
 
       # Compare the header with other header for equivalency
@@ -231,7 +241,7 @@ module Veritas
       #
       # @api public
       def empty?
-        @names.empty?
+        to_ary.empty?
       end
 
       # Return a string representing the header
@@ -250,14 +260,13 @@ module Veritas
 
       # Utility method to instantiate a Header
       #
-      # @param [#to_ary] attributes
-      #   the header attributes
+      # @param [Array] *args
       #
       # @return [Header]
       #
       # @api private
-      def new(attributes)
-        self.class.new(attributes)
+      def new(*args)
+        self.class.new(*args)
       end
 
       # Coerce the object into a Header
@@ -281,11 +290,9 @@ module Veritas
       #
       # @api private
       def self.coerce(object)
-        object.kind_of?(Header) ? object : new(object)
+        object.kind_of?(self) ? object : new(object)
       end
 
-      memoize :to_ary
-
     end # class Header
   end # class Relation
 end # module Veritas

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

@@ -31,6 +31,18 @@ module Veritas
             @attribute = attribute
           end
 
+          # Return the attribute name
+          #
+          # @example
+          #   direction.name  # => :id
+          #
+          # @return [Symbol]
+          #
+          # @api public
+          def name
+            attribute.name
+          end
+
           # Compare the left and right Tuple attribute values
           #
           # @example
@@ -51,7 +63,7 @@ module Veritas
           # @api public
           def call(left, right)
             attribute = self.attribute
-            self.class.call(left[attribute], right[attribute])
+            self.class.call(attribute.call(left), attribute.call(right))
           end
 
           # Rename the contained attribute with the provided aliases

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

@@ -6,108 +6,23 @@ module Veritas
       class Order
 
         # A class that represents a tuple sort order for a set of attributes
-        class DirectionSet
-          extend Aliasable, Comparator
-          include Enumerable, Immutable
+        class DirectionSet < Header
+          EMPTY = new
 
           compare :to_ary
 
-          inheritable_alias(:| => :union)
-
-          # Instantiate a DirectionSet
-          #
-          # @example
-          #   directions = DirectionSet.new(directions)
-          #
-          # @param [#to_ary] directions
-          #   optional attributes
-          #
-          # @return [undefined]
-          #
-          # @api public
-          def self.new(directions)
-            directions = coerce_directions(directions)
-            assert_unique_attributes(directions.map { |direction| direction.attribute })
-            super
-          end
-
-          # Coerce the attributes into an Array of Direction objects
-          #
-          # @param [Array<Direction>] attributes
-          #
-          # @return [Array<Direction>]
-          #
-          # @api private
-          def self.coerce_directions(directions)
-            Array(directions).map { |direction| Ascending.coerce(direction) }
-          end
-
-          # Assert the attributes are unique
-          #
-          # @param [Array<Attribute>] attributes
-          #
-          # @return [undefined]
-          #
-          # @raise [DuplicateAttributeError]
-          #   raised if the attributes are not unique
-          #
-          # @api private
-          def self.assert_unique_attributes(attributes)
-            duplicates = duplicate_attributes(attributes)
-            if duplicates
-              raise DuplicateAttributeError, "duplicate attributes: #{duplicates.join(', ')}"
-            end
-          end
-
-          # Returns the duplicate attribute names, if any
-          #
-          # @param [Array<Attribute>] attributes
-          #
-          # @return [Array<Symbol>]
-          #   returns an array of duplicate attributes
+          # Coerce the attribute into a Direction
           #
-          # @return [nil]
-          #   returns nil if there are no duplicate attributes
+          # @param [Object] attribute
           #
-          # @api private
-          def self.duplicate_attributes(attributes)
-            names = attributes.map { |attribute| attribute.name }
-            names.select! { |name| names.count(name) > 1 }
-            names.uniq!
-          end
-
-          private_class_method :coerce_directions, :assert_unique_attributes, :duplicate_attributes
-
-          # Initialize a DirectionSet
-          #
-          # @param [Array<Direction>] directions
-          #   the directions to sort with
-          #
-          # @return [undefined]
+          # @return [Direction]
           #
           # @api private
-          def initialize(directions)
-            @directions = directions
+          def self.coerce_attribute(attribute)
+            Ascending.coerce(attribute)
           end
 
-          EMPTY = new([])
-
-          # Return a direction set with only the attributes specified
-          #
-          # @example
-          #   projected = directions.project([ attribute ])
-          #
-          # @param [Array<Attribute>] attributes
-          #   the attributes to keep in the direction set
-          #
-          # @return [DirectionSet]
-          #
-          # @api public
-          def project(attributes)
-            new select { |direction|
-              attributes.include?(direction.attribute)
-            }
-          end
+          private_class_method :coerce_attribute
 
           # Rename the contained attributes with the provided aliases
           #
@@ -136,50 +51,6 @@ module Veritas
             new(map { |direction| direction.reverse })
           end
 
-          # Iterate over each direction in the set
-          #
-          # @example
-          #   directions = DirectionSet.new(directions)
-          #   directions.each { |direction| ... }
-          #
-          # @yield [direction]
-          #
-          # @yieldparam [Direction] direction
-          #   each direction in the set
-          #
-          # @return [self]
-          #
-          # @api public
-          def each
-            return to_enum unless block_given?
-            to_ary.each { |tuple| yield tuple }
-            self
-          end
-
-          # Return the directions as an Array
-          #
-          # @return [Array]
-          #
-          # @api private
-          def to_ary
-            @directions
-          end
-
-          # Union the directions with another set of directions
-          #
-          # @example
-          #   union = directions.union(other)
-          #
-          # @param [DirectionSet] other
-          #   the directions to union with
-          #
-          # @return [DirectionSet]
-          #
-          # @api public
-          def union(other)
-            new(to_ary | other.to_ary)
-          end
-
           # Return each attribute in an Array
           #
           # @return [Array]
@@ -202,46 +73,8 @@ module Veritas
             tuples.sort { |left, right| cmp_tuples(left, right) }
           end
 
-          # Compare the directions with other directions for equivalency
-          #
-          # @example
-          #   directions == other  # => true or false
-          #
-          # @param [DirectionSet] other
-          #   the other directions to compare with
-          #
-          # @return [Boolean]
-          #
-          # @api public
-          def ==(other)
-            cmp?(__method__, coerce(other))
-          end
-
-          # Test if there are no directions
-          #
-          # @example
-          #   directions.empty?  # => true or false
-          #
-          # @return [Boolean]
-          #
-          # @api public
-          def empty?
-            @directions.empty?
-          end
-
         private
 
-          # Utility method for initializing a set of directions
-          #
-          # @param [Array<Direction>] directions
-          #
-          # @return [DirectionSet]
-          #
-          # @api private
-          def new(directions)
-            self.class.new(directions)
-          end
-
           # Compare the attributes for each Tuple
           #
           # @param [Tuple] left
@@ -264,29 +97,7 @@ 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>]
-          #
-          # @return [DirectionSet]
-          #
-          # @api private
-          def self.coerce(object)
-            object.kind_of?(DirectionSet) ? object : new(object)
-          end
-
-          memoize :reverse
+          memoize :reverse, :attributes
 
         end # class DirectionSet
       end # class Order