nql 0.0.5 → 0.1.0

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+script: bundle exec rspec spec

data/README.md

@@ -1,5 +1,7 @@
 # NQL
 
+[![Build Status](https://travis-ci.org/gabynaiman/nql.png)](https://travis-ci.org/gabynaiman/nql)
+
 Natural Query Language built on top of ActiveRecord and Ransack
 
 ## Installation
@@ -36,16 +38,29 @@ Or install it yourself as:
 
 Converts from natural language to query expression
 
-    q = '(name: arg | name: br) & region = south'
-    Country.search(NQL.to_ransack(q)).result.to_sql
+    Country.nql('(name: arg | name: br) & region = south').to_sql
     => "SELECT coutries.* FROM countries WHERE (countries.name LIKE '%arg%' OR countries.name LIKE '%br%') AND region = 'south'"
 
 ### Joins support
 
-    q = 'cities.name: buenos'
-    Country.search(NQL.to_ransack(q)).result.to_sql
+    Country.nql('cities.name: buenos').to_sql
     => "SELECT countries.* FROM countries LEFT OUTER JOIN cities ON countries.id = cities.country_id WHERE cities.name LIKE '%buenos%'"
 
+### Invalid expressions handling
+
+Safe query
+
+    Country.nql('xyz').to_sql
+    => "SELECT coutries.* FROM countries WHERE (1=2)
+
+Raising exceptions
+
+    Country.nql!('xyz') => raise NQL::SyntaxError
+
+    Country.nql!('xyz: arg') => raise NQL::AttributesNotFoundError
+
+    Country.nql!(1234) => raise NQL::DataTypeError
+
 ## Contributing
 
 1. Fork it

data/lib/nql.rb

@@ -4,22 +4,8 @@ require 'active_support/all'
 require 'ransack'
 
 require 'nql/version'
+require 'nql/extension/hash'
+require 'nql/extension/active_record'
 require 'nql/grammar'
-require 'nql/invalid_expression_error'
-
-module NQL
-
-  def self.to_ransack(query)
-    return nil if query.nil? || query.strip.empty?
-    expression = parser.parse(query)
-    raise InvalidExpressionError.new(parser.failure_reason) unless expression
-    expression.to_ransack
-  end
-
-  private
-
-  def self.parser
-    @@parser ||= SyntaxParser.new
-  end
-
-end
+require 'nql/query'
+require 'nql/error'

data/lib/nql/error.rb

@@ -0,0 +1,26 @@
+module NQL
+  class Error < StandardError
+  end
+
+  class SyntaxError < Error
+  end
+
+  class DataTypeError < Error
+    def initialize(text)
+      super "#{text} must be a String"
+    end
+  end
+
+  class InvalidModelError < Error
+    def initialize(model)
+      super "#{model} must be subclass of ActiveRecord::Base"
+    end
+  end
+
+  class AttributesNotFoundError < Error
+    def initialize(model, attributes)
+      super "#{model} does not contains the attributes #{attributes}"
+    end
+  end
+
+end

data/lib/nql/extension/active_record.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  class Base
+
+    def self.nql(query, options={})
+      nql! query, options
+    rescue NQL::Error
+      self.where('1=2')
+    end
+
+    def self.nql!(query, options={})
+      nql_search(query).result(options)
+    end
+
+    def self.nql_search(query)
+      NQL::Query.new(self, query).ransack_search
+    end
+
+  end
+end

data/lib/nql/extension/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def deep_symbolize_keys
+    inject({}) { |result, (key, value)|
+      value = value.deep_symbolize_keys if value.is_a?(Hash)
+      result[(key.to_sym rescue key) || key] = value
+      result
+    }
+  end unless Hash.method_defined?(:deep_symbolize_keys)
+end

data/lib/nql/query.rb

@@ -0,0 +1,62 @@
+module NQL
+  class Query
+
+    attr_reader :model
+    attr_reader :text
+    attr_reader :expression
+
+    def initialize(model, text)
+      raise InvalidModelError.new model unless model.ancestors.include? ::ActiveRecord::Base
+      raise DataTypeError.new text if text && !text.is_a?(String)
+      @model = model
+      @text = text
+      evaluate
+    end
+
+    def ransack_search
+      if expression
+        model.search(expression.to_ransack)
+      else
+        model.search
+      end
+    end
+
+    private
+
+    def evaluate
+      if text.nil? || text.strip.empty?
+        @expression = nil
+      else
+        parser = SyntaxParser.new
+        @expression = parser.parse(text)
+        raise SyntaxError.new(parser.failure_reason) unless expression
+        validate_attributes!
+      end
+    end
+
+    def validate_attributes!
+      return unless expression
+      extended_attributes = model.column_names | model.reflections.flat_map { |k, v| v.klass.column_names.map { |c| "#{k}_#{c}" } }
+      invalid_attributes(expression.to_ransack, extended_attributes).tap do |attributes|
+        raise AttributesNotFoundError.new model, attributes if attributes.any?
+      end
+    end
+
+    def invalid_attributes(node, valid_attributes)
+      return [] unless node
+
+      node.deep_symbolize_keys.flat_map do |k, v|
+        if k == :a
+          [v['0'.to_sym][:name]] unless valid_attributes.include?(v['0'.to_sym][:name])
+        else
+          if v.is_a?(Hash)
+            invalid_attributes(v, valid_attributes)
+          elsif v.is_a?(Array)
+            v.select { |e| e.is_a?(Hash) }.flat_map { |e| invalid_attributes(e, valid_attributes) }
+          end
+        end
+      end.compact
+    end
+
+  end
+end

data/lib/nql/version.rb

@@ -1,3 +1,3 @@
 module NQL
-  VERSION = '0.0.5'
+  VERSION = '0.1.0'
 end

data/nql.gemspec

@@ -15,10 +15,10 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
 
-  s.add_dependency 'treetop'
+  s.add_dependency 'treetop', '~> 1.4'
   s.add_dependency 'activerecord', '>= 3.2.0'
   s.add_dependency 'activesupport', '>= 3.2.0'
-  s.add_dependency 'ransack'
+  s.add_dependency 'ransack', '~> 0.7'
 
   s.add_development_dependency 'sqlite3'
   s.add_development_dependency 'rspec'

data/spec/query_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe NQL::Query do
+
+  before :all do
+    ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ":memory:"
+    ActiveRecord::Base.connection
+    ActiveRecord::Migrator.migrate ActiveRecord::Migrator.migrations_path
+  end
+
+  it 'Valid expression' do
+    query = NQL::Query.new Country, 'name: Argentina'
+
+    query.text.should eq 'name: Argentina'
+    query.expression.should be_a Treetop::Runtime::SyntaxNode
+  end
+
+  it 'Valid with empty expression' do
+    query = NQL::Query.new Country, ''
+
+    query.text.should eq ''
+    query.expression.should be_nil
+  end
+
+  it 'Valid with nil expression' do
+    query = NQL::Query.new Country, nil
+
+    query.text.should be_nil
+    query.expression.should be_nil
+  end
+
+  it 'Invalid model type' do
+    expect { NQL::Query.new Object, nil }.to raise_error NQL::InvalidModelError
+  end
+
+  it 'Invalid expression type' do
+    expect { NQL::Query.new Country, Object.new }.to raise_error NQL::DataTypeError
+  end
+
+  it 'Invalid expression syntax' do
+    expect { NQL::Query.new Country, 'xyz1234' }.to raise_error NQL::SyntaxError
+  end
+
+  it 'Invalid fields' do
+    expect { NQL::Query.new Country, 'name: Argentina | xyz: 1234 | abc: 0000'}.to raise_error NQL::AttributesNotFoundError
+  end
+
+end

data/spec/sql_spec.rb

@@ -12,42 +12,42 @@ describe 'SQL generation' do
 
     it 'Equals' do
       q = 'name = abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE \"countries\".\"name\" = 'abcd'"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE \"countries\".\"name\" = 'abcd'"
     end
 
     it 'Not equals' do
       q = 'name != abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" != 'abcd')"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" != 'abcd')"
     end
 
     it 'Greater than' do
       q = 'name > abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" > 'abcd')"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" > 'abcd')"
     end
 
     it 'Greater or equals than' do
       q = 'name >= abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" >= 'abcd')"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" >= 'abcd')"
     end
 
     it 'Less than' do
       q = 'name < abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" < 'abcd')"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" < 'abcd')"
     end
 
     it 'Less or equals than' do
       q = 'name <= abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" <= 'abcd')"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" <= 'abcd')"
     end
 
     it 'Contains' do
       q = 'name : abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" LIKE '%abcd%')"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" LIKE '%abcd%')"
     end
 
     it 'Matches' do
       q = 'name ~ abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" LIKE 'abcd')"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (\"countries\".\"name\" LIKE 'abcd')"
     end
 
   end
@@ -56,22 +56,22 @@ describe 'SQL generation' do
 
     it 'And' do
       q = 'id > 1234 & name = abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE ((\"countries\".\"id\" > 1234 AND \"countries\".\"name\" = 'abcd'))"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE ((\"countries\".\"id\" > 1234 AND \"countries\".\"name\" = 'abcd'))"
     end
 
     it 'Or' do
       q = 'id < 1234 | name : abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE ((\"countries\".\"id\" < 1234 OR \"countries\".\"name\" LIKE '%abcd%'))"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE ((\"countries\".\"id\" < 1234 OR \"countries\".\"name\" LIKE '%abcd%'))"
     end
 
     it 'And then Or' do
       q = 'id > 1234 & name = abcd | name : efgh'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE ((\"countries\".\"id\" > 1234 AND (\"countries\".\"name\" = 'abcd' OR \"countries\".\"name\" LIKE '%efgh%')))"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE ((\"countries\".\"id\" > 1234 AND (\"countries\".\"name\" = 'abcd' OR \"countries\".\"name\" LIKE '%efgh%')))"
     end
 
     it 'With parentheses' do
       q = '(id > 1234 & name = abcd) | name : efgh'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE ((\"countries\".\"name\" LIKE '%efgh%' OR (\"countries\".\"id\" > 1234 AND \"countries\".\"name\" = 'abcd')))"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE ((\"countries\".\"name\" LIKE '%efgh%' OR (\"countries\".\"id\" > 1234 AND \"countries\".\"name\" = 'abcd')))"
     end
 
   end
@@ -80,17 +80,17 @@ describe 'SQL generation' do
 
     it 'Parent join' do
       q = 'country.name : abcd'
-      City.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"cities\".* FROM \"cities\" LEFT OUTER JOIN \"countries\" ON \"countries\".\"id\" = \"cities\".\"country_id\" WHERE (\"countries\".\"name\" LIKE '%abcd%')"
+      City.nql(q).should produce_sql "SELECT \"cities\".* FROM \"cities\" LEFT OUTER JOIN \"countries\" ON \"countries\".\"id\" = \"cities\".\"country_id\" WHERE (\"countries\".\"name\" LIKE '%abcd%')"
     end
 
     it 'Children join' do
       q = 'cities.name : abcd'
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\" LEFT OUTER JOIN \"cities\" ON \"cities\".\"country_id\" = \"countries\".\"id\" WHERE (\"cities\".\"name\" LIKE '%abcd%')"
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\" LEFT OUTER JOIN \"cities\" ON \"cities\".\"country_id\" = \"countries\".\"id\" WHERE (\"cities\".\"name\" LIKE '%abcd%')"
     end
 
     it 'Children join distinct' do
       q = 'cities.name : abcd'
-      Country.search(NQL.to_ransack(q)).result(distinct: true).should produce_sql "SELECT DISTINCT \"countries\".* FROM \"countries\" LEFT OUTER JOIN \"cities\" ON \"cities\".\"country_id\" = \"countries\".\"id\" WHERE (\"cities\".\"name\" LIKE '%abcd%')"
+      Country.nql(q, distinct: true).should produce_sql "SELECT DISTINCT \"countries\".* FROM \"countries\" LEFT OUTER JOIN \"cities\" ON \"cities\".\"country_id\" = \"countries\".\"id\" WHERE (\"cities\".\"name\" LIKE '%abcd%')"
     end
 
   end
@@ -99,22 +99,22 @@ describe 'SQL generation' do
 
     it 'Nil' do
       q = nil
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\""
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\""
     end
 
     it 'Empty' do
       q = ''
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\""
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\""
     end
 
     it 'Empty with spaces' do
       q = '   '
-      Country.search(NQL.to_ransack(q)).result.should produce_sql "SELECT \"countries\".* FROM \"countries\""
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\""
     end
 
     it 'Partial expression' do
       q = 'id ='
-      expect { Country.search(NQL.to_ransack(q)).result }.to raise_exception NQL::InvalidExpressionError
+      Country.nql(q).should produce_sql "SELECT \"countries\".* FROM \"countries\"  WHERE (1=2)"
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nql
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-15 00:00:00.000000000 Z
+date: 2013-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -64,17 +64,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -115,14 +115,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/nql.rb
+- lib/nql/error.rb
+- lib/nql/extension/active_record.rb
+- lib/nql/extension/hash.rb
 - lib/nql/grammar.rb
 - lib/nql/grammar.treetop
-- lib/nql/invalid_expression_error.rb
+- lib/nql/query.rb
 - lib/nql/version.rb
 - nql.gemspec
 - spec/comparison_parser_spec.rb
@@ -131,6 +135,7 @@ files:
 - spec/migrations/20121108154508_create_cities.rb
 - spec/models/city.rb
 - spec/models/country.rb
+- spec/query_spec.rb
 - spec/ransack_spec.rb
 - spec/spec_helper.rb
 - spec/sql_spec.rb
@@ -165,6 +170,8 @@ test_files:
 - spec/migrations/20121108154508_create_cities.rb
 - spec/models/city.rb
 - spec/models/country.rb
+- spec/query_spec.rb
 - spec/ransack_spec.rb
 - spec/spec_helper.rb
 - spec/sql_spec.rb
+has_rdoc: 

data/lib/nql/invalid_expression_error.rb

@@ -1,7 +0,0 @@
-module NQL
-  class InvalidExpressionError < StandardError
-    def initialize(message)
-      super
-    end
-  end
-end