axiom 0.1.1 → 0.2.0

data/lib/axiom/function/numeric/exponentiation.rb

@@ -31,7 +31,7 @@ module Axiom
         #
         # @api public
         def inverse
-          self.class.new(left, Division.new(1, right)).memoize(:inverse, self)
+          self.class.new(left, Division.new(1, right)).memoize(inverse: self)
         end
 
         module Methods

data/lib/axiom/function/numeric/square_root.rb

@@ -46,7 +46,7 @@ module Axiom
         #
         # @api public
         def inverse
-          Exponentiation.new(operand, 2).memoize(:inverse, self)
+          Exponentiation.new(operand, 2).memoize(inverse: self)
         end
 
         # Return the type returned from #call

data/lib/axiom/function/predicate/enumerable.rb

@@ -18,20 +18,6 @@ module Axiom
           enumerable.respond_to?(:cover?) ? :cover? : :include?
         end
 
-        # Initialize an Enumerable predicate
-        #
-        # @param [Object] left
-        #   the attribute or object to test for in the Enumerable
-        # @param [Enumerable] right
-        #   the enumerable to test
-        #
-        # @return [undefined]
-        #
-        # @api private
-        def initialize(left, right)
-          super(left, freeze_object(right))
-        end
-
         # Evaluate the enumerable function using the tuple
         #
         # @example

data/lib/axiom/function/predicate/exclusion.rb

@@ -22,7 +22,7 @@ module Axiom
         #
         # @api public
         def self.call(left, right)
-          ! right.send(Enumerable.compare_method(right), left)
+          !right.public_send(Enumerable.compare_method(right), left)
         end
 
         # Return the inverse predicate class

data/lib/axiom/function/predicate/inclusion.rb

@@ -22,7 +22,7 @@ module Axiom
         #
         # @api public
         def self.call(left, right)
-          right.send(Enumerable.compare_method(right), left)
+          right.public_send(Enumerable.compare_method(right), left)
         end
 
         # Return the inverse predicate class

data/lib/axiom/function/proposition.rb

@@ -5,8 +5,7 @@ module Axiom
 
     # Abstract base class for logical propositions
     class Proposition < Function
-      include AbstractType,
-              Singleton,
+      include Singleton,
               Function::Connective::Conjunction::Methods,
               Function::Connective::Disjunction::Methods,
               Function::Connective::Negation::Methods
@@ -24,36 +23,24 @@ module Axiom
         Types::Boolean
       end
 
-      # Instantiate a new Proposition
+      # Coerce a boolean into a proposition
       #
-      # @example using a true value
-      #   tautology = Proposition.new(true)
-      #
-      # @example using a false value
-      #   contradiction = Proposition.new(false)
+      # @param [Object] object
       #
       # @return [Proposition]
+      #   returned twhen the object can be coerced into a proposition
       #
-      # @overload self.new(true)
-      #   Return the Tautology singleton instance
-      #
-      #   @param [Array(true)] args
-      #
-      #   @return [Tautology]
-      #
-      # @overload self.new(false)
-      #   Return the Contradiction singleton instance
-      #
-      #   @param [Array(false)] args
-      #
-      #   @return [Contradiction]
+      # @raise [ArgumentError]
+      #   raised when the object cannot be coerced into a proposition
       #
       # @api public
-      def self.new(*args)
-        if args.empty?
-          super
+      def self.coerce(object)
+        case object
+        when Proposition then object
+        when true        then Tautology.instance
+        when false       then Contradiction.instance
         else
-          (args.first.equal?(true) ? Tautology : Contradiction).instance
+          fail ArgumentError, "Invalid object #{object.inspect}"
         end
       end
 

data/lib/axiom/function/unary.rb

@@ -3,134 +3,120 @@
 module Axiom
   class Function
 
-      # Mixin for unary functions
-      module Unary
-        include Operation::Unary
-        include Equalizer.new(:operand)
+    # Mixin for unary functions
+    module Unary
+      include Operation::Unary
+      include Equalizer.new(:operand)
 
-        # Mixin for adding #call to unary function classes
-        module Callable
+      # 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
+        # Hook called when module is included
         #
-        # @example
-        #   unary.call(tuple)  # => true or false
-        #
-        # @param [Tuple] tuple
-        #   the tuple to pass to operand#call
+        # @param [Module] descendant
+        #   the module or class including Callable
         #
