squeel_rbg 0.8.2

data/lib/squeel/visitors/predicate_visitor.rb

@@ -0,0 +1,319 @@
+require 'squeel/visitors/base'
+
+module Squeel
+  module Visitors
+    class PredicateVisitor < Base
+
+      TRUE_SQL = Arel.sql('1=1').freeze
+      FALSE_SQL = Arel.sql('1=0').freeze
+
+      private
+
+      # Visit a Hash. This entails iterating through each key and value and
+      # visiting each value in turn.
+      #
+      # @param [Hash] o The Hash to visit
+      # @param parent The current parent object in the context
+      # @return [Array] An array of values for use in a where or having clause
+      def visit_Hash(o, parent)
+        predicates = o.map do |k, v|
+          if implies_context_change?(v)
+            visit_with_context_change(k, v, parent)
+          else
+            visit_without_context_change(k, v, parent)
+          end
+        end
+
+        predicates.flatten!
+
+        if predicates.size > 1
+          Arel::Nodes::Grouping.new(Arel::Nodes::And.new predicates)
+        else
+          predicates.first
+        end
+      end
+
+      # Visit an array, which involves accepting any values we know how to
+      # accept, and skipping the rest.
+      #
+      # @param [Array] o The Array to visit
+      # @param parent The current parent object in the context
+      # @return [Array] The visited array
+      def visit_Array(o, parent)
+        o.map { |v| can_accept?(v) ? accept(v, parent) : v }.flatten
+      end
+
+      # Visit ActiveRecord::Base objects. These should be converted to their
+      # id before being used in a comparison.
+      #
+      # @param [ActiveRecord::Base] o The AR::Base object to visit
+      # @param parent The current parent object in the context
+      # @return [Fixnum] The id of the object
+      def visit_ActiveRecord_Base(o, parent)
+        o.id
+      end
+
+      # Visit a KeyPath by traversing the path and then visiting the endpoint.
+      #
+      # @param [Nodes::KeyPath] o The KeyPath to visit
+      # @param parent The parent object in the context
+      # @return The visited endpoint, in the context of the KeyPath's path
+      def visit_Squeel_Nodes_KeyPath(o, parent)
+        parent = traverse(o, parent)
+
+        accept(o.endpoint, parent)
+      end
+
+      # Visit a Stub by converting it to an ARel attribute
+      #
+      # @param [Nodes::Stub] o The Stub to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Attribute] An attribute of the parent table with the
+      #   Stub's column
+      def visit_Squeel_Nodes_Stub(o, parent)
+        contextualize(parent)[o.symbol]
+      end
+
+      # Visit a Squeel predicate, converting it into an ARel predicate
+      #
+      # @param [Nodes::Predicate] o The predicate to visit
+      # @param parent The parent object in the context
+      # @return An ARel predicate node
+      #   (Arel::Nodes::Equality, Arel::Nodes::Matches, etc)
+      def visit_Squeel_Nodes_Predicate(o, parent)
+        value = o.value
+
+        if Array === value && value.empty? && [:in, :not_in].include?(o.method_name)
+          # Special case, in/not_in with empty arrays should be false/true respectively
+          return o.method_name == :in ? FALSE_SQL : TRUE_SQL
+        end
+
+        if Nodes::KeyPath === value
+          value = can_accept?(value.endpoint) ? accept(value, parent) : contextualize(traverse(value, parent))[value.endpoint.to_sym]
+        else
+          value = accept(value, parent) if can_accept?(value)
+        end
+
+        case o.expr
+        when Nodes::Stub
+          accept(o.expr, parent).send(o.method_name, value)
+        when Nodes::Function
+          accept(o.expr, parent).send(o.method_name, quote(value))
+        else
+          contextualize(parent)[o.expr].send(o.method_name, value)
+        end
+      end
+
+      # Visit a Squeel function, returning an ARel NamedFunction node.
+      #
+      # @param [Nodes::Function] o The function node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::NamedFunction] A named function node. Function
+      #   arguments are visited, if necessary, before being passed to the NamedFunction.
+      def visit_Squeel_Nodes_Function(o, parent)
+        args = o.args.map do |arg|
+          case arg
+          when Nodes::Function
+            accept(arg, parent)
+          when ActiveRecord::Relation
+            arg.arel.ast
+          when Nodes::KeyPath
+            can_accept?(arg.endpoint) ? accept(arg, parent) : contextualize(traverse(arg, parent))[arg.endpoint.to_sym]
+          when Symbol, Nodes::Stub
+            Arel.sql(arel_visitor.accept contextualize(parent)[arg.to_sym])
+          else
+            quote arg
+          end
+        end
+        Arel::Nodes::NamedFunction.new(o.name, args, o.alias)
+      end
+
+      # Visit an ActiveRecord Relation, returning an Arel::SelectManager
+      # @param [ActiveRecord::Relation] o The Relation to visit
+      # @param parent The parent object in the context
+      # @return [Arel::SelectManager] The ARel select manager that represents
+      #   the relation's query
+      def visit_ActiveRecord_Relation(o, parent)
+        o.arel
+      end
+
+      # Visit a Squeel operation node, convering it to an ARel InfixOperation
+      # (or subclass, as appropriate)
+      #
+      # @param [Nodes::Operation] o The Operation node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::InfixOperation] The InfixOperation (or Addition,
+      #   Multiplication, etc) node, with both operands visited, if needed.
+      def visit_Squeel_Nodes_Operation(o, parent)
+        args = o.args.map do |arg|
+          case arg
+          when Nodes::Function
+            accept(arg, parent)
+          when Nodes::KeyPath
+            can_accept?(arg.endpoint) ? accept(arg, parent) : contextualize(traverse(arg, parent))[arg.endpoint.to_sym]
+          when Symbol, Nodes::Stub
+            Arel.sql(arel_visitor.accept contextualize(parent)[arg.to_sym])
+          else
+            quote arg
+          end
+        end
+
+        op = case o.operator
+        when :+
+          Arel::Nodes::Addition.new(args[0], args[1])
+        when :-
+          Arel::Nodes::Subtraction.new(args[0], args[1])
+        when :*
+          Arel::Nodes::Multiplication.new(args[0], args[1])
+        when :/
+          Arel::Nodes::Division.new(args[0], args[1])
+        else
+          Arel::Nodes::InfixOperation(o.operator, args[0], args[1])
+        end
+        o.alias ? op.as(o.alias) : op
+      end
+
+      # Visit a Squeel And node, returning an ARel Grouping containing an
+      # ARel And node.
+      #
+      # @param [Nodes::And] o The And node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::Grouping] A grouping node, containnig an ARel
+      #   And node as its expression. All children will be visited before
+      #   being passed to the And.
+      def visit_Squeel_Nodes_And(o, parent)
+        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(accept(o.children, parent)))
+      end
+
+      # Visit a Squeel Or node, returning an ARel Or node.
+      #
+      # @param [Nodes::Or] o The Or node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::Or] An ARel Or node, with left and right sides visited
+      def visit_Squeel_Nodes_Or(o, parent)
+        accept(o.left, parent).or(accept(o.right, parent))
+      end
+
+      def visit_Squeel_Nodes_Not(o, parent)
+        accept(o.expr, parent).not
+      end
+
+      # @return [Boolean] Whether the given value implies a context change
+      # @param v The value to consider
+      def implies_context_change?(v)
+        case v
+        when Hash, Nodes::Predicate, Nodes::Unary, Nodes::Binary, Nodes::Nary
+          true
+        when Nodes::KeyPath
+          can_accept?(v.endpoint) && !(Nodes::Stub === v.endpoint)
+        else
+          false
+        end
+      end
+
+      # Change context (by setting the new parent to the result of a #find or
+      # #traverse on the key), then accept the given value.
+      #
+      # @param k The hash key
+      # @param v The hash value
+      # @param parent The current parent object in the context
+      # @return The visited value
+      def visit_with_context_change(k, v, parent)
+        parent = case k
+          when Nodes::KeyPath
+            traverse(k, parent, true)
+          else
+            find(k, parent)
+          end
+
+        case v
+        when Hash, Nodes::KeyPath, Nodes::Predicate, Nodes::Unary, Nodes::Binary, Nodes::Nary
+          accept(v, parent || k)
+        when Array
+          v.map {|val| accept(val, parent || k)}
+        else
+          raise ArgumentError, <<-END
+          Hashes, Predicates, and arrays of visitables as values imply that their
+          corresponding keys are a parent. This didn't work out so well in the case
+          of key = #{k} and value = #{v}"
+          END
+        end
+      end
+
+      # Create a predicate for a given key/value pair. If the value is
+      # a Symbol, Stub, or KeyPath, it's converted to a table.column for
+      # the predicate value.
+      #
+      # @param k The hash key
+      # @param v The hash value
+      # @param parent The current parent object in the context
+      # @return An ARel predicate
+      def visit_without_context_change(k, v, parent)
+        case v
+        when Nodes::Stub, Symbol
+          v = contextualize(parent)[v.to_sym]
+        when Nodes::KeyPath # If we could accept the endpoint, we wouldn't be here
+          v = contextualize(traverse(v, parent))[v.endpoint.to_sym]
+        end
+
+        case k
+        when Nodes::Predicate
+          accept(k % quote_for_node(k.expr, v), parent)
+        when Nodes::Function
+          arel_predicate_for(accept(k, parent), quote(v), parent)
+        when Nodes::KeyPath
+          accept(k % quote_for_node(k.endpoint, v), parent)
+        else
+          attr_name = k.to_s
+          attribute = if attr_name.include?('.')
+              table_name, attr_name = attr_name.split(/\./, 2)
+              Arel::Table.new(table_name.to_sym, :engine => engine)[attr_name.to_sym]
+            else
+              contextualize(parent)[k.to_sym]
+            end
+          arel_predicate_for(attribute, v, parent)
+        end
+      end
+
+      # Determine whether to use IN or equality testing for a predicate,
+      # based on its value class, then return the appropriate predicate.
+      #
+      # @param attribute The ARel attribute (or function/operation) the
+      #   predicate will be created for
+      # @param value The value to be compared against
+      # @return [Arel::Nodes::Node] An ARel predicate node
+      def arel_predicate_for(attribute, value, parent)
+        value = can_accept?(value) ? accept(value, parent) : value
+        if [Array, Range, Arel::SelectManager].include?(value.class)
+          if Array === value && value.empty?
+            FALSE_SQL
+          else
+            attribute.in(value)
+          end
+        else
+          attribute.eq(value)
+        end
+      end
+
+      # Function nodes require us to do the quoting before the ARel
+      # visitor gets a chance to try, because we want to avoid having our
+      # values quoted as a type of the last visited column. Otherwise, we
+      # can end up with annoyances like having "joe" quoted to 0, if the
+      # last visited column was of an integer type.
+      #
+      # @param node The node we (might) be quoting for
+      # @param v The value to (possibly) quote
+      def quote_for_node(node, v)
+        case node
+        when Nodes::Function
+          quote(v)
+        when Nodes::Predicate
+          Nodes::Function === node.expr ? quote(v) : v
+        else
+          v
+        end
+      end
+
+    end
+  end
+end

