nql 0.0.1

data/lib/nql/grammar.treetop

@@ -0,0 +1,109 @@
+module NQL
+  grammar Syntax
+
+    rule expression
+      boolean / primary
+    end
+
+    rule boolean
+      left:primary space coordinator:coordinator space right:expression {
+        def to_ransack
+          group = {'g' => [{'m' => coordinator.to_ransack}]}
+
+          [left, right].each do |side|
+            if side.is_node?(:boolean)
+              group['g'][0].merge! side.to_ransack
+            else
+              group['g'][0]['c'] ||= []
+              group['g'][0]['c'] << side.to_ransack
+            end
+          end
+
+          group
+        end
+
+        def is_node?(node_type)
+          node_type.to_sym == :boolean
+        end
+      }
+    end
+
+    rule primary
+      (space comparison space / '(' space expression space ')') {
+        def to_ransack
+          detect_node.to_ransack
+        end
+
+        def detect_node
+          self.send %w(comparison expression).detect { |m| self.respond_to? m }
+        end
+
+        def is_node?(node_type)
+          detect_node.is_node?(node_type)
+        end
+      }
+    end
+
+    rule coordinator
+      ('|' / '&') {
+        def to_ransack
+          coordinators = {'|' => 'or', '&' => 'and'}
+          coordinators[text_value]
+        end
+      }
+    end
+
+    rule comparison
+      variable:alphanumeric space comparator:comparator space value:text {
+        def to_ransack
+          hash = {'a' => {'0' => {'name' => self.variable.text_value.gsub('.', '_')}}, 'p' => self.comparator.to_ransack, 'v' => {'0' => {'value' => self.value.text_value}}}
+          hash = {'c' => [hash]} if !parent || !parent.parent || text_value == parent.parent.text_value
+          hash
+        end
+
+        def is_node?(node_type)
+          node_type.to_sym == :comparison
+        end
+      }
+    end
+
+    rule comparator
+      ('=' / '!=' / '>' / '>=' / '<' / '<=' / '%')+ {
+        def to_ransack
+          comparators = {
+            '=' => 'eq',
+            '!=' => 'not_eq',
+            '>' => 'gt',
+            '>=' => 'gteq',
+            '<' => 'lt',
+            '<=' => 'lteq',
+            '%' => 'cont'
+          }
+          comparators[text_value]
+        end
+      }
+    end
+
+    rule text
+      (alphanumeric / utf8 / symbol)+
+      (space (alphanumeric / utf8 / symbol)+)*
+    end
+
+    rule alphanumeric
+      [a-zA-Z0-9_.]+
+    end
+
+    rule space
+      ' '*
+    end
+
+    rule symbol
+      [><=+-\/\\@#$%!?:]
+    end
+
+    rule utf8
+      [\u00c1\u00c0\u00c9\u00c8\u00cd\u00cc\u00d3\u00d2\u00da\u00d9\u00dc\u00d1\u00c7\u00e1\u00e0\u00e9\u00e8\u00ed\u00ec\u00f3\u00f2\u00fa\u00f9\u00fc\u00f1\u00e7]
+    end
+
+  end
+end

data/lib/nql/version.rb

@@ -0,0 +1,3 @@
+module NQL
+  VERSION = '0.0.1'
+end

data/nql.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nql/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'nql'
+  s.version       = NQL::VERSION
+  s.authors       = ['Gabriel Naiman']
+  s.email         = ['gabynaiman@gmail.com']
+  s.description   = 'Natural Query Language built on top of ActiveRecord and Ransack'
+  s.summary       = 'Natural Query Language built on top of ActiveRecord and Ransack'
+  s.homepage      = 'https://github.com/gabynaiman/nql'
+
+  s.files         = `git ls-files`.split($\)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'treetop'
+  s.add_dependency 'activerecord', '>= 3.2.0'
+  s.add_dependency 'activesupport', '>= 3.2.0'
+  s.add_dependency 'ransack'
+
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'rspec'
+end

data/spec/comparison_parser_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe NQL::SyntaxParser, '-> Comparison' do
+
+  let(:parser) { NQL::SyntaxParser.new }
+
+  context 'Structure and comparators' do
+
+    it 'Equals' do
+      tree = parser.parse('var = value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '='
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+    it 'Not equals' do
+      tree = parser.parse('var != value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '!='
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+    it 'Greater than' do
+      tree = parser.parse('var > value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '>'
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+    it 'Greater or equals than' do
+      tree = parser.parse('var >= value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '>='
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+    it 'Less than' do
+      tree = parser.parse('var < value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '<'
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+    it 'Less or equals than' do
+      tree = parser.parse('var <= value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '<='
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+    it 'Contains' do
+      tree = parser.parse('var % value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '%'
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+  end
+
+  context 'Space separators' do
+
+    it 'Without spaces' do
+      tree = parser.parse('var=value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '='
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+    it 'With many spaces' do
+      tree = parser.parse('var   =   value')
+
+      tree.comparison.variable.text_value.should eq 'var'
+      tree.comparison.comparator.text_value.should eq '='
+      tree.comparison.value.text_value.should eq 'value'
+    end
+
+  end
+
+  context 'Variable names' do
+
+    it 'With numbers' do
+      tree = parser.parse('var1 = value')
+      tree.comparison.variable.text_value.should eq 'var1'
+    end
+
+    it 'With uppercase' do
+      tree = parser.parse('varName = value')
+      tree.comparison.variable.text_value.should eq 'varName'
+    end
+
+    it 'With underscore' do
+      tree = parser.parse('var_name = value')
+      tree.comparison.variable.text_value.should eq 'var_name'
+    end
+
+    it 'With dot' do
+      tree = parser.parse('var.name = value')
+      tree.comparison.variable.text_value.should eq 'var.name'
+    end
+
+  end
+
+  context 'Values' do
+
+    it 'With numbers' do
+      tree = parser.parse('var = value1')
+      tree.comparison.value.text_value.should eq 'value1'
+    end
+
+    it 'With uppercase' do
+      tree = parser.parse('var = valueDummy')
+      tree.comparison.value.text_value.should eq 'valueDummy'
+    end
+
+    it 'With dot' do
+      tree = parser.parse('var = value.dummy')
+      tree.comparison.value.text_value.should eq 'value.dummy'
+    end
+
+
+    it 'With utf8 chars and symbols' do
+      utf8_symbols = "\u00c1\u00c0\u00c9\u00c8\u00cd\u00cc\u00d3\u00d2\u00da\u00d9\u00dc\u00d1\u00c7\u00e1\u00e0\u00e9\u00e8\u00ed\u00ec\u00f3\u00f2\u00fa\u00f9\u00fc\u00f1\u00e7"
+      tree = parser.parse("var = .#+-#{utf8_symbols}")
+      tree.comparison.value.text_value.should eq ".#+-#{utf8_symbols}"
+    end
+
+    it 'With spaces' do
+      tree = parser.parse('var = value 123')
+      tree.comparison.value.text_value.should eq 'value 123'
+    end
+
+    it 'With comparators, symbols and spaces' do
+      tree = parser.parse('var = value1 > value2 ! value3')
+      tree.comparison.value.text_value.should eq 'value1 > value2 ! value3'
+    end
+
+  end
+
+end

data/spec/coordination_parser_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe NQL::SyntaxParser, '-> Coordination' do
+
+  let(:parser) { NQL::SyntaxParser.new }
+
+  it 'And' do
+    tree = parser.parse('var1 = value1 & var2 = value2')
+
+    tree.left.text_value.strip.should eq 'var1 = value1'
+    tree.coordinator.text_value.should eq '&'
+    tree.right.text_value.strip.should eq 'var2 = value2'
+  end
+
+  it 'Or' do
+    tree = parser.parse('var1 = value1 | var2 = value2')
+
+    tree.left.text_value.strip.should eq 'var1 = value1'
+    tree.coordinator.text_value.should eq '|'
+    tree.right.text_value.strip.should eq 'var2 = value2'
+  end
+
+  it 'And then Or' do
+    tree = parser.parse('var1 = value1 & var2 = value2 | var3 = value3')
+
+    tree.left.text_value.strip.should eq 'var1 = value1'
+    tree.coordinator.text_value.should eq '&'
+    tree.right.left.text_value.strip.should eq 'var2 = value2'
+    tree.right.coordinator.text_value.strip.should eq '|'
+    tree.right.right.text_value.strip.should eq 'var3 = value3'
+  end
+
+  it 'With parentheses' do
+    tree = parser.parse('(var1 = value1 & var2 = value2) | var3 = value3')
+
+    tree.left.expression.left.text_value.strip.should eq 'var1 = value1'
+    tree.left.expression.coordinator.text_value.should eq '&'
+    tree.left.expression.right.text_value.strip.should eq 'var2 = value2'
+    tree.coordinator.text_value.strip.should eq '|'
+    tree.right.text_value.strip.should eq 'var3 = value3'
+  end
+
+end

data/spec/migrations/20121108154439_create_countries.rb

@@ -0,0 +1,9 @@
+class CreateCountries < ActiveRecord::Migration
+  def change
+    create_table :countries do |t|
+      t.string :name, null: false
+
+      t.timestamps
+    end
+  end
+end

data/spec/migrations/20121108154508_create_cities.rb

@@ -0,0 +1,10 @@
+class CreateCities < ActiveRecord::Migration
+  def change
+    create_table :cities do |t|
+      t.string :name, null: false
+      t.references :country
+
+      t.timestamps
+    end
+  end
+end

data/spec/models/city.rb

@@ -0,0 +1,3 @@
+class City < ActiveRecord::Base
+  belongs_to :country
+end

data/spec/models/country.rb

@@ -0,0 +1,3 @@
+class Country < ActiveRecord::Base
+  has_many :cities, dependent: :destroy
+end

data/spec/ransack_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe 'Ransack Query' do
+
+  let(:parser) { NQL::SyntaxParser.new }
+
+  context 'Single comparisons' do
+
+    it 'Equals' do
+      q = parser.parse('id = 1234').to_ransack
+
+      q['c'][0].should have_attribute 'id'
+      q['c'][0].should have_predicate 'eq'
+      q['c'][0].should have_value '1234'
+    end
+
+    it 'Not equals' do
+      q = parser.parse('id != 1234').to_ransack
+
+      q['c'][0].should have_attribute 'id'
+      q['c'][0].should have_predicate 'not_eq'
+      q['c'][0].should have_value '1234'
+    end
+
+    it 'Greater than' do
+      q = parser.parse('id > 1234').to_ransack
+
+      q['c'][0].should have_attribute 'id'
+      q['c'][0].should have_predicate 'gt'
+      q['c'][0].should have_value '1234'
+    end
+
+    it 'Greater or equals than' do
+      q = parser.parse('id >= 1234').to_ransack
+
+      q['c'][0].should have_attribute 'id'
+      q['c'][0].should have_predicate 'gteq'
+      q['c'][0].should have_value '1234'
+    end
+
+    it 'Less than' do
+      q = parser.parse('id < 1234').to_ransack
+
+      q['c'][0].should have_attribute 'id'
+      q['c'][0].should have_predicate 'lt'
+      q['c'][0].should have_value '1234'
+    end
+
+    it 'Less or equals than' do
+      q = parser.parse('id <= 1234').to_ransack
+
+      q['c'][0].should have_attribute 'id'
+      q['c'][0].should have_predicate 'lteq'
+      q['c'][0].should have_value '1234'
+    end
+
+    it 'Contains' do
+      q = parser.parse('id % 1234').to_ransack
+
+      q['c'][0].should have_attribute 'id'
+      q['c'][0].should have_predicate 'cont'
+      q['c'][0].should have_value '1234'
+    end
+
+    it 'Model references' do
+      q = parser.parse('models.id = 1234').to_ransack
+
+      q['c'][0].should have_attribute 'models_id'
+      q['c'][0].should have_predicate 'eq'
+      q['c'][0].should have_value '1234'
+    end
+
+  end
+
+  context 'Coordinated comparisons' do
+
+    it 'And' do
+      q = parser.parse('id > 1234 & name = abcd').to_ransack
+
+      q['g'][0]['m'].should eq 'and'
+      q['g'][0]['c'][0].should have_attribute 'id'
+      q['g'][0]['c'][0].should have_predicate 'gt'
+      q['g'][0]['c'][0].should have_value '1234'
+      q['g'][0]['c'][1].should have_attribute 'name'
+      q['g'][0]['c'][1].should have_predicate 'eq'
+      q['g'][0]['c'][1].should have_value 'abcd'
+    end
+
+    it 'Or' do
+      q = parser.parse('id < 1234 | name % abcd').to_ransack
+
+      q['g'][0]['m'].should eq 'or'
+      q['g'][0]['c'][0].should have_attribute 'id'
+      q['g'][0]['c'][0].should have_predicate 'lt'
+      q['g'][0]['c'][0].should have_value '1234'
+      q['g'][0]['c'][1].should have_attribute 'name'
+      q['g'][0]['c'][1].should have_predicate 'cont'
+      q['g'][0]['c'][1].should have_value 'abcd'
+    end
+
+    it 'And then Or' do
+      q = parser.parse('id > 1234 & name = abcd | name % efgh').to_ransack
+
+      q['g'][0]['m'].should eq 'and'
+      q['g'][0]['c'][0].should have_attribute 'id'
+      q['g'][0]['c'][0].should have_predicate 'gt'
+      q['g'][0]['c'][0].should have_value '1234'
+      q['g'][0]['g'][0]['m'].should eq 'or'
+      q['g'][0]['g'][0]['c'][0].should have_attribute 'name'
+      q['g'][0]['g'][0]['c'][0].should have_predicate 'eq'
+      q['g'][0]['g'][0]['c'][0].should have_value 'abcd'
+      q['g'][0]['g'][0]['c'][1].should have_attribute 'name'
+      q['g'][0]['g'][0]['c'][1].should have_predicate 'cont'
+      q['g'][0]['g'][0]['c'][1].should have_value 'efgh'
+    end
+
+    it 'With parentheses' do
+      q = parser.parse('(id > 1234 & name = abcd) | name % efgh').to_ransack
+
+      q['g'][0]['g'][0]['m'].should eq 'and'
+      q['g'][0]['g'][0]['c'][0].should have_attribute 'id'
+      q['g'][0]['g'][0]['c'][0].should have_predicate 'gt'
+      q['g'][0]['g'][0]['c'][0].should have_value '1234'
+      q['g'][0]['g'][0]['c'][1].should have_attribute 'name'
+      q['g'][0]['g'][0]['c'][1].should have_predicate 'eq'
+      q['g'][0]['g'][0]['c'][1].should have_value 'abcd'
+      q['g'][0]['m'].should eq 'or'
+      q['g'][0]['c'][0].should have_attribute 'name'
+      q['g'][0]['c'][0].should have_predicate 'cont'
+      q['g'][0]['c'][0].should have_value 'efgh'
+    end
+
+  end
+
+end