axiom 0.1.0 → 0.1.1

data/lib/axiom/attribute/integer.rb

@@ -6,16 +6,16 @@ module Axiom
     # Represents an Integer value in a relation tuple
     class Integer < Numeric
 
-      # The Integer primitive
+      # The attribute type
       #
       # @example
-      #   Integer.primitive  # => ::Integer
+      #   type = Axiom::Attribute::Integer.type  # => Axiom::Types::Integer
       #
-      # @return [Class<::Integer>]
+      # @return [Class<Types::Integer>]
       #
       # @api public
-      def self.primitive
-        ::Integer
+      def self.type
+        Types::Integer
       end
 
     end # class Integer

data/lib/axiom/attribute/numeric.rb

@@ -7,66 +7,42 @@ module Axiom
     class Numeric < Object
       include Comparable,
               Aggregate::Sum::Methods
-      include Equalizer.new(:name, :required?, :size)
 
-      DEFAULT_SIZE = (-::Float::INFINITY..::Float::INFINITY).freeze
-
-      inheritable_alias(:range => :size)
-
-      # The Numeric range for a valid value
-      #
-      # @example
-      #   numeric.size  # => 0..10
-      #
-      # @return [Range<::Numeric>]
-      #
-      # @api public
-      attr_reader :size
-
-      # The Numeric primitive
+      # The attribute type
       #
       # @example
-      #   Numeric.primitive  # => ::Numeric
+      #   type = Axiom::Attribute::Numeric.type  # => Axiom::Types::Numeric
       #
-      # @return [Class<::Numeric>]
+      # @return [Class<Types::Numeric>]
       #
       # @api public
-      def self.primitive
-        ::Numeric
+      def self.type
+        Types::Numeric
       end
 
       # Initialize a Numeric Attribute
       #
       # @param [#to_sym] _name
       #   the attribute name
-      # @param [#to_hash] _options
+      # @param [#to_hash] options
       #   the options for the attribute
       # @option options [Boolean] :required (true)
       #   if true, then the value cannot be nil
-      # @option options [Range<::Numeric>] :size (0..2**31-1)
+      # @option options [Range<::Numeric>] :size
       #   The numeric range for a valid value
       #
       # @return [undefined]
       #
       # @api private
-      def initialize(_name, _options = EMPTY_HASH)
+      def initialize(_name, options = EMPTY_HASH)
         super
-        @size = @options.fetch(:size, self.class::DEFAULT_SIZE).to_inclusive
-      end
-
-      # Test if the value matches the attribute constraints
-      #
-      # @example
-      #   numeric.valid_value?(value)  # => true or false
-      #
-      # @param [Object] value
-      #   the value to test
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def valid_value?(value)
-        valid_or_optional?(value) { super && size.cover?(value) }
+        size = options[:size]
+        if size
+          @type = type.new do
+            minimum(size.first)
+            maximum(size.last)
+          end
+        end
       end
 
     end # class Numeric

data/lib/axiom/attribute/object.rb

@@ -11,16 +11,16 @@ module Axiom
               Function::Predicate::Inclusion::Methods,
               Aggregate::Count::Methods
 
-      # The Object primitive
+      # The attribute type
       #
       # @example
-      #   Object.primitive  # => ::Object
+      #   type = Axiom::Attribute::Object.type  # => Axiom::Types::Object
       #
-      # @return [Class<::Object>]
+      # @return [Class<Types::Object>]
       #
       # @api public
-      def self.primitive
-        ::Object
+      def self.type
+        Types::Object
       end
 
     end # class Object

data/lib/axiom/attribute/string.rb

@@ -8,91 +8,44 @@ module Axiom
       include Comparable,
               Function::Predicate::Match::Methods,
               Function::Predicate::NoMatch::Methods
-      include Equalizer.new(:name, :required?, :min_length, :max_length)
 