-        # @return [Boolean]
+        # @return [self]
         #
-        # @api public
-        def call(tuple)
-          util = self.class
-          util.call(util.extract_value(operand, tuple))
+        # @api private
+        def included(descendant)
+          super
+          descendant.extend(Callable)
+          self
         end
 
-        # Rename the contained attributes with the provided aliases
+        # Return the response from the unary operation called on the value
         #
         # @example
-        #   renamed = unary.rename(aliases)
+        #   callable.call(value)  # => any object
         #
-        # @param [Algebra::Rename::Aliases] aliases
-        #   the old and new attributes
+        # @param [Object] value
         #
-        # @return [self]
-        #   if the operand is not renamed
-        # @return [Unary]
-        #   if the operand is renamed
-        #
-        # @todo handle case where operand is a literal
+        # @return [Object]
         #
         # @api public
-        def rename(aliases)
-          util            = self.class
-          renamed_operand = util.rename_attributes(operand, aliases)
-
-          if operand.equal?(renamed_operand)
-            self
-          else
-            util.new(renamed_operand)
-          end
+        def call(value)
+          value.public_send(operation)
         end
 
-        # Return the type returned from #call
+      end # module Callable
+
+      extend Callable
+
+      # Evaluate the unary connective using the tuple
+      #
+      # @example
+      #   unary.call(tuple)  # => true or false
+      #
+      # @param [Tuple] tuple
+      #   the tuple to pass to operand#call
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def call(tuple)
+        util = self.class
+        util.call(util.extract_value(operand, tuple))
+      end
+
+      # Rename the contained attributes with the provided aliases
+      #
+      # @example
+      #   renamed = unary.rename(aliases)
+      #
+      # @param [Algebra::Rename::Aliases] aliases
+      #   the old and new attributes
+      #
+      # @return [self]
+      #   if the operand is not renamed
+      # @return [Unary]
+      #   if the operand is renamed
+      #
+      # @todo handle case where operand is a literal
+      #
+      # @api public
+      def rename(aliases)
+        util            = self.class
+        renamed_operand = util.rename_attributes(operand, aliases)
+
+        if operand.equal?(renamed_operand)
+          self
+        else
+          util.new(renamed_operand)
+        end
+      end
+
+      # Return the type returned from #call
+      #
+      # @example
+      #   type = unary.type  # => Axiom::Types::Numeric
+      #
+      # @return [Class<Types::Numeric>]
+      #
+      # @api public
+      def type
+        Attribute.infer_type(operand)
+      end
+
+      # Mixin for invertable unary functions
+      module Invertible
+        include Adamantium
+
+        # Return the inverse function
         #
         # @example
-        #   type = unary.type  # => Axiom::Types::Numeric
+        #   inverse = function.inverse
         #
-        # @return [Class<Types::Numeric>]
+        # @return [Function]
         #
         # @api public
-        def type
-          Attribute.infer_type(operand)
+        def inverse
+          self.class.inverse.new(operand).memoize(inverse: self)
         end
 
-        # Mixin for invertable unary functions
-        module Invertible
-
-          # Hook called when module is included
-          #
-          # @param [Module] descendant
-          #   the module or class including Invertible
-          #
-          # @return [undefined]
-          #
-          # @api private
-          def self.included(descendant)
-            super
-            descendant.memoize :inverse
-          end
-
-          private_class_method :included
-
-          # Return the inverse function
-          #
-          # @example
-          #   inverse = function.inverse
-          #
-          # @return [Function]
-          #
-          # @todo move this to classes that use it
-          #
-          # @api public
-          def inverse
-            self.class.inverse.new(operand).memoize(:inverse, self)
-          end
+        memoize :inverse
 
-        end # module Invertible
-      end # module Unary
+      end # module Invertible
+    end # module Unary
   end # class Function
 end # module Axiom

data/lib/axiom/relation.rb

@@ -24,11 +24,11 @@ module Axiom
 
     # The relation sort order
     #
-    # @return [Operation::Order::DirectionSet]
+    # @return [Operation::Sorted::DirectionSet]
     #
     # @api private
     def directions
-      Operation::Order::DirectionSet::EMPTY
+      Operation::Sorted::DirectionSet::EMPTY
     end
 
     # Instantiate a new Relation