data/lib/squeel/visitors/symbol_visitor.rb

@@ -0,0 +1,48 @@
+require 'squeel/visitors/base'
+
+module Squeel
+  module Visitors
+    class SymbolVisitor < Base
+
+      def initialize
+      end
+
+      def accept(object, parent = nil)
+        visit(object, parent)
+      end
+
+      private
+
+      def visit_Array(o, parent)
+        o.map {|e| accept(e, parent)}.flatten
+      end
+
+      def visit_Hash(o, parent)
+        {}.tap do |hash|
+          o.each do |key, value|
+            hash[accept(key, parent)] = accept(value, parent)
+          end
+        end
+      end
+
+      def visit_Symbol(o, parent)
+        o
+      end
+
+      def visit_Squeel_Nodes_Stub(o, parent)
+        o.symbol
+      end
+
+      def visit_Squeel_Nodes_KeyPath(o, parent)
+        o.path_with_endpoint.reverse.map(&:to_sym).inject do |hash, key|
+          {key => hash}
+        end
+      end
+
+      def visit_Squeel_Nodes_Join(o, parent)
+        o._name
+      end
+
+    end
+  end
+end

data/lib/squeel/visitors.rb

@@ -0,0 +1,3 @@
+require 'squeel/visitors/predicate_visitor'
+require 'squeel/visitors/attribute_visitor'
+require 'squeel/visitors/symbol_visitor'

