veritas 0.0.3 → 0.0.4

data/.rvmrc

@@ -0,0 +1 @@
+rvm use @$(basename `pwd`) --create

data/.travis.yml

@@ -0,0 +1,8 @@
+bundler_args: --without guard metrics
+script: "bundle exec rake spec"
+rvm:
+  - ree
+  - 1.8.7
+  - 1.9.2
+  - ruby-head
+  - rbx

data/Gemfile

@@ -1,25 +1,35 @@
+# encoding: utf-8
+
 source :rubygems
 
 group :development do
-  gem 'backports', '~> 2.1.0'
-  gem 'jeweler',   '~> 1.5.2'
-  gem 'rake',      '~> 0.8.7'
+  gem 'backports', '~> 2.2.1'
+  gem 'jeweler',   '~> 1.6.0'
+  gem 'rake',      '~> 0.9.0'
   gem 'rspec',     '~> 1.3.2'
-  gem 'yard',      '~> 0.6.8'
+  gem 'yard',      '~> 0.7.1'
 end
 
-group :jruby do
-  platform :jruby do
-    gem 'jruby-openssl', '~> 0.7.3'
-  end
+group :guard do
+  gem 'growl',         '~> 1.0.3'
+  gem 'guard',         '~> 0.3.4'
+  gem 'guard-bundler', '~> 0.1.3'
+  gem 'guard-ego',     '~> 0.0.1'
+  gem 'guard-rspec',   '~> 0.3.1'
 end
 
 group :benchmarks do
   gem 'rbench', '~> 0.2.3'
 end
 
+platform :jruby do
+  group :jruby do
+    gem 'jruby-openssl', '~> 0.7.4'
+  end
+end
+
 platforms :mri_18 do
-  group :quality do
+  group :metrics do
     gem 'flay',      '~> 1.4.2'
     gem 'flog',      '~> 2.5.1'
     gem 'heckle',    '~> 1.4.3'
@@ -30,6 +40,6 @@ platforms :mri_18 do
     gem 'reek',      '~> 1.2.8', :git => 'git://github.com/dkubb/reek.git'
     gem 'roodi',     '~> 2.1.0'
     gem 'ruby2ruby', '=  1.2.2'
-    gem 'yardstick', '~> 0.3.0'
+    gem 'yardstick', '~> 0.4.0'
   end
 end

data/Guardfile

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+guard 'ego' do
+  watch('Guardfile')
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+end
+
+guard 'rspec' do
+  # run all specs if the spec_helper or supporting files files are modified
+  watch('spec/spec_helper.rb')                      { 'spec' }
+  watch(%r{\Aspec/(?:lib|support|shared)/.+\.rb\z}) { 'spec' }
+
+  # run unit specs if associated lib code is modified
+  watch(%r{\Alib/(.+)\.rb\z})                                         { |m| Dir["spec/unit/#{m[1]}"] }
+  watch("lib/#{File.basename(File.expand_path('../', __FILE__))}.rb") { 'spec'                       }
+
+  # run a spec if it is modified
+  watch(%r{\Aspec/(?:unit|integration)/.+_spec\.rb\z})
+end

data/README.rdoc

@@ -2,6 +2,8 @@
 
 Simplifies querying of structured data using relational algebra
 
+http://travis-ci.org/dkubb/veritas.png
+
 == Usage
 
   relation = Veritas::Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])
@@ -34,11 +36,9 @@ Simplifies querying of structured data using relational algebra
   new_relation = relation.difference(other)  # OR relation - other
 
   # restriction
-  new_relation = relation.restrict(relation.name.eq('other'))
   new_relation = relation.restrict { |r| r[:a].eq('other').and(r[:b].gte(42)) }
 
   # theta-join
-  new_relation = relation.join(other, relation[:a].gte(other[:b]))
   new_relation = relation.join(other) { |r| r[:a].gte(r[:b]) }
 
   # NOTE: theta-join is effectively restricting a product of the relations
