veritas-do-adapter 0.0.5

data/lib/veritas/relation/gateway.rb

@@ -0,0 +1,363 @@
+# encoding: utf-8
+
+module Veritas
+  class Relation
+
+    # A relation backed by an adapter
+    class Gateway < Relation
+
+      DECORATED_CLASS = superclass
+
+      # remove methods so they can be proxied
+      undef_method *DECORATED_CLASS.public_instance_methods(false).map(&:to_s) - %w[ materialize ]
+      undef_method :project, :remove, :extend, :rename, :restrict, :sort_by, :reverse, :drop, :take
+
+      # The adapter the gateway will use to fetch results
+      #
+      # @return [Adapter::DataObjects]
+      #
+      # @api private
+      attr_reader :adapter
+      protected :adapter
+
+      # The relation the gateway will use to generate SQL
+      #
+      # @return [Relation]
+      #
+      # @api private
+      attr_reader :relation
+      protected :relation
+
+      # Initialize a Gateway
+      #
+      # @param [Adapter::DataObjects] adapter
+      #
+      # @param [Relation] relation
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(adapter, relation)
+        @adapter  = adapter
+        @relation = relation
+      end
+
+      # Iterate over each row in the results
+      #
+      # @example
+      #   gateway = Gateway.new(adapter, relation)
+      #   gateway.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the results
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        return to_enum unless block_given?
+        tuples.each { |tuple| yield tuple }
+        self
+      end
+
+      # Return a relation that is the join of two relations
+      #
+      # @example natural join
+      #   join = relation.join(other)
+      #
+      # @example theta-join using a block
+      #   join = relation.join(other) { |r| r.a.gte(r.b) }
+      #
+      # @param [Relation] other
+      #   the other relation to join
+      #
+      # @yield [relation]
+      #   optional block to restrict the tuples with
+      #
+      # @yieldparam [Relation] relation
+      #   the context to evaluate the restriction with
+      #
+      # @yieldreturn [Function, #call]
+      #   predicate to restrict the tuples with
+      #
+      # @return [Gateway]
+      #   return a gateway if the adapters are equal
+      # @return [Algebra::Join]
+      #   return a normal join when the adapters are not equal
+      # @return [Algebra::Restriction]
+      #   return a normal restriction when the adapters are not equal
+      #   for a theta-join
+      #
+      # @api public
+      def join(other)
+        if block_given?
+          super
+        else
+          binary_operation(__method__, other, Algebra::Join)
+        end
+      end
+
+      # Return a relation that is the cartesian product of two relations
+      #
+      # @example
+      #   product = gateway.product(other)
+      #
+      # @param [Relation] other
+      #   the other relation to find the product with
+      #
+      # @return [Gateway]
+      #   return a gateway if the adapters are equal
+      # @return [Algebra::Product]
+      #   return a normal product when the adapters are not equal
+      #
+      # @api public
+      def product(other)
+        binary_operation(__method__, other, Algebra::Product)
+      end
+
+      # Return the union between relations
+      #
+      # @example
+      #   union = gateway.union(other)
+      #
+      # @param [Relation] other
+      #   the other relation to find the union with
+      #
+      # @return [Gateway]
+      #   return a gateway if the adapters are equal
+      # @return [Algebra::Union]
+      #   return a normal union when the adapters are not equal
+      #
+      # @api public
+      def union(other)
+        binary_operation(__method__, other, Algebra::Union)
+      end
+
+      # Return the intersection between relations
+      #
+      # @example
+      #   intersect = gateway.intersect(other)
+      #
+      # @param [Relation] other
+      #   the other relation to find the intersect with
+      #
+      # @return [Gateway]
+      #   return a gateway if the adapters are equal
+      # @return [Algebra::Intersection]
+      #   return a normal intersection when the adapters are not equal
+      #
+      # @api public
+      def intersect(other)
+        binary_operation(__method__, other, Algebra::Intersection)
+      end
+
+      # Return the diferrence between relations
+      #
+      # @example
+      #   difference = gateway.difference(other)
+      #
+      # @param [Relation] other
+      #   the other relation to find the difference with
+      #
+      # @return [Gateway]
+      #   return a gateway if the adapters are equal
+      # @return [Algebra::Difference]
+      #   return a normal dfference when the adapters are not equal
+      #
+      # @api public
+      def difference(other)
+        binary_operation(__method__, other, Algebra::Difference)
+      end
+
+      # Return a summarized relation
+      #
+      # @example with no arguments
+      #   summarization = gateway.summarize do |context|
+      #     context.add(:count, context[:id].count)
+      #   end
+      #
+      # @example with a relation
+      #   summarization = gateway.summarize(relation) do |context|
+      #     context.add(:count, context[:id].count)
+      #   end
+      #
+      # @example with a header
+      #   summarization = gateway.summarize([ :name ]) do |context|
+      #     context.add(:count, context[:id].count)
+      #   end
+      #
+      # @example with another gateway
+      #   summarization = gateway.summarize(other_gateway) do |context|
+      #     context.add(:count, context[:id].count)
+      #   end
+      #
+      # @param [Gateway, Relation, Header, #to_ary] summarize_with
+      #
+      # @yield [function]
+      #   Evaluate a summarization function
+      #
+      # @yieldparam [Evaluator::Context] context
+      #   the context to evaluate the function within
+      #
+      # @return [Gateway]
+      #   return a gateway if the adapters are equal, or there is no adapter
+      # @return [Algebra::Summarization]
+      #   return a normal summarization when the adapters are not equal
+      #
+      # @api public
+      def summarize(summarize_with = TABLE_DEE, &block)
+        if summarize_merge?(summarize_with)
+          summarize_merge(summarize_with, &block)
+        else
+          summarize_split(summarize_with, &block)
+        end
+      end
+
+      # Test if the method is supported on this object
+      #
+      # @param [Symbol] method
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def respond_to?(method, *)
+        super || forwardable?(method)
+      end
+
+    private
+
+      # Proxy the message to the relation
+      #
+      # @param [Symbol] method
+      #
+      # @param [Array] *args
+      #
+      # @return [self]
+      #   return self for all command methods
+      # @return [Object]
+      #   return response from all query methods
+      #
+      # @api private
+      def method_missing(method, *args, &block)
+        forwardable?(method) ? forward(method, *args, &block) : super
+      end
+
+      # Test if the method can be forwarded to the relation
+      #
+      # @param [Symbol] method
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def forwardable?(method)
+        relation.respond_to?(method)
+      end
+
+      # Forward the message to the relation
+      #
+      # @param [Array] *args
+      #
+      # @return [self]
+      #   return self for all command methods
+      # @return [Object]
+      #   return response from all query methods
+      #
+      # @api private
+      def forward(*args, &block)
+        relation = self.relation
+        response = relation.public_send(*args, &block)
+        if response.equal?(relation)
+          self
+        elsif response.kind_of?(DECORATED_CLASS)
+          self.class.new(adapter, response)
+        else
+          response
+        end
+      end
+
+      # Return a list of tuples to iterate over
+      #
+      # @return [#each]
+      #
+      # @api private
+      def tuples
+        relation = self.relation
+        if materialized?
+          relation
+        else
+          DECORATED_CLASS.new(header, adapter.read(relation))
+        end
+      end
+
+      # Return a binary relation
+      #
+      # @param [Relation] other
+      #
+      # @return [Gateway]
+      #   return a gateway if the adapters are equal
+      # @return [Relation]
+      #   return a binary relation when the adapters are not equal
+      #
+      # @api private
+      def binary_operation(method, other, factory)
+        if same_adapter?(other)
+          forward(method, other.relation)
+        else
+          factory.new(self, other)
+        end
+      end
+
+      # Test if the other object uses the same adapter
+      #
+      # @param [Gateway, Relation] other
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def same_adapter?(other)
+        other.respond_to?(:adapter) && adapter.eql?(other.adapter)
+      end
+
+      # Test if the summarize_with object can be merged into the summarization
+      #
+      # @param [Gateway, Relation, Header] summarize_with
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def summarize_merge?(summarize_with)
+        !summarize_with.respond_to?(:header) ||
+        summarize_with.equal?(TABLE_DEE)     ||
+        same_adapter?(summarize_with)
+      end
+
+      # Merge the summarize_with into the summarization
+      #
+      # @param [Gateway, Relation, Header] summarize_with
+      #
+      # @return [Gateway]
+      #
+      # @api private
+      def summarize_merge(summarize_with, &block)
+        summarize_with = summarize_with.relation if summarize_with.respond_to?(:relation)
+        forward(:summarize, summarize_with, &block)
+      end
+
+      # Split the summarize_with into a separate relation, wrapped in a summarization
+      #
+      # @param [Gateway, Relation, Header] summarize_with
+      #
+      # @return [Algebra::Summarization]
+      #
+      # @api private
+      def summarize_split(summarize_with, &block)
+        # evaluate the gateway, then summarize with the provided relation
+        context = Evaluator::Context.new(header - summarize_with.header, &block)
+        Algebra::Summarization.new(self, summarize_with, context.functions)
+      end
+
+    end # class Gateway
+  end # class Relation
+end # module Veritas

