activerecord-hierarchical_query 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 031176cf523c47f50c3ca2a10b7c79129766b1e2
-  data.tar.gz: 9abc865a1f8e2bcbc42f084611b1d588ab7f8879
+  metadata.gz: e317315d0b567e0880277e328380478df97fecd7
+  data.tar.gz: f1918a2d4c9a9e8a84f59b7af8fec42d6fb57dfa
 SHA512:
-  metadata.gz: e5a632144805142246f4ba00cdf938b785660e5bac28063194782efbd446d901fc9154c79c8ee0c039d2d61e7afe4b10a58ff62a84115941653f5943cc137059
-  data.tar.gz: 7931d4bf31d74b4759ab93d779efdac40ef0cdb10f3b1d583bc9120a48395eeb5c9409ee48790ff626303bf47a4129d924df98c7b2c0613f9b638696e4b5c5ea
+  metadata.gz: aad9047098ff944791fd13f5fed4a120e39195d3f9f4d08a17f5e734dfc8e7409e2a034acec7e0200df336c4a530003ebca1d68c2a494fac9629db3d253ace5f
+  data.tar.gz: 890c7ebfff9df375347f00c061ed213167fe8e09da1cf567996afc9ca5417f264215c270e987a9e8a16925284d0f9cbafc842c2f26d8c8fd142dfd29761e88d9

data/README.md

