veritas 0.0.2 → 0.0.3

data/Gemfile

@@ -1,10 +1,11 @@
 source :rubygems
 
 group :development do
-  gem 'backports', '~> 2.0.2'
+  gem 'backports', '~> 2.1.0'
   gem 'jeweler',   '~> 1.5.2'
   gem 'rake',      '~> 0.8.7'
-  gem 'rspec',     '~> 1.3.1'
+  gem 'rspec',     '~> 1.3.2'
+  gem 'yard',      '~> 0.6.8'
 end
 
 group :jruby do
@@ -19,18 +20,16 @@ end
 
 platforms :mri_18 do
   group :quality do
-    gem 'activesupport', '~> 2.3.11'
-    gem 'flay',          '~> 1.4.2'
-    gem 'flog',          '~> 2.5.1'
-    gem 'heckle',        '~> 1.4.3'
-    gem 'json',          '~> 1.5.1'
-    gem 'metric_fu',     '~> 2.1.1'
-    gem 'mspec',         '~> 1.5.17'
-    gem 'rcov',          '~> 0.9.9'
-    gem 'reek',          '~> 1.2.8', :git => 'git://github.com/dkubb/reek.git'
-    gem 'roodi',         '~> 2.1.0'
-    gem 'ruby2ruby',     '=  1.2.2'
-    gem 'yard',          '~> 0.6.4'
-    gem 'yardstick',     '~> 0.2.0'
+    gem 'flay',      '~> 1.4.2'
+    gem 'flog',      '~> 2.5.1'
+    gem 'heckle',    '~> 1.4.3'
+    gem 'json',      '~> 1.5.1'
+    gem 'metric_fu', '~> 2.1.1'
+    gem 'mspec',     '~> 1.5.17'
+    gem 'rcov',      '~> 0.9.9'
+    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'
   end
 end

data/README.rdoc

@@ -16,7 +16,7 @@ Simplifies querying of structured data using relational algebra
   new_relation = relation.remove([ :a, :b, :c ])
 
   # rename
-  new_relation = relation.rename(:a => :b, :c => :d)
+  new_relation = relation.rename(a: :b, c: :d)
 
   # natural join
   new_relation = relation.join(other)        # OR relation + other
@@ -88,8 +88,8 @@ Simplifies querying of structured data using relational algebra
   # --------------
 
   # can only modify relations that project all candidate keys for the base relations
-  new_relation = relation.create(:a => 'test', :b => 'other', :c => 'yet another')
-  new_relation = relation.update(:a => 'test', :b => 'other', :c => 'yet another')
+  new_relation = relation.create(a: 'test', b: 'other', c: 'yet another')
+  new_relation = relation.update(a: 'test', b: 'other', c: 'yet another')
   new_relation = relation.delete
 
 == Goals
@@ -114,7 +114,7 @@ This is 100% complete now.
 
 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.
 
