axiom 0.1.0 → 0.1.1

data/benchmarks/speed.rb

@@ -12,17 +12,17 @@ include Axiom
 
 TIMES = 5_000
 
-header   = Relation::Header.new([ [ :id, Integer ], [ :name, String ] ])
-array    = (1..100).map { |n| Tuple.new(header, [ n, 'Dan Kubb' ]) }
+header   = Relation::Header.new([[:id, Integer], [:name, String]])
+array    = (1..100).map { |n| Tuple.new(header, [n, 'Dan Kubb']) }
 relation = Relation.new(header, array)
-join     = Relation.new([ [ :id, Integer, ], [ :age, Integer ] ], [ [ 1, 35 ] ])
-product  = Relation.new([ [ :age, Integer ] ], [ [ 35 ] ])
-ordered  = relation.sort_by { |r| [ r.id, r.name ] }
+join     = Relation.new([[:id, Integer], [:age, Integer]], [[1, 35]])
+product  = Relation.new([[:age, Integer]], [[35]])
+ordered  = relation.sort_by { |r| [r.id, r.name] }
 
 RBench.run(TIMES) do
-  column :ruby,  :title => 'Ruby'
-  column :axiom, :title => 'Axiom'
-  column :diff,  :title => 'Diff', :compare => [ :ruby, :axiom ]
+  column :ruby,  title: 'Ruby'
+  column :axiom, title: 'Axiom'
+  column :diff,  title: 'Diff', compare: [:ruby, :axiom]
 
   report 'each' do
     ruby  { array.each {}    }
@@ -30,13 +30,13 @@ RBench.run(TIMES) do
   end
 
   report 'projection' do
-    ruby  { array.map { |tuple| [ tuple[:id] ] }.each {} }
-    axiom { relation.project([ :id ]).each {}            }
+    ruby  { array.map { |tuple| [tuple[:id]] }.each {} }
+    axiom { relation.project([:id]).each {}            }
   end
 
   report 'removal' do
-    ruby  { array.map { |tuple| [ tuple[:id] ] }.each {} }
-    axiom { relation.remove([ :name ]).each {}           }
+    ruby  { array.map { |tuple| [tuple[:id]] }.each {} }
+    axiom { relation.remove([:name]).each {}           }
   end
 
   report 'restriction' do
@@ -69,8 +69,8 @@ RBench.run(TIMES) do
   end
 
   report 'order' do
-    ruby  { array.sort_by { |tuple| [ -tuple[:id], tuple[:name] ] }.each {} }
-    axiom { relation.sort_by { |r| [ r.id.desc, r.name ] }.each {}          }
+    ruby  { array.sort_by { |tuple| [-tuple[:id], tuple[:name]] }.each {} }
+    axiom { relation.sort_by { |r| [r.id.desc, r.name] }.each {}          }
   end
 
   report 'take' do

data/config/devtools.yml

@@ -0,0 +1,2 @@
+---
+unit_test_timeout: 1.0

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 41
-total_score: 936.0
+total_score: 919

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 16.7
+threshold: 15.3

data/config/reek.yml

@@ -56,10 +56,10 @@ DuplicateMethodCall:
   - Axiom::Algebra::Restriction#insert
   - Axiom::Algebra::Restriction::Methods#coerce_to_predicate
   - Axiom::Function::Binary#rename
-  - Axiom::Function::Binary#rename
   - Axiom::Function::Unary#rename
   - Axiom::Relation::Operation::Order::Direction#call
   - Axiom::Relation::Operation::Order::Direction#rename
+  - Axiom::Relation::Operation::Order::Methods#coerce_to_directions
   - Axiom::Relation::Proxy#forward
   - Axiom::Relation::Proxy#method_missing
   max_calls: 1
@@ -104,6 +104,7 @@ NilCheck:
   - Axiom::Aggregate::Sum#self.call
   - Axiom::Aggregate::Variance#self.call
   - Axiom::Attribute#valid_or_optional?
+  - Axiom::Relation#self.materialized?
   - Axiom::Relation::Operation::Limit#self.assert_valid_limit
   - Axiom::Relation::Operation::Offset#self.assert_valid_offset
 RepeatedConditional:
@@ -112,8 +113,7 @@ RepeatedConditional:
   max_ifs: 1
 TooManyInstanceVariables:
   enabled: true
-  exclude:
-  - Axiom::Relation::Header
+  exclude: []
   max_instance_variables: 3
 TooManyMethods:
   enabled: true

data/config/rubocop.yml