data/lib/squeel.rb

@@ -0,0 +1,28 @@
+require 'squeel/configuration'
+
+module Squeel
+
+  extend Configuration
+
+  # Prevent warnings on the console when doing things some might describe as "evil"
+  def self.evil_things
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = original_verbosity
+  end
+
+  # Set up initial predicate aliases
+  Constants::PREDICATE_ALIASES.each do |original, aliases|
+    aliases.each do |aliaz|
+      alias_predicate aliaz, original
+    end
+  end
+
+end
+
+require 'squeel/nodes'
+require 'squeel/dsl'
+require 'squeel/visitors'
+require 'squeel/adapters/active_record'

data/lib/squeel_rbg.rb

@@ -0,0 +1,5 @@
+module SqueelRbg
+
+  extend Squeel
+
+end

data/spec/blueprints/articles.rb

@@ -0,0 +1,5 @@
+Article.blueprint do
+  person
+  title
+  body
+end

data/spec/blueprints/comments.rb

@@ -0,0 +1,5 @@
+Comment.blueprint do
+  article
+  person
+  body
+end

data/spec/blueprints/notes.rb

@@ -0,0 +1,3 @@
+Note.blueprint do
+  note
+end

data/spec/blueprints/people.rb

@@ -0,0 +1,4 @@
+Person.blueprint do
+  name
+  salary
+end

