queryfy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c768903e4796eae77d516db581ddd7e81082cf5c
+  data.tar.gz: f39cedbe011e43574d9fe1c576c18da29406fd23
+SHA512:
+  metadata.gz: 1f9a43dcb7b136941069f71f850633b964c2dad17f98b52dd5eedae4979a2bd8165abfceb4ce1e2783f03981ab6a8de4535fb39cf750bcc737b983a390fb4cbf
+  data.tar.gz: d0ecbe8bc5f0d6602d2b9df2fb6c22acfcfb0d390664cf927ae980122268c9288a58ecf166e0da16b01ee269f4543e470811d5af5381bb5bff843c868367b794

data/.gitignore

@@ -0,0 +1,33 @@
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+.ruby-gemset
+.ruby-version
+# Gemfile.lock
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+## Documentation cache and generated files:
+## Environment normalisation:
+## Specific to RubyMotion:
+*.gem
+*.rbc
+.dat*
+.repl_history
+.rvmrc
+/.bundle/
+/.config
+/.yardoc
+/.yardoc/
+/Gemfile.lock
+/InstalledFiles
+/_yardoc/
+/coverage/
+/doc/
+/lib/bundler/man/
+/pkg/
+/rdoc/
+/spec/examples.txt
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+/vendor/bundle
+build/

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gem 'sqlite3'
+
+# Specify your gem's dependencies in queryfy.gemspec
+rails = ENV['RAILS'] || '~> 4.2.0'
+gem 'rails', rails
+
+gem 'pry'
+gem 'pry-doc'
+gem 'pry-nav'
+gem 'pry-rescue'
+gem 'pry-stack_explorer'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Bonemind
+
+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,123 @@
+# Queryfy
+
+Queryfy is a gem that allows you to simply and easily paginate and filter activerecord models using queryparams.
+The gem assumes you pass it a hash of queryparams which contain a filterstring in `filter`, and optionally `offset` and `limit` fields.
+
+Queryfy uses a filterstring to query models that supports nesting of conditions, e.g:
+```
+name=="name"&&(desc="desc"||(isbn=2||isbn=4))||author=~"%orwell%"
+```
+
+This gem uses [FilterLexer](https://github.com/MaienM/FilterLexer/) to parse the filterstring
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'queryfy'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install queryfy
+
+## Usage
+
+### General
+```
+require 'queryfy'
+
+class SomeModel
+    include Queryfy
+end
+
+SomeModel.queryfy(queryparams)
+```
+
+The gem adds makes a `queryfy` method available to ActiveRecord::Base when included.
+The queryfy method takes a hash in the following format:
+```
+{'filter': 'name=="name", 'offset': 50, 'limit': 10}
+```
+All three are optional, and any extra values are ignored.
+
+Defaults:
+```
+offset = 0
+limit = 50
+```
+
+If filter is either nil or empty, queryfy will assume everything should be selected, almost like `SomeModel.all`
+
+After calling `queryfy` you will get back the following:
+```
+{data: [your data], count: total results, offset: the offset used, limit: the limit used}
+```
+
+### Exceptions
+
+All exceptions queryfy can raise inherit from `QueryfyError`
+
+Currently, the following exceptions exist:
+```
+FilterParseError: Occurs when filter_lexer fails to parse the filter_query
+NoSuchFieldError: Occurs when trying to filter on a nonexistant column
+```
+
+### Querystrings
+
+Queryfy supports arbitratily deeply nested conditions in filters, and uses
+`filter_lexer` under the hood to parse the filter strings
+
+Examples:
+```
+//SQL: name = 'name'
+name=="name" 
+
+//SQL: name = 'name' AND description = 'desc'
+name=="name"&&description=="desc"
+
+//SQL: name = 'name' AND (description = 'desc1' OR isb = 1234)
+name=="name"&&(description=="desc1"||isbn=1234)
+
+//SQL: name = 'name' AND (description = 'desc1' OR isb = 1234) OR name != 'somename'
+name=="name"&&(description=="desc1"||isbn=1234)||name!="somename"
+
+//SQL: name = 'name' AND (description = 'desc1' OR (isb = 1234 || isbn = 5678))
+name=="name"&&(description=="desc1"||(isbn=1234||isbn=5678))
+```
+
+### Operators
+
+Since queryfy builds on filter_lexer it supports all operators filter lexer supports:
+```
+Equal: ==, eq, EQ, is, IS
+Not equal: !=, <>, neq, NEQ, not is, NOT IS, is not, IS NOT
+Less than: <, lt, LT
+Less or equal: <=, le, LE
+greater than: >, gt, GT
+Greated than or equal: >=, ge, GE
+Like: =~, like, LIKE
+Not like: !=~, not like, NOT LIKE
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Bonemind/queryfy.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+require 'rake/testtask'
+Bundler::GemHelper.install_tasks
+
+
+Rake::TestTask.new do |t|
+	t.libs << "test"
+	t.test_files = FileList['test/*_test.rb']
+	t.verbose = true
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "queryfy"
+require "active_record"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/queryfy.rb

@@ -0,0 +1,117 @@
+require "queryfy/version"
+require 'filter_lexer'
+require 'queryfy/filter_lexer/formatter.rb'
+require 'queryfy/queryfy_errors.rb'
+require 'queryfy/configuration'
+require 'active_record'
+
+module Queryfy
+	extend Configuration
+	define_setting :max_limit, 100
+	define_setting :default_limit, 50
+
+	# Actually builds the query
+	def self.build_query(klass, querystring, limit = 50, offset = 0)
+		limit = [max_limit, limit.to_i].min
+		# Handle empty and nil queries
+		if (querystring.nil? || querystring == '')
+			return {
+				data: klass.limit(limit).offset(offset), 
+				count: klass.all.count, 
+				limit: limit.to_i, offset: offset.to_i
+			}
+		end
+
+		begin
+			tree = FilterLexer::Parser.parse(querystring)
+		rescue FilterLexer::ParseException => e
+			raise FilterParseError, "Failed to parse querystring, #{ e.message }"
+			return
+		end
+
+		# Build the query with pagination
+		query = klass.arel_table.project(Arel.star).take(limit).skip(offset)
+
+		cleaned_tree = self.clean_tree(tree)
+		arel_tree = self.cleaned_to_arel(klass.arel_table, cleaned_tree)
+		# If we want to actually query, add the conditions to query
+		query = query.where(arel_tree) unless arel_tree.nil?
+
+		total = 0
+		if arel_tree.nil?
+			total = klass.all.count
+		else
+			countquery = klass.arel_table.project(klass.arel_table[klass.primary_key.to_sym].count.as('total')).where(arel_tree)
+			results = klass.connection.execute(countquery.to_sql)
+			if results.count == 0
+				raise QueryfyError, 'Failed to select count, this should not happen'
+			else
+				total = results[0]['total']
+			end
+		end
+
+		# Return the results
+		return {data: klass.find_by_sql(query.to_sql), count: total.to_i, limit: limit.to_i, offset: offset.to_i}
+	end
+
+	# Cleans the filterlexer tree
+	# Output is an array with either filterentries and operators, or an array of filterentries and operators
+	# The latter represents a group
+	def self.clean_tree(tree, input = [])
+		tree.elements.each do |el|
+			if el.is_a?(FilterLexer::Expression)
+				input += clean_tree(el)
+			elsif el.is_a?(FilterLexer::Group)
+				input += [clean_tree(el)]
+			else
+				input.push(el)
+			end
+		end
+		return input
+	end
+
+	# Converts a cleaned tree to something arel can understand
+	def self.cleaned_to_arel(arel_table, tree, ast = nil)
+		tree.each_with_index do |el, idx|
+			next if el.is_a?(FilterLexer::LogicalOperator)
+			operator = nil
+			operator = tree[idx - 1] if idx > 0
+			if el.is_a?(Array)
+				ast = join_ast(ast, arel_table.grouping(cleaned_to_arel(arel_table, el)), operator)
+			else
+				ast = join_ast(ast, el.to_arel(arel_table), operator)
+			end
+		end
+
+		return ast
+	end
+
+	# Merges an existing ast with the passed nodes and uses the operator as a merge operator
+	def self.join_ast(ast, nodes, operator)
+		if ast.nil? && !operator.nil?
+			raise InvalidFilterFormat, "Cannot join on nil tree with operator near #{operator.text_value}"
+		end
+		if operator.nil? || ast.nil?
+			ast = nodes
+		else
+			ast = ast.send(operator.to_arel, nodes)
+		end
+		return ast
+	end
+end
+
+class ActiveRecord::Base
+	def self.queryfy(queryparams)
+		filter = ''
+		offset = 0
+		limit = Queryfy::default_limit
+		if (queryparams.is_a?(Hash))
+			filter = queryparams['filter'] unless queryparams['filter'].nil?
+			offset = queryparams['offset'] unless queryparams['offset'].nil?
+			limit = queryparams['limit'] unless queryparams['limit'].nil?
+		elsif(queryparams.is_a?(String))
+			filter = queryparams
+		end
+		return Queryfy.build_query(self, filter, limit, offset)
+	end
+end

data/lib/queryfy/configuration.rb

@@ -0,0 +1,22 @@
+# Provides module configuration
+# Source: https://viget.com/extend/easy-gem-configuration-variables-with-defaults
+module Configuration
+	def configuration
+		yield self
+	end
+	def define_setting(name, default = nil)
+		class_variable_set("@@#{name}", default)
+		define_class_method "#{name}=" do |value|
+			class_variable_set("@@#{name}", value)
+		end
+		define_class_method name do
+			class_variable_get("@@#{name}")
+		end
+	end
+	private
+	def define_class_method(name, &block)
+		(class << self; self; end).instance_eval do
+			define_method name, &block
+		end
+	end
+end

data/lib/queryfy/filter_lexer/formatter.rb

@@ -0,0 +1,96 @@
+require 'queryfy/queryfy_errors'
+module FilterLexer
+	class Filter
+		# Converts a FilterLexer::Filter to an arel node
+		def to_arel(arel_table)
+			# Get the elements we want to operate on
+			field = elements[0].text_value
+			operator_method = elements[1].to_arel
+			val = elements[2].text_value
+
+			# Check if the field we want to filter on exists
+			field_index = arel_table.engine.column_names.index(field)
+
+			# Field does not exist, fail
+			if field_index.nil?
+				raise NoSuchFieldError, "Unknown field #{ field }"
+			else
+				# Get the arel field name from our input, just to make sure
+				# there is nothing weird is in the input
+				field = arel_table.engine.column_names[field_index]
+			end
+			ast_node = arel_table[field.to_sym]
+
+			# Build an arel node from the resolved operator, value and field
+			return ast_node.send(operator_method, val)
+		end
+	end
+
+	# The list below converts Filter::Operators to arel functions
+	class AndOperator
+		def to_arel
+			return 'and'
+		end
+	end
+
+	class OrOperator
+		def to_arel
+			return 'or'
+		end
+	end
+
+	class EQOperator
+		def to_arel
+			return 'eq'
+		end
+	end
+
+	class NEQOperator
+		def to_arel
+			return 'not_eq'
+		end
+	end
+
+	class LTOperator
+		def to_arel
+			return 'lt'
+		end
+	end
+
+	class LEOperator
+		def to_arel
+			return 'lteq'
+		end
+	end
+
+	class GTOperator
+		def to_arel
+			return 'gt'
+		end
+	end
+
+	class GEOperator
+		def to_arel
+			return 'gteq'
+		end
+	end
+
+	class NotLikeOperator
+		def to_arel
+			return 'does_not_match'
+		end
+	end
+
+	class LikeOperator
+		def to_arel
+			return 'matches'
+		end
+	end
+
+	class StringLiteral
+		def text_value
+			val = super
+			return val.gsub!(/\A["']|["']\Z/, '')
+		end
+	end
+end

data/lib/queryfy/queryfy_errors.rb

@@ -0,0 +1,12 @@
+# Base exception class
+class QueryfyError < StandardError
+end
+
+class FilterParseError < QueryfyError
+end
+
+class NoSuchFieldError < QueryfyError
+end
+
+class InvalidFilterFormat < QueryfyError
+end

data/lib/queryfy/version.rb

@@ -0,0 +1,3 @@
+module Queryfy
+  VERSION = "0.1.0"
+end

data/queryfy.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'queryfy/version'
+
+Gem::Specification.new do |spec|
+	spec.name          = "queryfy"
+	spec.version       = Queryfy::VERSION
+	spec.authors       = ["Bonemind"]
+	spec.email         = ["subhime@gmail.com"]
+
+	spec.summary       = %q{Query activerecord models based on query strings}
+	spec.description   = %q{Query activerecord models based on sql-like syntax with arbitratily deeply nested conditions}
+	spec.homepage      = "https://github.com/Bonemind/Queryfy"
+	spec.license       = "MIT"
+
+	# Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+	# delete this section to allow pushing this gem to any host.
+	if spec.respond_to?(:metadata)
+		spec.metadata['allowed_push_host'] = "https://rubygems.org"
+	else
+		raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+	end
+
+	spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+	spec.bindir        = "exe"
+	spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+	spec.require_paths = ["lib"]
+
+	spec.add_runtime_dependency 'filter_lexer', '~>0.2', '>= 0.2.1'
+	spec.add_development_dependency "bundler", "~> 1.10"
+	spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: queryfy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bonemind
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: filter_lexer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Query activerecord models based on sql-like syntax with arbitratily deeply
+  nested conditions
+email:
+- subhime@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/queryfy.rb
+- lib/queryfy/configuration.rb
+- lib/queryfy/filter_lexer/formatter.rb
+- lib/queryfy/queryfy_errors.rb
+- lib/queryfy/version.rb
+- queryfy.gemspec
+homepage: https://github.com/Bonemind/Queryfy
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Query activerecord models based on query strings
+test_files: []
+has_rdoc: