veritas 0.0.3 → 0.0.4

data/lib/veritas/logic/connective/binary.rb

@@ -1,70 +0,0 @@
-module Veritas
-  module Logic
-    class Connective
-
-      # Abstract base class for binary connectives
-      class Binary < Connective
-        include AbstractClass, Operation::Binary
-
-        # Evaluate the binary connective using the tuple
-        #
-        # @example
-        #   binary.call(tuple)  # => true or false
-        #
-        # @param [Tuple] tuple
-        #   the tuple to pass to #call in the left and right operands
-        #
-        # @return [Boolean]
-        #
-        # @api public
-        def call(tuple)
-          self.class.call(left.call(tuple), right.call(tuple))
-        end
-
-        # Rename the contained attributes with the provided aliases
-        #
-        # @example
-        #   renamed = binary.rename(aliases)
-        #
-        # @param [Algebra::Rename::Aliases] aliases
-        #   the old and new attributes
-        #
-        # @return [self]
-        #   if the left and right operands are not renamed
-        # @return [Binary]
-        #   if the left or right operand is renamed
-        #
-        # @api public
-        def rename(aliases)
-          left          = self.left
-          right         = self.right
-          renamed_left  = left.rename(aliases)
-          renamed_right = right.rename(aliases)
-
-          if left.equal?(renamed_left) && right.equal?(renamed_right)
-            self
-          else
-            self.class.new(renamed_left, renamed_right)
-          end
-        end
-
-        # Compare the operation with the other operation for equivalency
-        #
-        # @example
-        #   binary == other  # => true or false
-        #
-        # @param [Object] other
-        #
-        # @return [Boolean]
-        #
-        # @api public
-        def ==(other)
-          (kind_of?(other.class) || other.kind_of?(self.class)) &&
-          left  == other.left                                   &&
-          right == other.right
-        end
-
-      end # class Binary
-    end # class Connective
-  end # module Logic
-end # module Veritas

data/lib/veritas/logic/connective.rb

@@ -1,24 +0,0 @@
-module Veritas
-  module Logic
-
-    # Abstract base class for logical connectives
-    class Connective < Expression
-      include AbstractClass
-
-      # Return the inverse connective
-      #
-      # @example
-      #   negation = connective.inverse
-      #
-      # @return [Negation]
-      #
-      # @api public
-      def inverse
-        Negation.new(self)
-      end
-
-      memoize :inverse
-
-    end # class Connective
-  end # module Logic
-end # module Veritas

data/lib/veritas/logic/expression.rb

@@ -1,99 +0,0 @@
-module Veritas
-  module Logic
-
-    # Abstract base class for logical expressions
-    class Expression
-      extend Aliasable
-      include AbstractClass, Immutable, Visitable
-
-      # Evaluate the expression using the operands
-      #
-      # @return [undefined]
-      #
-      # @api public
-      def self.call(*)
-        raise NotImplementedError, "#{name}.call must be implemented"
-      end
-
-      # Rename the contained attributes with the provided aliases
-      #
-      # @example
-      #   renamed = expression.rename(aliases)
-      #
-      # @param [Algebra::Rename::Aliases] aliases
-      #   the old and new attributes
-      #
-      # @return [self]
-      #
-      # @api public
-      def rename(aliases)
-        self
-      end
-
-      # Return the inverse expression
-      #
-      # @example
-      #   inverse = expression.inverse
-      #
-      # @return [Expression]
-      #
-      # @api public
-      def inverse
-        raise NotImplementedError, "#{self.class}#inverse must be implemented"
-      end
-
-      # Compare the expression with other expression for equivalency
-      #
-      # @example
-      #   expression == other  # => true or false
-      #
-      # @param [Expression] other
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def ==(other)
-        raise NotImplementedError, "#{self.class}#== must be implemented"
-      end
-
-      # Compare the expression with other expression for equality
-      #
-      # @example
-      #   expression.eql?(other)  # => true or false
-      #
-      # @param [Expression] other
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def eql?(other)
-        raise NotImplementedError, "#{self.class}#eql? must be implemented"
-      end
-
-      # Return the hash of the expression
-      #
-      # @example
-      #   hash = expression.hash
-      #
-      # @return [Fixnum]
-      #
-      # @api public
-      def hash
-        raise NotImplementedError, "#{self.class}#hash must be implemented"
-      end
-
-      # Return a string representing the expression
-      #
-      # @example
-      #   expression.inspect  # (String representation of Expression)
-      #
-      # @return [String]
-      #
-      # @api public
-      def inspect
-        raise NotImplementedError, "#{self.class}#inspect must be implemented"
-      end
-
-    end # class Expression
-  end # module Logic
-end # module Veritas

