minidusen 0.7.0

data/lib/minidusen/token.rb

@@ -0,0 +1,25 @@
+module Minidusen
+  class Token
+
+    attr_reader :field, :value, :exclude
+
+    def initialize(options)
+      @value = options.fetch(:value)
+      @exclude = options.fetch(:exclude)
+      @field = options.fetch(:field).to_s
+    end
+
+    def to_s
+      value
+    end
+
+    def text?
+      field == 'text'
+    end
+
+    def exclude?
+      exclude
+    end
+
+  end
+end

data/lib/minidusen/util.rb

@@ -0,0 +1,55 @@
+module Minidusen
+  module Util
+    extend self
+
+    def postgres?(scope)
+      adapter_name = scope.connection.class.name
+      adapter_name =~ /postgres/i
+    end
+
+    def like_expression(phrase)
+      "%#{escape_for_like_query(phrase)}%"
+    end
+
+    def ilike_operator(scope)
+      if postgres?(scope)
+        'ILIKE'
+      else
+        'LIKE'
+      end
+    end
+
+    def regexp_operator(scope)
+      if postgres?(scope)
+        '~'
+      else
+        'REGEXP'
+      end
+    end
+
+    def escape_with_backslash(phrase, characters)
+      characters << '\\'
+      pattern = /[#{characters.collect(&Regexp.method(:quote)).join('')}]/
+      # debugger
+      phrase.gsub(pattern) do |match|
+        "\\#{match}"
+      end
+    end
+
+    def escape_for_like_query(phrase)
+      # phrase.gsub("%", "\\%").gsub("_", "\\_")
+      escape_with_backslash(phrase, ['%', '_'])
+    end
+
+    def qualify_column_name(model, column_name)
+      column_name = column_name.to_s
+      unless column_name.include?('.')
+        quoted_table_name = model.connection.quote_table_name(model.table_name)
+        quoted_column_name = model.connection.quote_column_name(column_name)
+        column_name = "#{quoted_table_name}.#{quoted_column_name}"
+      end
+      column_name
+    end
+
+  end
+end

data/lib/minidusen/version.rb

@@ -0,0 +1,3 @@
+module Minidusen
+  VERSION = '0.7.0'
+end

data/minidusen.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "minidusen/version"
+
+Gem::Specification.new do |s|
+  s.name = 'minidusen'
+  s.version = Minidusen::VERSION
+  s.authors = ["Henning Koch"]
+  s.email = 'henning.koch@makandra.de'
+  s.homepage = 'https://github.com/makandra/minidusen'
+  s.summary = 'Low-tech search for ActiveRecord with MySQL or PostgreSQL'
+  s.description = s.summary
+  s.license = 'MIT'
+
+  s.files         = `git ls-files`.split("\n").reject { |path| File.lstat(path).symlink? }
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n").reject { |path| File.lstat(path).symlink? }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('activesupport', '>=3.2')
+  s.add_dependency('activerecord', '>=3.2')
+  s.add_dependency('edge_rider', '>=0.2.5')
+
+end

data/spec/minidusen/active_record_ext_spec.rb

@@ -0,0 +1,45 @@
+describe ActiveRecord::Base do
+
+  describe '.where_like' do
+
+    it 'matches a record if a word appears in any of the given columns' do
+      match1 = User.create!(:name => 'word', :city => 'XXXX')
+      match2 = User.create!(:name => 'XXXX', :city => 'word')
+      no_match = User.create!(:name => 'XXXX', :city => 'XXXX')
+      User.where_like([:name, :city] => 'word').to_a.should =~ [match1, match2]
+    end
+
+    it 'matches a record if it contains all the given words' do
+      match1 = User.create!(:city => 'word1 word2')
+      match2 = User.create!(:city => 'word2 word1')
+      no_match = User.create!(:city => 'word1')
+      User.where_like(:city => ['word1', 'word2']).to_a.should =~ [match1, match2]
+    end
+
+    describe 'with :negate option' do
+
+      it 'rejects a record if a word appears in any of the given columns' do
+        no_match1 = User.create!(:name => 'word', :city => 'XXXX')
+        no_match2 = User.create!(:name => 'XXXX', :city => 'word')
+        match = User.create!(:name => 'XXXX', :city => 'XXXX')
+        User.where_like({ [:name, :city] => 'word' }, :negate => true).to_a.should =~ [match]
+      end
+
+      it 'rejects a record if it matches at least one of the given words' do
+        no_match1 = User.create!(:city => 'word1')
+        no_match2 = User.create!(:city => 'word2')
+        match = User.create!(:city => 'word3')
+        User.where_like({ :city => ['word1', 'word2'] }, :negate => true).to_a.should =~ [match]
+      end
+
+      it "doesn't match NULL values" do
+        no_match = User.create!(:city => nil)
+        match = User.create!(:city => 'word3')
+        User.where_like({ :city => ['word1'] }, :negate => true).to_a.should =~ [match]
+      end
+
+    end
+
+  end
+
+end

data/spec/minidusen/filter_spec.rb

@@ -0,0 +1,196 @@
+describe Minidusen::Filter do
+
+  let :user_filter do
+    UserFilter.new
+  end
+
+  let :recipe_filter do
+    RecipeFilter.new
+  end
+
+  describe '#filter' do
+
+    it 'should find records by given words' do
+      match = User.create!(:name => 'Abraham')
+      no_match = User.create!(:name => 'Elizabath')
+      user_filter.filter(User, 'Abraham').to_a.should == [match]
+    end
+
+    it 'should make a case-insensitive search' do
+      match = User.create!(:name => 'Abraham')
+      no_match = User.create!(:name => 'Elizabath')
+      user_filter.filter(User, 'aBrAhAm').to_a.should == [match]
+    end
+
+    it 'should not find stale text after fields were updated (bugfix)' do
+      match = User.create!(:name => 'Abraham')
+      no_match = User.create!(:name => 'Elizabath')
+      match.update_attributes!(:name => 'Johnny')
+      user_filter.filter(User, 'Abraham').to_a.should be_empty
+      user_filter.filter(User, 'Johnny').to_a.should == [match]
+    end
+
+    it 'should AND multiple words' do
+      match = User.create!(:name => 'Abraham Lincoln')
+      no_match = User.create!(:name => 'Abraham')
+      user_filter.filter(User, 'Abraham Lincoln').to_a.should == [match]
+    end
+
+    it 'should find records by phrases' do
+      match = User.create!(:name => 'Abraham Lincoln')
+      no_match = User.create!(:name => 'Abraham John Lincoln')
+      user_filter.filter(User, '"Abraham Lincoln"').to_a.should == [match]
+    end
+
+    it 'should find records by qualified fields' do
+      match = User.create!(:name => 'foo@bar.com', :email => 'foo@bar.com')
+      no_match = User.create!(:name => 'foo@bar.com', :email => 'bam@baz.com')
+      user_filter.filter(User, 'email:foo@bar.com').to_a.should == [match]
+    end
+
+    it 'should find no records if a nonexistent qualifier is used' do
+      User.create!(:name => 'someuser', :email => 'foo@bar.com')
+      user_filter.filter(User, 'nonexistent_qualifier:someuser email:foo@bar.com').to_a.should == []
+    end
+
+    it 'should allow phrases as values for qualified field queries' do
+      match = User.create!(:name => 'Foo Bar', :city => 'Foo Bar')
+      no_match = User.create!(:name => 'Foo Bar', :city => 'Bar Foo')
+      user_filter.filter(User, 'city:"Foo Bar"').to_a.should == [match]
+    end
+
+    it 'should allow to mix multiple types of tokens in a single query' do
+      match = User.create!(:name => 'Abraham', :city => 'Foohausen')
+      no_match = User.create!(:name => 'Abraham', :city => 'Barhausen')
+      user_filter.filter(User, 'Foo city:Foohausen').to_a.should == [match]
+    end
+
+    it 'should not find records from another model' do
+      match = User.create!(:name => 'Abraham')
+      Recipe.create!(:name => 'Abraham')
+      user_filter.filter(User, 'Abraham').to_a.should == [match]
+    end
+
+    it 'should find words where one letter is separated from other letters by a period' do
+      match = User.create!(:name => 'E.ONNNEN')
+      user_filter.filter(User, 'E.ONNNEN').to_a.should == [match]
+    end
+
+    it 'should find words where one letter is separated from other letters by a semicolon' do
+      match = User.create!(:name => 'E;ONNNEN')
+      user_filter.filter(User, 'E;ONNNEN')
+      user_filter.filter(User, 'E;ONNNEN').to_a.should == [match]
+    end
+
+    it 'should distinguish between "Baden" and "Baden-Baden" (bugfix)' do
+      match = User.create!(:city => 'Baden-Baden')
+      no_match = User.create!(:city => 'Baden')
+      user_filter.filter(User, 'Baden-Baden').to_a.should == [match]
+    end
+
+    it 'should handle umlauts and special characters' do
+      match = User.create!(:city => 'púlvérìsätëûr')
+      user_filter.filter(User, 'púlvérìsätëûr').to_a.should == [match]
+    end
+
+    context 'with excludes' do
+
+      it 'should exclude words with prefix - (minus)' do
+        match = User.create!(:name => 'Sunny Flower')
+        no_match = User.create!(:name => 'Sunny Power')
+        no_match2 = User.create!(:name => 'Absolutly no match')
+        user_filter.filter(User, 'Sunny -Power').to_a.should == [match]
+      end
+
+      it 'should exclude phrases with prefix - (minus)' do
+        match = User.create!(:name => 'Buch Tastatur Schreibtisch')
+        no_match = User.create!(:name => 'Buch Schreibtisch Tastatur')
+        no_match2 = User.create!(:name => 'Absolutly no match')
+        user_filter.filter(User, 'Buch -"Schreibtisch Tastatur"').to_a.should == [match]
+      end
+
+      it 'should exclude qualified fields with prefix - (minus)' do
+        match = User.create!(:name => 'Abraham', :city => 'Foohausen')
+        no_match = User.create!(:name => 'Abraham', :city => 'Barhausen')
+        no_match2 = User.create!(:name => 'Absolutly no match')
+        user_filter.filter(User, 'Abraham -city:Barhausen').to_a.should == [match]
+      end
+
+      it 'should work if the query only contains excluded words' do
+        match = User.create!(:name => 'Sunny Flower')
+        no_match = User.create!(:name => 'Sunny Power')
+        user_filter.filter(User, '-Power').to_a.should == [match]
+      end
+
+      it 'should work if the query only contains excluded phrases' do
+        match = User.create!(:name => 'Buch Tastatur Schreibtisch')
+        no_match = User.create!(:name => 'Buch Schreibtisch Tastatur')
+        user_filter.filter(User, '-"Schreibtisch Tastatur"').to_a.should == [match]
+      end
+
+      it 'should work if the query only contains excluded qualified fields' do
+        match = User.create!(:name => 'Abraham', :city => 'Foohausen')
+        no_match = User.create!(:name => 'Abraham', :city => 'Barhausen')
+        user_filter.filter(User, '-city:Barhausen').to_a.should == [match]
+      end
+
+      it 'respects an existing scope chain when there are only excluded tokens (bugfix)' do
+        match = User.create!(:name => 'Abraham', :city => 'Foohausen')
+        no_match = User.create!(:name => 'Abraham', :city => 'Barhausen')
+        also_no_match = User.create!(:name => 'Bebraham', :city => 'Foohausen')
+        user_scope = User.scoped(:conditions => { :name => 'Abraham' })
+        user_filter.filter(user_scope, '-Barhausen').to_a.should == [match]
+      end
+
+      it 'should work if there are fields contained in the search that are NULL' do
+        match = User.create!(:name => 'Sunny Flower', :city => nil, :email => nil)
+        no_match = User.create!(:name => 'Sunny Power', :city => nil, :email => nil)
+        no_match2 = User.create!(:name => 'Absolutly no match')
+        user_filter.filter(User, 'Sunny -Power').to_a.should == [match]
+      end
+
+      it 'should work if search_by contains a join (bugfix)' do
+        category1 = Recipe::Category.create!(:name => 'Rice')
+        category2 = Recipe::Category.create!(:name => 'Barbecue')
+        match = Recipe.create!(:name => 'Martini Chicken', :category => category1)
+        no_match = Recipe.create!(:name => 'Barbecue Chicken', :category => category2)
+        recipe_filter.filter(Recipe, 'Chicken -category:Barbecue').to_a.should == [match]
+      end
+
+      it 'should work when search_by uses SQL-Regexes which need to be "and"ed together by syntax#build_exclude_scope (bugfix)' do
+        match = User.create!(:name => 'Sunny Flower', :city => "Flower")
+        no_match = User.create!(:name => 'Sunny Power', :city => "Power")
+        user_filter.filter(User, '-name_and_city_regex:Power').to_a.should == [match]
+      end
+
+    end
+
+    context 'when the given query is blank' do
+
+      it 'returns all records' do
+        match = User.create!
+        user_filter.filter(User, '').scoped.to_a.should == [match]
+      end
+
+      it 'respects an existing scope chain' do
+        match = User.create!(:name => 'Abraham')
+        no_match = User.create!(:name => 'Elizabath')
+        scope = User.scoped(:conditions => { :name => 'Abraham' })
+        user_filter.filter(scope, '').scoped.to_a.should == [match]
+      end
+
+    end
+
+  end
+
+  describe '#minidusen_syntax' do
+
+    it "should return the model's syntax definition" do
+      syntax = UserFilter.send(:minidusen_syntax)
+      syntax.should be_a(Minidusen::Syntax)
+      syntax.fields.keys.should =~ ['text', 'email', 'city', 'role', 'name_and_city_regex']
+    end
+
+  end
+
+end

data/spec/minidusen/parser_spec.rb

@@ -0,0 +1,22 @@
+describe Minidusen::Parser do
+
+  describe '.parse' do
+
+    it 'should parse field tokens first, because they usually give maximum filtering at little cost' do
+      query = Minidusen::Parser.parse('word1 field1:field1-value word2 field2:field2-value')
+      query.collect(&:value).should == ['field1-value', 'field2-value', 'word1', 'word2']
+    end
+
+    it 'should not consider the dash to be a word boundary' do
+      query = Minidusen::Parser.parse('Baden-Baden')
+      query.collect(&:value).should == ['Baden-Baden']
+    end
+
+    it 'should parse umlauts and accents' do
+      query = Minidusen::Parser.parse('field:åöÙÔøüéíÁ "ÄüÊçñÆ ððÿáÒÉ" pulvérisateur pędzić')
+      query.collect(&:value).should == ['åöÙÔøüéíÁ', 'ÄüÊçñÆ ððÿáÒÉ', 'pulvérisateur', 'pędzić']
+    end
+
+  end
+
+end

data/spec/minidusen/query_spec.rb

@@ -0,0 +1,18 @@
+describe Minidusen::Query do
+
+  describe '#condensed' do
+
+    it 'should return a version of the query where all text tokens have been collapsed into a single token with an Array value' do
+      query = Minidusen::Parser.parse('field:value foo bar baz')
+      query.tokens.size.should == 4
+      condensed_query = query.condensed
+      condensed_query.tokens.size.should == 2
+      condensed_query[0].field.should == 'field'
+      condensed_query[0].value.should == 'value'
+      condensed_query[1].field.should == 'text'
+      condensed_query[1].value.should == ['foo', 'bar', 'baz']
+    end
+
+  end
+
+end

data/spec/minidusen/util_spec.rb

@@ -0,0 +1,3 @@
+describe Minidusen::Util do
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+$: << File.join(File.dirname(__FILE__), "/../../lib" )
+
+require 'minidusen'
+require 'byebug'
+
+ActiveRecord::Base.default_timezone = :local
+
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].sort.each {|f| require f}
+Dir["#{File.dirname(__FILE__)}/shared_examples/*.rb"].sort.each {|f| require f}
+
+
+RSpec.configure do |config|
+
+  config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
+
+  config.around do |example|
+    if example.metadata.fetch(:rollback, true)
+      ActiveRecord::Base.transaction do
+        begin
+          example.run
+        ensure
+          raise ActiveRecord::Rollback
+        end
+      end
+    else
+      example.run
+    end
+  end
+end