@@ -0,0 +1,62 @@
+AllCops:
+  Includes:
+    - '../**/*.rake'
+    - 'Gemfile'
+    - 'Gemfile.devtools'
+  Excludes:
+    - '**/vendor/**'
+    - '**/benchmarks/**'
+
+# Avoid parameter lists longer than five parameters.
+ParameterLists:
+  Max: 3
+  CountKeywordArgs: true
+
+# Avoid more than `Max` levels of nesting.
+BlockNesting:
+  Max: 3
+
+# Align with the style guide.
+CollectionMethods:
+  PreferredMethods:
+    collect:  'map'
+    inject:   'reduce'
+    find:     'detect'
+    find_all: 'select'
+
+# Do not force public/protected/private keyword to be indented at the same
+# level as the def keyword. My personal preference is to outdent these keywords
+# because I think when scanning code it makes it easier to identify the
+# sections of code and visually separate them. When the keyword is at the same
+# level I think it sort of blends in with the def keywords and makes it harder
+# to scan the code and see where the sections are.
+AccessControl:
+  Enabled: false
+
+# Limit line length
+LineLength:
+  Max: 143  # TODO: lower to 79
+
+# Disable documentation checking until a class needs to be documented once
+Documentation:
+  Enabled: false
+
+# Do not always use &&/|| instead of and/or.
+AndOr:
+  Enabled: false
+
+# Do not favor modifier if/unless usage when you have a single-line body
+IfUnlessModifier:
+  Enabled: false
+
+# Allow case equality operator (in limited use within the specs)
+CaseEquality:
+  Enabled: false
+
+# Constants do not always have to use SCREAMING_SNAKE_CASE
+ConstantName:
+  Enabled: false
+
+# Not all trivial readers/writers can be defined with attr_* methods
+TrivialAccessors:
+  Enabled: false

data/lib/axiom.rb

@@ -7,8 +7,6 @@ require 'singleton'
 
 require 'abstract_type'
 require 'adamantium'
-require 'backports'
-require 'backports/basic_object' unless defined?(::BasicObject)
 require 'descendants_tracker'
 require 'equalizer'
 
@@ -26,9 +24,6 @@ module Axiom
   # Raised when the offset is not a positive integer
   class InvalidOffsetError < ArgumentError; end
 
-  # Raised when the order does not include every attribute in the header
-  class InvalidDirectionsError < ArgumentError; end
-
   # Raised when a method requiring ordering is called on an unordered relation
   class OrderedRelationRequiredError < StandardError; end
 
@@ -72,10 +67,10 @@ module Axiom
   Undefined = Object.new.freeze
 
   # An empty Hash to use as for default options
-  EMPTY_HASH = Hash.new.freeze
+  EMPTY_HASH = {}.freeze
 
   # An empty Array to use for a default value
-  EMPTY_ARRAY = Array.new.freeze
+  EMPTY_ARRAY = [].freeze
 
   # Error message constants for inserted and deleted messages
   INSERTED = 'inserted'.freeze
@@ -95,15 +90,6 @@ require 'axiom/support/evaluator'
 require 'axiom/support/operation/binary'
 require 'axiom/support/operation/unary'
 
-require 'axiom/aggregate'
-require 'axiom/aggregate/count'
-require 'axiom/aggregate/maximum'
-require 'axiom/aggregate/mean'
-require 'axiom/aggregate/minimum'
-require 'axiom/aggregate/sum'
-require 'axiom/aggregate/variance'
-require 'axiom/aggregate/standard_deviation'
-
 require 'axiom/function'
 require 'axiom/function/binary'
 require 'axiom/function/unary'
@@ -131,14 +117,25 @@ require 'axiom/function/proposition'
 require 'axiom/function/proposition/contradiction'
 require 'axiom/function/proposition/tautology'
 
+require 'axiom/aggregate'
+require 'axiom/aggregate/count'
+require 'axiom/aggregate/maximum'
+require 'axiom/aggregate/mean'
+require 'axiom/aggregate/minimum'
+require 'axiom/aggregate/sum'
+require 'axiom/aggregate/variance'
+require 'axiom/aggregate/standard_deviation'
+
 require 'axiom/relation'
 
 require 'axiom/relation/proxy'
 
-require 'axiom/relation/base'
 require 'axiom/relation/keys'
 require 'axiom/relation/header'
 
+require 'axiom/relation/base'
+require 'axiom/relation/variable'
+
 require 'axiom/relation/materialized'
 require 'axiom/relation/empty'
 
