arel-ltree 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTRhNjY0ZTk0NTk3YTE1ZDM5NzVkMjZhYWY4OWY0ODAwNGZiODQ4Nw==
+  data.tar.gz: !binary |-
+    YzU3ZmY2ZTNlZDIwMmQ4NzZkZmY0MmYxZThkNzRiZDIxNmQ1ZGNhMQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZGQxYjQyZmU2NmUwZTlmYWM0ZTRkYWM4NTk4ODZmMmMzOWQ0ZjBhZDJmMjAy
+    MGQ0NzIzMjRlYjQxY2FhNDZlMTlmNmYyNTU5OTk1MDNlZWIzNDllM2I1ZjE2
+    YzRiZmYyNDY3ODRmMzM4OGExMDIwM2U4NTBiZDkxMWYwM2Q2MDY=
+  data.tar.gz: !binary |-
+    YTA3YjM4OGFlM2Y2MzlhYmExMzVjMjA5ZjliMGZjNGU1MDY0Mzg0NzVhZDk0
+    ZDBlZjhmNWRmYmE5MTQyYTE1YjgzYmEwNjZjOTQwZTRlNWUxYzA4NzhmMzMx
+    OTIwZWM2YzQ5NmE4ZGYyOTk3YzU5NTg4MzJlNWM0YzIxMDJkYzM=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+script:
+  - bundle exec rake spec
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - rbx-19mode
+  - jruby
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andrew Slotin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+[![Build Status](https://travis-ci.org/andrewslotin/arel-ltree.png?branch=master)](https://travis-ci.org/andrewslotin/arel-ltree) [![Dependency Status](https://gemnasium.com/andrewslotin/arel-ltree.png)](https://gemnasium.com/andrewslotin/arel-ltree)
+
+# arel-ltree
+
+Arel extension for PostgreSQL [ltree](http://www.postgresql.org/docs/9.2/static/ltree.html) type.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'arel-ltree'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install arel-ltree
+
+## Usage
+
+Select all parent nodes:
+```ruby
+Node.where(Node.arel_table[:path].ancestor_of('root.subtree.node')).to_sql
+# => SELECT * FROM nodes WHERE "nodes"."path" @> 'root.subtree.node'::ltree;
+```
+
+Select all children nodes:
+```ruby
+Node.where(Node.arel_table[:path].descendant_of('root.subtree')).to_sql
+# => SELECT * FROM nodes WHERE "nodes"."path" <@ 'root.subtree'::ltree;
+
+Match against ltree:
+```ruby
+Node.where(Node.arel_table[:path].matches.ltree('root.subtree')).to_sql
+# => SELECT * FROM nodes WHERE "nodes"."path" ~ 'root.subtree'::ltree;
+
+ltree = Arel::Attributes::Ltree.new('root.subtree')
+Node.where(Node.arel_table[:path].matches(ltree).to_sql
+# => SELECT * FROM nodes WHERE "nodes"."path" ~ 'root.subtree'::ltree;
+```
+
+Match against lquery (simple regex for ltree):
+```ruby
+Node.where(Node.arel_table[:path].matches.lquery('root.*{1}.node')).to_sql
+# => SELECT * FROM nodes WHERE "nodes"."path" <@ 'root.*{1}.node'::lquery;
+
+lquery = Arel::Attributes::Lquery.new('root.*{1}.node')
+Node.where(Node.arel_table[:path].matches(lquery).to_sql
+# => SELECT * FROM nodes WHERE "nodes"."path" <@ 'root.*{1}.node'::lquery;
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/arel-ltree.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'arel-ltree/ltree/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "arel-ltree"
+  spec.version       = Arel::Ltree::VERSION
+  spec.authors       = ["Andrew Slotin"]
+  spec.email         = ["andrew.slotin@gmail.com"]
+  spec.description   = %q{Arel extension for PostgreSQL ltree type}
+  spec.summary       = %q{Adds support for ltree operatos to Arel}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency             "arel", ">= 3.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/arel-ltree.rb

@@ -0,0 +1,6 @@
+require 'arel'
+require 'arel-ltree/ltree/version'
+require 'arel-ltree/ltree/nodes'
+require 'arel-ltree/ltree/visitors'
+require 'arel-ltree/ltree/predications'
+require 'arel-ltree/attributes'

data/lib/arel-ltree/attributes.rb

@@ -0,0 +1,23 @@
+module Arel
+  module Attributes
+    class Ltree < Struct.new(:query)
+      include ::Arel::Ltree::Predications
+
+      def method_missing(name, *args)
+        if query.respond_to?(name)
+          query.send(name, *args)
+        else
+          super
+        end
+      end
+
+      def to_s
+        query
+      end
+    end
+
+    class Lquery < Ltree; end
+
+    Attribute.send :include, Arel::Ltree::Predications
+  end
+end

data/lib/arel-ltree/ltree/nodes.rb

@@ -0,0 +1,14 @@
+module Arel
+  module Ltree
+    module Nodes
+      class AncestorOf < ::Arel::Nodes::Binary; end
+      class DescendantOf < ::Arel::Nodes::Binary; end
+
+      class Matches < Arel::Nodes::Binary
+        def initialize(left, right = nil)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/arel-ltree/ltree/predications.rb

@@ -0,0 +1,49 @@
+module Arel
+  module Ltree
+    module Predications
+      def ancestor_of(other)
+        Arel::Ltree::Nodes::AncestorOf.new(self, other)
+      end
+
+      def descendant_of(other)
+        Arel::Ltree::Nodes::DescendantOf.new(self, other)
+      end
+
+      def matches(*args)
+        case args[0]
+        when Attributes::Lquery, Attributes::Ltree
+          Arel::Ltree::Nodes::Matches.new(self, args[0])
+        when nil
+          Arel::Ltree::Nodes::Matches.new(self)
+        else
+          super
+        end
+      end
+    end
+
+    module MatchesPredications
+      def lquery(other)
+        ltree_matches_node(other, Attributes::Lquery)
+      end
+
+      def ltree(other)
+        ltree_matches_node(other, Attributes::Ltree)
+      end
+
+      private
+
+      def ltree_matches_node(other, rop_node_klass)
+        case other
+        when String
+          Arel::Ltree::Nodes::Matches.new(self.left, rop_node_klass.new(other))
+        when Array
+          Arel::Ltree::Nodes::Matches.new(self.left, other.map { |o| rop_node_klass.new(o) })
+        else
+          Arel::Ltree::Nodes::Matches.new(self.left, other)
+        end
+      end
+    end
+
+    Nodes::Matches.send :include, MatchesPredications
+  end
+end

data/lib/arel-ltree/ltree/version.rb

@@ -0,0 +1,5 @@
+module Arel
+  module Ltree
+    VERSION = '0.0.1'
+  end
+end

data/lib/arel-ltree/ltree/visitors.rb

@@ -0,0 +1,32 @@
+module Arel
+  module Ltree
+    module Visitors
+      private
+
+      def visit_Arel_Ltree_Nodes_AncestorOf(o)
+        "#{visit o.left} @> #{visit o.right}"
+      end
+
+      def visit_Arel_Ltree_Nodes_DescendantOf(o)
+        "#{visit o.left} <@ #{visit o.right}"
+      end
+
+      def visit_Arel_Ltree_Nodes_Matches(o)
+        raise ArgumentError.new("Missing right operand for MATCH") unless o.right
+        "#{visit o.left} ~ #{visit o.right}"
+      end
+
+      def visit_Arel_Attributes_Ltree(o)
+        "'#{o}'::ltree"
+      end
+
+      def visit_Arel_Attributes_Lquery(o)
+        "'#{o}'::lquery"
+      end
+    end
+  end
+
+  module Visitors
+    PostgreSQL.send :include, Ltree::Visitors
+  end
+end

data/spec/arel-ltree/ltree/nodes_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Arel::Ltree::Nodes do
+  %w{AncestorOf DescendantOf Matches}.each do |klass_name|
+    it "defines a binary operation #{klass_name}" do
+      expect(Arel::Ltree::Nodes.const_get(klass_name).superclass).to be Arel::Nodes::Binary
+    end
+  end
+end

data/spec/arel-ltree/ltree/visitiors_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Arel
+  module Ltree
+    describe Visitors do
+      subject            { Arel::Visitors::PostgreSQL.new(Arel::Table.engine.connection) }
+      let(:parent_ltree) { Arel::Attributes::Ltree.new('1.2') }
+      let(:child_ltree)  { Arel::Attributes::Ltree.new('1.2.3') }
+      let(:lquery)       { Arel::Attributes::Lquery.new('*.a{2}.b') }
+
+      it 'visit_Arel_Attributes_Ltree' do
+        expect(subject.accept(parent_ltree)).to eq "'1.2'::ltree"
+      end
+
+      it 'visit_Arel_Attributes_Lquery' do
+        expect(subject.accept(lquery)).to eq "'*.a{2}.b'::lquery"
+      end
+
+      it 'supports ancestor_of operator' do
+        node = Nodes::AncestorOf.new(parent_ltree, child_ltree)
+        expect(subject.accept(node)).to eq "'1.2'::ltree @> '1.2.3'::ltree"
+      end
+
+      it 'supports descendant_of operator' do
+        node = Nodes::DescendantOf.new(child_ltree, parent_ltree)
+        expect(subject.accept(node)).to eq "'1.2.3'::ltree <@ '1.2'::ltree"
+      end
+
+      it 'supports matching against the lquery' do
+        node = Nodes::Matches.new(child_ltree, lquery)
+        expect(subject.accept(node)).to eq "'1.2.3'::ltree ~ '*.a{2}.b'::lquery"
+      end
+
+      it 'supports matching against the ltree' do
+        node = Nodes::Matches.new(child_ltree, parent_ltree)
+        expect(subject.accept(node)).to eq "'1.2.3'::ltree ~ '1.2'::ltree"
+      end
+
+      context 'with attribute as a left parameter' do
+        let(:table) { Table.new(:nodes) }
+        let(:attr)  { table[:path] }
+        let(:ltree) { parent_ltree }
+
+        it 'supports ancestor_of operator' do
+          node = attr.ancestor_of(ltree)
+          expect(subject.accept(node)).to eq %q{"nodes"."path" @> '1.2'::ltree}
+        end
+
+        it 'supports descendant_of operator' do
+          node = attr.descendant_of(ltree)
+          expect(subject.accept(node)).to eq %q{"nodes"."path" <@ '1.2'::ltree}
+        end
+
+        describe ".matches" do
+          it 'supports matching against the lquery' do
+            node = attr.matches.lquery(lquery)
+            expect(subject.accept(node)).to eq %q{"nodes"."path" ~ '*.a{2}.b'::lquery}
+          end
+
+          it 'supports matching against the ltree' do
+            node = attr.matches.ltree(ltree)
+            expect(subject.accept(node)).to eq %q{"nodes"."path" ~ '1.2'::ltree}
+          end
+
+          it 'supports matching against the lquery given lquery as an argument' do
+            node = attr.matches(lquery)
+            expect(subject.accept(node)).to eq %q{"nodes"."path" ~ '*.a{2}.b'::lquery}
+          end
+
+          it 'supports matching against the ltree given ltree as an argument' do
+            node = attr.matches(ltree)
+            expect(subject.accept(node)).to eq %q{"nodes"."path" ~ '1.2'::ltree}
+          end
+
+          it 'raises an ArgumentError when .match is called without arguments' do
+            node = attr.matches
+            expect { subject.accept(node) }.to raise_error ArgumentError
+          end
+
+          it 'uses LIKE match given a string' do
+            node = attr.matches("123")
+            expect(subject.accept(node)).to eq %q{"nodes"."path" ILIKE '123'}
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'arel-ltree'
+require 'support/fake_record'
+
+Arel::Table.engine = Arel::Sql::Engine.new(FakeRecord::Base.new)
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)

data/spec/support/fake_record.rb

@@ -0,0 +1,123 @@
+module FakeRecord
+  class Column < Struct.new(:name, :type)
+  end
+
+  class Connection
+    attr_reader :tables
+    attr_accessor :visitor
+
+    def initialize(visitor = nil)
+      @tables = %w{ users photos developers products}
+      @columns = {
+        'users' => [
+          Column.new('id', :integer),
+          Column.new('name', :string),
+          Column.new('bool', :boolean),
+          Column.new('created_at', :date)
+        ],
+        'products' => [
+          Column.new('id', :integer),
+          Column.new('price', :decimal)
+        ]
+      }
+      @columns_hash = {
+        'users' => Hash[@columns['users'].map { |x| [x.name, x] }],
+        'products' => Hash[@columns['products'].map { |x| [x.name, x] }]
+      }
+      @primary_keys = {
+        'users' => 'id',
+        'products' => 'id'
+      }
+      @visitor = visitor
+    end
+
+    def columns_hash table_name
+      @columns_hash[table_name]
+    end
+
+    def primary_key name
+      @primary_keys[name.to_s]
+    end
+
+    def table_exists? name
+      @tables.include? name.to_s
+    end
+
+    def columns name, message = nil
+      @columns[name.to_s]
+    end
+
+    def quote_table_name name
+      "\"#{name.to_s}\""
+    end
+
+    def quote_column_name name
+      "\"#{name.to_s}\""
+    end
+
+    def schema_cache
+      self
+    end
+
+    def quote thing, column = nil
+      if column && column.type == :integer
+        return 'NULL' if thing.nil?
+        return thing.to_i
+      end
+
+      case thing
+      when true
+        "'t'"
+      when false
+        "'f'"
+      when nil
+        'NULL'
+      when Numeric
+        thing
+      else
+        "'#{thing}'"
+      end
+    end
+  end
+
+  class ConnectionPool
+    class Spec < Struct.new(:config)
+    end
+
+    attr_reader :spec, :connection
+
+    def initialize
+      @spec = Spec.new(:adapter => 'america')
+      @connection = Connection.new
+      @connection.visitor = Arel::Visitors::ToSql.new(connection)
+    end
+
+    def with_connection
+      yield connection
+    end
+
+    def table_exists? name
+      connection.tables.include? name.to_s
+    end
+
+    def columns_hash
+      connection.columns_hash
+    end
+
+    def schema_cache
+      connection
+    end
+  end
+
+  class Base
+    attr_accessor :connection_pool
+
+    def initialize
+      @connection_pool = ConnectionPool.new
+    end
+
+    def connection
+      connection_pool.connection
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: arel-ltree
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Slotin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: arel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Arel extension for PostgreSQL ltree type
+email:
+- andrew.slotin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- arel-ltree.gemspec
+- lib/arel-ltree.rb
+- lib/arel-ltree/attributes.rb
+- lib/arel-ltree/ltree/nodes.rb
+- lib/arel-ltree/ltree/predications.rb
+- lib/arel-ltree/ltree/version.rb
+- lib/arel-ltree/ltree/visitors.rb
+- spec/arel-ltree/ltree/nodes_spec.rb
+- spec/arel-ltree/ltree/visitiors_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_record.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4
+signing_key: 
+specification_version: 4
+summary: Adds support for ltree operatos to Arel
+test_files:
+- spec/arel-ltree/ltree/nodes_spec.rb
+- spec/arel-ltree/ltree/visitiors_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_record.rb