@@ -48,7 +48,7 @@ Simplifies querying of structured data using relational algebra
   new_relation = relation.extend { |r| r.add(:total) { |t| t[:unit_price] * t[:quantity] } }
 
   # summarize
-  new_relation = relation.summarize(relation.project([ :name ])) { |r| r.add(:count, r[:name].count)
+  new_relation = relation.summarize(relation.project([ :name ])) { |r| r.add(:count, r[:name].count) }
   new_relation = relation.summarize(relation.project([ :name ])) { |r| r.add(:count) { |acc, t| acc.to_i + 1 } }
 
   # Non-Relational Operators
@@ -64,7 +64,6 @@ Simplifies querying of structured data using relational algebra
   relation = relation.each { |tuple| ... }
 
   # order by attribute and direction
-  new_relation = relation.order([ relation[:a].desc, relation[:b] ])
   new_relation = relation.order { |r| [ r[:a].desc, r[:b] ] }
 
   # reverse the relation (only allowed if ordered)
@@ -112,9 +111,9 @@ This is 100% complete now.
 
 === Phase 2: RDBMS Engines
 
-The second phase of this project will be to add an RDBMS based engine, and move the in-memory matching to it's own engine. I'll also be working on a system where if the primary engine cannot carry out some operation, that it first look at alternate forms (eg. using a join instead of an intersection), and then fall-back to in-memory matching. I also want to look at re-arranging queries so that all the operations that can be performed natively are "pushed down" the hierarchy and then the in-memory matching is performed last.
+The second phase of this project will be to add a RDBMS based engine, and move the in-memory matching to it's own engine. I'll also be working on a system where if the primary engine cannot carry out some operation, that it first look at alternate forms (eg. using a join instead of an intersection), and then fall-back to in-memory matching. I also want to look at re-arranging queries so that all the operations that can be performed natively are "pushed down" the hierarchy and then the in-memory matching is performed last.
 
-This is 80% complete. I have finished a first pass on the veritas-sql-compiler[https://github.com/dkubb/veritas-sql-compiler] which is a visitor that walks the AST and produces SQL for every operation except extend and summarize. To finish those I will need to add function support to veritas that are introspectable (i.e. not Proc objects). Once I can introspect them, then I can serialize them to SQL and other query languages.
+This is 90% complete. I have finished a first pass on the veritas-sql-compiler[https://github.com/dkubb/veritas-sql-compiler] which is a visitor that walks the AST and produces SQL for every operation except extend and summarize. To finish those I will need to add function support to veritas that are introspectable (i.e. not Proc objects). Once I can introspect them, then I can serialize them to SQL and other query languages.
 
 === Phase 3: DataMapper Integration
 

data/Rakefile

@@ -1,9 +1,11 @@
+# encoding: utf-8
+
 require 'rake'
 
 require File.expand_path('../lib/veritas/version', __FILE__)
 
 begin
-  gem('jeweler', '~> 1.5.2') if respond_to?(:gem, true)
+  gem('jeweler', '~> 1.6.0') if respond_to?(:gem, true)
   require 'jeweler'
 
   Jeweler::Tasks.new do |gem|
@@ -21,5 +23,5 @@ begin
 
   FileList['tasks/**/*.rake'].each { |task| import task }
 rescue LoadError
-  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler -v 1.5.2'
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler -v 1.6.0'
 end

data/TODO

@@ -1,6 +1,3 @@
-* Add Extension and Summarization Functions
-  * Overview: https://gist.github.com/584588
-
 * Remove Order, Reverse, Limit and Offset from the Relation inheritance chain
   * Instead make it so they are proxy classes that wrap Relations, but
     proxy method calls to the Relation methods, and then wrap the return
@@ -8,12 +5,6 @@
   * Also this will allow knowledge of #directions to be removed from
     all the Relation classes. Only the Ranking classes will need to know
     about directions.
-  * We can also do things like optimize away an Order that is not
-    wrapped by a Limit/Offset if it is wrapped in Join or Set relation.
-    We can do this because joining sorted relations results in
-    an undefined sort order depending on the algorithm used to join
-    the tuples. The correct approach to get unambiguous results is to
-    wrap the Join in an Order.
   * The Reverse class will probably not be needed either. All we need is
     for the #reverse method to create a new Order with the directions
     reversed.
@@ -21,11 +12,7 @@
     and instead wrap materialized relations in the Order object
     if any.
 
-* Allow Inclusion match to accept a Relation
-  * Ensure that Inclusion can have the left/right be an Array of
-    Attributes.
-  * Consider transforming the value provided to an Inclusion into
-    a Relation.
+* Add Relation#nest and Relation#unnest
 
 * Update Attributes so that constraints are modelled using predicates,
   so that when "join-ability" is tested, the predicates can just be
@@ -35,11 +22,26 @@
     caller. This will allow a "complex" predicate to set the errors
     on tuples, while still allowing all the same objects to be used.
 
+* Update memoization to take into account the arguments passed into
+  the method. It should memoize differently for different
+  methods. Perhaps it could have a special case for methods
+  with a 0-arity vs n-arity methods, but it needs to handle cases
+  like with #hash that accept no args, and #optimize that accepts
+  1 arg.
+
 * Add Relation#antijoin
+  * Allows "NOT EXISTS/IN" type queries to be executes where every tuple
+    from the relation is returned that *does not* join with the tuples in
+    the operand.
 
-* Add Relation#nest and Relation#unnest
+* Inclusion/Exclusion improvements:
+  * Allow attribute/function expressions to exist within the enumerable part
+    of the Inclusion and Exclusion operations
+    * The #call method should propagate the Tuple down to each callable entry
+      in the Enumerable.
 
-* Add aliases for some common operations in Method classes, eg:
+* Update context to return an object that allows aliasing of ruby-ish predicates
+  to specific operations, eg:
   * Predicates:
     * Alias #== to #eq (may break alot)
     * Alias #!= to #ne (in 1.9 only)
@@ -51,10 +53,3 @@
   * Direction:
     * Alias #@+ to #asc
     * Alias #@- to #desc
-
-* Update memoization to take into account the arguments passed into
-  the method. It should memoize differently for different
-  methods. Perhaps it could have a special case for methods
-  with a 0-arity vs n-arity methods, but it needs to handle cases
-  like with #hash that accept no args, and #optimize that accepts
-  1 arg.

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 68
-total_score: 778
+total_score: 654

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 16.8
+threshold: 15.7

data/config/roodi.yml

@@ -11,7 +11,7 @@ EmptyRescueBodyCheck:            { }
 ForLoopCheck:                    { }
 # TODO: decrease line_count to 5 to 10
 MethodLineCountCheck:            { line_count: 14 }
-MethodNameCheck:                 { pattern: !ruby/regexp /\A(?:[a-z](?:_?[a-z])+[?!=]?|\[\]=?|==|<=>|[+*&|-])\z/ }
+MethodNameCheck:                 { pattern: !ruby/regexp /\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|[+*&|-])\z/ }
 ModuleLineCountCheck:            { line_count: 392 }
 ModuleNameCheck:                 { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
 # TODO: decrease parameter_count to 2 or less

data/config/site.reek

@@ -8,10 +8,10 @@ UncommunicativeParameterName:
   - !ruby/regexp /[0-9]$/
   - !ruby/regexp /[A-Z]/
 LargeClass:
-  max_methods: 16  # TODO: decrease max_methods to 10-15 or less
+  max_methods: 15  # TODO: decrease max_methods to 10-15 or less
   exclude: []
   enabled: true
-  max_instance_variables: 3
+  max_instance_variables: 5
 UncommunicativeMethodName:
   accept: []
   exclude: []
@@ -91,6 +91,6 @@ ControlCouple:
   exclude: []
   enabled: true
 LongYieldList:
-  max_params: 1
+  max_params: 2
   exclude: []
   enabled: true

data/lib/veritas/aggregate/count.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Veritas
+  class Aggregate
+
+    # The count of a series of values
+    class Count < Aggregate
+
+      DEFAULT = 0
+
+      # Return the count for a series of values
+      #
+      # @example
+      #   count = Count.call(count, value)
+      #
+      # @param [Integer] count
+      #
+      # @param [Object] _value
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def self.call(count, value)
+        value.nil? ? count : count.succ
+      end
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Integer>]
+      #
+      # @api public
+      def type
+        Attribute::Integer
+      end
+
+      module Methods
+
+        # Return a count aggregate function
+        #
+        # @example
+        #   count = attribute.count
+        #
+        # @param [Attribute]
+        #
+        # @return [Count]
+        #
+        # @api public
+        def count
+          Count.new(self)
+        end
+
+      end # module Methods
+    end # class Count
+  end # class Aggregate
+end # module Veritas

data/lib/veritas/aggregate/maximum.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Veritas
+  class Aggregate
+
+    # The maximum value in a sequence of numbers
+    class Maximum < Aggregate
+
+      DEFAULT = -Float::INFINITY
+
+      # Return the maximum value for a sequence of numbers
+      #
+      # @example
+      #   maximum = Maximum.call(maximum, value)
+      #
+      # @param [Numeric] maximum
+      #
+      # @param [Numeric] value
+      #
+      # @return [Numeric]
+      #
+      # @api public
+      def self.call(maximum, value)
+        return maximum if value.nil?
+        value > maximum ? value : maximum
+      end
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Numeric>]
+      #
+      # @api public
+      def type
+        Attribute.infer_type(operand)
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:max => :maximum)
+
+        # Return a maximum aggregate function
+        #
+        # @example
+        #   maximum = attribute.maximum
+        #
+        # @param [Attribute]
+        #
+        # @return [Maximum]
+        #
+        # @api public
+        def maximum
+          Maximum.new(self)
+        end
+
+      end # module Methods
+    end # class Maximum
+  end # class Aggregate
+end # module Veritas

