axiom-sql-generator 0.1.0

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

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

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

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module Axiom
+  module SQL
+    module Generator
+
+      # Visit each node in a axiom 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 Axiom

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'devtools/spec_helper'
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name     'spec:unit'
+    add_filter       'config'
+    add_filter       'core_ext'
+    add_filter       'spec'
+    minimum_coverage 100
+  end
+end
+
+require 'axiom-sql-generator'
+
+include Axiom
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+end

data/spec/support/config_alias.rb

@@ -0,0 +1,3 @@
+require 'rbconfig'
+
+::Config = RbConfig unless defined?(::Config)

data/spec/unit/axiom/sql/generator/attribute/visit_axiom_attribute_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Attribute, '#visit_axiom_attribute' do
+  subject { object.visit_axiom_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/axiom/sql/generator/class_methods/parenthesize_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator, '.parenthesize!' do
+  subject { object.parenthesize!(string) }
+
+  let(:string) { '1 + 1'                    }
+  let(:object) { self.class.described_class }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  it 'modifies the string inline' do
+    should equal(string)
+  end
+
+  its(:to_s) { should == '(1 + 1)' }
+end

data/spec/unit/axiom/sql/generator/direction/visit_axiom_relation_operation_order_ascending_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Direction, '#visit_axiom_relation_operation_order_ascending' do
+  subject { object.visit_axiom_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/axiom/sql/generator/direction/visit_axiom_relation_operation_order_descending_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Direction, '#visit_axiom_relation_operation_order_descending' do
+  subject { object.visit_axiom_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/axiom/sql/generator/function/aggregate/visit_axiom_aggregate_count_spec.rb

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

data/spec/unit/axiom/sql/generator/function/aggregate/visit_axiom_aggregate_maximum_spec.rb

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

data/spec/unit/axiom/sql/generator/function/aggregate/visit_axiom_aggregate_mean_spec.rb

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

data/spec/unit/axiom/sql/generator/function/aggregate/visit_axiom_aggregate_minimum_spec.rb

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

data/spec/unit/axiom/sql/generator/function/aggregate/visit_axiom_aggregate_standard_deviation_spec.rb

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

data/spec/unit/axiom/sql/generator/function/aggregate/visit_axiom_aggregate_sum_spec.rb

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

data/spec/unit/axiom/sql/generator/function/aggregate/visit_axiom_aggregate_variance_spec.rb

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

data/spec/unit/axiom/sql/generator/function/connective/visit_axiom_function_connective_conjunction_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Connective, '#visit_axiom_function_connective_conjunction' do
+  subject { object.visit_axiom_function_connective_conjunction(conjunction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Connective } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                         }
+  let(:conjunction)     { attribute.eq(1).and(attribute.ne(2))                                                }
+  let(:object)          { described_class.new                                                                 }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Predicate }
+  end
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("id" = 1 AND "id" <> 2)') }
+end

data/spec/unit/axiom/sql/generator/function/connective/visit_axiom_function_connective_disjunction_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Connective, '#visit_axiom_function_connective_disjunction' do
+  subject { object.visit_axiom_function_connective_disjunction(disjunction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Connective } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                         }
+  let(:disjunction)     { attribute.eq(1).or(attribute.eq(2))                                                 }
+  let(:object)          { described_class.new                                                                 }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Predicate }
+  end
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("id" = 1 OR "id" = 2)') }
+end

data/spec/unit/axiom/sql/generator/function/connective/visit_axiom_function_connective_negation_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Connective, '#visit_axiom_function_connective_negation' do
+  subject { object.visit_axiom_function_connective_negation(negation) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Connective } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                         }
+  let(:negation)        { Function::Connective::Negation.new(attribute.eq(1))                                 }
+  let(:object)          { described_class.new                                                                 }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Predicate }
+  end
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('NOT ("id" = 1)') }
+end