axiom 0.1.0

data/axiom.gemspec

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/axiom/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name             = 'axiom'
+  gem.version          = Axiom::VERSION.dup
+  gem.authors          = ['Dan Kubb']
+  gem.email            = 'dan.kubb@gmail.com'
+  gem.description      = 'Simplifies querying of structured data using relational algebra'
+  gem.summary          = 'Ruby Relational Algebra'
+  gem.homepage         = 'https://github.com/dkubb/axiom'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split($/)
+  gem.test_files       = `git ls-files -- spec/{unit,integration}`.split($/)
+  gem.extra_rdoc_files = %w[LICENSE README.md TODO]
+
+  gem.add_runtime_dependency('backports',           '~> 3.1', '>= 3.1.1')
+  gem.add_runtime_dependency('adamantium',          '~> 0.0.7')
+  gem.add_runtime_dependency('descendants_tracker', '~> 0.0.1')
+  gem.add_runtime_dependency('equalizer',           '~> 0.0.5')
+  gem.add_runtime_dependency('abstract_type',       '~> 0.0.5')
+
+  gem.add_development_dependency('rake',  '~> 10.0.4')
+  gem.add_development_dependency('rspec', '~> 2.13.0')
+  gem.add_development_dependency('yard',  '~> 0.8.5.2')
+end

data/benchmarks/memory.rb

@@ -0,0 +1,173 @@
+#!/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__)
+
+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 'axiom lib' do
+  require 'axiom'
+end
+
+include Axiom
+
+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.sort_by { |r| [ r.id.desc, r.name ] }.each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.sort_by { |r| [ r.id, r.name ] }
+
+  gc_statistics "take (#{count} tuples)" do
+    relation.take(count).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.sort_by { |r| [ r.id, r.name ] }
+
+  gc_statistics "drop (#{count} tuples)" do
+    relation.drop(1).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.sort_by { |r| [ r.id, r.name ] }
+
+  gc_statistics "first (#{count} tuples)" do
+    relation.first(count).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.sort_by { |r| [ r.id, r.name ] }
+
+  gc_statistics "last (#{count} tuples)" do
+    relation.last(count).each {}
+  end
+end
+
+each_count do |array, relation, count|
+  relation = relation.sort_by { |r| [ r.id, r.name ] }
+
+  gc_statistics "reverse (#{count} tuples)" do
+    relation.reverse.each {}
+  end
+end

data/benchmarks/speed.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby -Ku
+
+# encoding: utf-8
+
+# benchmark speed of relation operations
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rbench'
+require 'axiom'
+include Axiom
+
+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.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 ]
+
+  report 'each' do
+    ruby  { array.each {}    }
+    axiom { relation.each {} }
+  end
+
+  report 'projection' do
+    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 {}           }
+  end
+
+  report 'restriction' do
+    ruby  { array.select { |tuple| tuple[:id] >= 1 }.each {} }
+    axiom { relation.restrict { |r| r.id.gte(1) }.each {}    }
+  end
+
+  report 'join' do
+    axiom { relation.join(join).each {} }
+  end
+
+  report 'product' do
+    ruby  { array.product(array).each {}      }
+    axiom { relation.product(product).each {} }
+  end
+
+  report 'intersection' do
+    ruby  { (array & array).each {}              }
+    axiom { relation.intersect(relation).each {} }
+  end
+
+  report 'union' do
+    ruby  { (array | array).each {}          }
+    axiom { relation.union(relation).each {} }
+  end
+
+  report 'difference' do
+    ruby  { (array - array).each {}               }
+    axiom { relation.difference(relation).each {} }
+  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 {}          }
+  end
+
+  report 'take' do
+    ruby  { array.take(1).each {}   }
+    axiom { ordered.take(1).each {} }
+  end
+
+  report 'drop' do
+    ruby  { array.drop(1).each {}   }
+    axiom { ordered.drop(1).each {} }
+  end
+
+  report 'first' do
+    ruby  { array.first(1).each {}   }
+    axiom { ordered.first(1).each {} }
+  end
+
+  report 'last' do
+    ruby  { array.last(1).each {}   }
+    axiom { ordered.last(1).each {} }
+  end
+
+  report 'reverse' do
+    ruby  { array.reverse.each {}   }
+    axiom { ordered.reverse.each {} }
+  end
+end

data/config/flay.yml

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

data/config/flog.yml

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

data/config/mutant.yml

@@ -0,0 +1,3 @@
+---
+name: axiom
+namespace: Axiom

data/config/reek.yml