data/lib/veritas/aggregate/mean.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module Veritas
+  class Aggregate
+
+    # The mean of a sequence of numbers
+    class Mean < Aggregate
+
+      DEFAULT = [ 0, nil ].freeze
+
+      # Return the count and mean for a sequence of numbers
+      #
+      # @example
+      #   count, mean = Mean.call([ count, mean ], value)
+      #
+      # @param [Array(Integer, Numeric)] accumulator
+      #
+      # @param [Numeric] value
+      #
+      # @return [Array(Integer, Numeric)]
+      #
+      # @api public
+      def self.call(accumulator, value)
+        return accumulator if value.nil?
+        count, mean = accumulator
+        count       = Count.call(count, value)
+        [ count, mean.nil? ? value.to_f : mean + ((value - mean) / count.to_f) ]
+      end
+
+      # Extract the mean from the accumulator
+      #
+      # @example
+      #   mean = Mean.finalize(accumulator)
+      #
+      # @param [Array(Integer, Numeric)] accumulator
+      #
+      # @return [Float]
+      #   returned for a non-empty set
+      # @return [nil]
+      #   returned for an empty set
+      #
+      # @api public
+      def self.finalize(accumulator)
+        accumulator.last
+      end
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Float>]
+      #
+      # @api public
+      def type
+        Attribute::Float
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(
+          :average => :mean,
+          :avg     => :mean
+        )
+
+        # Return a mean aggregate function
+        #
+        # @example
+        #   mean = attribute.mean
+        #
+        # @param [Attribute]
+        #
+        # @return [Mean]
+        #
+        # @api public
+        def mean
+          Mean.new(self)
+        end
+
+      end # module Methods
+    end # class Mean
+  end # class Aggregate
+end # module Veritas