-This is 30% complete. I am currently working on the veritas-sql-compiler[https://github.com/dkubb/veritas-sql-compiler] which is a visitor that walks the AST and produces SQL. Most of the Unary options work, and I am about to begin work on the binary options. Further refactoring will need to be performed to keep the Visitor class from growing huge (it has one method for each "node type").
+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.
 
 === Phase 3: DataMapper Integration
 

data/Rakefile

@@ -13,7 +13,6 @@ begin
     gem.email       = 'dan.kubb@gmail.com'
     gem.homepage    = 'https://github.com/dkubb/veritas'
     gem.authors     = [ 'Dan Kubb' ]
-    gem.has_rdoc    = 'yard'
 
     gem.version = Veritas::VERSION
   end

data/TODO

@@ -1,12 +1,3 @@
-* Raise an exception if a rename is going to duplicate and existing
-  header attribute.
-
-* Raise an exception if a rename has aliases with duplicate names.
-
-* Rename usage of "range" for attributes to "domain"
-  * Functions will have both a range and domain, but attributes
-    only have a domain.
-
 * Add Extension and Summarization Functions
   * Overview: https://gist.github.com/584588
 
@@ -30,82 +21,6 @@
     and instead wrap materialized relations in the Order object
     if any.
 
-* Add further optimizations:
-  * Projection
-    * When it contains a Rename, if the renamed attributes are projected
-      away, then the rename can be removed.
-  * Operation Order:
-    * Projection containing an Order
-      * Should remove the Order, since it is a noop
-    * Projection should follow Rename
-      * When a Projection contains a Restriction, wrap the Projection
-        in the Restriction, projecting away any attributes not used in
-        the restriction. If there are any remaining attributes, then
-        wrap the operation in a Projection removing those attributes.
-        * If all attributes are being used in the Restriction do nothing
-      * When a Projection contains a Join, wrap the Join with a Projection
-        of all the headers, minus those used in the Join. If there were
-        any used, then wrap the whole operation in a Projection with
-        the remaining attributes.
-        * If all the attributes are used in the Join, do nothing
-        * Try to use the same approach for Product
-        * Test if it's possible to fully distribute projections over
-          joins rather than splitting it up like this.
-    * Restriction should follow Projection
-      * Restriction optimizations:
-        * "attr > ? OR attr > ?" -> "attr > ?", with the least restrictive value
-          * Do the same for >=, <, <=
-        * "attr > ? AND attr > ?" -> "attr > ?", with the most restrictive value
-          * Do the same for >=, <, <=
-        * "attr > 5 OR attr == 5" -> "attr >= 5"
-        * "attr < 5 OR attr == 5" -> "attr <= 5"
-        * "attr" = "string" AND "attr" =~ /string/ -> "attr" = "string"
-          * If the regexp matches the constant, then it should be
-            optimized down to a constant match. If it does not match
-            then it should be optimized to False.
-        * Constant folding, eg:
-          "attr1 > attr2 AND attr1 = 5" -> "5 > attr2 AND attr1 = 5"
-          * This will probably only work across Conjunctions.
-        * "attr > 5 AND attr = 6" -> "attr = 6", because attr must be
-          equal to 6. this will probably be related to constant folding;
-          the first expression will become 6 > 5, which evaluates to
-          True, then the expression is True AND attr = 6, which simplifies
-          down to attr = 6.
-        * "attr < 5 AND attr = 6" -> "False", because attr must be equal to
-          6, and 6 < 5 evaluates to False.  False AND attr = 6 simplifies
-          down to False.
-      * Figure out how to reorganize the Restriction predicates so that all
-        similar operations are closer together to allow more efficient
-        optimizations. This would allow optimizations of stuff like this:
-
-          "attr1 = ? OR attr2 = ? OR attr1 = ?"
-
-        Into:
-
-          "attr1 IN(..) OR attr2 = ?"
-    * Rename should distribute over Join, Product and Set operations
-      * The goal should be to push Rename as close to the base tables
-        as possible so that the names of attribute will be consistent
-        throughout the whole tree.
-  * A Union of relations with the same base, header, and restrictions should
-    try to combine into a single relation with the restrictions using OR.
-  * An Intersection of relations with the same base, header, and restrictions
-    should try to combine into a single relation with the restrictions using
-    AND.
-  * A Difference of relations with the same base and restrictions should
-    try to combine into a single relation with the restrictions using NOT.
-  * Join Optimizations
-    * When a Join contains a Join, and the size of the base relations is
-      known, join the smallest with the largest, and then join that result
-      with the remaining relation.
-    * Make sure the smallest relation (with a known size) is always the
-      right-most operation.
-  * When a restriction uses a unique index:
-    * Order can be factored out
-    * Limit with a limit >= 1 can be factored out
-    * Offset with an offset > 0 can be transformed into an empty
-      relation, since at most there can be only one match.
-
 * Allow Inclusion match to accept a Relation
   * Ensure that Inclusion can have the left/right be an Array of
     Attributes.

data/benchmarks/speed.rb

@@ -26,23 +26,23 @@ RBench.run(TIMES) do
   column :diff,    :title => 'Diff', :compare => [ :ruby, :veritas ]
 
   report 'each' do
-    ruby    { array.each {} }
+    ruby    { array.each {}    }
     veritas { relation.each {} }
   end
 
   report 'projection' do
     ruby    { array.map { |tuple| [ tuple[:id] ] }.each {} }
-    veritas { relation.project([ :id ]).each {} }
+    veritas { relation.project([ :id ]).each {}            }
   end
 
   report 'removal' do
     ruby    { array.map { |tuple| [ tuple[:id] ] }.each {} }
-    veritas { relation.remove([ :name ]).each {} }
+    veritas { relation.remove([ :name ]).each {}           }
   end
 
   report 'restriction' do
     ruby    { array.select { |tuple| tuple[:id] >= 1 }.each {} }
-    veritas { relation.restrict { |r| r[:id].gte(1) }.each {} }
+    veritas { relation.restrict { |r| r[:id].gte(1) }.each {}  }
   end
 
   report 'join' do
@@ -50,52 +50,52 @@ RBench.run(TIMES) do
   end
 
   report 'product' do
-    ruby    { array.product(array).each {} } if Array.method_defined?(:product)
+    ruby    { array.product(array).each {}      }
     veritas { relation.product(product).each {} }
   end
 
   report 'intersection' do
-    ruby    { (array & array).each {} }
+    ruby    { (array & array).each {}              }
     veritas { relation.intersect(relation).each {} }
   end
 
   report 'union' do
-    ruby    { (array | array).each {} }
+    ruby    { (array | array).each {}          }
     veritas { relation.union(relation).each {} }
   end
 
   report 'difference' do
-    ruby    { (array - array).each {} }
+    ruby    { (array - array).each {}               }
     veritas { relation.difference(relation).each {} }
   end
 
   report 'order' do
     ruby    { array.sort_by { |tuple| [ -tuple[:id], tuple[:name] ] }.each {} }
-    veritas { relation.order { |r| [ r[:id].desc, r[:name] ] }.each {} }
+    veritas { relation.order { |r| [ r[:id].desc, r[:name] ] }.each {}        }
   end
 
   report 'take' do
-    ruby    { array.take(1).each {} }
+    ruby    { array.take(1).each {}   }
     veritas { ordered.take(1).each {} }
   end
 
   report 'drop' do
-    ruby    { array.drop(1).each {} }
+    ruby    { array.drop(1).each {}   }
     veritas { ordered.drop(1).each {} }
   end
 
   report 'first' do
-    ruby    { array.first(1).each {} }
+    ruby    { array.first(1).each {}   }
     veritas { ordered.first(1).each {} }
   end
 
   report 'last' do
-    ruby    { array.last(1).each {} }
+    ruby    { array.last(1).each {}   }
     veritas { ordered.last(1).each {} }
   end
 
   report 'reverse' do
-    ruby    { array.reverse.each {} }
+    ruby    { array.reverse.each {}   }
     veritas { ordered.reverse.each {} }
   end
 end

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
-threshold: 131
-total_score: 1579
+threshold: 68
+total_score: 778

data/config/flog.yml

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

data/config/roodi.yml

@@ -1,9 +1,9 @@
 ---
-AbcMetricMethodCheck:            { score: 11 }
+AbcMetricMethodCheck:            { score: 11.8 }
 AssignmentInConditionalCheck:    { }
 CaseMissingElseCheck:            { }
 ClassLineCountCheck:             { line_count: 390 }
-ClassNameCheck:                  { pattern: !ruby/regexp /\A[A-Z][a-z](?:[A-Z]?[a-z])+\z/ }
+ClassNameCheck:                  { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
 ClassVariableCheck:              { }
 CyclomaticComplexityBlockCheck:  { complexity: 2 }
 CyclomaticComplexityMethodCheck: { complexity: 5 }
@@ -13,6 +13,6 @@ ForLoopCheck:                    { }
 MethodLineCountCheck:            { line_count: 14 }
 MethodNameCheck:                 { pattern: !ruby/regexp /\A(?:[a-z](?:_?[a-z])+[?!=]?|\[\]=?|==|<=>|[+*&|-])\z/ }
 ModuleLineCountCheck:            { line_count: 392 }
-ModuleNameCheck:                 { pattern: !ruby/regexp /\A[A-Z][a-z](?:[A-Z]?[a-z])+\z/ }
+ModuleNameCheck:                 { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
 # TODO: decrease parameter_count to 2 or less
 ParameterNumberCheck:            { parameter_count: 3 }

data/lib/veritas.rb

@@ -10,7 +10,6 @@ require 'veritas/core_ext/time'
 require 'veritas/support/abstract_class'
 require 'veritas/support/aliasable'
 require 'veritas/support/immutable'
-require 'veritas/support/optimizable'
 require 'veritas/support/visitable'
 
 require 'veritas/support/operation/binary'
@@ -18,12 +17,77 @@ require 'veritas/support/operation/unary'
 
 require 'veritas/support/evaluator'
 
-require 'veritas/logic'
+require 'veritas/logic/expression'
+require 'veritas/logic/connective'
+require 'veritas/logic/connective/binary'
+require 'veritas/logic/connective/unary'
+require 'veritas/logic/connective/conjunction'
+require 'veritas/logic/connective/disjunction'
+require 'veritas/logic/connective/negation'
+
+require 'veritas/logic/predicate'
+require 'veritas/logic/predicate/comparable'
+require 'veritas/logic/predicate/enumerable'
+require 'veritas/logic/predicate/equality'
+require 'veritas/logic/predicate/exclusion'
+require 'veritas/logic/predicate/greater_than'
+require 'veritas/logic/predicate/greater_than_or_equal_to'
+require 'veritas/logic/predicate/inclusion'
+require 'veritas/logic/predicate/inequality'
+require 'veritas/logic/predicate/less_than'
+require 'veritas/logic/predicate/less_than_or_equal_to'
+require 'veritas/logic/predicate/no_match'
+require 'veritas/logic/predicate/match'
+
+require 'veritas/logic/proposition'
+require 'veritas/logic/proposition/contradiction'
+require 'veritas/logic/proposition/tautology'
+
 require 'veritas/relation'
-require 'veritas/algebra'
 
-require 'veritas/optimizer'
+require 'veritas/relation/header'
+
+require 'veritas/relation/materialized'
+require 'veritas/relation/empty'
+
+require 'veritas/relation/operation/unary'
+require 'veritas/relation/operation/binary'
+require 'veritas/relation/operation/combination'
+require 'veritas/relation/operation/set'
+require 'veritas/relation/operation/offset'
+require 'veritas/relation/operation/order'
+require 'veritas/relation/operation/order/direction'
+require 'veritas/relation/operation/order/direction_set'
+require 'veritas/relation/operation/limit'
+require 'veritas/relation/operation/reverse'
+
+require 'veritas/algebra/difference'
+require 'veritas/algebra/extension'
+require 'veritas/algebra/intersection'
+require 'veritas/algebra/join'
+require 'veritas/algebra/product'
+require 'veritas/algebra/projection'
+require 'veritas/algebra/rename'
+require 'veritas/algebra/rename/aliases'
+require 'veritas/algebra/restriction'
+require 'veritas/algebra/summarization'
+require 'veritas/algebra/union'
+
 require 'veritas/attribute'
+require 'veritas/attribute/orderable'
+require 'veritas/attribute/comparable'
+require 'veritas/attribute/object'
+require 'veritas/attribute/numeric'
+require 'veritas/attribute/boolean'
+require 'veritas/attribute/class'
+require 'veritas/attribute/date'
+require 'veritas/attribute/date_time'
+require 'veritas/attribute/decimal'
+require 'veritas/attribute/float'
+require 'veritas/attribute/integer'
+require 'veritas/attribute/time'
+require 'veritas/attribute/string'
+
 require 'veritas/tuple'
 require 'veritas/version'
 
@@ -32,6 +96,9 @@ module Veritas
   # Raised when the headers are invalid for Join and Product
   class InvalidHeaderError < ArgumentError; end
 
+  # Raised when the aliases are duplicated
+  class DuplicateAliasError < ArgumentError; end
+
   # Raised when the limit is not a positive integer
   class InvalidLimitError < ArgumentError; end
 
@@ -47,9 +114,9 @@ module Veritas
   # Raised when a binary operation mixes ordered and unordered relations
   class RelationMismatchError < StandardError; end
 
-  # Raised when an attribute is added to a relation that already exists
-  class DuplicateHeaderName < StandardError; end
+  # Raised when an attribute is a duplicate of another in the header
+  class DuplicateAttributeError < StandardError; end
 
-  TABLE_DUM = Relation.new([], [    ]).optimize
-  TABLE_DEE = Relation.new([], [ [] ]).optimize
+  TABLE_DUM = Relation::Empty.new([])
+  TABLE_DEE = Relation.new([], [ [] ])
 end

data/lib/veritas/algebra/difference.rb

@@ -20,6 +20,7 @@ module Veritas
       #
       # @api public
       def each
+        return to_enum unless block_given?
         right_set = right.to_set
         left.each { |tuple| yield(tuple) unless right_set.include?(tuple) }
         self

data/lib/veritas/algebra/extension.rb

@@ -12,46 +12,6 @@ module Veritas
       # @api private
       attr_reader :extensions
 
-      # Instantiate a new Extension
-      #
-      # @example
-      #   extension = Extension.new(operand, extensions)
-      #
-      # @param [Relation] operand
-      #   the relation to extend
-      # @param [Hash] extensions
-      #   the extensions to add
-      #
-      # @return [Extension]
-      #
-      # @api public
-      def self.new(operand, extensions)
-        assert_unique_header(operand, extensions)
-        super
-      end
-
-      # Assert the extensions are uniquely named
-      #
-      # @param [Relation] operand
-      # @param [Hash] extensions
-      #
-      # @return [undefined]
-      #
-      # @raise [DuplicateHeaderName]
-      #   raised if an extensions is named the same as an existing
-      #   attribute in the header
-      #
-      # @api private
-      def self.assert_unique_header(operand, extensions)
-        header     = operand.header
-        duplicates = extensions.keys.select { |attribute| header[attribute] }.sort
-        if duplicates.any?
-          raise DuplicateHeaderName, "extensions with duplicate header names: #{duplicates.join(', ')}"
-        end
-      end
-
-      private_class_method :assert_unique_header
-
       # Initialize an Extension
       #
       # @param [Relation] operand
@@ -83,6 +43,7 @@ module Veritas
       #
       # @api public
       def each
+        return to_enum unless block_given?
         header     = self.header
         extensions = self.extensions.values
         operand.each { |tuple| yield tuple.extend(header, extensions) }