data/lib/veritas-do-adapter.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require 'veritas/adapter/data_objects'
+require 'veritas/relation/gateway'

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/shared/binary_relation_method_behaviour.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+shared_examples_for 'a binary relation method' do
+  describe 'when other has the same adapter' do
+    let(:other_relation) { mock('Other Relation')                       }
+    let(:other)          { described_class.new(adapter, other_relation) }
+    let(:gateway)        { mock('Other Gateway')                        }
+
+    before do
+      relation.stub!(operation).and_return(gateway)
+    end
+
+    it { should equal(gateway) }
+
+    it 'passes the other relation to the binary operation' do
+      relation.should_receive(operation).with(other_relation)
+      subject
+    end
+  end
+
+  describe 'when other has a different adapter' do
+    let(:other_adapter) { mock('Other Adapter')                    }
+    let(:other)         { described_class.new(other_adapter, stub) }
+
+    before do
+      factory.stub!(:new).and_return(binary_relation)
+    end
+
+    it { should equal(binary_relation) }
+
+    it 'initializes the binary operation with the gateways' do
+      factory.should_receive(:new).with(object, other)
+      subject
+    end
+  end
+
+  describe 'when other has no adapter' do
+    let(:other) { mock('Other Relation') }
+
+    before do
+      factory.stub!(:new).and_return(binary_relation)
+    end
+
+    it { should equal(binary_relation) }
+
+    it 'initializes the binary operation with the gateway and other relation' do
+      factory.should_receive(:new).with(object, other)
+      subject
+    end
+  end
+end

