tsearch 1.0.5

data/lib/texticle.rb

@@ -0,0 +1,78 @@
+require 'texticle/full_text_index'
+
+####
+# Texticle exposes full text search capabilities from PostgreSQL, and allows
+# you to declare full text indexes.  Texticle will extend ActiveRecord with
+# named_scope methods making searching easy and fun!
+#
+# Texticle.index is automatically added to ActiveRecord::Base.
+#
+# To declare an index on a model, just use the index method:
+#
+#   class Product < ActiveRecord::Base
+#     index do
+#       name
+#       description
+#     end
+#   end
+#
+# This will allow you to do full text search on the name and description
+# columns for the Product model.  It defines a named_scope method called
+# "search", so you can take advantage of the search like this:
+#
+#   Product.search('foo bar')
+#
+# Indexes may also be named.  For example:
+#
+#   class Product < ActiveRecord::Base
+#     index 'author' do
+#       name
+#       author
+#     end
+#   end
+#
+# A named index will add a named_scope with the index name prefixed by
+# "search".  In order to take advantage of the "author" index, just call:
+#
+#   Product.search_author('foo bar')
+#
+# Finally, column names can be ranked.  The ranks are A, B, C, and D.  This
+# lets us declare that matches in the "name" column are more important
+# than matches in the "description" column:
+#
+#   class Product < ActiveRecord::Base
+#     index do
+#       name          'A'
+#       description   'B'
+#     end
+#   end
+module Texticle
+  # The version of Texticle you are using.
+  VERSION = '1.0.2'
+
+  # A list of full text indexes
+  attr_accessor :full_text_indexes
+
+  ###
+  # Create an index with +name+ using +dictionary+
+  def index name = nil, dictionary = 'english', &block
+    search_name = ['search', name].compact.join('_')
+
+    class_eval do
+      named_scope search_name.to_sym, lambda { |term|
+        p = Texticle::Parser.new
+        term = p.parse(term)
+        {
+          :select => "#{table_name}.*, ts_rank_cd((#{full_text_indexes.first.to_s}),
+            to_tsquery(#{connection.quote(term)})) as rank",
+          :conditions =>
+            ["#{full_text_indexes.first.to_s} @@ to_tsquery(?)", term],
+          :order => 'rank DESC'
+        }
+      }
+    end
+    index_name = [table_name, name, 'fts_idx'].compact.join('_')
+    (self.full_text_indexes ||= []) <<
+      FullTextIndex.new(index_name, dictionary, self, &block)
+  end
+end

data/lib/texticle/full_text_index.rb

@@ -0,0 +1,54 @@
+module Texticle
+  class FullTextIndex # :nodoc:
+    attr_accessor :index_columns
+
+    def initialize name, dictionary, model_class, &block
+      @name           = name
+      @dictionary     = dictionary
+      @model_class    = model_class
+      @index_columns  = {}
+      @string         = nil
+      instance_eval(&block)
+    end
+
+    def create
+      @model_class.connection.execute create_sql
+    end
+
+    def destroy
+      @model_class.connection.execute destroy_sql
+    end
+
+    def create_sql
+      <<-eosql
+        CREATE index #{@name}
+        ON #{@model_class.table_name}
+        USING gin((#{to_s}))
+      eosql
+    end
+
+    def destroy_sql
+      "DROP index IF EXISTS #{@name}"
+    end
+
+    def to_s
+      return @string if @string
+      vectors = []
+      @index_columns.sort_by { |k,v| k }.each do |weight, columns|
+        c = columns.map { |x| "coalesce(#{@model_class.table_name}.#{x}, '')" }
+        if weight == 'none'
+          vectors << "to_tsvector('#{@dictionary}', #{c.join(" || ' ' || ")})"
+        else
+          vectors <<
+        "setweight(to_tsvector('#{@dictionary}', #{c.join(" || ' ' || ")}), '#{weight}')"
+        end
+      end
+      @string = vectors.join(" || ' ' || ")
+    end
+
+    def method_missing name, *args
+      weight = args.shift || 'none'
+      (index_columns[weight] ||= []) << name.to_s
+    end
+  end
+end

data/lib/texticle/nodes/and_term_node.rb

@@ -0,0 +1,5 @@
+class AndTermNode < Treetop::Runtime::SyntaxNode
+  def to_tquery
+    " & #{term.to_tquery}"
+  end
+end

data/lib/texticle/nodes/boolean_term_node.rb

@@ -0,0 +1,2 @@
+class BooleanTermNode < Treetop::Runtime::SyntaxNode
+end

data/lib/texticle/nodes/expression_node.rb

@@ -0,0 +1,17 @@
+class ExpressionNode < Treetop::Runtime::SyntaxNode
+  def to_tquery
+    buffer = []
+    elements[0].elements.each do |elem|
+      if elem.respond_to?(:to_tquery)
+        t = elem.to_tquery
+        if t =~ /^\s+(\||&).*$/ || buffer.empty?
+          buffer << t
+        else
+          buffer << " | " + t
+        end
+      end
+    end
+    
+    buffer.join(' ')
+  end
+end

data/lib/texticle/nodes/grouped_term_node.rb

@@ -0,0 +1,15 @@
+class GroupedTermNode < Treetop::Runtime::SyntaxNode
+  def to_tquery
+    buffer = []
+    elements[1].elements.each do |elem|
+      t = elem.to_tquery
+      if t =~ /^\s+(\||&).*$/ || buffer.empty?
+        buffer << t
+      else
+        buffer << " | " + t
+      end
+    end
+
+    '(' + buffer.join(' ') + ')'
+  end
+end

data/lib/texticle/nodes/not_term_node.rb

@@ -0,0 +1,5 @@
+class NotTermNode < Treetop::Runtime::SyntaxNode
+  def to_tquery
+    " & !#{term.to_tquery}"
+  end
+end

data/lib/texticle/nodes/or_term_node.rb

@@ -0,0 +1,5 @@
+class OrTermNode < Treetop::Runtime::SyntaxNode
+  def to_tquery
+    " | #{term.to_tquery}"
+  end
+end

data/lib/texticle/nodes/query_node.rb

@@ -0,0 +1,8 @@
+class QueryNode < Treetop::Runtime::SyntaxNode
+  def to_tquery
+    buffer = []
+    elements.each do |elem|
+      buffer << elem.to_tquery if elem.respond_to?(:to_tquery)
+    end
+  end
+end

data/lib/texticle/nodes/quoted_term_node.rb

@@ -0,0 +1,5 @@
+class QuotedTermNode < Treetop::Runtime::SyntaxNode
+  def to_tquery
+    "'" + elements[1].text_value + "'"
+  end
+end

data/lib/texticle/nodes/term_node.rb

@@ -0,0 +1,23 @@
+class TermNode < Treetop::Runtime::SyntaxNode
+# module TermNode
+  def to_tquery
+    terms = []
+    
+    return '' if elements.empty?
+    
+    elements.each do |child_elem|
+      next if child_elem.elements.empty?
+      if child_elem.respond_to?(:to_tquery)
+        terms << child_elem.to_tquery
+      else
+        child_elem.elements.each do |grand_child_elem|
+          if grand_child_elem.respond_to?(:to_tquery)
+            terms << grand_child_elem.to_tquery
+          end
+        end
+      end
+    end
+
+    terms.join(' ')
+  end
+end

data/lib/texticle/nodes/word_node.rb

@@ -0,0 +1,9 @@
+class WordNode < Treetop::Runtime::SyntaxNode
+  def to_tquery
+    word
+  end
+  
+  def word
+    text_value
+  end
+end

data/lib/texticle/parser.rb

@@ -0,0 +1,53 @@
+require 'treetop'
+require File.dirname(__FILE__) + '/tquery'
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'nodes','**','*.rb'))].each {|f| require f}
+
+module Texticle
+  class Parser
+    attr_accessor :parse_tree, :tquery
+  
+    def parse(str)
+      s = str.strip
+      p = TQueryParser.new
+      @parse_tree = nil
+      @tquery = nil
+      return @tquery if s.blank?
+      failed = false
+      while @parse_tree.nil?
+        begin
+          @parse_tree = p.parse(s)
+          raise p.failure_reason if @parse_tree.nil?
+          result = parser_tree_to_tquery(@parse_tree)
+          break if effectively_empty?(result)
+          @tquery = result
+        rescue
+          raise $! if failed
+          failed = true
+          s = s.gsub(/[^A-Za-z0-9\s]/, '').strip
+          break if effectively_empty?(s)
+        end
+      end
+      @tquery
+    end
+  
+  private
+    # the search string is effectively empty (meaning tsearch will see it as blank)
+    def effectively_empty?(str)
+      s = str.gsub(/[^A-Za-z0-9\s]/, '').strip
+      unique_terms = s.downcase.split(/\s+/).uniq
+      s.blank? || unique_terms.reject {|e| e == 'and' || e == 'or'}.empty?
+    end
+    
+    def parser_tree_to_tquery(parse_tree)
+      results = if parse_tree.expression.nil?
+        ''
+      else
+        parse_tree.expression.to_tquery
+      end
+      unless results.nil?
+        results.gsub(/^\s+(\||\&)/, '')
+      end
+    end
+  end
+end