@@ -238,7 +238,7 @@ module Axiom
     #
     # @api private
     def self.coerce(header, object)
-      if object.kind_of?(Relation) || ! object.kind_of?(Enumerable)
+      if object.kind_of?(Relation) || !object.kind_of?(Enumerable)
         object
       else
         Relation.new(header, object)

data/lib/axiom/relation/base.rb

@@ -34,6 +34,21 @@ module Axiom
         @name = name.to_sym
       end
 
+      # Compare the base relation with other relation for equivalency
+      #
+      # @example
+      #   base == other  # => true or false
+      #
+      # @param [Relation] other
+      #   the other relation to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        super && (!other.respond_to?(:name) || name == other.name)
+      end
+
     end # class Base
   end # class Relation
 end # module Axiom

data/lib/axiom/relation/header.rb

@@ -10,7 +10,7 @@ module Axiom
       include Equalizer.new(:to_set, :keys)
 
       inheritable_alias(
-        :[] => :call,
+        :[] => :fetch,
         :&  => :intersect,
         :|  => :union,
         :-  => :difference
@@ -23,6 +23,16 @@ module Axiom
       # @api private
       attr_reader :keys
 
+      # Convert the Header into an Array
+      #
+      # @example
+      #   array = header.to_ary
+      #
+      # @return [Array]
+      #
+      # @api public
+      attr_reader :to_ary
+
       # Coerce an Array-like object into a Header
       #
       # @param [Header, #to_ary] object
@@ -61,7 +71,7 @@ module Axiom
       # @return [Header]
       #
       # @api public
-      def self.new(attributes = EMPTY_ARRAY, _options = EMPTY_HASH)
+      def self.new(attributes = EMPTY_ARRAY, *)
         assert_unique_names(attributes.map(&:name))
         super
       end
@@ -90,7 +100,7 @@ module Axiom
       def self.assert_unique_names(names)
         duplicates = duplicate_names(names)
         if duplicates
-          raise DuplicateNameError, "duplicate names: #{duplicates.inspect}"
+          fail DuplicateNameError, "duplicate names: #{duplicates}"
         end
       end
 
@@ -123,9 +133,9 @@ module Axiom
       # @return [undefined]
       #
       # @api public
-      def initialize(attributes, options)
-        @attributes    = freeze_object(attributes)
-        @attribute_for = Hash[@attributes.map(&:name).zip(@attributes)]
+      def initialize(attributes, options = EMPTY_HASH)
+        @to_ary        = self.class.freezer.call(attributes)
+        @attribute_for = Hash[@to_ary.map(&:name).zip(@to_ary)]
         @keys          = coerce_keys(options.fetch(:keys, EMPTY_ARRAY))
       end
 
@@ -160,9 +170,9 @@ module Axiom
       #   the attribute when the name is known
       #
       # @api public
-      def call(name)
+      def fetch(name)
         @attribute_for.fetch(Attribute.name_from(name)) do |attribute_name|
-          raise(
+          fail(
             UnknownAttributeError,
             "the attribute #{attribute_name} is unknown"
           )
@@ -220,10 +230,8 @@ module Axiom
       #
       # @api public
       def rename(aliases)
-        new(
-          map { |attribute| aliases[attribute] },
-          keys: keys.rename(aliases)
-        )
+        aliases = Algebra::Rename::Aliases.coerce(self, aliases)
+        new(map(&aliases.method(:[])), keys: keys.rename(aliases))
       end
 
       # Return the intersection of the header with another header
@@ -296,16 +304,13 @@ module Axiom
         Evaluator::Context.new(self, &block)
       end
 
-      # Convert the Header into an Array
+      # The number of attributes
       #
-      # @example
-      #   array = header.to_ary
-      #
-      # @return [Array]
+      # @return [Integer]
       #
       # @api public
-      def to_ary
-        @attributes
+      def size
+        to_ary.size
       end
 
       # Test if there are no attributes
@@ -352,9 +357,7 @@ module Axiom
       #
       # @api private
       def coerce(*args)
-        self.class.coerce(*args) do |attribute|
-          @attribute_for[attribute]
-        end
+        self.class.coerce(*args, &@attribute_for.method(:[]))
       end
 
       # Represent an empty set of attributes