data/lib/veritas/aggregate/minimum.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Veritas
+  class Aggregate
+
+    # The maximum value in a sequence of numbers
+    class Minimum < Aggregate
+
+      DEFAULT = Float::INFINITY
+
+      # Return the minimum value for a sequence of numbers
+      #
+      # @example
+      #   minimum = Minimum.call(minimum, value)
+      #
+      # @param [Numeric] minimum
+      #
+      # @param [Numeric] value
+      #
+      # @return [Numeric]
+      #
+      # @api public
+      def self.call(minimum, value)
+        return minimum if value.nil?
+        value < minimum ? value : minimum
+      end
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Numeric>]
+      #
+      # @api public
+      def type
+        Attribute.infer_type(operand)
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:min => :minimum)
+
+        # Return a minimum aggregate function
+        #
+        # @example
+        #   minimum = attribute.minimum
+        #
+        # @param [Attribute]
+        #
+        # @return [Minimum]
+        #
+        # @api public
+        def minimum
+          Minimum.new(self)
+        end
+
+      end # module Methods
+    end # class Minimum
+  end # class Aggregate
+end # module Veritas

data/lib/veritas/aggregate/standard_deviation.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Veritas
+  class Aggregate
+
+    # The standard deviation of a sequence of numbers
+    class StandardDeviation < Variance
+
+      # Calculate the standard deviation from the accumulator
+      #
+      # @example
+      #   standard_deviation = StandardDeviation.finalize(accumulator)
+      #
+      # @param [Array(Numeric, Integer, Numeric)] accumulator
+      #
+      # @return [Float]
+      #   returned for a non-empty set
+      # @return [nil]
+      #   returned for an empty set
+      #
+      # @api public
+      def self.finalize(*)
+        variance = super
+        Math.sqrt(variance) if variance
+      end
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Float>]
+      #
+      # @api public
+      def type
+        Attribute::Float
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:stddev => :standard_deviation)
+
+        # Return a standard deviation aggregate function
+        #
+        # @example
+        #   standard_deviation = attribute.standard_deviation
+        #
+        # @param [Attribute]
+        #
+        # @return [StandardDeviation]
+        #
+        # @api public
+        def standard_deviation
+          StandardDeviation.new(self)
+        end
+
+      end # module Methods
+    end # class StandardDeviation
+  end # class Aggregate
+end # module Veritas