-      DEFAULT_MIN_LENGTH = 0
-      DEFAULT_MAX_LENGTH = 50
-
-      # The minimum string length for a valid value
-      #
-      # @example
-      #   string.min_length  # => 0
-      #
-      # @return [::Integer]
-      #
-      # @api public
-      attr_reader :min_length
-
-      # The maximum string length for a valid value
+      # The attribute type
       #
       # @example
-      #   string.max_length  # => 50
+      #   type = Axiom::Attribute::String.type  # => Axiom::Types::String
       #
-      # @return [::Integer]
+      # @return [Class<Types::String>]
       #
       # @api public
-      attr_reader :max_length
-
-      # The String primitive
-      #
-      # @example
-      #   String.primitive  # => ::String
-      #
-      # @return [Class<::String>]
-      #
-      # @api public
-      def self.primitive
-        ::String
+      def self.type
+        Types::String
       end
 
       # Initialize a String Attribute
       #
       # @param [#to_sym] _name
       #   the attribute name
-      # @param [#to_hash] _options
+      # @param [#to_hash] options
       #   the options for the attribute
       # @option options [Boolean] :required (true)
       #   if true, then the value cannot be nil
-      # @option options [::Integer] :min_length
+      # @option options [::Integer] :minimum_length
       #   The minimum string length for a valid value
-      # @option options [::Integer] :mmax_length
+      # @option options [::Integer] :maximum_length
       #   The maximum string length for a valid value
       #
       # @return [undefined]
       #
       # @api private
-      def initialize(_name, _options = EMPTY_HASH)
+      def initialize(_name, options = EMPTY_HASH)
         super
-        @min_length = @options.fetch(:min_length, DEFAULT_MIN_LENGTH)
-        @max_length = @options.fetch(:max_length, DEFAULT_MAX_LENGTH)
-      end
-
-      # Test if the value matches the attribute constraints
-      #
-      # @example
-      #   string.valid_value?(value)  # => true or false
-      #
-      # @param [Object] value
-      #   the value to test
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def valid_value?(value)
-        valid_or_optional?(value) { super && valid_length?(value) }
-      end
-
-    private
-
-      # Test if the value is the correct length
-      #
-      # @param [String] value
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      def valid_length?(value)
-        value.length.between?(min_length, max_length)
+        min, max = options.values_at(:minimum_length, :maximum_length)
+        if min || max
+          @type = type.new do
+            minimum_length(min) if min
+            maximum_length(max) if max
+          end
+        end
       end
 
     end # class String

data/lib/axiom/attribute/time.rb

@@ -7,30 +7,16 @@ module Axiom
     class Time < Object
       include Comparable
 
-      DEFAULT_RANGE = (::Time.at(0)..::Time.at(2 ** 31-1)).freeze
-
-      # The Time primitive
-      #
-      # @example
-      #   Time.primitive  # => ::Time
-      #
-      # @return [Class<::Time>]
-      #
-      # @api public
-      def self.primitive
-        ::Time
-      end
-
-      # The Time range for a valid value
+      # The attribute type
       #
       # @example
-      #   Time.range  # => ::Time.utc(*from)..::Time.utc(*to)
+      #   type = Axiom::Attribute::Time.type  # => Axiom::Types::Time
       #
-      # @return [Range<::Time>]
+      # @return [Class<Types::Time>]
       #
       # @api public
-      def range
-        DEFAULT_RANGE
+      def self.type
+        Types::Time
       end
 
     end # class Time

data/lib/axiom/function.rb

@@ -6,8 +6,8 @@ module Axiom
   class Function
     include AbstractType, Adamantium, Visitable
 
-    abstract_singleton_method :call
-    abstract_method :rename, :type
+    abstract_singleton_method :call, :type
+    abstract_method :rename
 
     # Rename the attribute(s) inside the function
     #
@@ -42,5 +42,17 @@ module Axiom
       operand.respond_to?(:call) ? operand.call(tuple) : operand
     end
 