data/lib/texticle/tasks.rb

@@ -0,0 +1,55 @@
+require 'rake'
+require 'texticle'
+
+namespace :texticle do
+  desc "Create full text index migration"
+  task :migration => :environment do
+    now = Time.now.utc
+    filename = "#{now.strftime('%Y%m%d%H%m%S')}_full_text_search_#{now.to_i}.rb"
+    File.open(File.join(RAILS_ROOT, 'db', 'migrate', filename), 'wb') { |fh|
+      fh.puts "class FullTextSearch#{now.to_i} < ActiveRecord::Migration"
+      fh.puts "  def self.up"
+      Dir[File.join(RAILS_ROOT, 'app', 'models', '*.rb')].each do |f|
+        klass = File.basename(f, '.rb').classify.constantize
+        if klass.respond_to?(:full_text_indexes)
+          (klass.full_text_indexes || []).each do |fti|
+            fh.puts <<-eostmt
+      ActiveRecord::Base.connection.execute(<<-'eosql')
+        #{fti.destroy_sql}
+      eosql
+      ActiveRecord::Base.connection.execute(<<-'eosql')
+        #{fti.create_sql}
+      eosql
+            eostmt
+          end
+        end
+      end
+      fh.puts "  end"
+      fh.puts "end"
+    }
+  end
+
+  desc "Create full text indexes"
+  task :create_indexes => ['texticle:destroy_indexes'] do
+    Dir[File.join(RAILS_ROOT, 'app', 'models', '*.rb')].each do |f|
+      klass = File.basename(f, '.rb').classify.constantize
+      if klass.respond_to?(:full_text_indexes)
+        (klass.full_text_indexes || []).each do |fti|
+          fti.create
+        end
+      end
+    end
+  end
+
+  desc "Destroy full text indexes"
+  task :destroy_indexes => [:environment] do
+    Dir[File.join(RAILS_ROOT, 'app', 'models', '*.rb')].each do |f|
+      klass = File.basename(f, '.rb').classify.constantize
+      if klass.respond_to?(:full_text_indexes)
+        (klass.full_text_indexes || []).each do |fti|
+          fti.destroy
+        end
+      end
+    end
+  end
+end