@@ -186,8 +183,6 @@ require 'axiom/attribute/time'
 require 'axiom/attribute/string'
 
 require 'axiom/function/numeric'
-require 'axiom/function/numeric/binary'
-require 'axiom/function/numeric/unary'
 
 require 'axiom/function/numeric/absolute'
 require 'axiom/function/numeric/addition'
@@ -205,12 +200,14 @@ require 'axiom/function/string/length'
 require 'axiom/tuple'
 require 'axiom/version'
 
+require 'axiom-types'
+
 module Axiom
 
   # Represent a relation with an empty header and no tuples
   TABLE_DUM = Relation::Empty.new(Relation::Header::EMPTY)
 
   # Represent a relation with an empty header and a single tuple
-  TABLE_DEE = Relation.new(Relation::Header::EMPTY, [ EMPTY_ARRAY ])
+  TABLE_DEE = Relation.new(Relation::Header::EMPTY, [EMPTY_ARRAY])
 
 end # module Axiom

data/lib/axiom/aggregate.rb

@@ -3,13 +3,10 @@
 module Axiom
 
   # Abstract class for aggregate functions
-  class Aggregate
-    include AbstractType, Visitable, Operation::Unary
+  class Aggregate < Function
+    include Operation::Unary
     include Equalizer.new(:operand)
 
-    abstract_singleton_method :call
-    abstract_method :type
-
     # Return the default accumulator
     #
     # @example

data/lib/axiom/aggregate/count.rb

@@ -27,13 +27,13 @@ module Axiom
       # Return the type returned from #call
       #
       # @example
-      #   type = Axiom::Aggregate::Count.type
+      #   type = Axiom::Aggregate::Count.type  # => Axiom::Types::Integer
       #
-      # @return [Class<Attribute::Integer>]
+      # @return [Class<Types::Integer>]
       #
       # @api public
-      def type
-        Attribute::Integer
+      def self.type
+        Types::Integer
       end
 
       module Methods

data/lib/axiom/aggregate/maximum.rb

@@ -28,9 +28,9 @@ module Axiom
       # Return the type returned from #call
       #
       # @example
-      #   type = Axiom::Aggregate::Maximum.type
+      #   type = aggregate.type  # => Axiom::Types::Numeric
       #
-      # @return [Class<Attribute::Numeric>]
+      # @return [Class<Types::Numeric>]
       #
       # @api public
       def type
@@ -40,7 +40,7 @@ module Axiom
       module Methods
         extend Aliasable
 
-        inheritable_alias(:max => :maximum)
+        inheritable_alias(max: :maximum)
 
         # Return a maximum aggregate function
         #

data/lib/axiom/aggregate/mean.rb

@@ -6,12 +6,12 @@ module Axiom
     # The mean of a sequence of numbers
     class Mean < Aggregate
 
-      DEFAULT = [ 0, nil ].freeze
+      DEFAULT = [0, nil].freeze
 
       # Return the count and mean for a sequence of numbers
       #
       # @example
-      #   count, mean = Mean.call([ count, mean ], value)
+      #   count, mean = Mean.call([count, mean], value)
       #
       # @param [Array(Integer, Numeric)] accumulator
       #
@@ -24,7 +24,7 @@ module Axiom
         return accumulator if value.nil?
         count, mean = accumulator
         count       = Count.call(count, value)
-        [ count, mean.nil? ? value.to_f : mean + ((value - mean) / count) ]
+        [count, mean ? Rational(value - mean, count) + mean : Rational(value)]
       end
 
       # Extract the mean from the accumulator
@@ -47,21 +47,21 @@ module Axiom
       # Return the type returned from #call
       #
       # @example
-      #   type = Axiom::Aggregate::Mean.type
+      #   type = Axiom::Aggregate::Mean.type  # => Axiom::Types::Float
       #
-      # @return [Class<Attribute::Float>]
+      # @return [Class<Types::Float>]
       #
       # @api public
-      def type
-        Attribute::Float
+      def self.type
+        Types::Float
       end
 
       module Methods
         extend Aliasable
 
         inheritable_alias(
-          :average => :mean,
-          :avg     => :mean
+          average: :mean,
+          avg:     :mean
         )
 
         # Return a mean aggregate function

data/lib/axiom/aggregate/minimum.rb

@@ -28,9 +28,9 @@ module Axiom
       # Return the type returned from #call
       #
       # @example
-      #   type = Axiom::Aggregate::Minimum.type
+      #   type = aggregate.type  # => Axiom::Types::Numeric
       #
