veritas 0.0.2 → 0.0.3

data/.autotest

@@ -1,44 +0,0 @@
-%w[ fsevent growl ].each do |autotest_ext|
-  begin
-    require "autotest/#{autotest_ext}"
-  rescue LoadError
-    # do nothing
-  end
-end
-
-MATCH_ALL_SPECS = %r{\Aspec/.+_spec\.rb\z}.freeze
-
-Autotest.add_hook :initialize do |at|
-  at.clear_mappings
-
-  # run the spec if it is modified
-  at.add_mapping(MATCH_ALL_SPECS) { |filename, _| filename }
-
-  # run specs if core_ext patches are modified
-  at.add_mapping(%r{\Alib/veritas/core_ext/(.+)\.rb\z}) do |_, match|
-    at.files_matching %r{\Aspec/unit/#{Regexp.quote(match[1])}/.*_spec\.rb\z}
-  end
-
-  # run specs if support libs are modified
-  at.add_mapping(%r{\Alib/veritas/support/(.+)\.rb\z}) do |_, match|
-    at.files_matching %r{\Aspec/unit/veritas/#{Regexp.quote(match[1])}/.*_spec\.rb\z}
-  end
-
-  # run specs if the main libs are modified
-  at.add_mapping(%r{\Alib/(.+)\.rb\z}) do |_, match|
-    at.files_matching %r{\Aspec/unit/#{Regexp.quote(match[1])}/.*_spec\.rb\z}
-  end
-
-  # run all specs if the spec_helper or spec support lib are modified
-  at.add_mapping(%r{\Aspec/(?:spec_helper\.rb|(?:support|shared)/.+)\z}) do
-    at.files_matching MATCH_ALL_SPECS
-  end
-
-  at.add_exception('.git')
-
-  File.foreach('.gitignore') do |line|
-    line.strip!
-    next if line.empty? || line[0, 1] == '#'
-    at.add_exception(File.expand_path(line))
-  end
-end

data/lib/veritas/algebra.rb

@@ -1,10 +0,0 @@
-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/restriction'
-require 'veritas/algebra/summarization'
-require 'veritas/algebra/union'

data/lib/veritas/logic.rb

@@ -1,5 +0,0 @@
-require 'veritas/logic/expression'
-
-require 'veritas/logic/connective'
-require 'veritas/logic/predicate'
-require 'veritas/logic/proposition'

data/lib/veritas/optimizer.rb

@@ -1,94 +0,0 @@
-module Veritas
-
-  # A optimization for an operation
-  class Optimizer
-    include AbstractClass, Immutable
-
-    # A noop optimizer that returns the operation as-is
-    Noop = 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(Noop) 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 Veritas
-
-require 'veritas/optimizer/relation'
-require 'veritas/optimizer/algebra'
-require 'veritas/optimizer/logic'

data/lib/veritas/optimizer/algebra.rb

@@ -1,10 +0,0 @@
-require 'veritas/optimizer/algebra/difference'
-require 'veritas/optimizer/algebra/extension'
-require 'veritas/optimizer/algebra/intersection'
-require 'veritas/optimizer/algebra/join'
-require 'veritas/optimizer/algebra/product'
-require 'veritas/optimizer/algebra/projection'
-require 'veritas/optimizer/algebra/rename'
-require 'veritas/optimizer/algebra/restriction'
-require 'veritas/optimizer/algebra/summarization'
-require 'veritas/optimizer/algebra/union'

data/lib/veritas/optimizer/algebra/difference.rb

@@ -1,64 +0,0 @@
-module Veritas
-  class Optimizer
-    module Algebra
-
-      # Abstract base class representing Difference optimizations
-      class Difference < Relation::Operation::Binary
-
-        # Optimize when operands are equal
-        class EqualOperands < self
-          include Relation::Operation::Binary::EqualOperands
-
-          # A Difference with equal operands is empty
-          #
-          # @return [Relation::Empty]
-          #
-          # @api private
-          def optimize
-            Veritas::Relation::Empty.new(operation.header)
-          end
-
-        end # class EqualOperands
-
-        # Optimize when the left operand is empty
-        class EmptyLeft < self
-          include Relation::Operation::Binary::EmptyLeft
-
-          # A Difference with an empty left operand is empty
-          #
-          # @return [Relation::Empty]
-          #
-          # @api private
-          def optimize
-            left
-          end
-
-        end # class EmptyLeft
-
-        # Optimize when the right operand is empty
-        class EmptyRight < self
-          include Relation::Operation::Binary::EmptyRight
-
-          # A Difference with an empty right operand is equivalent to the left
-          #
-          # @return [Relation]
-          #
-          # @api private
-          def optimize
-            left
-          end
-
-        end # class EmptyRight
-
-        Veritas::Algebra::Difference.optimizer = chain(
-          EqualOperands,
-          EmptyLeft,
-          EmptyRight,
-          MaterializedOperand,
-          UnoptimizedOperand
-        )
-
-      end # class Difference
-    end # module Algebra
-  end # class Optimizer
-end # module Veritas

data/lib/veritas/optimizer/algebra/extension.rb

@@ -1,40 +0,0 @@
-module Veritas
-  class Optimizer
-    module Algebra
-
-      # Abstract base class representing Extension optimizations
-      class Extension < Relation::Operation::Unary
-
-        # Optimize when operands are optimizable
-        class UnoptimizedOperand < self
-
-          # Test if the operand is unoptimized
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            !operand.equal?(operation.operand)
-          end
-
-          # Return an Extension with an optimized operand
-          #
-          # @return [Algebra::Extension]
-          #
-          # @api private
-          def optimize
-            operation = self.operation
-            operation.class.new(operand, operation.extensions).optimize
-          end
-
-        end # class UnoptimizedOperand
-
-        Veritas::Algebra::Extension.optimizer = chain(
-          MaterializedOperand,
-          UnoptimizedOperand
-        )
-
-      end # class Extension
-    end # module Algebra
-  end # class Optimizer
-end # module Veritas

data/lib/veritas/optimizer/algebra/intersection.rb

@@ -1,64 +0,0 @@
-module Veritas
-  class Optimizer
-    module Algebra
-
-      # Abstract base class representing Intersection optimizations
-      class Intersection < Relation::Operation::Binary
-
-        # Optimize when operands are equal
-        class EqualOperands < self
-          include Relation::Operation::Binary::EqualOperands
-
-          # An Intersection with equal operands is equivalent to either operand
-          #
-          # @return [Relation]
-          #
-          # @api private
-          def optimize
-            left
-          end
-
-        end # class EqualOperands
-
-        # Optimize when the left operand is empty
-        class EmptyLeft < self
-          include Relation::Operation::Binary::EmptyLeft
-
-          # An Intersection with an empty left operand is empty
-          #
-          # @return [Relation::Empty]
-          #
-          # @api private
-          def optimize
-            left
-          end
-
-        end # class EmptyLeft
-
-        # Optimize when the right operand is empty
-        class EmptyRight < self
-          include Relation::Operation::Binary::EmptyRight
-
-          # An Intersection with an empty right operand is empty
-          #
-          # @return [Relation::Empty]
-          #
-          # @api private
-          def optimize
-            right
-          end
-
-        end # class EmptyRight
-
-        Veritas::Algebra::Intersection.optimizer = chain(
-          EqualOperands,
-          EmptyLeft,
-          EmptyRight,
-          MaterializedOperand,
-          UnoptimizedOperand
-        )
-
-      end # class Intersection
-    end # module Algebra
-  end # class Optimizer
-end # module Veritas

data/lib/veritas/optimizer/algebra/join.rb

@@ -1,42 +0,0 @@
-module Veritas
-  class Optimizer
-    module Algebra
-
-      # Abstract base class representing Join optimizations
-      class Join < Relation::Operation::Combination
-
-        # Optimize when operand headers are equivalent
-        class EqualHeaders < self
-
-          # Test if the operands' headers are equal
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            left.header.eql?(right.header)
-          end
-
-          # A Join with equal headers is an Intersection
-          #
-          # @return [Algebra::Intersection]
-          #
-          # @api private
-          def optimize
-            Veritas::Algebra::Intersection.new(left, right).optimize
-          end
-
-        end # class EqualHeaders
-
-        Veritas::Algebra::Join.optimizer = chain(
-          EmptyLeft,
-          EmptyRight,
-          EqualHeaders,
-          MaterializedOperand,
-          UnoptimizedOperand
-        )
-
-      end # class Join
-    end # module Algebra
-  end # class Optimizer
-end # module Veritas

data/lib/veritas/optimizer/algebra/product.rb

@@ -1,68 +0,0 @@
-module Veritas
-  class Optimizer
-    module Algebra
-
-      # Abstract base class representing Product optimizations
-      class Product < Relation::Operation::Combination
-
-        # Optimize when left operand is a TABLE DEE
-        class TableDeeLeft < self
-
-          # Test if the left operand is a TABLE DEE
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            left = self.left
-            left.header.empty? && !left.kind_of?(Veritas::Relation::Empty)
-          end
-
-          # A Product with a left TABLE DEE is equivalent to the right operand
-          #
-          # @return [Relation]
-          #
-          # @api private
-          def optimize
-            right
-          end
-
-        end # class TableDeeLeft
-
-        # Optimize when right operand is a TABLE DEE
-        class TableDeeRight < self
-
-          # Test if the right operand is a TABLE DEE
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            right = self.right
-            right.header.empty? && !right.kind_of?(Veritas::Relation::Empty)
-          end
-
-          # A Product with a right TABLE DEE is equivalent to the left operand
-          #
-          # @return [Relation]
-          #
-          # @api private
-          def optimize
-            left
-          end
-
-        end # class TableDeeRight
-
-        Veritas::Algebra::Product.optimizer = chain(
-          TableDeeLeft,
-          TableDeeRight,
-          EmptyLeft,
-          EmptyRight,
-          MaterializedOperand,
-          UnoptimizedOperand
-        )
-
-      end # class Product
-    end # module Algebra
-  end # class Optimizer
-end # module Veritas