data/lib/veritas/logic/predicate/comparable.rb

@@ -1,57 +0,0 @@
-module Veritas
-  module Logic
-    class Predicate
-
-      # A mixin for predicates with directly compared operands
-      module Comparable
-        include Immutable
-
-        # Hook called when module is included
-        #
-        # @param [Module] descendant
-        #   the module or class including Comparable
-        #
-        # @return [self]
-        #
-        # @api private
-        def self.included(descendant)
-          descendant.extend ClassMethods
-          self
-        end
-
-        # Return a string representing the predicate
-        #
-        # @example
-        #   predicate.inspect  # (String representation of Predicate)
-        #
-        # @return [String]
-        #
-        # @api public
-        def inspect
-          "#{left.inspect} #{self.class.operation} #{right.inspect}"
-        end
-
-        module ClassMethods
-
-          # Evaluate the values using the ruby operation
-          #
-          # @example
-          #   predicate.call(left, right)  # => true or false
-          #
-          # @param [Object] left
-          # @param [Object] right
-          #
-          # @return [Boolean]
-          #
-          # @api public
-          def call(left, right)
-            # methods ending in ? should return true or false only,
-            # force boolean context using !!
-            !!left.send(operation, right)
-          end
-
-        end # module Classmethods
-      end # module Comparable
-    end # class Predicate
-  end # module Logic
-end # module Veritas

data/lib/veritas/logic/predicate.rb

@@ -1,99 +0,0 @@
-module Veritas
-  module Logic
-
-    # Abstract base class for logical predicates
-    class Predicate < Expression
-      include AbstractClass, Operation::Binary
-
-      # Evaluate the predicate using the provided Tuple
-      #
-      # @example
-      #   value = predicate.call(tuple)
-      #
-      # @param [Tuple] tuple
-      #
-      # @return [Object]
-      #
-      # @api public
-      def call(tuple)
-        util = self.class
-        util.call(
-          util.extract_value(left,  tuple),
-          util.extract_value(right, tuple)
-        )
-      end
-
-      # Rename the contained attributes with the provided aliases
-      #
-      # @example
-      #   renamed = predicate.rename(aliases)
-      #
-      # @param [Algebra::Rename::Aliases] aliases
-      #   the old and new attributes
-      #
-      # @return [Predicate]
-      #
-      # @api public
-      def rename(aliases)
-        left  = self.left
-        right = self.right
-        util  = self.class
-
-        renamed_left  = aliases[left]
-        renamed_right = aliases[right]
-
-        if left.equal?(renamed_left) && right.equal?(renamed_right)
-          self
-        else
-          util.new(renamed_left, renamed_right)
-        end
-      end
-
-      # Return the inverse predicate
-      #
-      # @example
-      #   inverse = predicate.inverse
-      #
-      # @return [Predicate]
-      #
-      # @api public
-      def inverse
-        self.class.inverse.new(left, right).
-          memoize(:inverse, self)
-      end
-
-      # Compare the operation with the other operation for equivalency
-      #
-      # @example
-      #   binary == other  # => true or false
-      #
-      # @param [Predicate] other
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def ==(other)
-        (kind_of?(other.class) || other.kind_of?(self.class)) &&
-        left  == other.left                                   &&
-        right == other.right
-      end
-
-      # Extract the value from the operand or tuple
-      #
-      # @param [Object, #call] operand
-      #   the operand to extract the value from
-      # @param [Tuple] tuple
-      #   the tuple to pass in to the operand if it responds to #call
-      #
-      # @return [Object]
-      #
-      # @api private
-      def self.extract_value(operand, tuple)
-        operand.respond_to?(:call) ? operand.call(tuple) : operand
-      end
-
-      memoize :inverse
-
-    end # class Predicate
-  end # module Logic
-end # module Veritas

