axiom 0.1.0 → 0.1.1

data/lib/axiom/algebra/extension.rb

@@ -157,9 +157,9 @@ module Axiom
         # @return [Extension]
         #
         # @api private
-        def coerce_to_extensions(extensions = Undefined)
+        def coerce_to_extensions(extensions = Undefined, &block)
           if extensions.equal?(Undefined)
-            Evaluator::Context.new(header) { |context| yield context }.functions
+            header.context(&block).functions
           else
             extensions
           end

data/lib/axiom/algebra/projection.rb

@@ -39,7 +39,7 @@ module Axiom
       # @api public
       def each
         return to_enum unless block_given?
-        seen = Hash.new
+        seen = {}
         operand.each do |tuple|
           tuple = tuple.project(header)
           yield seen[tuple] = tuple unless seen.key?(tuple)
@@ -158,7 +158,7 @@ module Axiom
         # Return a relation with only the attributes specified
         #
         # @example
-        #   projection = relation.project([ :a, :b, :c ])
+        #   projection = relation.project([:a, :b, :c])
         #
         # @param [#to_ary] attributes
         #   the attributes to keep in the header
@@ -173,7 +173,7 @@ module Axiom
         # Return a relation with attributes not specified
         #
         # @example
-        #   projection = relation.remove([ :a, b, c ])
+        #   projection = relation.remove([:a, b, c])
         #
         # @param [#to_ary] attributes
         #   the attributes to remove from the header

data/lib/axiom/algebra/rename/aliases.rb

@@ -87,12 +87,12 @@ module Axiom
           other_aliases = other.to_hash.dup
           inverted      = other_aliases.invert
 
+          # Remove aliases that cancel out, and preserve different aliases
           each do |old_attribute, new_attribute|
             old_attribute = inverted.fetch(old_attribute, old_attribute)
+            other_aliases.delete(old_attribute)
 
-            if old_attribute.eql?(new_attribute)
-              other_aliases.delete(new_attribute)
-            else
+            unless old_attribute.eql?(new_attribute)
               other_aliases[old_attribute] = new_attribute
             end
           end
@@ -143,8 +143,8 @@ module Axiom
         #
         # @api public
         def inverse
-          self.class.new(@aliases.invert).
-            memoize(:inverse, self)
+          self.class.new(@aliases.invert)
+            .memoize(:inverse, self)
         end
 
         # Compare the aliases with other aliases for equivalency
@@ -208,7 +208,7 @@ module Axiom
         def self.coerce_alias_pair(attributes, old_attr, new_attr)
           old_attr = attributes[old_attr]
           new_attr = old_attr.rename(new_attr) if new_attr.kind_of?(Symbol)
-          [ old_attr, new_attr ]
+          [old_attr, new_attr]
         end
 
         private_class_method :coerce_alias_pair

data/lib/axiom/algebra/restriction.rb

@@ -104,7 +104,7 @@ module Axiom
         #  restriction = relation.restrict(id: 1)
         #
         # @example restriction using an Array
-        #  restriction = relation.restrict([ [ :id, 1 ] ])
+        #  restriction = relation.restrict([[:id, 1]])
         #
         # @param [Array] args
         #   optional arguments

data/lib/axiom/algebra/summarization.rb

@@ -162,17 +162,17 @@ module Axiom
         #   end
         #
         # @example with a relation
-        #   summarization = relation.summarize(relation.project([ :name ])) do |context|
+        #   summarization = relation.summarize(relation.project([:name])) do |context|
         #     context.add(:count, context[:id].count)
         #   end
         #
         # @example with a header
-        #   summarization = relation.summarize([ :name ]) do |context|
+        #   summarization = relation.summarize([:name]) do |context|
         #     context.add(:count, context[:id].count)
         #   end
         #
         # @example with summarizers
-        #   summarization = relation.summarize([ :name ], summarizers)
+        #   summarization = relation.summarize([:name], summarizers)
         #
         # @param [Relation, Header, #to_ary] summarize_with
         #
@@ -225,11 +225,9 @@ module Axiom
         # @return [#to_hash]
         #
         # @api private
-        def coerce_to_summarizers(summarize_per, summarizers = Undefined)
+        def coerce_to_summarizers(summarize_per, summarizers = Undefined, &block)
           if summarizers.equal?(Undefined)
-            Evaluator::Context.new(header - summarize_per.header) { |context|
-              yield context
-            }.functions
+            (header - summarize_per.header).context(&block).functions
           else
             summarizers
           end

data/lib/axiom/algebra/summarization/summaries.rb

@@ -17,8 +17,8 @@ module Axiom
         #
         # @api private
         def initialize(header, summarizers)
-          @header = header
-          @summaries = Hash.new
+          @header    = header
+          @summaries = {}
           summarizers.each do |name, summarizer|
             @summaries[name] = Summary.new(summarizer)
           end

data/lib/axiom/algebra/union.rb

