veritas-sql-generator 0.0.3

data/lib/veritas/sql/generator/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      VERSION = '0.0.3'
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/lib/veritas/sql/generator/visitor.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+
+      # Visit each node in a veritas AST and execute an associated method
+      class Visitor
+
+        # Raised when the object is not handled by the generator
+        class UnknownObject < StandardError; end
+
+        NAME_SEP_REGEXP = /([a-z])([A-Z])/.freeze
+        NAME_REP        = '\1_\2'.freeze
+        DOUBLE_COLON    = '::'.freeze
+        UNDERSCORE      = '_'.freeze
+
+        # Lookup the handler method for a visitable class
+        #
+        # @param [Class<Visitable>] visitable_class
+        #
+        # @return [#to_sym]
+        #
+        # @raise [UnknownObject]
+        #   raised when the visitable object has no handler
+        #
+        # @api private
+        def self.handler_for(visitable_class)
+          handlers[visitable_class] or raise UnknownObject, "No handler for #{visitable_class} in #{self}"
+        end
+
+        # Return the handler cache that maps modules to method names
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def self.handlers
+          @handlers ||= Hash.new do |hash, key|
+            hash[key] = ancestor_methods_for(key).detect do |method|
+              method_defined?(method) || private_method_defined?(method)
+            end
+          end
+        end
+
+        # Return handler methods for a module's ancestors
+        #
+        # @param [Module] mod
+        #
+        # @return [Array<Symbol>]
+        #
+        # @api private
+        def self.ancestor_methods_for(mod)
+          mod.ancestors.map { |ancestor| method_for(ancestor) }
+        end
+
+        # Return the handler method for a given module
+        #
+        # @param [Module] mod
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        def self.method_for(mod)
+          name = "visit_#{mod.name}"
+          name.gsub!(NAME_SEP_REGEXP, NAME_REP)
+          name.gsub!(DOUBLE_COLON,    UNDERSCORE)
+          name.downcase!
+          name.to_sym
+        end
+
+        private_class_method :handlers, :ancestor_methods_for, :method_for
+
+        # Visit an object and generate SQL from each node
+        #
+        # @example
+        #   generator.visit(visitable)
+        #
+        # @param [Visitable] visitable
+        #
+        # @return [self]
+        #
+        # @raise [UnknownObject]
+        #   raised when the visitable object has no handler
+        #
+        # @api public
+        def visit(visitable)
+          raise NotImplementedError, "#{self.class}#visit must be implemented"
+        end
+
+        # Test if a visitable object has been visited
+        #
+        # @example
+        #   visitor.visited?  # true or false
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def visited?
+          raise NotImplementedError, "#{self.class}#visited? must be implemented"
+        end
+
+      private
+
+        # Dispatch the visitable object to a handler method
+        #
+        # @param [Visitable] visitable
+        #
+        # @return [#to_s]
+        #
+        # @raise [UnknownObject]
+        #   raised when the visitable object has no handler
+        #
+        # @api private
+        def dispatch(visitable)
+          send(self.class.handler_for(visitable.class), visitable)
+        end
+
+      end # class Visitor
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/spec/rcov.opts

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

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/generated_sql_behavior.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+shared_examples_for 'a generated SQL expression' do
+  it { should respond_to(:to_s) }
+
+  its(:to_s) { should be_kind_of(String) }
+end
+
+shared_examples_for 'a generated SQL SELECT query' do
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:name) { should == relation_name }
+
+  its(:name) { should be_frozen }
+end

data/spec/shared/idempotent_method_behavior.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/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'backports'
+require 'veritas/sql/generator'
+require 'spec'
+require 'spec/autorun'
+
+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|
+end

data/spec/unit/veritas/base_relation/name_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe BaseRelation, '#name' do
+  subject { object.name }
+
+  let(:header) { [ [ :id, Integer ] ]                    }
+  let(:body)   { [ [ 1 ] ].each                          }
+  let(:object) { described_class.new(name, header, body) }
+
+  context 'when name is a frozen String' do
+    let(:name) { 'users'.freeze }
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should equal(name) }
+
+    it { should be_frozen }
+  end
+
+  context 'when name is a String' do
+    let(:name) { 'users' }
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should_not equal(name) }
+
+    it { should eql(name) }
+
+    it { should be_frozen }
+  end
+
+  context 'when name responds to #to_s' do
+    let(:name) { :users }
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should_not equal(name) }
+
+    it { should eql(name.to_s) }
+
+    it { should be_frozen }
+  end
+end

data/spec/unit/veritas/sql/generator/attribute/visit_veritas_attribute_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Attribute, '#visit_veritas_attribute' do
+  subject { object.visit_veritas_attribute(attribute) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Attribute } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                              }
+  let(:object)          { described_class.new                                                      }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id"') }
+end