data/lib/veritas/aggregate/sum.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module Veritas
+  class Aggregate
+
+    # The sum of a sequence of numbers
+    class Sum < Aggregate
+
+      DEFAULT = 0
+
+      # Return the sum for a sequence of numbers
+      #
+      # @example
+      #   sum = Sum.call(sum, value)
+      #
+      # @param [Numeric] sum
+      #
+      # @param [Object] value
+      #
+      # @return [Numeric]
+      #
+      # @api public
+      def self.call(sum, value)
+        return sum if value.nil?
+        sum + value
+      end
+
+      # Return the default sum
+      #
+      # @example when the operand is a float
+      #   default = sum.default  # => 0.0
+      #
+      # @example when the operand is a decimal
+      #   default = sum.default  # => BigDecimal('0.0')
+      #
+      # @example when the operand is an integer
+      #   default = sum.default  # => 0
+      #
+      # @return [Numeric]
+      #
+      # @todo refactor once functions know their return types
+      #
+      # @api public
+      def default
+        type = self.type
+        if    type.equal?(Attribute::Float)   then super.to_f
+        elsif type.equal?(Attribute::Decimal) then BigDecimal(super.to_s)
+        else
+          super
+        end
+      end
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Numeric>]
+      #
+      # @api public
+      def type
+        Attribute.infer_type(operand)
+      end
+
+      module Methods
+
+        # Return a sum aggregate function
+        #
+        # @example
+        #   sum = attribute.sum
+        #
+        # @param [Attribute]
+        #
+        # @return [Sum]
+        #
+        # @api public
+        def sum
+          Sum.new(self)
+        end
+
+      end # module Methods
+    end # class Sum
+  end # class Aggregate
+end # module Veritas