data/spec/shared/command_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'a command method' do
+  it 'returns self' do
+    should equal(object)
+  end
+end

data/spec/shared/each_method_behaviour.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+shared_examples_for 'an #each method' do
+  it_should_behave_like 'a command method'
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected values' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+end

data/spec/shared/idempotent_method_behaviour.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/shared/unary_relation_method_behaviour.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+shared_examples_for 'a unary relation method' do
+  let(:gateway) { mock('New Gateway') }
+
+  before do
+    described_class.stub!(:new).and_return(gateway)
+  end
+
+  it { should equal(gateway) }
+
+  it 'tests the response is a relation' do
+    response.should_receive(:kind_of?).with(Relation)
+    subject
+  end
+
+  it 'initializes the new gateway with the adapter and response' do
+    described_class.should_receive(:new).with(adapter, response)
+    subject
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--loadby random
+--format profile

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'backports'
+require 'backports/basic_object'
+require 'spec'
+require 'spec/autorun'
+require 'veritas'
+require 'veritas-sql-generator'
+
+include Veritas
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require f }
+
+Spec::Runner.configure do |config|
+
+  # Record the original Attribute descendants
+  config.before do
+    @original_descendants = Attribute.descendants.dup
+  end
+
+  # Reset the Attribute descendants
+  config.after do
+    Attribute.descendants.replace(@original_descendants)
+  end
+
+end

data/spec/unit/veritas/adapter/data_objects/class_methods/new_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'veritas/adapter/data_objects'
+
+describe Adapter::DataObjects, '.new' do
+  subject { object.new(uri) }
+
+  let(:uri)    { stub            }
+  let(:object) { described_class }
+
+  it { should be_instance_of(described_class) }
+
+  it { should be_frozen }
+end

