axiom-optimizer 0.1.0

data/axiom-optimizer.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/axiom/optimizer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'axiom-optimizer'
+  gem.version     = Axiom::Optimizer::VERSION.dup
+  gem.authors     = ['Dan Kubb']
+  gem.email       = 'dan.kubb@gmail.com'
+  gem.description = 'Optimizes axiom relations'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/dkubb/axiom-optimizer'
+  gem.licenses    = %w[MIT]
+
+  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 CONTRIBUTING.md TODO]
+
+  gem.add_runtime_dependency('axiom', '~> 0.1.0')
+
+  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/config/flay.yml

@@ -0,0 +1,3 @@
+---
+threshold: 66
+total_score: 913

data/config/flog.yml

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

data/config/mutant.yml

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

data/config/reek.yml

@@ -0,0 +1,162 @@
+---
+Attribute:
+  enabled: true
+  exclude:
+  - Axiom::Optimizer
+  - Axiom::Optimizer::Algebra::Extension
+  - Axiom::Optimizer::Algebra::Rename
+  - Axiom::Optimizer::Algebra::Restriction
+  - Axiom::Optimizer::Algebra::Summarization
+  - Axiom::Optimizer::Function::Binary
+  - Axiom::Optimizer::Function::Unary
+  - Axiom::Optimizer::Optimizable::ClassMethods
+  - Axiom::Optimizer::PredicatePartition
+  - Axiom::Optimizer::Relation::Operation::Unary
+BooleanParameter:
+  enabled: true
+  exclude: []
+ClassVariable:
+  enabled: true
+  exclude: []
+ControlParameter:
+  enabled: true
+  exclude: []
+DataClump:
+  enabled: true
+  exclude: []
+  max_copies: 2
+  min_clump_size: 2
+DuplicateMethodCall:
+  enabled: true
+  exclude:
+  - Axiom::Optimizer::Algebra::Difference::EqualOperands#optimize
+  - Axiom::Optimizer::Algebra::Join::MaterializedLeft#right_matching_left?
+  - Axiom::Optimizer::Algebra::Join::MaterializedRight#left_matching_right?
+  - Axiom::Optimizer::Algebra::Product::TableDeeLeft#optimizable?
+  - Axiom::Optimizer::Algebra::Product::TableDeeRight#optimizable?
+  - Axiom::Optimizer::Algebra::Projection::ExtensionOperand#optimizable?
+  - Axiom::Optimizer::Algebra::Rename::ProjectionOperand#removed_attributes
+  - Axiom::Optimizer::Algebra::Restriction::CombinationOperand#partition
+  - Axiom::Optimizer::Algebra::Restriction::Contradiction#optimize
+  - Axiom::Optimizer::Algebra::Summarization::EmptySummarizePer#optimize
+  - Axiom::Optimizer::Function::Connective::Binary#contradiction?
+  - Axiom::Optimizer::Function::Connective::Binary#contradiction?
+  - Axiom::Optimizer::Function::Connective::Binary#left_equality?
+  - Axiom::Optimizer::Function::Connective::Binary#left_inequality?
+  - Axiom::Optimizer::Function::Connective::Binary#right_equality?
+  - Axiom::Optimizer::Function::Connective::Binary#right_inequality?
+  - Axiom::Optimizer::Function::Connective::Binary::RedundantLeft#optimizable?
+  - Axiom::Optimizer::Function::Connective::Binary::RedundantRight#optimizable?
+  - Axiom::Optimizer::Function::Predicate::Comparable::NeverEquivalent#joinable?
+  - Axiom::Optimizer::Function::Predicate::Enumerable#optimize_right_range
+  - Axiom::Optimizer::Function::Predicate::GreaterThanOrEqualTo::Tautology#optimizable?
+  - Axiom::Optimizer::Function::Predicate::LessThanOrEqualTo::Tautology#optimizable?
+  - Axiom::Optimizer::Relation::Materialized::EmptyOperand#optimize
+  - Axiom::Optimizer::Relation::Operation::Combination#optimize
+  - Axiom::Optimizer::Relation::Operation::Limit::ZeroLimit#optimize
+  - Axiom::Optimizer::Relation::Operation::Order::OneLimitOperand#optimizable?
+  max_calls: 1
+  allow_calls: []
+FeatureEnvy:
+  enabled: true
+  exclude: []
+IrresponsibleModule:
+  enabled: true
+  exclude: []
+LongParameterList:
+  enabled: true
+  exclude: []
+  max_params: 2
+  overrides:
+    initialize:
+      max_params: 3
+LongYieldList:
+  enabled: true
+  exclude: []
+  max_params: 2
+NestedIterators:
+  enabled: true
+  exclude: []
+  max_allowed_nesting: 1
+  ignore_iterators: []
+NilCheck:
+  enabled: true
+  exclude:
+  - Axiom::Optimizer::Function::Predicate::Comparable::NeverEquivalent#nil_operand?
+  - Axiom::Optimizer::Function::Predicate::Enumerable::EmptyRight#right_nil?
+  - Axiom::Optimizer::Function::Util#self.constant?
+RepeatedConditional:
+  enabled: true
+  exclude: []
+  max_ifs: 1
+TooManyInstanceVariables:
+  enabled: true
+  exclude:
+  - Axiom::Optimizer::PredicatePartition
+  max_instance_variables: 3
+TooManyMethods:
+  enabled: true
+  exclude:
+  - Axiom::Optimizer::Function::Connective::Binary
+  max_methods: 10
+TooManyStatements:
+  enabled: true
+  exclude:
+  - Axiom::Optimizer#self.link_optimizers
+  - Axiom::Optimizer::Algebra::Projection::ExtensionOperand#new_extensions
+  - Axiom::Optimizer::Algebra::Summarization::EmptyOperand#extensions
+  - Axiom::Optimizer::Function#self.optimize_functions
+  - Axiom::Optimizer::Function::Predicate::Comparable::NeverComparable#optimizable?
+  - Axiom::Optimizer::Function::Predicate::Comparable::NeverEquivalent#optimizable?
+  - Axiom::Optimizer::Function::Predicate::Enumerable#normalized_right_enumerable
+  - Axiom::Optimizer::Function::Predicate::Enumerable#optimize_right
+  - Axiom::Optimizer::Function::Predicate::Enumerable#optimize_right_enumerable
+  - Axiom::Optimizer::Function::Predicate::Enumerable#optimize_right_range
+  - Axiom::Optimizer::Optimizable#optimize
+  - Axiom::Optimizer::PredicatePartition#partition!
+  - Axiom::Optimizer::PredicatePartition#partition_binary!
+  - Axiom::Optimizer::PredicatePartition#partition_proposition!
+  - Axiom::Optimizer::PredicatePartition#partition_unary!
+  max_statements: 2
+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:
+  - Axiom::Optimizer::Function::Connective::Conjunction::Contradiction#optimize
+  - Axiom::Optimizer::Function::Connective::Disjunction::Tautology#optimize
+  - Axiom::Optimizer::Function::Predicate::Contradiction#optimize
+  - Axiom::Optimizer::Function::Predicate::Tautology#optimize
+  max_helper_calls: 0