@@ -23,7 +23,7 @@ module Axiom
       # @api public
       def each
         return to_enum unless block_given?
-        seen = Hash.new
+        seen = {}
         left.each  { |tuple| yield seen[tuple] = tuple           }
         right.each { |tuple| yield tuple unless seen.key?(tuple) }
         self

data/lib/axiom/attribute.rb

@@ -6,7 +6,9 @@ module Axiom
   class Attribute
     extend Aliasable, DescendantsTracker
     include AbstractType, ::Comparable, Visitable
-    include Equalizer.new(:name, :required?)
+    include Equalizer.new(:name, :type, :required?)
+
+    abstract_singleton_method :type
 
     # The attribute name
     #
@@ -15,13 +17,12 @@ module Axiom
     # @api private
     attr_reader :name
 
-    # The attribute options
+    # The attribute type
     #
-    # @return [Hash]
+    # @return [Class<Types::Object>]
     #
     # @api private
-    attr_reader :options
-    private :options
+    attr_reader :type
 
     # Coerce an object into an Attribute
     #
@@ -66,12 +67,10 @@ module Axiom
     #
     # @api private
     def self.infer_type(operand)
-      case operand
-      when Attribute, Function, Aggregate then operand.type
-      when FalseClass                     then Boolean
+      if operand.respond_to?(:type)
+        operand.type
       else
-        type = operand.class
-        descendants.detect { |descendant| type <= descendant.primitive }
+        Types::Type.descendants.detect { |type| type.include?(operand) }
       end
     end
 
@@ -89,8 +88,8 @@ module Axiom
     # @api private
     def initialize(name, options = EMPTY_HASH)
       @name     = name.to_sym
-      @options  = freeze_object(options)
-      @required = @options.fetch(:required, true)
+      @required = options.fetch(:required, true)
+      @type     = self.class.type
     end
 
     # Extract the value corresponding to this attribute from a tuple
@@ -122,16 +121,11 @@ module Axiom
     #
     # @api public
     def rename(new_name)
-      name.equal?(new_name) ? self : self.class.new(new_name, options)
-    end
-
-    # Return the type returned from #call
-    #
-    # @return [Class<Attribute>]
-    #
-    # @api public
-    def type
-      self.class
+      if name.equal?(new_name)
+        self
+      else
+        self.class.new(new_name, required: required?)
+      end
     end
 
     # Test if the attribute is required
@@ -146,25 +140,22 @@ module Axiom
       @required
     end
 
-    # Test if a value is the correct primitive type
+    # Test if the attribute is optional
     #
     # @example
-    #   attribute.valid_primitive?(value)  # => true or false
-    #
-    # @param [Object] value
-    #   the value to test
+    #   attribute.optional?  # => true or false
     #
     # @return [Boolean]
     #
     # @api public
-    def valid_primitive?(value)
-      value.kind_of?(self.class.primitive)
+    def optional?
+      ! required?
     end
 
     # Test if the value matches the attribute constraints
     #
     # @example
-    #   attribute.valid_value?(value)  # => true or false
+    #   attribute.include?(value)  # => true or false
     #
     # @param [Object] value
     #   the value to test
@@ -172,8 +163,8 @@ module Axiom
     # @return [Boolean]
     #
     # @api public
-    def valid_value?(value)
-      valid_or_optional?(value) { valid_primitive?(value) }
+    def include?(value)
+      valid_or_optional?(value, &type.method(:include?))
     end
 
   private
@@ -189,7 +180,7 @@ module Axiom
     #
     # @api private
     def valid_or_optional?(value)
-      value.nil? ? ! required? : yield
+      value.nil? ? optional? : yield(value)
     end
 
     # Coerce the object into an Attribute

data/lib/axiom/attribute/boolean.rb

@@ -9,33 +9,23 @@ module Axiom
               Function::Connective::Disjunction::Methods,
               Function::Connective::Negation::Methods
 
-      # The Boolean primitive
+      # The attribute type
       #
       # @example
-      #   Boolean.primitive  # => TrueClass
+      #   type = Axiom::Attribute::Boolean.type  # => Axiom::Types::Boolean
       #
-      # @return [Class<TrueClass>]
+      # @return [Class<Types::Boolean>]
       #
       # @api public
-      def self.primitive
-        TrueClass
-      end
-
-      # Test if the value is a boolean
-      #
-      # @example
-      #   boolean.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 || value.kind_of?(FalseClass) }
+      def self.type
+        Types::Boolean
       end
 
     end # class Boolean
+
+    # Add aliases for Boolean
+    TrueClass  = Boolean
+    FalseClass = Boolean
+
   end # class Attribute
 end # module Axiom

data/lib/axiom/attribute/class.rb

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

data/lib/axiom/attribute/date.rb

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

data/lib/axiom/attribute/date_time.rb

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

data/lib/axiom/attribute/decimal.rb

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

data/lib/axiom/attribute/float.rb

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