veritas 0.0.1

data/benchmarks/memory.rb

@@ -0,0 +1,175 @@
+#!/usr/bin/env ruby -Ku
+
+# encoding: utf-8
+
+# benchmark memory usage of lib, core object init and relation operations
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'backports'
+
+unless GC.respond_to?(:enable_stats)
+  puts 'Error: benchmark works on ree, or ruby with Railsbench GC patch only'
+  exit 1
+end
+
+COUNTS    = [ 1, 10, 100, 1_000, 10_000, 100_000 ].freeze
+NAME      = 'Dan Kubb'.freeze
+RELATIONS = {}
+
+# original code from http://blog.pluron.com/2008/02/memory-profilin.html
+def gc_statistics(description = '', options = {})
+  GC.enable_stats || GC.clear_stats
+  GC.disable if options[:disable_gc]
+
+  yield
+
+  stat_string = "#{description}: "
+  stat_string += "allocated: #{GC.allocated_size} bytes total in #{GC.num_allocations} allocations, "
+  stat_string += "GC calls: #{GC.collections}, "
+  stat_string += "GC time: #{GC.time}"
+
+  GC.log stat_string
+  GC.dump if options[:show_gc_dump]
+
+  GC.enable if options[:disable_gc]
+  GC.disable_stats
+end
+
+puts '-' * 80
+gc_statistics 'veritas lib' do
+  require 'veritas'
+end
+
+include Veritas
+
+puts '-' * 80
+gc_statistics 'header' do
+  HEADER = Relation::Header.new([ [ :id, Integer ], [ :name, String ] ])
+end
+
+puts '-' * 80
+gc_statistics 'tuple' do
+  TUPLE = Tuple.new(HEADER, [ 1, NAME ])
+end
+
+puts '-' * 80
+gc_statistics 'relation' do
+  Relation.new(HEADER, Tuple.new(HEADER, TUPLE))
+end
+
+# pre-allocate all the relations for the preceding operations
+COUNTS.each do |count|
+  RELATIONS[count] = Relation.new(
+    HEADER,
+    (1..count).map { |n| Tuple.new(HEADER, [ n, NAME ]) }
+  )
+end
+
+def each_count
+  puts '-' * 80
+  COUNTS.each do |count|
+    relation = RELATIONS[count].dup
+    yield(relation.to_a, relation, count)
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "enumeration (#{count} tuples)" do
+    relation.each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "projection (#{count} tuples)" do
+    relation.project([ :id ]).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "removal (#{count} tuples)" do
+    relation.remove([ :name ]).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "restriction (#{count} tuples)" do
+    relation.restrict { |r| r[:id].gte(1) }.each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "join (#{count} tuples)" do
+    relation.join(Relation.new([ [ :id, Integer, ], [ :age, Integer ] ], [ [ 1, 35 ] ])).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "product (#{count} tuples)" do
+    relation.product(Relation.new([ [ :age, Integer ] ], [ [ 35 ] ])).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "intersection (#{count} tuples)" do
+    relation.intersect(relation).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "union (#{count} tuples)" do
+    relation.union(relation).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "difference (#{count} tuples)" do
+    relation.difference(relation).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  gc_statistics "order (#{count} tuples)" do
+    relation.order { |r| [ r[:id].desc, r[:name] ] }.each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.order(relation.header)
+
+  gc_statistics "take (#{count} tuples)" do
+    relation.take(count).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.order(relation.header)
+
+  gc_statistics "drop (#{count} tuples)" do
+    relation.drop(1).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.order(relation.header)
+
+  gc_statistics "first (#{count} tuples)" do
+    relation.first(count).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.order(relation.header)
+
+  gc_statistics "last (#{count} tuples)" do
+    relation.last(count).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.order(relation.header)
+
+  gc_statistics "reverse (#{count} tuples)" do
+    relation.reverse.each {}
+  end
+end

data/benchmarks/speed.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby -Ku
+
+# encoding: utf-8
+
+# benchmark speed of relation operations
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'backports'
+require 'rbench'
+require 'veritas'
+include Veritas
+
+TIMES = 5_000
+
+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.order(relation.header)
+
+RBench.run(TIMES) do
+  column :ruby,    :title => 'Ruby'
+  column :veritas, :title => 'Veritas'
+  column :diff,    :title => 'Diff', :compare => [ :ruby, :veritas ]
+
+  report 'each' do
+    ruby    { array.each {} }
+    veritas { relation.each {} }
+  end
+
+  report 'projection' do
+    ruby    { array.map { |tuple| [ tuple[:id] ] }.each {} }
+    veritas { relation.project([ :id ]).each {} }
+  end
+
+  report 'removal' do
+    ruby    { array.map { |tuple| [ tuple[:id] ] }.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 {} }
+  end
+
+  report 'join' do
+    veritas { relation.join(join).each {} }
+  end
+
+  report 'product' do
+    ruby    { array.product(array).each {} } if Array.method_defined?(:product)
+    veritas { relation.product(product).each {} }
+  end
+
+  report 'intersection' do
+    ruby    { (array & array).each {} }
+    veritas { relation.intersect(relation).each {} }
+  end
+
+  report 'union' do
+    ruby    { (array | array).each {} }
+    veritas { relation.union(relation).each {} }
+  end
+
+  report 'difference' do
+    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 {} }
+  end
+
+  report 'take' do
+    ruby    { array.take(1).each {} }
+    veritas { ordered.take(1).each {} }
+  end
+
+  report 'drop' do
+    ruby    { array.drop(1).each {} }
+    veritas { ordered.drop(1).each {} }
+  end
+
+  report 'first' do
+    ruby    { array.first(1).each {} }
+    veritas { ordered.first(1).each {} }
+  end
+
+  report 'last' do
+    ruby    { array.last(1).each {} }
+    veritas { ordered.last(1).each {} }
+  end
+
+  report 'reverse' do
+    ruby    { array.reverse.each {} }
+    veritas { ordered.reverse.each {} }
+  end
+end

