minidusen 0.7.0

data/gemfiles/Gemfile.4.2.pg

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~>4.2.1'
+gem 'rspec', '~>3.4'
+gem 'pg'
+
+gem 'byebug'
+
+gem 'minidusen', :path => '..'

data/gemfiles/Gemfile.4.2.pg.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: ..
+  specs:
+    minidusen (0.7.0)
+      activerecord (>= 3.2)
+      activesupport (>= 3.2)
+      edge_rider (>= 0.2.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.5)
+      activesupport (= 4.2.5)
+      builder (~> 3.1)
+    activerecord (4.2.5)
+      activemodel (= 4.2.5)
+      activesupport (= 4.2.5)
+      arel (~> 6.0)
+    activesupport (4.2.5)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.3)
+    builder (3.2.2)
+    byebug (8.2.0)
+    diff-lcs (1.2.5)
+    edge_rider (0.3.1)
+      activerecord
+    i18n (0.7.0)
+    json (1.8.3)
+    minitest (5.8.3)
+    pg (0.18.4)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 4.2.1)
+  byebug
+  minidusen!
+  pg
+  rspec (~> 3.4)
+
+BUNDLED WITH
+   1.12.5

data/gemfiles/Gemfile.5.0.mysql2

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~>5.0.0'
+gem 'rspec', '~>3.5'
+gem 'mysql2', '~>0.4.4'
+
+gem 'byebug'
+
+gem 'minidusen', :path => '..'

data/gemfiles/Gemfile.5.0.mysql2.lock

@@ -0,0 +1,60 @@
+PATH
+  remote: ..
+  specs:
+    minidusen (0.7.0)
+      activerecord (>= 3.2)
+      activesupport (>= 3.2)
+      edge_rider (>= 0.2.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.0.0.1)
+      activesupport (= 5.0.0.1)
+    activerecord (5.0.0.1)
+      activemodel (= 5.0.0.1)
+      activesupport (= 5.0.0.1)
+      arel (~> 7.0)
+    activesupport (5.0.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (7.1.2)
+    byebug (9.0.5)
+    concurrent-ruby (1.0.2)
+    diff-lcs (1.2.5)
+    edge_rider (0.3.1)
+      activerecord
+    i18n (0.7.0)
+    minitest (5.9.0)
+    mysql2 (0.4.4)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.3)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 5.0.0)
+  byebug
+  minidusen!
+  mysql2 (~> 0.4.4)
+  rspec (~> 3.5)
+
+BUNDLED WITH
+   1.12.5

data/gemfiles/Gemfile.5.0.pg

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~>5.0.0'
+gem 'rspec', '~>3.5'
+gem 'pg', '~>0.18.4'
+
+gem 'byebug'
+
+gem 'minidusen', :path => '..'

data/gemfiles/Gemfile.5.0.pg.lock

@@ -0,0 +1,60 @@
+PATH
+  remote: ..
+  specs:
+    minidusen (0.7.0)
+      activerecord (>= 3.2)
+      activesupport (>= 3.2)
+      edge_rider (>= 0.2.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.0.0.1)
+      activesupport (= 5.0.0.1)
+    activerecord (5.0.0.1)
+      activemodel (= 5.0.0.1)
+      activesupport (= 5.0.0.1)
+      arel (~> 7.0)
+    activesupport (5.0.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (7.1.2)
+    byebug (9.0.5)
+    concurrent-ruby (1.0.2)
+    diff-lcs (1.2.5)
+    edge_rider (0.3.1)
+      activerecord
+    i18n (0.7.0)
+    minitest (5.9.0)
+    pg (0.18.4)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.3)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 5.0.0)
+  byebug
+  minidusen!
+  pg (~> 0.18.4)
+  rspec (~> 3.5)
+
+BUNDLED WITH
+   1.12.5

data/lib/minidusen.rb

@@ -0,0 +1,12 @@
+require 'active_support'
+require 'active_record'
+require 'edge_rider'
+
+require 'minidusen/version'
+require 'minidusen/util'
+require 'minidusen/token'
+require 'minidusen/parser'
+require 'minidusen/query'
+require 'minidusen/syntax'
+require 'minidusen/filter'
+require 'minidusen/active_record_ext'

data/lib/minidusen/active_record_ext.rb

@@ -0,0 +1,39 @@
+module Minidusen
+  module ActiveRecordExtensions
+    module ClassMethods
+
+      def where_like(conditions, options = {})
+        scope = scoped
+
+        ilike_operator = Util.ilike_operator(scope)
+
+        if options[:negate]
+          match_operator = "NOT #{ilike_operator}"
+          join_operator = 'AND'
+        else
+          match_operator = ilike_operator
+          join_operator = 'OR'
+        end
+
+        conditions.each do |field_or_fields, query|
+          fields = Array(field_or_fields).collect do |field|
+            Util.qualify_column_name(scope, field)
+          end
+          Array.wrap(query).each do |phrase|
+            phrase_with_placeholders = fields.collect { |field|
+              "#{field} #{match_operator} ?"
+            }.join(" #{join_operator} ")
+            like_expression = Minidusen::Util.like_expression(phrase)
+            bindings = [like_expression] * fields.size
+            conditions = [ phrase_with_placeholders, *bindings ]
+            scope = scope.where(conditions)
+          end
+        end
+        scope
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, Minidusen::ActiveRecordExtensions::ClassMethods)

