eric-keyword_search 1.4.0

data/lib/keyword_search.rl

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) << '/keyword_search/definition.rb'
+
+module KeywordSearch
+
+  class ParseError < ::SyntaxError; end  
+      
+  class << self
+  
+    %%{
+      
+      machine parser;
+      
+      action start {
+        tokstart = p;
+      }
+      
+      action key {
+        key = word
+        results[key] ||= []
+      }
+      
+      action default {
+        key = nil
+      }
+      
+      action word {
+        word = data[tokstart..p-1]
+      }
+      
+      action value {
+        (results[key || :default] ||= []) << [ word, positive_match ]
+      }
+      
+      action negative_match {
+        positive_match = false
+      }
+      
+      action positive_match {
+        positive_match = true
+      }
+      
+      action quote { quotes += 1 }
+      
+      action unquote { quotes -= 1 }
+
+      seperators = ' '+ | / *[,|] */ ;
+
+      bareword = ( [^ '"(:] . [^ "):]* ) > start % word ; # allow apostrophes
+      dquoted = '"' @ quote ( [^"]* > start % word ) :>> '"' @ unquote;
+      squoted = '\'' @ quote ( [^']* > start % word ) :>> '\'' @ unquote;
+
+      anyword = dquoted | squoted | bareword ;      
+
+      anyvalue = anyword % value ;
+      multivalues = anyvalue ( seperators anyvalue )* ;
+      groupedvalues = '(' @ quote multivalues :>> ')' @ unquote;
+
+      value = groupedvalues | anyvalue ;
+
+      pair = bareword % key ':' value ;
+
+      value_only = value > default ;
+      
+      match_mode = ('-' % negative_match | '+'? % positive_match ) ;
+
+      definition = match_mode? <: ( pair | value_only ) ;
+      
+      definitions = definition ( ' '+ definition )*;
+
+      main := ' '* definitions? ' '* 0
+              @!{ raise ParseError, "At offset #{p}, near: '#{data[p,10]}'" };        
+
+    }%%
+    
+    def search(input_string, definition=nil, &block)
+      definition ||= Definition.new(&block)
+      results = parse(input_string)
+      results.each do |key, terms|
+        definition.handle(key, terms)
+      end
+      results
+    end
+    
+    #######
+    private
+    #######
+    
+    def parse(input) #:nodoc:
+      data = input + ' '
+      %% write data;
+    	p = 0
+      eof = nil
+      word = nil
+    	pe = data.length
+    	key = nil
+      positive_match = nil
+    	tokstart = nil
+    	results = {}
+    	quotes = 0
+      %% write init;
+      %% write exec;
+    	unless quotes.zero?
+    	  raise ParseError, "Unclosed quotes"
+    	end
+    	results
+    end
+    
+  end
+  
+end
+
+

data/lib/keyword_search/definition.rb

@@ -0,0 +1,59 @@
+module KeywordSearch
+  
+  class Definition
+    
+    class Keyword
+      
+      attr_reader :name, :description, :handler
+      def initialize(name, description=nil, &handler)
+        @name, @description = name, description
+        @handler = handler
+      end
+      
+      def handle(value, sign)
+        # If the handler is only expecting one argument, 
+        # only give them the positive matches
+        if handler.arity == 1
+          handler.call(value) if sign
+        else
+          handler.call(value, sign)
+        end
+      end
+      
+    end
+
+    def initialize
+      @default_keyword = nil
+      yield self if block_given?
+    end
+    
+    def keywords
+      @keywords ||= []
+    end
+
+    def keyword(name, description=nil, &block)
+      keywords << Keyword.new(name, description, &block)
+    end
+      
+    def default_keyword(name)
+      @default_keyword = name
+    end
+      
+    def handle(key, values)
+      key = @default_keyword if key == :default
+      return false unless key
+      true_values, false_values = *values.partition { |v| v[1] }
+      
+      # Get just the values
+      true_values.collect! { |v| v[0] }
+      false_values.collect! { |v| v[0] }
+      
+      if k = keywords.detect { |kw| kw.name == key.to_sym}
+        k.handle(true_values, true)
+        k.handle(false_values, false) if false_values.length > 0
+      end
+    end
+    
+  end
+  
+end

data/test/test_keyword_search.rb

@@ -0,0 +1,319 @@
+require 'test/unit'
+
+require 'rubygems' rescue nil
+require 'test/spec'
+
+require File.dirname(__FILE__) + '/../lib/keyword_search'
+  
+context "KeywordSearch" do
+  
+  NAME_AND_AGE = %<bruce williams age:26>
+  NAME_QUOTED_AND_AGE = %<"bruce williams" age:26>
+  NAME_AND_QUOTED_AGE = %<bruce williams age:"26">  
+  DEFAULT_AGE_WITH_QUOTED_AGE = %<26 name:"bruce williams">
+  DEFAULT_AGE_WITH_SINGLE_QUOTED_AGE = %<26 name:'bruce williams'>
+  NAME_WITH_NESTED_SINGLE_QUOTES = %<"d'arcy d'uberville" age:28>
+  NAME_AND_GROUPED_AGE = %<coda hale age:(27)>
+  NAME_AND_GROUPED_QUOTED_AGE = %<coda hale age:("27")>
+  NAME_AND_GROUPED_QUOTED_AGES = %<coda hale age:("27" 34 '48')>
+  GROUPED_NAMES_AND_AGE = %<(coda bruce 'hale' "williams") age:20>
+  
+  specify "default keyword" do
+    result = nil
+    KeywordSearch.search(NAME_AND_AGE) do |with|
+      with.default_keyword :name
+      with.keyword :name do |values|
+        result = values.join(' ')
+      end
+    end
+    assert_equal 'bruce williams', result
+  end
+  
+  specify "grouped default keywords" do
+    result = nil
+    KeywordSearch.search(GROUPED_NAMES_AND_AGE) do |with|
+      with.default_keyword :name
+      with.keyword :name do |values|
+        result = values
+      end
+    end
+    assert_equal ['coda', 'bruce', 'hale', 'williams'], result
+  end
+  
+  specify "unquoted keyword term" do
+    result = nil
+    KeywordSearch.search(NAME_AND_AGE) do |with|
+      with.keyword :age do |values|
+        result = Integer(values.first)
+      end
+    end
+    assert_equal 26, result    
+  end
+  
+  specify "unquoted grouped keyword term" do
+    result = nil
+    KeywordSearch.search(NAME_AND_GROUPED_AGE) do |with|
+      with.keyword :age do |values|
+        result = Integer(values.first)
+      end
+    end
+    assert_equal 27, result    
+  end
+  
+  specify "quoted grouped keyword term" do
+    result = nil
+    KeywordSearch.search(NAME_AND_GROUPED_QUOTED_AGE) do |with|
+      with.keyword :age do |values|
+        result = Integer(values.first)
+      end
+    end
+    assert_equal 27, result    
+  end
+  
+  specify "mixed grouped keyword terms" do
+    result = nil
+    KeywordSearch.search(NAME_AND_GROUPED_QUOTED_AGES) do |with|
+      with.keyword :age do |values|
+        result = values.map { |v| v.to_i }
+      end
+    end
+    assert_equal [27, 34, 48], result
+  end
+  
+  specify "quoted default keyword term" do
+    result = nil
+    KeywordSearch.search(NAME_QUOTED_AND_AGE) do |with|
+      with.default_keyword :name
+      with.keyword :name do |values|
+        result = values.join(' ')
+      end
+    end
+    assert_equal 'bruce williams', result    
+  end
+  
+  specify "quoted keyword term" do
+    result = nil
+    KeywordSearch.search(NAME_AND_QUOTED_AGE) do |with|
+      with.keyword :age do |values|
+        result = Integer(values.first)
+      end
+    end
+    assert_equal 26, result    
+  end
+  
+  specify "quoted keyword term with whitespace" do
+    result = nil
+    KeywordSearch.search(DEFAULT_AGE_WITH_QUOTED_AGE) do |with|
+      with.default_keyword :age
+      with.keyword :name do |values|
+        result = values.first
+      end
+    end
+    assert_equal 'bruce williams', result    
+  end
+  
+  specify "single quoted keyword term with whitespace" do
+    result = nil    
+    r = KeywordSearch.search(DEFAULT_AGE_WITH_SINGLE_QUOTED_AGE) do |with|
+      with.default_keyword :age
+      with.keyword :name do |values|
+        result = values.first
+      end
+    end
+    assert_equal 'bruce williams', result    
+  end
+  
+  specify "nested single quote is accumulated" do
+    result = nil
+    KeywordSearch.search(NAME_WITH_NESTED_SINGLE_QUOTES) do |with|
+      with.default_keyword :name
+      with.keyword :name do |values|
+        result = values.first
+      end
+    end
+    assert_equal %<d'arcy d'uberville>, result    
+  end
+  
+  specify "nested double quote is accumulated" do
+    result = nil
+    KeywordSearch.search(%<'he was called "jake"'>) do |with|
+      with.default_keyword :text
+      with.keyword :text do |values|
+        result = values.first
+      end
+    end
+    assert_equal %<he was called "jake">, result    
+  end
+  
+  specify "bare single quote in unquoted literal is accumulated" do
+    result = nil
+    KeywordSearch.search(%<bruce's age:27>) do |with|
+      with.default_keyword :text
+      with.keyword :text do |values|
+        result = values.first
+      end
+    end
+    assert_equal %<bruce's>, result    
+  end
+  
+  specify "single quoted literal is accumulated" do
+    result = nil
+    KeywordSearch.search(%<foo 'bruce williams' age:27>) do |with|
+      with.default_keyword :text
+      with.keyword :text do |values|
+        result = values.last
+      end
+    end
+    assert_equal %<bruce williams>, result    
+  end
+  
+  specify "period in literal is accumulated" do
+    result = nil
+    KeywordSearch.search(%<okay... age:27>) do |with|
+      with.default_keyword :text
+      with.keyword :text do |values|
+        result = values.first
+      end
+    end
+    assert_equal %<okay...>, result    
+  end
+  
+  specify "parse error results in exception" do
+    assert_raises(KeywordSearch::ParseError) do
+      KeywordSearch.search(%<we_do_not_allow:! or ::>) do |with|
+        with.default_keyword :text
+        with.keyword :text do |values|
+          result = values.first
+        end
+      end
+    end
+  end
+  
+  specify "can use apostrophes in unquoted literal" do
+    result = nil
+    KeywordSearch.search(%<d'correct>) do |with|
+      with.default_keyword :text
+      with.keyword :text do |values|
+        result = values.first
+      end
+    end
+    assert_equal "d'correct", result
+  end
+  
+  specify "can use apostrophes in unquoted literal values" do
+    result = nil
+    KeywordSearch.search(%<text:d'correct>) do |with|
+      with.default_keyword :text
+      with.keyword :text do |values|
+        result = values.first
+      end
+    end
+    assert_equal "d'correct", result
+  end
+  
+  specify "cannot use an apostrophe at the beginning on an unquoted literal" do
+    assert_raises(KeywordSearch::ParseError) do
+      KeywordSearch.search(%<'thisiswrong>) do |with|
+        with.default_keyword :text
+        with.keyword :text do |values|
+          result = values.first
+        end
+      end
+    end
+  end
+  
+  specify "keywords are case sensitive" do
+    result = nil
+    KeywordSearch.search(%<Text:justtesting>) do |with|
+      with.keyword :text do |values|
+        result = :small
+      end
+      with.keyword :Text do |values|
+        result = :big
+      end      
+    end
+    assert_equal :big, result
+  end
+  
+  specify "values are case sensitive" do
+    result = nil
+    KeywordSearch.search(%<text:Big>) do |with|
+      with.keyword :text do |values|
+        result = values.first
+      end
+    end
+    assert_equal 'Big', result
+  end
+  
+  specify "spaces are condensed" do
+    result = nil
+    KeywordSearch.search(%<   this   is    some    text   >) do |with|
+      with.default_keyword :text
+      with.keyword :text do |values|
+        result = values
+      end
+    end
+    assert_equal [], result.select { |v| v.match(/ /) }
+  end
+  
+  specify "an empty search is successful" do
+    result = nil
+    KeywordSearch.search(%<>) do |with|
+      with.default_keyword :text
+      with.keyword :text do |values|
+        result = values
+      end
+    end
+    assert_nil result
+  end
+  
+  specify 'a negative search' do
+    result = nil
+
+    KeywordSearch.search(%<-site:google.com>) do |with|
+      with.keyword :site do |values, positive|
+        result = [ values, positive ]
+      end
+    end
+    assert_equal [ [ 'google.com' ], false ], result
+  end
+
+  specify 'a positive search' do
+    result = nil
+
+    KeywordSearch.search(%<+site:google.com>) do |with|
+      with.keyword :site do |values, positive|
+        result = [ values, positive ]
+      end
+    end
+    assert_equal [ [ 'google.com' ], true ], result
+  end
+
+  specify 'a search with no sign' do
+    result = nil
+
+    KeywordSearch.search(%<site:google.com>) do |with|
+      with.keyword :site do |values, positive|
+        result = [ values, positive ]
+      end
+    end
+    assert_equal [ [ 'google.com' ], true ], result
+  end
+
+  specify 'a term should default to positive with no sign' do
+    result = nil
+
+    KeywordSearch.search(%<-site:google.com inurl:atom>) do |with|
+      with.keyword :inurl do |values, positive|
+        result = [ values, positive ]
+      end
+    end
+    assert_equal [ [ 'atom' ], true ], result
+  end
+end
+
+
+
+
+
+