data/spec/unit/veritas/algebra/projection/directions_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Algebra::Projection, '#directions' do
-  subject { object.directions }
-
-  let(:relation) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ]) }
-  let(:object)   { described_class.new(operand, [ :id ])                                        }
-
-  context 'containing an unordered relation' do
-    let(:operand) { relation }
-
-    it_should_behave_like 'an idempotent method'
-
-    it { should equal(Relation::Operation::Order::DirectionSet::EMPTY) }
-  end
-
-  context 'containing an ordered relation' do
-    let(:operand) { relation.order }
-
-    it_should_behave_like 'an idempotent method'
-
-    it { should equal(Relation::Operation::Order::DirectionSet::EMPTY) }
-  end
-end

data/spec/unit/veritas/algebra/summarization/class_methods/summarize_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Algebra::Summarization, '.summarize' do
-  subject { object.summarize(tuple, summary, summarizer) }
-
-  let(:header)     { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuple)      { Tuple.new(header, [ 1 ])                   }
-  let(:summarizer) { lambda { |acc, tuple| acc.to_i + 1 }       }
-  let(:object)     { described_class                            }
-
-  context 'when the accumulator is uninitialized' do
-    let(:summary) { {} }
-
-    it { should equal(object) }
-
-    it { expect { subject }.to change { summary.dup }.from({}).to({ summarizer => 1 }) }
-  end
-
-  context 'when the accumulator is initialized' do
-    let(:summary) { { summarizer => 1 } }
-
-    it { should equal(object) }
-
-    it { expect { subject }.to change { summary.dup }.from({ summarizer => 1 }).to({ summarizer => 2 }) }
-  end
-end

data/spec/unit/veritas/attribute/string/length_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-[ :length, :range ].each do |method|
-  describe Attribute::String, "##{method}" do
-    subject { object.send(method) }
-
-    context 'without :length option passed to constructor' do
-      let(:object) { described_class.new(:name) }
-
-      it { should == (0..50) }
-    end
-
-    context 'with :length option passed to constructor' do
-      let(:length) { 1..100                                        }
-      let(:object) { described_class.new(:name, :length => length) }
-
-      it { should == length }
-    end
-  end
-end

data/spec/unit/veritas/evaluator/expression/add_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Evaluator::Expression, '#add' do
-  let(:attribute) { Attribute::Integer.new(:id) }
-
-  context 'when a function is provided' do
-    subject { described_class.new { |object| object.add(attribute, function) } }
-
-    let(:function) { mock('Function') }
-
-    its(:expressions) { should == { attribute => function } }
-  end
-
-  context 'when a block is provided' do
-    subject { described_class.new { |object| object.add(attribute, &block) } }
-
-    let(:block) { proc {} }
-
-    its(:expressions) { should == { attribute => block } }
-  end
-end

data/spec/unit/veritas/evaluator/expression/expressions_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Evaluator::Expression, '#expressions' do
-  subject { object.expressions }
-
-  let(:attribute) { Attribute::Integer.new(:id)                            }
-  let(:function)  { mock('Function')                                       }
-  let(:object)    { described_class.new { |o| o.add(attribute, function) } }
-
-  it { should == { attribute => function } }
-
-  it { should be_frozen }
-end

data/spec/unit/veritas/logic/connective/inspect_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe Logic::Connective, '#inspect' do
-  subject { object.inspect }
-
-  let(:described_class) { Class.new(Logic::Connective) }
-  let(:object)          { described_class.new          }
-
-  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#inspect must be implemented") }
-end

data/spec/unit/veritas/logic/connective/inverse_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Logic::Connective, '#inverse' do
-  subject { object.inverse }
-
-  let(:described_class) { Class.new(Logic::Connective) }
-  let(:object)          { described_class.new          }
-
-  before do
-    described_class.class_eval do
-      def inspect
-        'Connective()'
-      end
-    end
-  end
-
-  it_should_behave_like 'an idempotent method'
-
-  it { should be_kind_of(Logic::Connective::Negation) }
-
-  its(:operand) { should equal(object) }
-
-  it 'is invertible' do
-    subject.inverse.should equal(object)
-  end
-end

data/spec/unit/veritas/logic/connective/negation/methods/fixtures/classes.rb

@@ -1,6 +0,0 @@
-module NegationMethodsSpecs
-  class Object
-    include Logic::Connective::Conjunction::Methods
-    include Logic::Connective::Negation::Methods
-  end # class Object
-end # module NegationMethodsSpecs