data/spec/blueprints/tags.rb

@@ -0,0 +1,3 @@
+Tag.blueprint do
+  name    { Sham.tag_name }
+end

data/spec/console.rb

@@ -0,0 +1,22 @@
+Bundler.setup
+require 'machinist/active_record'
+require 'sham'
+require 'faker'
+
+Dir[File.expand_path('../../spec/{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+Sham.define do
+  name     { Faker::Name.name }
+  title    { Faker::Lorem.sentence }
+  body     { Faker::Lorem.paragraph }
+  salary   {|index| 30000 + (index * 1000)}
+  tag_name { Faker::Lorem.words(3).join(' ') }
+  note     { Faker::Lorem.words(7).join(' ') }
+end
+
+Schema.create
+
+require 'squeel'
+

data/spec/core_ext/symbol_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Symbol do
+
+  Squeel::Constants::PREDICATES.each do |method_name|
+    it "creates #{method_name} predicates with no value" do
+      predicate = :attribute.send(method_name)
+      predicate.expr.should eq :attribute
+      predicate.method_name.should eq method_name
+      predicate.value?.should be_false
+    end
+
+    it "creates #{method_name} predicates with a value" do
+      predicate = :attribute.send(method_name, 'value')
+      predicate.expr.should eq :attribute
+      predicate.method_name.should eq method_name
+      predicate.value.should eq 'value'
+    end
+  end
+
+  Squeel::Constants::PREDICATE_ALIASES.each do |method_name, aliases|
+    aliases.each do |aliaz|
+      ['', '_any', '_all'].each do |suffix|
+        it "creates #{method_name.to_s + suffix} predicates with no value using the alias #{aliaz.to_s + suffix}" do
+          predicate = :attribute.send(aliaz.to_s + suffix)
+          predicate.expr.should eq :attribute
+          predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
+          predicate.value?.should be_false
+        end
+
+        it "creates #{method_name.to_s + suffix} predicates with a value using the alias #{aliaz.to_s + suffix}" do
+          predicate = :attribute.send((aliaz.to_s + suffix), 'value')
+          predicate.expr.should eq :attribute
+          predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
+          predicate.value.should eq 'value'
+        end
+      end
+    end
+  end
+
+  it 'creates ascending orders' do
+    order = :attribute.asc
+    order.should be_ascending
+  end
+
+  it 'creates descending orders' do
+    order = :attribute.desc
+    order.should be_descending
+  end
+
+  it 'creates functions' do
+    function = :function.func
+    function.should be_a Squeel::Nodes::Function
+  end
+
+  it 'creates inner joins' do
+    join = :join.inner
+    join.should be_a Squeel::Nodes::Join
+    join._type.should eq Arel::InnerJoin
+  end
+
+  it 'creates outer joins' do
+    join = :join.outer
+    join.should be_a Squeel::Nodes::Join
+    join._type.should eq Arel::OuterJoin
+  end
+
+  it 'creates as nodes' do
+    as = :column.as('other_name')
+    as.should be_a Squeel::Nodes::As
+    as.left.should eq :column
+    as.right.should eq 'other_name'
+  end
+
+end

data/spec/helpers/squeel_helper.rb

@@ -0,0 +1,21 @@
+module SqueelHelper
+  def dsl(&block)
+    Squeel::DSL.eval(&block)
+  end
+
+  def queries_for
+    $queries_executed = []
+    yield
+    $queries_executed
+  ensure
+    %w{ BEGIN COMMIT }.each { |x| $queries_executed.delete(x) }
+  end
+
+  def new_join_dependency(*args)
+    if defined?(ActiveRecord::Associations::JoinDependency)
+      ActiveRecord::Associations::JoinDependency.new(*args)
+    else
+      ActiveRecord::Associations::ClassMethods::JoinDependency.new(*args)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+require 'machinist/active_record'
+require 'sham'
+require 'faker'
+
+module ActiveRecord
+  class SQLCounter
+    IGNORED_SQL = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/,
+      /SELECT name\s+FROM sqlite_master\s+WHERE type = 'table' AND NOT name = 'sqlite_sequence'/]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL.  This ignored SQL is for Oracle.
+    IGNORED_SQL.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
+
+    def initialize
+      $queries_executed = []
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      unless 'CACHE' == values[:name]
+        $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+      end
+    end
+  end
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end
+
+Dir[File.expand_path('../{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+Sham.define do
+  name     { Faker::Name.name }
+  title    { Faker::Lorem.sentence }
+  body     { Faker::Lorem.paragraph }
+  salary   {|index| 30000 + (index * 1000)}
+  tag_name { Faker::Lorem.words(3).join(' ') }
+  note     { Faker::Lorem.words(7).join(' ') }
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    puts '=' * 80
+    puts "Running specs against ActiveRecord #{ActiveRecord::VERSION::STRING} and ARel #{Arel::VERSION}..."
+    puts '=' * 80
+    Schema.create
+  end
+  config.before(:all)   { Sham.reset(:before_all) }
+  config.before(:each)  { Sham.reset(:before_each) }
+
+  config.include SqueelHelper
+end
+
+RSpec::Matchers.define :be_like do |expected|
+  match do |actual|
+    actual.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip ==
+      expected.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip
+  end
+end
+
+require 'squeel'
+
+Squeel.configure do |config|
+  config.load_core_extensions :hash, :symbol
+end

data/spec/squeel/adapters/active_record/context_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      describe Context do
+        before do
+          @jd = new_join_dependency(Person, {
+                 :children => {
+                   :children => {
+                     :parent => :parent
+                   }
+                 }
+               }, [])
+          @c = Context.new(@jd)
+        end
+
+        it 'contextualizes join parts with the proper alias' do
+          table = @c.contextualize @jd.join_parts.last
+          table.table_alias.should eq 'parents_people_2'
+        end
+
+        it 'contextualizes symbols as a generic table' do
+          table = @c.contextualize :table
+          table.name.should eq 'table'
+          table.table_alias.should be_nil
+        end
+
+        it 'contextualizes polymorphic Join nodes to the arel_table of their klass' do
+          table = @c.contextualize Nodes::Join.new(:notable, Arel::InnerJoin, Article)
+          table.name.should eq 'articles'
+          table.table_alias.should be_nil
+        end
+
+        it 'contextualizes non-polymorphic Join nodes to the table for their name' do
+          table = @c.contextualize Nodes::Join.new(:notes, Arel::InnerJoin)
+          table.name.should eq 'notes'
+          table.table_alias.should be_nil
+        end
+
+      end
+    end
+  end
+end

data/spec/squeel/adapters/active_record/join_association_spec.rb

@@ -0,0 +1,18 @@
+module Squeel
+  module Adapters
+    module ActiveRecord
+      describe JoinAssociation do
+        before do
+          @jd = new_join_dependency(Note, {}, [])
+          @notable = Note.reflect_on_association(:notable)
+        end
+
+        it 'accepts a 4th parameter to set a polymorphic class' do
+          join_association = JoinAssociation.new(@notable, @jd, @jd.join_base, Article)
+          join_association.reflection.klass.should eq Article
+        end
+
+      end
+    end
+  end
+end