data/spec/unit/veritas/sql/generator/direction/visit_veritas_relation_operation_order_ascending_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Direction, '#visit_veritas_relation_operation_order_ascending' do
+  subject { object.visit_veritas_relation_operation_order_ascending(direction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Direction } }
+  let(:direction)       { Attribute::Integer.new(:id).asc                                          }
+  let(:object)          { described_class.new                                                      }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id"') }
+end

data/spec/unit/veritas/sql/generator/direction/visit_veritas_relation_operation_order_descending_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Direction, '#visit_veritas_relation_operation_order_descending' do
+  subject { object.visit_veritas_relation_operation_order_descending(direction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Direction } }
+  let(:direction)       { Attribute::Integer.new(:id).desc                                         }
+  let(:object)          { described_class.new                                                      }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" DESC') }
+end

data/spec/unit/veritas/sql/generator/identifier/visit_identifier_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Identifier, '#visit_identifier' do
+  subject { object.visit_identifier(identifier) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Identifier } }
+  let(:object)          { described_class.new                                                       }
+
+  context 'with an identifier containing no quotes' do
+    let(:identifier) { 'users' }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"users"') }
+  end
+
+  context 'with an identifier containing quotes' do
+    let(:identifier) { 'users"name' }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"users""name"') }
+  end
+end

data/spec/unit/veritas/sql/generator/literal/class_methods/dup_frozen_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '.dup_frozen' do
+  subject { object.dup_frozen(object_arg) }
+
+  let(:object) { SQL::Generator::Literal }
+
+  context 'with a frozen object' do
+    let(:object_arg) { Date.today.freeze }
+
+    it { should_not equal(object_arg) }
+
+    it { should == object_arg }
+  end
+
+  context 'with a non-frozen object' do
+    let(:object_arg) { Date.today }
+
+    it { should equal(object_arg) }
+  end
+end

data/spec/unit/veritas/sql/generator/literal/visit_class_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_class' do
+  subject { object.visit_class(klass) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  before do
+    Object.class_eval { remove_const(:NamedClass) if const_defined?(:NamedClass) }
+    class ::NamedClass; end
+  end
+
+  context 'with a named class' do
+    let(:klass) { NamedClass.freeze }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql("'NamedClass'") }
+  end
+
+  context 'with an anonymous class' do
+    let(:klass) { described_class }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('NULL') }
+  end
+end

data/spec/unit/veritas/sql/generator/literal/visit_date_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_date' do
+  subject { object.visit_date(date) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:date)            { Date.new(2010, 12, 31).freeze                                          }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql("'2010-12-31'") }
+end

data/spec/unit/veritas/sql/generator/literal/visit_date_time_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_date_time' do
+  subject { object.visit_date_time(date_time) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:nsec_in_seconds) { Rational(nsec, 10**9)                                                  }
+  let(:object)          { described_class.new                                                    }
+
+  context 'when the DateTime is UTC' do
+    let(:offset) { 0 }
+
+    context 'and the nanoseconds are equal to 0' do
+      let(:nsec)      { 0                                                                       }
+      let(:date_time) { DateTime.new(2010, 12, 31, 23, 59, 59 + nsec_in_seconds, offset).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000+00:00'") }
+    end
+
+    # rubinius 1.2.3 has problems with fractional seconds above 59
+    unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx' && Rubinius::VERSION <= '1.2.3'
+      context 'and the nanoseconds are greater than 0' do
+        let(:nsec)      { 1                                                                       }
+        let(:date_time) { DateTime.new(2010, 12, 31, 23, 59, 59 + nsec_in_seconds, offset).freeze }
+
+        it_should_behave_like 'a generated SQL expression'
+
+        its(:to_s) { should eql("'2010-12-31T23:59:59.000000001+00:00'") }
+      end
+    end
+  end
+
+  context 'when the DateTime is not UTC' do
+    let(:offset) { Rational(-8, 24) }
+
+    context 'and the nanoseconds are equal to 0' do
+      let(:nsec)      { 0                                                                       }
+      let(:date_time) { DateTime.new(2010, 12, 31, 15, 59, 59 + nsec_in_seconds, offset).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000+00:00'") }
+    end
+
+    # rubinius 1.2.3 has problems with fractional seconds above 59
+    unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx' && Rubinius::VERSION <= '1.2.3'
+      context 'and the nanoseconds are greater than 0' do
+        let(:nsec)      { 1                                                                       }
+        let(:date_time) { DateTime.new(2010, 12, 31, 15, 59, 59 + nsec_in_seconds, offset).freeze }
+
+        it_should_behave_like 'a generated SQL expression'
+
+        its(:to_s) { should eql("'2010-12-31T23:59:59.000000001+00:00'") }
+      end
+    end
+  end
+end