data/spec/unit/veritas/adapter/data_objects/read_spec.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'veritas/adapter/data_objects'
+
+shared_examples_for 'it uses the data_objects driver' do
+  let(:connection) { mock('Connection', :close => nil) }
+
+  before do
+    DataObjects::Connection.stub!(:new).and_return(connection)
+  end
+
+  it 'opens a connection' do
+    DataObjects::Connection.should_receive(:new).with(uri).and_return(connection)
+    subject
+  end
+
+  it 'closes a connection' do
+    connection.should_receive(:close).with(no_args)
+    subject
+  end
+
+  it 'does not close a connection if the constructor throws an exception' do
+    mock_exception = Class.new(Exception)
+    DataObjects::Connection.should_receive(:new).and_raise(mock_exception)
+    connection.should_not_receive(:close)
+    expect { subject }.to raise_error(mock_exception)
+  end
+end
+
+describe Adapter::DataObjects, '#read' do
+  let(:uri)       { stub                     }
+  let(:object)    { described_class.new(uri) }
+  let(:relation)  { mock('Relation')         }
+  let(:statement) { mock('Statement')        }
+  let(:rows)      { [ [ 1 ], [ 2 ], [ 3 ] ]  }
+  let(:yields)    { []                       }
+
+  before do
+    expectation = statement.stub(:each)
+    rows.each { |row| expectation.and_yield(row) }
+
+    described_class::Statement.stub!(:new).and_return(statement)
+  end
+
+  context 'with a block' do
+    subject { object.read(relation) { |row| yields << row } }
+
+
+    it_should_behave_like 'it uses the data_objects driver'
+    it_should_behave_like 'a command method'
+
+    it 'yields each row' do
+      expect { subject }.to change { yields.dup }.
+        from([]).
+        to(rows)
+    end
+
+    it 'initializes a statement' do
+      described_class::Statement.should_receive(:new).with(connection, relation).and_return(statement)
+      subject
+    end
+  end
+
+  context 'without a block' do
+    subject { object.read(relation) }
+
+    it { should be_instance_of(to_enum.class) }
+  end
+end

data/spec/unit/veritas/adapter/data_objects/statement/class_methods/new_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'veritas/adapter/data_objects/statement'
+
+describe Adapter::DataObjects::Statement, '.new' do
+  let(:connection) { stub            }
+  let(:relation)   { stub            }
+  let(:object)     { described_class }
+
+  context 'without a visitor' do
+    subject { object.new(connection, relation) }
+
+    it { should be_instance_of(described_class) }
+
+    it { should be_frozen }
+  end
+
+  context 'with a visitor' do
+    subject { object.new(connection, relation, visitor) }
+
+    let(:visitor) { stub }
+
+    it { should be_instance_of(described_class) }
+
+    it { should be_frozen }
+  end
+end

data/spec/unit/veritas/adapter/data_objects/statement/each_spec.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'veritas/adapter/data_objects/statement'
+
+describe Adapter::DataObjects::Statement, '#each' do
+  let(:reader)     { mock('Reader', :next! => false).as_null_object            }
+  let(:command)    { mock('Command', :execute_reader => reader).as_null_object }
+  let(:connection) { mock('Connection', :create_command => command)            }
+  let(:attribute)  { stub                                                      }
+  let(:primitive)  { stub                                                      }
+  let(:relation)   { mock('Relation', :header => [ attribute ])                }
+  let(:generator)  { mock('Generator').as_null_object                          }
+  let(:rows)       { [ stub, stub ]                                            }
+  let(:object)     { described_class.new(connection, relation, generator)      }
+  let(:yields)     { []                                                        }
+
+  before do
+    command.stub!(:dup => command, :freeze => command)
+    attribute.stub_chain(:class, :primitive).and_return(primitive)
+  end
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected attributes' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+
+  context 'with a block' do
+    subject { object.each { |row| yields << row } }
+
+    before do
+      connection.should_receive(:create_command).with(object.to_s)
+
+      command.should_receive(:set_types).with([ primitive ]).ordered
+      command.should_receive(:execute_reader).with(no_args).ordered
+
+      rows.each do |values|
+        reader.should_receive(:next!).with(no_args).ordered.and_return(true)
+        reader.should_receive(:values).with(no_args).ordered.and_return(values)
+      end
+
+      reader.should_receive(:next!).with(no_args).ordered.and_return(false)
+      reader.should_receive(:close).with(no_args).ordered
+    end
+
+    before do
+      relation.should_receive(:header)
+    end
+
+    it_should_behave_like 'a command method'
+
+    it 'yields each row' do
+      expect { subject }.to change { yields.dup }.
+        from([]).
+        to(rows)
+    end
+  end
+end