data/lib/texticle/tquery.rb

@@ -0,0 +1,762 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module TQuery
+  include Treetop::Runtime
+
+  def root
+    @root || :query
+  end
+
+  module Query0
+    def space1
+      elements[0]
+    end
+
+    def expression
+      elements[1]
+    end
+
+    def space2
+      elements[3]
+    end
+  end
+
+  def _nt_query
+    start_index = index
+    if node_cache[:query].has_key?(index)
+      cached = node_cache[:query][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_space
+    s0 << r1
+    if r1
+      r2 = _nt_expression
+      s0 << r2
+      if r2
+        r4 = _nt_more_query
+        if r4
+          r3 = r4
+        else
+          r3 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r3
+        if r3
+          r5 = _nt_space
+          s0 << r5
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(QueryNode,input, i0...index, s0)
+      r0.extend(Query0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:query][start_index] = r0
+
+    r0
+  end
+
+  module MoreQuery0
+    def space1
+      elements[0]
+    end
+
+    def query
+      elements[1]
+    end
+
+    def space2
+      elements[2]
+    end
+  end
+
+  def _nt_more_query
+    start_index = index
+    if node_cache[:more_query].has_key?(index)
+      cached = node_cache[:more_query][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_space
+    s0 << r1
+    if r1
+      r2 = _nt_query
+      s0 << r2
+      if r2
+        r3 = _nt_space
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(QueryNode,input, i0...index, s0)
+      r0.extend(MoreQuery0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:more_query][start_index] = r0
+
+    r0
+  end
+
+  module Expression0
+    def space
+      elements[1]
+    end
+
+    def more
+      elements[2]
+    end
+  end
+
+  def _nt_expression
+    start_index = index
+    if node_cache[:expression].has_key?(index)
+      cached = node_cache[:expression][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    s1, i1 = [], index
+    loop do
+      r2 = _nt_term
+      if r2
+        s1 << r2
+      else
+        break
+      end
+    end
+    if s1.empty?
+      @index = i1
+      r1 = nil
+    else
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+    end
+    s0 << r1
+    if r1
+      r3 = _nt_space
+      s0 << r3
+      if r3
+        r5 = _nt_more_expression
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(ExpressionNode,input, i0...index, s0)
+      r0.extend(Expression0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:expression][start_index] = r0
+
+    r0
+  end
+
+  module MoreExpression0
+    def space
+      elements[0]
+    end
+
+    def expression
+      elements[1]
+    end
+  end
+
+  def _nt_more_expression
+    start_index = index
+    if node_cache[:more_expression].has_key?(index)
+      cached = node_cache[:more_expression][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_space
+    s0 << r1
+    if r1
+      r2 = _nt_expression
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(ExpressionNode,input, i0...index, s0)
+      r0.extend(MoreExpression0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:more_expression][start_index] = r0
+
+    r0
+  end
+
+  module GroupedTerm0
+  end
+
+  def _nt_grouped_term
+    start_index = index
+    if node_cache[:grouped_term].has_key?(index)
+      cached = node_cache[:grouped_term][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?('(', false, index)
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('(')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_term
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+      if r2
+        if has_terminal?(')', false, index)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure(')')
+          r4 = nil
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(GroupedTermNode,input, i0...index, s0)
+      r0.extend(GroupedTerm0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:grouped_term][start_index] = r0
+
+    r0
+  end
+
+  module QuotedTerm0
+    def quoted_stuff
+      elements[1]
+    end
+
+  end
+
+  def _nt_quoted_term
+    start_index = index
+    if node_cache[:quoted_term].has_key?(index)
+      cached = node_cache[:quoted_term][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?('"', false, index)
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?('\G[^\\"]', true, index)
+          r3 = true
+          @index += 1
+        else
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        if has_terminal?('"', false, index)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('"')
+          r4 = nil
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(QuotedTermNode,input, i0...index, s0)
+      r0.extend(QuotedTerm0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:quoted_term][start_index] = r0
+
+    r0
+  end
+
+  module Term0
+    def space1
+      elements[0]
+    end
+
+    def space2
+      elements[2]
+    end
+  end
+
+  def _nt_term
+    start_index = index
+    if node_cache[:term].has_key?(index)
+      cached = node_cache[:term][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_space
+    s0 << r1
+    if r1
+      i2 = index
+      r3 = _nt_boolean_term
+      if r3
+        r2 = r3
+      else
+        r4 = _nt_quoted_term
+        if r4
+          r2 = r4
+        else
+          r5 = _nt_word
+          if r5
+            r2 = r5
+          else
+            r6 = _nt_grouped_term
+            if r6
+              r2 = r6
+            else
+              @index = i2
+              r2 = nil
+            end
+          end
+        end
+      end
+      s0 << r2
+      if r2
+        r7 = _nt_space
+        s0 << r7
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(TermNode,input, i0...index, s0)
+      r0.extend(Term0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:term][start_index] = r0
+
+    r0
+  end
+
+  def _nt_word
+    start_index = index
+    if node_cache[:word].has_key?(index)
+      cached = node_cache[:word][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_word_char
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(WordNode,input, i0...index, s0)
+    end
+
+    node_cache[:word][start_index] = r0
+
+    r0
+  end
+
+  def _nt_word_char
+    start_index = index
+    if node_cache[:word_char].has_key?(index)
+      cached = node_cache[:word_char][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_letter
+    if r1
+      r0 = r1
+    else
+      r2 = _nt_digit
+      if r2
+        r0 = r2
+      else
+        if has_terminal?('_', false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('_')
+          r3 = nil
+        end
+        if r3
+          r0 = r3
+        else
+          if has_terminal?('&', false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('&')
+            r4 = nil
+          end
+          if r4
+            r0 = r4
+          else
+            if has_terminal?('.', false, index)
+              r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('.')
+              r5 = nil
+            end
+            if r5
+              r0 = r5
+            else
+              if has_terminal?('!', false, index)
+                r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure('!')
+                r6 = nil
+              end
+              if r6
+                r0 = r6
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:word_char][start_index] = r0
+
+    r0
+  end
+
+  def _nt_letter
+    start_index = index
+    if node_cache[:letter].has_key?(index)
+      cached = node_cache[:letter][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?('\G[A-Za-z]', true, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      r0 = nil
+    end
+
+    node_cache[:letter][start_index] = r0
+
+    r0
+  end
+
+  def _nt_digit
+    start_index = index
+    if node_cache[:digit].has_key?(index)
+      cached = node_cache[:digit][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?('\G[0-9]', true, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      r0 = nil
+    end
+
+    node_cache[:digit][start_index] = r0
+
+    r0
+  end
+
+  def _nt_space
+    start_index = index
+    if node_cache[:space].has_key?(index)
+      cached = node_cache[:space][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      if has_terminal?('\G[\\s]', true, index)
+        r1 = true
+        @index += 1
+      else
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+    node_cache[:space][start_index] = r0
+
+    r0
+  end
+
+  def _nt_boolean_term
+    start_index = index
+    if node_cache[:boolean_term].has_key?(index)
+      cached = node_cache[:boolean_term][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_and_term
+    if r1
+      r0 = r1
+    else
+      r2 = _nt_or_term
+      if r2
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:boolean_term][start_index] = r0
+
+    r0
+  end
+
+  module AndTerm0
+    def term
+      elements[1]
+    end
+  end
+
+  def _nt_and_term
+    start_index = index
+    if node_cache[:and_term].has_key?(index)
+      cached = node_cache[:and_term][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    i1 = index
+    if has_terminal?('and', false, index)
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 3))
+      @index += 3
+    else
+      terminal_parse_failure('and')
+      r2 = nil
+    end
+    if r2
+      r1 = r2
+    else
+      if has_terminal?('&&', false, index)
+        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        @index += 2
+      else
+        terminal_parse_failure('&&')
+        r3 = nil
+      end
+      if r3
+        r1 = r3
+      else
+        @index = i1
+        r1 = nil
+      end
+    end
+    s0 << r1
+    if r1
+      r4 = _nt_term
+      s0 << r4
+    end
+    if s0.last
+      r0 = instantiate_node(AndTermNode,input, i0...index, s0)
+      r0.extend(AndTerm0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:and_term][start_index] = r0
+
+    r0
+  end
+
+  module OrTerm0
+    def term
+      elements[1]
+    end
+  end
+
+  def _nt_or_term
+    start_index = index
+    if node_cache[:or_term].has_key?(index)
+      cached = node_cache[:or_term][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    i1 = index
+    if has_terminal?('or', false, index)
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
+      @index += 2
+    else
+      terminal_parse_failure('or')
+      r2 = nil
+    end
+    if r2
+      r1 = r2
+    else
+      if has_terminal?('||', false, index)
+        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        @index += 2
+      else
+        terminal_parse_failure('||')
+        r3 = nil
+      end
+      if r3
+        r1 = r3
+      else
+        @index = i1
+        r1 = nil
+      end
+    end
+    s0 << r1
+    if r1
+      r4 = _nt_term
+      s0 << r4
+    end
+    if s0.last
+      r0 = instantiate_node(OrTermNode,input, i0...index, s0)
+      r0.extend(OrTerm0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:or_term][start_index] = r0
+
+    r0
+  end
+
+end
+
+class TQueryParser < Treetop::Runtime::CompiledParser
+  include TQuery
+end