@@ -0,0 +1,171 @@
+---
+Attribute:
+  enabled: true
+  exclude:
+  - Axiom::Algebra::Extension
+  - Axiom::Algebra::Join
+  - Axiom::Algebra::Rename
+  - Axiom::Algebra::Restriction
+  - Axiom::Algebra::Summarization
+  - Axiom::Attribute
+  - Axiom::Attribute::Numeric
+  - Axiom::Attribute::String
+  - Axiom::Evaluator::Context
+  - Axiom::Operation::Binary
+  - Axiom::Operation::Unary
+  - Axiom::Relation
+  - Axiom::Relation::Base
+  - Axiom::Relation::Header
+  - Axiom::Relation::Materialized
+  - Axiom::Relation::Operation::Limit
+  - Axiom::Relation::Operation::Offset
+  - Axiom::Relation::Operation::Order
+  - Axiom::Relation::Operation::Order::Direction
+  - Axiom::Relation::Proxy
+  - Axiom::Tuple
+BooleanParameter:
+  enabled: true
+  exclude: []
+ClassVariable:
+  enabled: true
+  exclude: []
+ControlParameter:
+  enabled: true
+  exclude: []
+DataClump:
+  enabled: true
+  exclude:
+  - Axiom::Immutable
+  - Axiom::Relation::Operation::Binary::ClassMethods
+  - Axiom::Relation::Operation::Set::ClassMethods
+  max_copies: 1
+  min_clump_size: 2
+DuplicateMethodCall:
+  enabled: true
+  exclude:
+  - Axiom::Aggregate::Sum#default
+  - Axiom::Algebra::Difference#delete
+  - Axiom::Algebra::Difference#insert
+  - Axiom::Algebra::Join#delete_left
+  - Axiom::Algebra::Join#delete_right
+  - Axiom::Algebra::Join#insert_left
+  - Axiom::Algebra::Join#insert_right
+  - Axiom::Algebra::Rename#delete
+  - Axiom::Algebra::Rename#insert
+  - Axiom::Algebra::Restriction#delete
+  - 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::Proxy#forward
+  - Axiom::Relation::Proxy#method_missing
+  max_calls: 1
+  allow_calls: []
+FeatureEnvy:
+  enabled: true
+  exclude:
+  - Axiom::Algebra::Projection#required_attribute_names
+IrresponsibleModule:
+  enabled: true
+  exclude: []
+LongParameterList:
+  enabled: true
+  exclude:
+  - Axiom::Algebra::Rename::Aliases#self.coerce_alias_pair
+  - Axiom::Algebra::Summarization#self.new
+  - Axiom::Relation::Operation::Combination#self.combine_tuples
+  max_params: 2
+  overrides:
+    initialize:
+      max_params: 3
+LongYieldList:
+  enabled: true
+  exclude: []
+  max_params: 2
+NestedIterators:
+  enabled: true
+  exclude:
+  - Axiom::Algebra::Projection#extend_other
+  - Axiom::Equalizer#define_cmp_method
+  - Axiom::Equalizer#define_hash_method
+  - Axiom::Equalizer#define_inspect_method
+  max_allowed_nesting: 1
+  ignore_iterators: []
+NilCheck:
+  enabled: true
+  exclude:
+  - Axiom::Aggregate::Count#self.call
+  - Axiom::Aggregate::Maximum#self.call
+  - Axiom::Aggregate::Mean#self.call
+  - Axiom::Aggregate::Minimum#self.call
+  - Axiom::Aggregate::Sum#self.call
+  - Axiom::Aggregate::Variance#self.call
+  - Axiom::Attribute#valid_or_optional?
+  - Axiom::Relation::Operation::Limit#self.assert_valid_limit
+  - Axiom::Relation::Operation::Offset#self.assert_valid_offset
+RepeatedConditional:
+  enabled: true
+  exclude: []
+  max_ifs: 1
+TooManyInstanceVariables:
+  enabled: true
+  exclude:
+  - Axiom::Relation::Header
+  max_instance_variables: 3
+TooManyMethods:
+  enabled: true
+  exclude:
+  - Axiom::Algebra::Join
+  - Axiom::Relation
+  - Axiom::Relation::Header
+  - Axiom::Relation::Keys
+  max_methods: 10
+TooManyStatements:
+  enabled: true
+  exclude:
+  - Axiom::Aggregate::Variance#self.call
+  - Axiom::Algebra::Rename::Aliases#union
+  - Axiom::Attribute#self.coerce
+  - each
+  max_statements: 5
+UncommunicativeMethodName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^[a-z]$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UncommunicativeModuleName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  accept: []
+UncommunicativeParameterName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UncommunicativeVariableName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UnusedParameters:
+  enabled: true
+  exclude: []
+UtilityFunction:
+  enabled: true
+  exclude: []
+  max_helper_calls: 0