axiom 0.1.0

data/lib/axiom/support/evaluator.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+module Axiom
+  module Evaluator
+
+    # Provide a context to evaluate a Relation operation block
+    class Context < BasicObject
+      extend Aliasable
+
+      inheritable_alias(:respond_to_missing? => :respond_to?)
+
+      # The functions to evaluate
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :functions
+
+      # Return the block results
+      #
+      # @return [Object]
+      #
+      # @api private
+      attr_reader :yield
+
+      # Initialize a Context
+      #
+      # @param [Header] header
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(header)
+        @header    = header
+        @functions = ::Hash.new
+        @yield     = yield self
+        @functions.freeze
+      end
+
+      # Add a function to be evaluated by the summarization operation
+      #
+      # @example of a function
+      #   context.add(:total, context[:unit_price] * context[:quantity])
+      #
+      # @example of a block
+      #   context.add(:total) { |tuple| tuple[:unit_price] * tuple[:quantity] } }
+      #
+      # @param [Attribute, #to_ary, #to_sym] attribute
+      #   the attribute to add to the header
+      # @param [Object] object
+      #   optional object
+      #
+      # @yield []
+      #   optional block to execute in the summarization operation
+      #
+      # @return [self]
+      #
+      # @api public
+      def add(attribute, object = Undefined, &block)
+        object = block if object.equal?(Undefined)
+        type   = Attribute.infer_type(object)
+        functions[type.coerce(attribute)] = object
+        self
+      end
+
+      # Lookup the attribute in the header
+      #
+      # @example
+      #   attribute = context[name]
+      #
+      # @param [Symbol] name
+      #
+      # @return [Attribute]
+      #
+      # @api public
+      def [](name)
+        @header[name]
+      end
+
+      # Test if the method is supported on this object
+      #
+      # @param [Symbol] name
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def respond_to?(name, *)
+        @header.any? { |attribute| attribute.name.equal?(name) }
+      end
+
+      # Forward a message to the object
+      #
+      # @param [Array] args
+      #
+      # @return [Object]
+      #
+      # @api private
+      def send(*args, &block)
+        __send__(*args, &block)
+      end
+
+    private
+
+      # Lookup the attribute in the header using the attribute name
+      #
+      # @example
+      #   attribute = context.id
+      #
+      # @param [Symbol] name
+      #
+      # @return [Attribute]
+      #
+      # @api private
+      def method_missing(name, *args)
+        super unless respond_to?(name)
+        ::Kernel.raise ::ArgumentError, "wrong number of arguments (#{args.length} for 0)" unless args.empty?
+        self[name]
+      end
+
+    end # class Context
+  end # module Evaluator
+end # module Axiom

data/lib/axiom/support/operation/binary.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Axiom
+  module Operation
+    module Binary
+      include Equalizer.new(:left, :right)
+
+      # The left operand for the operation
+      #
+      # @example
+      #   left = binary.left
+      #
+      # @return [Object]
+      #
+      # @api public
+      attr_reader :left
+
+      # The right operand for the operation
+      #
+      # @example
+      #   right = binary.right
+      #
+      # @return [Object]
+      #
+      # @api public
+      attr_reader :right
+
+      # Initialize Binary Operation
+      #
+      # @param [Object] left
+      #   the left operand for the operation
+      # @param [Object] right
+      #   the right operand for the operation
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(left, right)
+        @left  = freeze_object(left)
+        @right = freeze_object(right)
+      end
+
+    end # module Binary
+  end # module Operation
+end # module Axiom

data/lib/axiom/support/operation/unary.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Axiom
+  module Operation
+    module Unary
+      include Equalizer.new(:operand)
+
+      # The operand to the operation
+      #
+      # @example
+      #   operand = unary.operand
+      #
+      # @return [Object]
+      #
+      # @api public
+      attr_reader :operand
+
+      # Initialize Unary Operation
+      #
+      # @param [Object] operand
+      #   the operand for the operation
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand)
+        @operand = freeze_object(operand)
+      end
+
+    end # module Unary
+  end # module Operation
+end # module Axiom

data/lib/axiom/support/visitable.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Axiom
+
+  # A mixin to allow instances to be visited
+  module Visitable
+
+    # Accept a visitor and dispatch the object to the visitor
+    #
+    # @example
+    #   visitable = visitable.accept(visitor)
+    #
+    # @param [#visit] visitor
+    #   the visitor object
+    #
+    # @return [self]
+    #
+    # @api public
+    def accept(visitor)
+      visitor.visit(self)
+      self
+    end
+
+  end # module Visitable
+end # module Axiom