data/lib/minidusen/filter.rb

@@ -0,0 +1,31 @@
+module Minidusen
+  module Filter
+    module ClassMethods
+
+      private
+
+      attr_accessor :minidusen_syntax
+
+      def filter(field, &block)
+        minidusen_syntax.learn_field(field, &block)
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:minidusen_syntax=, Syntax.new)
+    end
+
+    def filter(scope, query)
+      minidusen_syntax.search(scope, query)
+    end
+
+    private
+
+    def minidusen_syntax
+      self.class.send(:minidusen_syntax)
+    end
+
+  end
+end

data/lib/minidusen/parser.rb

@@ -0,0 +1,35 @@
+module Minidusen
+  class Parser
+
+    TEXT_QUERY = /(?:(\-)?"([^"]+)"|(\-)?([\S]+))/
+    FIELD_QUERY = /(\-)?(\w+)\:#{TEXT_QUERY}/
+
+    def self.parse(query_string)
+      query_string = query_string.dup # we are going to delete substrings in-place
+      query = Query.new
+      extract_field_query_tokens(query_string, query)
+      extract_text_query_tokens(query_string, query)
+      query
+    end
+
+    def self.extract_text_query_tokens(query_string, query)
+      while query_string.sub!(TEXT_QUERY, '')
+        value = "#{$2}#{$4}"
+        exclude = "#{$1}#{$3}" == "-"
+        options = { :field => 'text', :value => value, :exclude => exclude }
+        query << Token.new(options)
+      end
+    end
+
+    def self.extract_field_query_tokens(query_string, query)
+      while query_string.sub!(FIELD_QUERY, '')
+        field = $2
+        value = "#{$4}#{$6}"
+        exclude = "#{$1}" == "-"
+        options = { :field => field, :value => value, :exclude => exclude }
+        query << Token.new(options)
+      end
+    end
+
+  end
+end

data/lib/minidusen/query.rb

@@ -0,0 +1,54 @@
+module Minidusen
+  class Query
+
+    include Enumerable
+
+    attr_reader :tokens
+
+    def initialize(initial_tokens = [])
+      @tokens = initial_tokens
+    end
+
+    def <<(token)
+      tokens << token
+    end
+
+    def [](index)
+      tokens[index]
+    end
+
+    def to_s
+      collect(&:to_s).join(" + ")
+    end
+
+    def each(&block)
+      tokens.each(&block)
+    end
+
+    def condensed
+      include_texts = include.select(&:text?).collect(&:value)
+      exclude_texts = exclude.select(&:text?).collect(&:value)
+      field_tokens = tokens.reject(&:text?)
+
+      condensed_tokens = field_tokens
+      if include_texts.present?
+        options = { :field => 'text', :value => include_texts, :exclude => false }
+        condensed_tokens << Token.new(options)
+      end
+      if exclude_texts.present?
+        options = { :field => 'text', :value => exclude_texts, :exclude => true }
+        condensed_tokens << Token.new(options)
+      end
+      self.class.new(condensed_tokens)
+    end
+
+    def include
+      self.class.new tokens.reject(&:exclude?)
+    end
+
+    def exclude
+      self.class.new tokens.select(&:exclude?)
+    end
+
+  end
+end

data/lib/minidusen/syntax.rb

@@ -0,0 +1,54 @@
+module Minidusen
+  class Syntax
+
+    def initialize
+      @scopers = {}
+    end
+
+    def learn_field(field, &scoper)
+      field = field.to_s
+      @scopers[field] = scoper
+    end
+
+    def search(root_scope, query)
+      query = parse(query) if query.is_a?(String)
+      query = query.condensed
+      matches = apply_query(root_scope, query.include)
+      if query.exclude.any?
+        matches = append_excludes(matches, query.exclude)
+      end
+      matches
+    end
+
+    def fields
+      @scopers
+    end
+
+    def parse(query)
+      Parser.parse(query)
+    end
+
+    private
+
+    NONE = lambda do |scope, *args|
+      scope.where('1=2')
+    end
+
+    def apply_query(root_scope, query)
+      scope = root_scope
+      query.each do |token|
+        scoper = @scopers[token.field] || NONE
+        scope = scoper.call(scope, token.value)
+      end
+      scope
+    end
+
+    def append_excludes(matches, exclude_query)
+      excluded_records = apply_query(matches.origin_class, exclude_query)
+      qualified_id_field = Util.qualify_column_name(excluded_records, excluded_records.primary_key)
+      exclude_sql = "#{qualified_id_field} NOT IN (#{excluded_records.select(qualified_id_field).to_sql})"
+      matches.where(exclude_sql)
+    end
+
+  end
+end