@@ -4,6 +4,7 @@
 [![Code Climate](https://codeclimate.com/github/take-five/activerecord-hierarchical_query.png)](https://codeclimate.com/github/take-five/activerecord-hierarchical_query)
 [![Coverage Status](https://coveralls.io/repos/take-five/activerecord-hierarchical_query/badge.png)](https://coveralls.io/r/take-five/activerecord-hierarchical_query)
 [![Dependency Status](https://gemnasium.com/take-five/activerecord-hierarchical_query.png)](https://gemnasium.com/take-five/activerecord-hierarchical_query)
+[![Gem Version](https://badge.fury.io/rb/activerecord-hierarchical_query.png)](http://badge.fury.io/rb/activerecord-hierarchical_query)
 
 Create hierarchical queries using simple DSL, recursively traverse trees using single SQL query.
 

data/lib/active_record/hierarchical_query/adapters.rb

@@ -1,20 +1,34 @@
 # coding: utf-8
 
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/string/inflections'
+
 module ActiveRecord
   module HierarchicalQuery
     module Adapters
       SUPPORTED_ADAPTERS = %w(PostgreSQL)
 
-      autoload :PostgreSQL, 'active_record/hierarchical_query/adapters/postgresql'
+      ADAPTERS = Hash[
+        :PostgreSQL => :PostgreSQL,
+        :PostGIS => :PostgreSQL,
+        :OracleEnhanced => :Oracle
+      ].stringify_keys
+
+      def self.autoload(name, path = name.to_s.underscore)
+        super name, "active_record/hierarchical_query/adapters/#{path}"
+      end
+
+      autoload :PostgreSQL, 'postgresql'
+      autoload :Oracle
 
       def self.lookup(klass)
         name = klass.connection.adapter_name
 
-        raise 'Your database does not support recursive queries' unless
-            SUPPORTED_ADAPTERS.include?(name)
+        raise 'Your database %s does not support recursive queries' % name unless
+            ADAPTERS.key?(name)
 
-        const_get(name)
+        const_get(ADAPTERS[name])
       end
     end # module Adapters
   end # module HierarchicalQuery
-end # module ActiveRecord
+end # module ActiveRecord

data/lib/active_record/hierarchical_query/adapters/abstract.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require 'active_record/hierarchical_query/visitors/visitor'
+
+module ActiveRecord
+  module HierarchicalQuery
+    module Adapters
+      # @api private
+      class Abstract
+        attr_reader :query,
+                    :table
+
+        delegate :klass, :to => :query
+
+        class << self
+          def visitors(*visitors_classes)
+            define_method :visitors do
+              @visitors ||= visitors_classes.map { |klass| klass.new(@query) }
+            end
+          end
+        end
+
+        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
+        def initialize(query)
+          @query = query
+          @table = klass.arel_table
+        end
+
+        # @example
+        #   visit(:recursive_term, recursive_term.arel)
+        def visit(kind, object)
+          method_name = "visit_#{kind}"
+
+          visitors.reduce(object) do |*, visitor|
+            visitor.send(method_name, object) if visitor.respond_to?(method_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/adapters/postgresql.rb

@@ -1,28 +1,18 @@
 # coding: utf-8
 
-require 'active_record/hierarchical_query/cte/query'
+require 'arel/nodes/postgresql'
+
+require 'active_record/hierarchical_query/adapters/abstract'
+require 'active_record/hierarchical_query/visitors/postgresql/cycle_detector'
+require 'active_record/hierarchical_query/visitors/postgresql/orderings'
 
 module ActiveRecord
   module HierarchicalQuery
     module Adapters
       # @api private
-      class PostgreSQL
-        attr_reader :builder,
-                    :table
-
-        delegate :klass, :to => :builder
-        delegate :build_join, :to => :@query
-
-        # @param [ActiveRecord::HierarchicalQuery::Builder] builder
-        def initialize(builder)
-          @builder = builder
-          @table = klass.arel_table
-          @query = CTE::Query.new(builder)
-        end
-
-        def prior
-          @query.recursive_table
-        end
+      class PostgreSQL < Abstract
+        visitors Visitors::PostgreSQL::CycleDetector,
+                 Visitors::PostgreSQL::Orderings
       end # class PostgreSQL
     end # module Adapters
   end # module HierarchicalQuery

data/lib/active_record/hierarchical_query/builder.rb

@@ -2,7 +2,8 @@
 
 require 'active_support/core_ext/array/extract_options'
 
-require 'active_record/hierarchical_query/adapters'
+require 'active_record/hierarchical_query/cte/query'
+require 'active_record/hierarchical_query/join_builder'
 
 module ActiveRecord
   module HierarchicalQuery
@@ -22,7 +23,7 @@ module ActiveRecord
 
       def initialize(klass)
         @klass = klass
-        @adapter = Adapters.lookup(@klass).new(self)
+        @query = CTE::Query.new(self)
 
         @start_with_value = nil
         @connect_by_value = nil
@@ -239,7 +240,7 @@ module ActiveRecord
       #
       # @return [Arel::Table]
       def prior
-        @adapter.prior
+        @query.recursive_table
       end
       alias_method :previous, :prior
 
@@ -269,7 +270,7 @@ module ActiveRecord
 
         table_alias = join_options.fetch(:as, "#{table.name}__recursive")
 
-        @adapter.build_join(relation, table_alias)
+        JoinBuilder.new(@query, relation, table_alias).build
       end
 
       private

data/lib/active_record/hierarchical_query/cte/non_recursive_term.rb

@@ -1,15 +1,13 @@
 # coding: utf-8
 
-require 'arel/nodes/postgresql'
-
 module ActiveRecord
   module HierarchicalQuery
     module CTE
       class NonRecursiveTerm
-        DISALLOWED_CLAUSES = :order, :limit, :offset
+        DISALLOWED_CLAUSES = :order, :limit, :offset, :group, :having
 
         attr_reader :query
-        delegate :builder, :orderings, :cycle_detector, :to => :query
+        delegate :builder, :adapter, :to => :query
         delegate :start_with_value, :klass, :to => :builder
 
         # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
@@ -19,25 +17,16 @@ module ActiveRecord
 
         def arel
           arel = scope.select(query.columns)
-                      .select(ordering_column)
                       .except(*DISALLOWED_CLAUSES)
                       .arel
 
-          cycle_detector.visit_non_recursive(arel)
+          adapter.visit(:non_recursive, arel)
         end
 
         private
         def scope
           start_with_value || klass.__send__(HierarchicalQuery::DELEGATOR_SCOPE)
         end
-
-        def ordering_column
-          if orderings.any?
-            Arel::Nodes::PostgresArray.new([orderings.row_number_expression]).as(orderings.column_name)
-          else
-            []
-          end
-        end
       end # class NonRecursiveTerm
     end
   end

data/lib/active_record/hierarchical_query/cte/query.rb

@@ -1,37 +1,30 @@
 # coding: utf-8
 
+require 'active_record/hierarchical_query/adapters'
 require 'active_record/hierarchical_query/cte/columns'
-require 'active_record/hierarchical_query/cte/cycle_detector'
-require 'active_record/hierarchical_query/cte/join_builder'
-require 'active_record/hierarchical_query/cte/orderings'
 require 'active_record/hierarchical_query/cte/union_term'
 
 module ActiveRecord
   module HierarchicalQuery
     module CTE
+      # CTE query builder
       class Query
         attr_reader :builder,
-                    :columns,
-                    :orderings,
-                    :cycle_detector
+                    :adapter,
+                    :columns
 
         delegate :klass, :table, :to => :builder
 
         # @param [ActiveRecord::HierarchicalQuery::Builder] builder
         def initialize(builder)
           @builder = builder
-          @orderings = Orderings.new(builder)
+          @adapter = Adapters.lookup(klass).new(self)
           @columns = Columns.new(self)
-          @cycle_detector = CycleDetector.new(self)
-        end
-
-        def build_join(relation, subquery_alias)
-          JoinBuilder.new(self, relation, subquery_alias).build
         end
 
         # @return [Arel::SelectManager]
         def arel
-          apply_ordering { build_arel }
+          adapter.visit(:cte, build_arel)
         end
 
         # @return [Arel::Table]
@@ -43,10 +36,6 @@ module ActiveRecord
           builder.connect_by_value[recursive_table, table]
         end
 
-        def order_clause
-          recursive_table[orderings.column_name].asc
-        end
-
         private
         # "categories__recursive" AS (
         #   SELECT ... FROM "categories"
@@ -62,16 +51,6 @@ module ActiveRecord
           UnionTerm.new(self)
         end
 
-        def apply_ordering
-          arel = yield
-
-          if should_order?
-            apply_ordering_to(arel)
-          else
-            arel
-          end
-        end
-
         def build_arel
           Arel::SelectManager.new(table.engine).
             with(:recursive, with_query).
@@ -80,14 +59,6 @@ module ActiveRecord
             take(builder.limit_value).
             skip(builder.offset_value)
         end
-
-        def should_order?
-          orderings.any? && builder.limit_value || builder.offset_value
-        end
-
-        def apply_ordering_to(select_manager)
-          select_manager.order(order_clause)
-        end
       end
     end
   end

data/lib/active_record/hierarchical_query/cte/recursive_term.rb

@@ -5,10 +5,9 @@ module ActiveRecord
         # @return [ActiveRecord::HierarchicalQuery::CTE::Query]
         attr_reader :query
 
-        delegate :orderings,
-                 :cycle_detector,
-                 :recursive_table,
+        delegate :recursive_table,
                  :join_conditions,
+                 :adapter,
                  :to => :query
 
         # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
@@ -18,29 +17,16 @@ module ActiveRecord
 
         def arel
           arel = scope.select(query.columns)
-                      .select(ordering_column)
                       .arel
                       .join(recursive_table).on(join_conditions)
 
-          cycle_detector.visit_recursive(arel)
+          adapter.visit(:recursive, arel)
         end
 
         private
         def scope
           query.builder.child_scope_value
         end
-
-        def ordering_column
-          if orderings.any?
-            Arel::Nodes::ArrayConcat.new(parent_ordering_column, orderings.row_number_expression)
-          else
-            []
-          end
-        end
-
-        def parent_ordering_column
-          recursive_table[orderings.column_name]
-        end
       end
     end
   end

data/lib/active_record/hierarchical_query/join_builder.rb

@@ -0,0 +1,47 @@
+module ActiveRecord
+  module HierarchicalQuery
+    class JoinBuilder
+      delegate :adapter, :to => :@query
+
+      # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
+      # @param [ActiveRecord::Relation] join_to
+      # @param [#to_s] subquery_alias
+      def initialize(query, join_to, subquery_alias)
+        @query = query
+        @relation = join_to
+        @alias = Arel::Table.new(subquery_alias, ActiveRecord::Base)
+      end
+
+      def build
+        relation = @relation.joins(inner_join.to_sql)
+
+        adapter.visit(:joined_relation, relation)
+      end
+
+      private
+      def inner_join
+        Arel::Nodes::InnerJoin.new(aliased_subquery, constraint)
+      end
+
+      def primary_key
+        @relation.table[@relation.klass.primary_key]
+      end
+
+      def foreign_key
+        @alias[@query.klass.primary_key]
+      end
+
+      def constraint
+        Arel::Nodes::On.new(primary_key.eq(foreign_key))
+      end
+
+      def subquery
+        Arel::Nodes::Grouping.new(@query.arel.ast)
+      end
+
+      def aliased_subquery
+        Arel::Nodes::As.new(subquery, @alias)
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module HierarchicalQuery
-    VERSION = '0.0.1'
+    VERSION = '0.0.2'
   end
 end

data/lib/active_record/hierarchical_query/visitors/orderings.rb

@@ -0,0 +1,87 @@
+module ActiveRecord
+  module HierarchicalQuery
+    module Visitors
+      class Orderings < Visitor
+        ORDERING_COLUMN_ALIAS = '__order_column'
+
+        delegate :recursive_table, :to => :query
+
+        def visit_joined_relation(relation)
+          visit(relation) do
+            relation.order(order_clause)
+          end
+        end
+
+        def visit_cte(select_manager)
+          if should_order_cte?
+            select_manager.order(order_clause)
+          else
+            select_manager
+          end
+        end
+
+        protected
+        def visit(object)
+          if orderings.any?
+            yield
+          else
+            object
+          end
+        end
+
+        def order_clause
+          recursive_table[column_name].asc
+        end
+
+        def should_order_cte?
+          orderings.any? && builder.limit_value || builder.offset_value
+        end
+
+        def orderings
+          @orderings ||= builder.order_values.each_with_object([]) do |value, orderings|
+            orderings.concat Array.wrap(as_orderings(value))
+          end
+        end
+
+        def column_name
+          ORDERING_COLUMN_ALIAS
+        end
+
+        def as_orderings(value)
+          case value
+            when Arel::Nodes::Ordering
+              value
+
+            when Arel::Nodes::Node, Arel::Attributes::Attribute
+              value.asc
+
+            when Symbol
+              table[value].asc
+
+            when Hash
+              value.map { |field, dir| table[field].send(dir) }
+
+            when String
+              value.split(',').map do |expr|
+                string_as_ordering(expr)
+              end
+
+            else
+              raise 'Unknown expression in ORDER BY SIBLINGS clause'
+          end
+        end
+
+        def string_as_ordering(expr)
+          expr.strip!
+
+          if expr.gsub!(/\bdesc\z/i, '')
+            Arel.sql(expr).desc
+          else
+            expr.gsub!(/\basc\z/i, '')
+            Arel.sql(expr).asc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/visitors/postgresql/cycle_detector.rb

@@ -0,0 +1,49 @@
+module ActiveRecord
+  module HierarchicalQuery
+    module Visitors
+      module PostgreSQL
+        class CycleDetector < Visitor
+          COLUMN_NAME = '__path'.freeze
+
+          def visit_non_recursive(arel)
+            if enabled?
+              arel.project Arel::Nodes::PostgresArray.new([primary_key]).as(column_name)
+            end
+
+            arel
+          end
+
+          def visit_recursive(arel)
+            if enabled?
+              arel.project Arel::Nodes::ArrayConcat.new(parent_column, primary_key)
+              arel.constraints << Arel::Nodes::Not.new(primary_key.eq(any(parent_column)))
+            end
+
+            arel
+          end
+
+          private
+          def enabled?
+            builder.nocycle_value
+          end
+
+          def column_name
+            COLUMN_NAME
+          end
+
+          def parent_column
+            query.recursive_table[column_name]
+          end
+
+          def primary_key
+            table[klass.primary_key]
+          end
+
+          def any(argument)
+            Arel::Nodes::NamedFunction.new('ANY', [argument])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/visitors/postgresql/orderings.rb

@@ -0,0 +1,70 @@
+require 'active_record/hierarchical_query/visitors/orderings'
+
+module ActiveRecord
+  module HierarchicalQuery
+    module Visitors
+      module PostgreSQL
+        class Orderings < Visitors::Orderings
+          NATURAL_SORT_TYPES = Set[
+              :integer, :float, :decimal,
+              :datetime, :timestamp, :time, :date,
+              :boolean, :itet, :cidr, :ltree
+          ]
+
+          delegate :first, :to => :orderings
+
+          def visit_non_recursive(arel)
+            project(arel) do
+              Arel::Nodes::PostgresArray.new([row_number_expression]).as(column_name)
+            end
+          end
+
+          def visit_recursive(arel)
+            project(arel) do
+              Arel::Nodes::ArrayConcat.new(recursive_table[column_name], row_number_expression)
+            end
+          end
+
+          private
+          def project(arel)
+            visit(arel) { arel.project(yield) }
+          end
+
+          def row_number_expression
+            if raw_ordering?
+              order_attribute
+            else
+              Arel.sql("ROW_NUMBER() OVER (ORDER BY #{orderings.map(&:to_sql).join(', ')})")
+            end
+          end
+
+          def raw_ordering?
+            ordered_by_attribute? &&
+                (column = order_column) &&
+                NATURAL_SORT_TYPES.include?(column.type)
+          end
+
+          def ordered_by_attribute?
+            orderings.one? && first.ascending? && order_attribute.is_a?(Arel::Attributes::Attribute)
+          end
+
+          def order_attribute
+            first.expr
+          end
+
+          def order_column
+            table = order_attribute.relation
+
+            if table.engine == ActiveRecord::Base
+              columns = table.engine.connection_pool.columns_hash[table.name]
+            else
+              columns = table.engine.columns_hash
+            end
+
+            columns[order_attribute.name.to_s]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/visitors/visitor.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module HierarchicalQuery
+    module Visitors
+      # @api private
+      class Visitor
+        attr_reader :query
+
+        delegate :builder, :to => :query
+        delegate :klass, :table, :to => :builder
+
+        def initialize(query)
+          @query = query
+        end
+      end
+    end
+  end
+end

data/spec/database.travis.yml

@@ -1,4 +1,5 @@
-adapter: postgresql
-database: hierarchical_query_test
-username: postgres
-min_messages: ERROR
+pg:
+  adapter: postgresql
+  database: hierarchical_query_test
+  username: postgres
+  min_messages: ERROR

data/spec/database.yml

@@ -1,4 +1,13 @@
-adapter: postgresql
-database: hierarchical_query_test
-username: vagrant
-min_messages: ERROR
+pg:
+  adapter: postgresql
+  database: hierarchical_query_test
+  username: vagrant
+  min_messages: ERROR
+
+oracle:
+  adapter: oracle_enhanced
+  host: localhost
+  port: 1521
+  database: xe
+  username: system
+  password: manager

data/spec/spec_helper.rb

@@ -2,17 +2,20 @@
 require 'pathname'
 require 'logger'
 
-SPEC_ROOT = Pathname.new(File.dirname(__FILE__))
+ENV['TZ'] = 'UTC'
+ENV['DB'] ||= 'pg'
 
-require 'bundler/setup'
+SPEC_ROOT = Pathname.new(File.dirname(__FILE__))
 
-Bundler.setup(:default, ENV['TRAVIS'] ? :travis : :local)
+require 'bundler'
+Bundler.setup(:default, ENV['TRAVIS'] ? :travis : :local, ENV['DB'].to_sym)
 
 require 'rspec'
 require 'database_cleaner'
 require 'active_record'
 
-ActiveRecord::Base.establish_connection(YAML.load(SPEC_ROOT.join('database.yml').read))
+ActiveRecord::Base.configurations = YAML.load(SPEC_ROOT.join('database.yml').read)
+ActiveRecord::Base.establish_connection(ENV['DB'].to_sym)
 ActiveRecord::Base.logger = Logger.new(ENV['DEBUG'] ? $stderr : '/dev/null')
 ActiveRecord::Base.logger.formatter = proc do |severity, datetime, progname, msg|
   "#{datetime.strftime('%H:%M:%S.%L')}: #{msg}\n"
@@ -35,11 +38,6 @@ RSpec.configure do |config|
   #     --seed 1234
   config.order = 'random'
 
-  config.before(:suite) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with(:truncation)
-  end
-
   config.around(:each) do |example|
     DatabaseCleaner.start
     example.run

metadata

@@ -1,111 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-hierarchical_query
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Alexei Mikhailov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-11 00:00:00.000000000 Z
+date: 2014-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 10.1.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 10.1.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.14.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.14.1
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.17.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.17.1
 - !ruby/object:Gem::Dependency
   name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.2
 description: 
@@ -115,19 +101,24 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
+- README.md
 - lib/active_record/hierarchical_query.rb
 - lib/active_record/hierarchical_query/adapters.rb
+- lib/active_record/hierarchical_query/adapters/abstract.rb
 - lib/active_record/hierarchical_query/adapters/postgresql.rb
 - lib/active_record/hierarchical_query/builder.rb
 - lib/active_record/hierarchical_query/cte/columns.rb
-- lib/active_record/hierarchical_query/cte/cycle_detector.rb
-- lib/active_record/hierarchical_query/cte/join_builder.rb
 - lib/active_record/hierarchical_query/cte/non_recursive_term.rb
-- lib/active_record/hierarchical_query/cte/orderings.rb
 - lib/active_record/hierarchical_query/cte/query.rb
 - lib/active_record/hierarchical_query/cte/recursive_term.rb
 - lib/active_record/hierarchical_query/cte/union_term.rb
+- lib/active_record/hierarchical_query/join_builder.rb
 - lib/active_record/hierarchical_query/version.rb
+- lib/active_record/hierarchical_query/visitors/orderings.rb
+- lib/active_record/hierarchical_query/visitors/postgresql/cycle_detector.rb
+- lib/active_record/hierarchical_query/visitors/postgresql/orderings.rb
+- lib/active_record/hierarchical_query/visitors/visitor.rb
 - lib/arel/nodes/postgresql.rb
 - spec/active_record/hierarchical_query_spec.rb
 - spec/database.travis.yml
@@ -135,8 +126,6 @@ files:
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
-- README.md
-- LICENSE.txt
 homepage: https://github.com/take-five/activerecord-hierarchical_query
 licenses:
 - MIT
@@ -147,17 +136,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.10
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Recursively traverse trees using a single SQL query

data/lib/active_record/hierarchical_query/cte/cycle_detector.rb

@@ -1,63 +0,0 @@
-# coding: utf-8
-
-module ActiveRecord
-  module HierarchicalQuery
-    module CTE
-      class CycleDetector
-        COLUMN_NAME = '__path'.freeze
-
-        attr_reader :query
-
-        delegate :builder, :to => :query
-        delegate :klass, :table, :to => :builder
-
-        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
-        def initialize(query)
-          @query = query
-        end
-
-        def column_name
-          COLUMN_NAME
-        end
-
-        def visit_non_recursive(arel)
-          visit arel do
-            arel.project Arel::Nodes::PostgresArray.new([primary_key]).as(column_name)
-          end
-        end
-
-        def visit_recursive(arel)
-          visit arel do
-            arel.project Arel::Nodes::ArrayConcat.new(parent_column, primary_key)
-            arel.constraints << Arel::Nodes::Not.new(primary_key.eq(any(parent_column)))
-          end
-        end
-
-        private
-        def enabled?
-          builder.nocycle_value
-        end
-
-        def parent_column
-          query.recursive_table[column_name]
-        end
-
-        def primary_key
-          table[klass.primary_key]
-        end
-
-        def visit(object)
-          if enabled?
-            yield
-          end
-
-          object
-        end
-
-        def any(argument)
-          Arel::Nodes::NamedFunction.new('ANY', [argument])
-        end
-      end
-    end
-  end
-end

data/lib/active_record/hierarchical_query/cte/join_builder.rb

@@ -1,55 +0,0 @@
-module ActiveRecord
-  module HierarchicalQuery
-    module CTE
-      class JoinBuilder
-        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
-        # @param [ActiveRecord::Relation] join_to
-        # @param [#to_s] subquery_alias
-        def initialize(query, join_to, subquery_alias)
-          @query = query
-          @relation = join_to
-          @alias = Arel::Table.new(subquery_alias, ActiveRecord::Base)
-        end
-
-        def build
-          apply_ordering { @relation.joins(inner_join.to_sql) }
-        end
-
-        private
-        def inner_join
-          Arel::Nodes::InnerJoin.new(aliased_subquery, constraint)
-        end
-
-        def primary_key
-          @relation.table[@relation.klass.primary_key]
-        end
-
-        def foreign_key
-          @alias[@query.klass.primary_key]
-        end
-
-        def constraint
-          Arel::Nodes::On.new(primary_key.eq(foreign_key))
-        end
-
-        def subquery
-          Arel::Nodes::Grouping.new(@query.arel.ast)
-        end
-
-        def aliased_subquery
-          Arel::Nodes::As.new(subquery, @alias)
-        end
-
-        def apply_ordering
-          scope = yield
-
-          if @query.orderings.any?
-            scope.order(@query.order_clause)
-          else
-            scope
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/hierarchical_query/cte/orderings.rb

@@ -1,108 +0,0 @@
-require 'set'
-require 'active_support/core_ext/array/wrap'
-
-module ActiveRecord
-  module HierarchicalQuery
-    module CTE
-      class Orderings
-        include Enumerable
-
-        ORDERING_COLUMN_ALIAS = '__order_column'
-
-        NATURAL_SORT_TYPES = Set[
-            :integer, :float, :decimal,
-            :datetime, :timestamp, :time, :date,
-            :boolean, :itet, :cidr, :ltree
-        ]
-
-        delegate :table, :to => :@builder
-        delegate :each, :to => :arel_nodes
-
-        # @param [ActiveRecord::HierarchicalQuery::Builder] builder
-        def initialize(builder)
-          @builder = builder
-        end
-
-        def arel_nodes
-          @arel_nodes ||= @builder.order_values.each_with_object([]) do |value, orderings|
-            orderings.concat Array.wrap(as_orderings(value))
-          end
-        end
-
-        def row_number_expression
-          if raw_ordering?
-            order_attribute
-          else
-            Arel.sql("ROW_NUMBER() OVER (ORDER BY #{arel_nodes.map(&:to_sql).join(', ')})")
-          end
-        end
-
-        def column_name
-          ORDERING_COLUMN_ALIAS
-        end
-
-        private
-        def as_orderings(value)
-          case value
-            when Arel::Nodes::Ordering
-              value
-
-            when Arel::Nodes::Node, Arel::Attributes::Attribute
-              value.asc
-
-            when Symbol
-              table[value].asc
-
-            when Hash
-              value.map { |field, dir| table[field].send(dir) }
-
-            when String
-              value.split(',').map do |expr|
-                string_as_ordering(expr)
-              end
-
-            else
-              raise 'Unknown expression in ORDER BY SIBLINGS clause'
-          end
-        end
-
-        def string_as_ordering(expr)
-          expr.strip!
-
-          if expr.gsub!(/\s+desc\z/i, '')
-            Arel.sql(expr).desc
-          else
-            expr.gsub!(/\s+asc\z/i, '')
-            Arel.sql(expr).asc
-          end
-        end
-
-        def raw_ordering?
-          ordered_by_attribute? &&
-              (column = order_column) &&
-              NATURAL_SORT_TYPES.include?(column.type)
-        end
-
-        def ordered_by_attribute?
-          arel_nodes.one? && first.ascending? && order_attribute.is_a?(Arel::Attributes::Attribute)
-        end
-
-        def order_attribute
-          first.expr
-        end
-
-        def order_column
-          table = order_attribute.relation
-
-          if table.engine == ActiveRecord::Base
-            columns = table.engine.connection_pool.columns_hash[table.name]
-          else
-            columns = table.engine.columns_hash
-          end
-
-          columns[order_attribute.name.to_s]
-        end
-      end # class Orderings
-    end
-  end
-end