data/config/roodi.yml

@@ -0,0 +1,16 @@
+---
+AbcMetricMethodCheck:            { score: 10.78 }
+AssignmentInConditionalCheck:    { }
+CaseMissingElseCheck:            { }
+ClassLineCountCheck:             { line_count: 396 }
+ClassNameCheck:                  { pattern: !ruby/regexp '/\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/' }
+ClassVariableCheck:              { }
+CyclomaticComplexityBlockCheck:  { complexity: 5 }
+CyclomaticComplexityMethodCheck: { complexity: 6 }
+EmptyRescueBodyCheck:            { }
+ForLoopCheck:                    { }
+MethodLineCountCheck:            { line_count: 13 }
+MethodNameCheck:                 { pattern: !ruby/regexp '/\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|<<|>>[+*&|-])\z/' }
+ModuleLineCountCheck:            { line_count: 398 }
+ModuleNameCheck:                 { pattern: !ruby/regexp '/\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/' }
+ParameterNumberCheck:            { parameter_count: 3 }

data/config/yardstick.yml

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

data/lib/axiom-optimizer.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require 'axiom/optimizer'

data/lib/axiom/optimizer.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+require 'axiom'
+
+module Axiom
+
+  # A optimization for an operation
+  class Optimizer
+    include AbstractType, Adamantium
+
+    # An optimizer that returns the operation
+    Identity = lambda { |operation| operation }.freeze
+
+    # The operation to optimize
+    #
+    # @return [Optimizable]
+    #
+    # @api private
+    attr_reader :operation
+
+    # Initialize an Optimizer
+    #
+    # @param [Optimizable] operation
+    #   the operation to optimize
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(operation)
+      @operation = operation
+    end
+
+    # Abstract method that tests if the optimization should be applied
+    #
+    # @example
+    #   optimizer.optimizable?  # => true or false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def optimizable?
+      raise NotImplementedError, "#{self.class}#optimizable? must be implemented"
+    end
+
+    # Abstract method that executes the optimization for the operation
+    #
+    # @example
+    #   optimized = optimizer.optimize
+    #
+    # @return [Optimizable]
+    #
+    # @api public
+    def optimize
+      raise NotImplementedError, "#{self.class}#optimize must be implemented"
+    end
+
+    # Chain together a list of optimizer classes into a callable object
+    #
+    # @example
+    #   Optimizer.chain(Optimizer::Foo, Optimizer::Bar)
+    #
+    # @param [Array<Class<Optimizer>>] optimizers
+    #   a list of optimizer classes to apply
+    #
+    # @return [#call]
+    #
+    # @api public
+    def self.chain(*optimizers)
+      optimizers.reverse_each.reduce(Identity) do |successor, optimizer|
+        link_optimizers(optimizer, successor)
+      end
+    end
+
+    # Link an optimizer to a successor
+    #
+    # @param [Class<Optimizer>] optimizer
+    #   the optimizer to link to the successor
+    # @param [#proc] successor
+    #   the next optimizer to call if the current optimizer is not applied
+    #
+    # @return [#call]
+    #
+    # @api private
+    def self.link_optimizers(optimizer, successor)
+      lambda do |operation|
+        op = optimizer.new(operation)
+        op.optimizable? ? op.optimize : successor.call(operation)
+      end
+    end
+
+    private_class_method :link_optimizers
+
+  end # class Optimizer
+end # module Axiom
+
+require 'axiom/optimizer/version'
+
+require 'axiom/optimizer/support/predicate_partition'
+
+require 'axiom/optimizer/optimizable'
+
+require 'axiom/optimizer/function'
+require 'axiom/optimizer/function/binary'
+require 'axiom/optimizer/function/unary'
+
+require 'axiom/optimizer/relation/materialized'
+
+require 'axiom/optimizer/relation/operation/binary'
+require 'axiom/optimizer/relation/operation/unary'
+require 'axiom/optimizer/relation/operation/combination'
+require 'axiom/optimizer/relation/operation/limit'
+require 'axiom/optimizer/relation/operation/offset'
+require 'axiom/optimizer/relation/operation/order'
+require 'axiom/optimizer/relation/operation/reverse'
+
+require 'axiom/optimizer/algebra/difference'
+require 'axiom/optimizer/algebra/extension'
+require 'axiom/optimizer/algebra/intersection'
+require 'axiom/optimizer/algebra/join'
+require 'axiom/optimizer/algebra/product'
+require 'axiom/optimizer/algebra/projection'
+require 'axiom/optimizer/algebra/rename'
+require 'axiom/optimizer/algebra/restriction'
+require 'axiom/optimizer/algebra/summarization'
+require 'axiom/optimizer/algebra/union'
+
+require 'axiom/optimizer/relation/operation/deletion'
+require 'axiom/optimizer/relation/operation/insertion'
+
+require 'axiom/optimizer/function/connective/binary'
+require 'axiom/optimizer/function/connective/conjunction'
+require 'axiom/optimizer/function/connective/disjunction'
+require 'axiom/optimizer/function/connective/negation'
+
+require 'axiom/optimizer/function/predicate'
+require 'axiom/optimizer/function/predicate/comparable'
+require 'axiom/optimizer/function/predicate/enumerable'
+require 'axiom/optimizer/function/predicate/equality'
+require 'axiom/optimizer/function/predicate/exclusion'
+require 'axiom/optimizer/function/predicate/greater_than'
+require 'axiom/optimizer/function/predicate/greater_than_or_equal_to'
+require 'axiom/optimizer/function/predicate/inequality'
+require 'axiom/optimizer/function/predicate/inclusion'
+require 'axiom/optimizer/function/predicate/less_than'
+require 'axiom/optimizer/function/predicate/less_than_or_equal_to'
+
+require 'axiom/optimizer/function/numeric'
+require 'axiom/optimizer/function/numeric/absolute'
+require 'axiom/optimizer/function/numeric/addition'
+require 'axiom/optimizer/function/numeric/division'
+require 'axiom/optimizer/function/numeric/exponentiation'
+require 'axiom/optimizer/function/numeric/modulo'
+require 'axiom/optimizer/function/numeric/multiplication'
+require 'axiom/optimizer/function/numeric/square_root'
+require 'axiom/optimizer/function/numeric/subtraction'
+require 'axiom/optimizer/function/numeric/unary_minus'
+require 'axiom/optimizer/function/numeric/unary_plus'
+
+require 'axiom/optimizer/function/string/length'
+
+require 'axiom/optimizer/aggregate'
+require 'axiom/optimizer/aggregate/count'
+require 'axiom/optimizer/aggregate/maximum'
+require 'axiom/optimizer/aggregate/mean'
+require 'axiom/optimizer/aggregate/minimum'
+require 'axiom/optimizer/aggregate/sum'
+require 'axiom/optimizer/aggregate/variance'
+require 'axiom/optimizer/aggregate/standard_deviation'

data/lib/axiom/optimizer/aggregate.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+
+    # Abstract base class representing Aggregate optimizations
+    class Aggregate < Optimizer
+      include AbstractType, Function::Unary
+
+      # Optimize when the operands are unoptimized
+      class UnoptimizedOperand < self
+        include Function::Unary::UnoptimizedOperand
+      end # class UnoptimizedOperand
+    end # class Aggregate
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/aggregate/count.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Count optimizations
+      class Count < self
+
+        Axiom::Aggregate::Count.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Count
+    end # class Aggregate
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/aggregate/maximum.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Maximum optimizations
+      class Maximum < self
+
+        Axiom::Aggregate::Maximum.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Maximum
+    end # class Aggregate
+  end # class Optimizer
+end # module Axiom