data/spec/unit/veritas/logic/connective/negation/methods/not_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-[ :not, :- ].each do |method|
-  describe Logic::Connective::Negation::Methods, "##{method}" do
-    subject { object.send(method, predicate) }
-
-    let(:described_class) { NegationMethodsSpecs::Object                   }
-    let(:header)          { Relation::Header.new([ [ :id, Integer ] ])     }
-    let(:predicate)       { Logic::Predicate::Equality.new(header[:id], 1) }
-    let(:object)          { described_class.new                            }
-
-    before do
-      def object.eql?(other)
-        equal?(other)
-      end
-      object.freeze
-    end
-
-    it 'returns a conjunction of the proposition and a inverted predicate' do
-      should eql(Logic::Connective::Conjunction.new(object, Logic::Connective::Negation.new(predicate)))
-    end
-  end
-end

data/spec/unit/veritas/logic/expression/eql_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe Logic::Expression, '#eql?' do
-  subject { object.eql?(other) }
-
-  let(:described_class) { ExpressionSpecs::Object }
-  let(:other)           { described_class.new     }
-  let(:object)          { described_class.new     }
-
-  specify { expect { subject }.to raise_error(NotImplementedError, 'ExpressionSpecs::Object#eql? must be implemented') }
-end

data/spec/unit/veritas/logic/expression/equal_value_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe Logic::Expression, '#==' do
-  subject { object == other }
-
-  let(:described_class) { ExpressionSpecs::Object }
-  let(:other)           { described_class.new     }
-  let(:object)          { described_class.new     }
-
-  specify { expect { subject }.to raise_error(NotImplementedError, 'ExpressionSpecs::Object#== must be implemented') }
-end

data/spec/unit/veritas/logic/expression/fixtures/classes.rb

@@ -1,4 +0,0 @@
-module ExpressionSpecs
-  class Object < Logic::Expression
-  end # class Object
-end # module ExpressionSpecs

data/spec/unit/veritas/logic/expression/inverse_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-methods = [ :inverse ]
-methods << '!' if respond_to?('!')  # available in Ruby 1.9
-
-methods.each do |method|
-  describe Logic::Expression, "##{method}" do
-    subject { object.send(method) }
-
-    let(:described_class) { ExpressionSpecs::Object }
-    let(:object)          { described_class.new     }
-
-    specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#inverse must be implemented") }
-  end
-end

data/spec/unit/veritas/logic/predicate/comparable/inspect_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe Logic::Predicate::Comparable, '#inspect' do
-  subject { object.inspect }
-
-  let(:described_class) { PredicateComparableSpecs::Object          }
-  let(:left)            { mock('Expression', :inspect => '<left>')  }
-  let(:right)           { mock('Expression', :inspect => '<right>') }
-  let(:object)          { described_class.new(left, right)          }
-
-  it { should == '<left> == <right>' }
-end

data/spec/unit/veritas/logic/predicate/equal_value_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe Logic::Predicate, '#==' do
-  subject { object == other }
-
-  let(:left)   { Attribute::Integer.new(:id)      }
-  let(:right)  { 1                                }
-  let(:object) { described_class.new(left, right) }
-
-  context 'with the same object' do
-    let(:other) { object }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should == (other == object)
-    end
-  end
-
-  context 'with an equivalent object' do
-    let(:other) { object.dup }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should == (other == object)
-    end
-  end
-
-  context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(described_class).new(left, right) }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should == (other == object)
-    end
-  end
-
-  context 'with an object having a different left operand' do
-    let(:other_left)  { Attribute::String.new(:name)                 }
-    let(:other_right) { right                                        }
-    let(:other)       { described_class.new(other_left, other_right) }
-
-    it { should be(false) }
-
-    it 'is symmetric' do
-      should == (other == object)
-    end
-  end
-
-  context 'with an object having a different right operand' do
-    let(:other_left)  { left                                         }
-    let(:other_right) { 2                                            }
-    let(:other)       { described_class.new(other_left, other_right) }
-
-    it { should be(false) }
-
-    it 'is symmetric' do
-      should == (other == object)
-    end
-  end
-end

data/spec/unit/veritas/logic/predicate/equality/class_methods/inverse_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Logic::Predicate::Equality, '.inverse' do
-  subject { object.inverse }
-
-  let(:object) { described_class }
-
-  it { should equal(Logic::Predicate::Inequality) }
-end

data/spec/unit/veritas/logic/predicate/exclusion/class_methods/inverse_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Logic::Predicate::Exclusion, '.inverse' do
-  subject { object.inverse }
-
-  let(:object) { described_class }
-
-  it { should equal(Logic::Predicate::Inclusion) }
-end