data/config/flay.yml

@@ -0,0 +1,3 @@
+---
+threshold: 131
+total_score: 1471

data/config/flog.yml

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

data/config/roodi.yml

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

data/config/site.reek

@@ -0,0 +1,96 @@
+---
+UncommunicativeParameterName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+LargeClass:
+  max_methods: 16  # TODO: decrease max_methods to 10-15 or less
+  exclude: []
+  enabled: true
+  max_instance_variables: 3
+UncommunicativeMethodName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^[a-z]$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+LongParameterList:
+  max_params: 3  # TODO: decrease max_params to 2
+  exclude: []
+  enabled: true
+  overrides: {}
+FeatureEnvy:
+  exclude: []
+  enabled: true
+ClassVariable:
+  exclude: []
+  enabled: true
+BooleanParameter:
+  exclude: []
+  enabled: true
+IrresponsibleModule:
+  exclude: []
+  enabled: true
+UncommunicativeModuleName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+NestedIterators:
+  ignore_iterators: []
+  exclude: []
+  enabled: true
+  max_allowed_nesting: 1
+LongMethod:
+  max_statements: 7  # TODO: decrease max_statements to 5 or less
+  exclude: []
+  enabled: true
+Duplication:
+  allow_calls: []
+  exclude: []
+  enabled: true
+  max_calls: 1
+UtilityFunction:
+  max_helper_calls: 1
+  exclude: []
+  enabled: true
+Attribute:
+  exclude: []
+  enabled: false
+UncommunicativeVariableName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+SimulatedPolymorphism:
+  exclude: []
+  enabled: true
+  max_ifs: 1
+DataClump:
+  exclude: [
+    # all of these classes have utility class methods that are
+    # incorrectly identified as instance methods
+    Veritas::Relation::Operation::Binary::ClassMethods,
+    Veritas::Relation::Operation::Set::ClassMethods
+  ]
+  enabled: true
+  max_copies: 1
+  min_clump_size: 2
+ControlCouple:
+  exclude: []
+  enabled: true
+LongYieldList:
+  max_params: 1
+  exclude: []
+  enabled: true

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

data/lib/veritas/algebra/difference.rb

@@ -0,0 +1,53 @@
+module Veritas
+  module Algebra
+
+    # The difference between relations
+    class Difference < Relation
+      include Relation::Operation::Set
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   difference = Difference.new(left, right)
+      #   difference.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        right_set = right.to_set
+        left.each { |tuple| yield(tuple) unless right_set.include?(tuple) }
+        self
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:- => :difference)
+
+        # Return the difference between relations
+        #
+        # @example
+        #   difference = relation.difference(other)
+        #
+        # @param [Relation] other
+        #
+        # @return [Difference]
+        #
+        # @api public
+        def difference(other)
+          Difference.new(self, other)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Difference
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra/extension.rb

@@ -0,0 +1,121 @@
+module Veritas
+  module Algebra
+
+    # Extend a relation to include calculated attributes
+    class Extension < Relation
+      include Relation::Operation::Unary
+
+      # The extensions for the relation
+      #
+      # @return [Hash]
+      #
+      # @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
+      #   the relation to extend
+      # @param [#to_hash] extensions
+      #   the extensions to add
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand, extensions)
+        super(operand)
+        @extensions  = extensions.to_hash
+        @header     |= @extensions.keys
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   extension = Extension.new(operand, extensions)
+      #   extension.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        header     = self.header
+        extensions = self.extensions.values
+        operand.each { |tuple| yield tuple.extend(header, extensions) }
+        self
+      end
+
+      module Methods
+
+        # Return an extended relation
+        #
+        # @example
+        #   extension = relation.extend do |expression|
+        #     expression.add(:total, expression[:unit_price] * expression[:quantity])
+        #   end
+        #
+        # @yield [expression]
+        #   Evaluate an extension expression
+        #
+        # @yieldparam [Evaluator::Expression] expression
+        #   the context to evaluate the extension with
+        #
+        # @return [Extension]
+        #
+        # @api public
+        def extend(&block)
+          evaluator = Evaluator::Expression.new(&block)
+          Extension.new(self, evaluator.expressions)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Extension
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra/intersection.rb

@@ -0,0 +1,53 @@
+module Veritas
+  module Algebra
+
+    # The intersection between relations
+    class Intersection < Relation
+      include Relation::Operation::Set
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   intersection = Intersection.new(left, right)
+      #   intersection.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        right_set = right.to_set
+        left.each { |tuple| yield(tuple) if right_set.include?(tuple) }
+        self
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:& => :intersect)
+
+        # Return the intersection between relations
+        #
+        # @example
+        #   intersection = relation.intersect(other)
+        #
+        # @param [Relation] other
+        #
+        # @return [Intersection]
+        #
+        # @api public
+        def intersect(other)
+          Intersection.new(self, other)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Intersection
+  end # module Algebra
+end # module Veritas