data/spec/support/database.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+
+database_config_file = ENV['TRAVIS'] ? 'database.travis.yml' : 'database.yml'
+database_config_file = File.join(File.dirname(__FILE__), database_config_file)
+File.exists?(database_config_file) or raise "Missing database configuration file: #{database_config_file}"
+
+database_config = YAML.load_file(database_config_file)
+
+connection_config = {}
+
+case ENV['BUNDLE_GEMFILE']
+when /pg/, /postgres/
+  connection_config = database_config['postgresql'].merge(adapter: 'postgresql')
+when /mysql2/
+  connection_config = database_config['mysql'].merge(adapter: 'mysql2', encoding: 'utf8')
+else
+  raise "Unknown database type in Gemfile suffix: #{ENV['BUNDLE_GEMFILE']}"
+end
+
+ActiveRecord::Base.establish_connection(connection_config)
+
+
+connection = ::ActiveRecord::Base.connection
+connection.tables.each do |table|
+  connection.drop_table table
+end
+
+ActiveRecord::Migration.class_eval do
+
+  create_table :users do |t|
+    t.string :name
+    t.string :email
+    t.string :city
+  end
+
+  create_table :recipes do |t|
+    t.string :name
+    t.integer :category_id
+  end
+
+  create_table :recipe_ingredients do |t|
+    t.string :name
+    t.integer :recipe_id
+  end
+
+  create_table :recipe_categories do |t|
+    t.string :name
+  end
+
+end