data/lib/axiom/tuple.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+
+module Axiom
+
+  # A set of objects representing a unique fact in a relation
+  class Tuple
+    extend Aliasable
+    include Equalizer.new(:data)
+
+    inheritable_alias(:[] => :call)
+
+    # The tuple header
+    #
+    # @return [Header]
+    #
+    # @api private
+    attr_reader :header
+
+    # The tuple data
+    #
+    # @return [Hash]
+    #
+    # @api private
+    attr_reader :data
+
+    # Initialize a Tuple
+    #
+    # @param [Header] header
+    #   the tuple header
+    # @param [#to_ary] data
+    #   the tuple data
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(header, data)
+      @header = header
+      @data   = Hash[header.zip(data)]
+    end
+
+    # Lookup a value in the tuple given an attribute
+    #
+    # @example
+    #   value = tuple.call(attribute)
+    #
+    # @param [Attribute] attribute
+    #
+    # @return [Object]
+    #
+    # @api public
+    def call(attribute)
+      data.fetch(header.call(attribute))
+    end
+
+    # Return a tuple with only the specified attributes
+    #
+    # @example
+    #   new_tuple = tuple.project(header)
+    #
+    # @param [Header] header
+    #   the attributes to include in the tuple
+    #
+    # @return [Tuple]
+    #
+    # @api public
+    def project(header)
+      self.class.new(header, data.values_at(*header))
+    end
+
+    # Append values to the tuple and return a new tuple
+    #
+    # @example
+    #   new_tuple = tuple.join(header, [ 1, 2, 3 ])
+    #
+    # @param [Header] header
+    #   the attributes to include in the tuple
+    # @param [Array] values
+    #   the values to append
+    #
+    # @return [Tuple]
+    #
+    # @api public
+    def join(header, values)
+      self.class.new(header, to_ary + values)
+    end
+
+    # Extend a tuple with function results
+    #
+    # @example
+    #   new_tuple = tuple.extend(header, [ func1, func2 ])
+    #
+    # @param [Header] header
+    #   the attributes to include in the tuple
+    # @param [Array<Object>] extensions
+    #   the functions to extend the tuple with
+    #
+    # @return [Tuple]
+    #
+    # @api public
+    def extend(header, extensions)
+      join(
+        header,
+        extensions.map { |extension| Function.extract_value(extension, self) }
+      )
+    end
+
+    # Return the predicate matching the tuple
+    #
+    # @return [Function]
+    #
+    # @api private
+    def predicate
+      header.reduce(Function::Proposition::Tautology.instance) do |predicate, attribute|
+        predicate.and(attribute.eq(attribute.call(self)))
+      end
+    end
+
+    # Convert the Tuple into an Array
+    #
+    # @example
+    #   array = tuple.to_ary
+    #
+    # @return [Array]
+    #
+    # @api public
+    def to_ary
+      data.values_at(*header).freeze
+    end
+
+  private
+
+    # Coerce an Array-like object into a Tuple
+    #
+    # @param [Tuple, #to_ary] object
+    #   the tuple or tuple data
+    #
+    # @return [Tuple]
+    #
+    # @api private
+    def coerce(object)
+      self.class.coerce(header, object)
+    end
+
+    # Coerce an Array-like object into a Tuple
+    #
+    # @param [Header] header
+    #   the tuple header
+    # @param [Tuple, #to_ary] object
+    #   the tuple or tuple data
+    #
+    # @return [Tuple]
+    #
+    # @api private
+    def self.coerce(header, object)
+      object.kind_of?(Tuple) ? object : new(header, object.to_ary)
+    end
+
+    memoize :predicate, :to_ary
+
+  end # class Tuple
+end # module Axiom

data/lib/axiom/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+module Axiom
+
+  # Gem version
+  VERSION = '0.1.0'.freeze
+
+end # module Axiom

data/spec/integration/axiom/algebra/join_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Join do
+  context 'Commutative property' do
+    subject { left.join(right) }
+
+    let(:left)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])                                             }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ]) }
+
+    it 'does not matter which order the relations are joined in' do
+      should == right.join(left)
+    end
+  end
+end

data/spec/integration/axiom/algebra/product_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Product do
+  context 'Commutative property' do
+    subject { left.product(right) }
+
+    let(:left)  { Relation.new([ [ :id,   Integer ] ], [ [ 1 ], [ 2 ] ])                    }
+    let(:right) { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ], [ 'Alex Kubb' ] ]) }
+
+    it 'does not matter which order the relations are multiplied in' do
+      should == right.product(left)
+    end
+  end
+end

data/spec/integration/axiom/algebra/projection_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Projection do
+  context 'remove attributes in predicate' do
+    subject { restriction.project([ :name ]) }
+
+    let(:left)        { Relation.new([ [ :id, Integer ] ], (0..11).map { |n| [ n ] })                           }
+    let(:right)       { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ], [ 'John Doe' ], [ 'Jane Doe' ] ]) }
+    let(:relation)    { left * right                                                                            }
+    let(:restriction) { relation.restrict { |r| r.id.gte(1).and(r.id.lte(10)).and(r.name.eq('Dan Kubb')) }      }
+
+    it 'returns a relation with a single tuple' do
+      should == [ [ 'Dan Kubb' ] ]
+    end
+  end
+end