+    # Return the function type
+    #
+    # @example
+    #   type = function.type  # => Axiom::Types::Object
+    #
+    # @return [Class<Types::Object>]
+    #
+    # @api public
+    def type
+      self.class.type
+    end
+
   end # class Function
 end # module Axiom

data/lib/axiom/function/binary.rb

@@ -54,6 +54,23 @@ module Axiom
         end
       end
 
+      # Return the type returned from #call
+      #
+      # Find the lowest common ancestor between the types.
+      #
+      # @example
+      #   type = binary.type  # => Axiom::Types::Object
+      #
+      # @return [Class<Types::Numeric>]
+      #
+      # @api public
+      def type
+        base = super.singleton_class
+        [left, right].map do |operand|
+          Attribute.infer_type(operand).ancestors.grep(base)
+        end.inject(:&).first
+      end
+
       # Mixin for invertable binary functions
       module Invertible
 

data/lib/axiom/function/connective.rb

@@ -9,11 +9,14 @@ module Axiom
 
       # Return the type returned from #call
       #
-      # @return [Class<Attribute::Boolean>]
+      # @example
+      #   type = Axiom::Function::Connective.type  # => Axiom::Types::Boolean
+      #
+      # @return [Class<Types::Boolean>]
       #
       # @api public
-      def type
-        Attribute::Boolean
+      def self.type
+        Types::Boolean
       end
 
     end # class Connective

data/lib/axiom/function/connective/conjunction.rb

@@ -43,8 +43,8 @@ module Axiom
         #
         # @api public
         def inverse
-          Disjunction.new(Negation.new(left), Negation.new(right)).
-            memoize(:inverse, self)
+          Disjunction.new(Negation.new(left), Negation.new(right))
+            .memoize(:inverse, self)
         end
 
         module Methods

data/lib/axiom/function/connective/disjunction.rb

@@ -43,8 +43,8 @@ module Axiom
         #
         # @api public
         def inverse
-          Conjunction.new(Negation.new(left), Negation.new(right)).
-            memoize(:inverse, self)
+          Conjunction.new(Negation.new(left), Negation.new(right))
+            .memoize(:inverse, self)
         end
 
         module Methods

data/lib/axiom/function/numeric.rb

@@ -6,6 +6,19 @@ module Axiom
     # Abstract class for Numeric functions
     class Numeric < Function
       include AbstractType
+
+      # Return the type returned from #call
+      #
+      # @example
+      #   type = Axiom::Function::Numeric.type  # => Axiom::Types::Numeric
+      #
+      # @return [Class<Types::Numeric>]
+      #
+      # @api public
+      def self.type
+        Types::Numeric
+      end
+
     end # class Numeric
   end # class Function
 end # module Axiom

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

@@ -23,7 +23,7 @@ module Axiom
         module Methods
           extend Aliasable
 
-          inheritable_alias(:abs => :absolute)
+          inheritable_alias(abs: :absolute)
 
           # Return an absolute function
           #

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

@@ -34,11 +34,27 @@ module Axiom
 
         # Return the type returned from #call
         #
-        # @return [Class<Attribute::Float>]
+        # @example
+        #   type = Axiom::Function::Numeric::Division.type
+        #   # => Axiom::Types::Float
+        #
+        # @return [Class<Types::Float>]
+        #
+        # @api public
+        def self.type
+          Types::Float
+        end
+
+        # Return the type returned from #call
+        #
+        # @example
+        #   type = division.type  # => Axiom::Types::Float
+        #
+        # @return [Class<Types::Float>]
         #
         # @api public
         def type
-          Attribute::Float
+          self.class.type
         end
 
         module Methods

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

@@ -39,7 +39,7 @@ module Axiom
 
           inheritable_alias(
             :**  => :exponent,
-            :pow => :exponent
+            pow: :exponent
           )
 
           # Return an exponential function

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

@@ -25,7 +25,7 @@ module Axiom
 
           inheritable_alias(
             :%   => :modulo,
-            :mod => :modulo
+            mod: :modulo
           )
 
           # Return a modulo function