-      # @return [Class<Attribute::Numeric>]
+      # @return [Class<Types::Numeric>]
       #
       # @api public
       def type
@@ -40,7 +40,7 @@ module Axiom
       module Methods
         extend Aliasable
 
-        inheritable_alias(:min => :minimum)
+        inheritable_alias(min: :minimum)
 
         # Return a minimum aggregate function
         #

data/lib/axiom/aggregate/standard_deviation.rb

@@ -28,18 +28,19 @@ module Axiom
       #
       # @example
       #   type = Axiom::Aggregate::StandardDeviation.type
+      #   # => Axiom::Types::Float
       #
-      # @return [Class<Attribute::Float>]
+      # @return [Class<Types::Float>]
       #
       # @api public
-      def type
-        Attribute::Float
+      def self.type
+        Types::Float
       end
 
       module Methods
         extend Aliasable
 
-        inheritable_alias(:stddev => :standard_deviation)
+        inheritable_alias(stddev: :standard_deviation)
 
         # Return a standard deviation aggregate function
         #

data/lib/axiom/aggregate/sum.rb

@@ -42,8 +42,8 @@ module Axiom
       #
       # @api public
       def default
-        if    type.equal?(Attribute::Float)   then super.to_f
-        elsif type.equal?(Attribute::Decimal) then BigDecimal(super.to_s)
+        if    type <= Types::Float   then super.to_f
+        elsif type <= Types::Decimal then BigDecimal(super)
         else
           super
         end
@@ -52,9 +52,9 @@ module Axiom
       # Return the type returned from #call
       #
       # @example
-      #   type = Axiom::Aggregate::Sum.type
+      #   type = aggregate.type  # => Axiom::Types::Numeric
       #
-      # @return [Class<Attribute::Numeric>]
+      # @return [Class<Types::Numeric>]
       #
       # @api public
       def type

data/lib/axiom/aggregate/variance.rb

@@ -6,18 +6,18 @@ module Axiom
     # The variance of a sequence of numbers
     class Variance < Aggregate
 
-      DEFAULT = [ 0, nil, 0.0 ].freeze
+      DEFAULT = [0, nil, Rational(0)].freeze
 
       # Return the count, mean, and sum of squares for a sequence of numbers
       #
       # @example
       #   count, mean, sum_of_squares = Variance.call(accumulator, value)
       #
-      # @param [Array(Integer, Numeric, Float)] accumulator
+      # @param [Array(Integer, Numeric, Rational)] accumulator
       #
       # @param [Numeric] value
       #
-      # @return [Array(Integer, Numeric, Numeric)]
+      # @return [Array(Integer, Numeric, Rational)]
       #
       # @api public
       def self.call(accumulator, value)
@@ -26,7 +26,7 @@ module Axiom
         delta                 = mean.nil? ? value : value - mean
         count, new_mean       = Mean.call(accumulator, value)
         sum_of_squares       += delta * (value - new_mean)
-        [ count, new_mean, sum_of_squares ]
+        [count, new_mean, sum_of_squares]
       end
 
       # Calculate the variance from the accumulator
@@ -34,35 +34,38 @@ module Axiom
       # @example
       #   variance = Variance.finalize(accumulator)
       #
-      # @param [Array(Numeric, Integer, Float)] accumulator
+      # @param [Array(Numeric, Integer, Rational)] accumulator
       #
-      # @return [Float]
+      # @return [Rational]
       #   returned for a non-empty set
+      # @return [Float::INFINITY]
+      #   returned for when the sum of squares is infinite
       # @return [nil]
       #   returned for an empty set
       #
       # @api public
       def self.finalize(accumulator)
         sum_of_squares, count = accumulator.values_at(2, 0)
-        sum_of_squares / count unless count.zero?
+        return Float::INFINITY if sum_of_squares.equal?(Float::INFINITY)
+        Rational(sum_of_squares, count) unless count.zero?
       end
 
       # Return the type returned from #call
       #
       # @example
-      #   type = Axiom::Aggregate::Variance.type
+      #   type = Axiom::Aggregate::Variance.type  # => Axiom::Types::Float
       #
-      # @return [Class<Attribute::Float>]
+      # @return [Class<Types::Float>]
       #
       # @api public
-      def type
-        Attribute::Float
+      def self.type
+        Types::Float
       end
 
       module Methods
         extend Aliasable
 
-        inheritable_alias(:var => :variance)
+        inheritable_alias(var: :variance)
 
         # Return a variance aggregate function
         #