xtf-ruby 1.0.0

data/lib/xtf/result/element/result.rb

@@ -0,0 +1,91 @@
+class XTF::Result::Element::Result
+#   require 'rubygems'
+#   require 'libxml_helper'
+  DEFAULT_DOCS_PER_PAGE = 50
+  attr_reader :tag_name,
+              :xml,
+              :doc,
+              :search,
+              :query,
+              :query_time,
+              :total_docs,
+              :start_doc,
+              :end_doc,
+              :doc_hits,
+              :docs_per_page,
+              :facets
+  alias :hits :doc_hits
+
+  def initialize(xml=nil, search=nil)
+    start = Time.now
+    @tag_name = "crossQueryResult"
+    @doc_hits = []
+    @facets = []
+    parse_xml(xml) if xml
+    @search = search
+#     RAILS_DEFAULT_LOGGER.debug("~~~~~ #{self.class.name} initialized #{@doc_hits.size} hits and #{@facets.size} facets in #{Time.now - start} seconds.")
+  end
+
+  # Parses the important bits out of the XTF search results using LibXML-Ruby.
+  def parse_xml(xml)
+    @xml = xml.to_s.gsub(/\s+/, " ").strip
+    @doc = XML::Document.parse_string(@xml).root
+
+    # the query metadata
+    @query_time = @doc.at('/crossQueryResult')['queryTime']
+    @total_docs = @doc.at('/crossQueryResult')['totalDocs']
+    @start_doc = @doc.at('/crossQueryResult')['startDoc']
+    @end_doc = @doc.at('/crossQueryResult')['endDoc']
+    @docs_per_page = @doc.at("/crossQueryResult/query")['maxDocs'] rescue DEFAULT_DOCS_PER_PAGE
+
+    @query = @doc.at('/crossQueryResult/query').to_s
+    # the docHits
+    # TODO deal with PDFS. This currently filters them from the results
+    @doc_hits = @doc.search('./docHit').collect { |h| XTF::Result::Element::DocHit.create(h, @query) }.compact
+
+    @facets = @doc.search('/crossQueryResult/facet').collect { |f| XTF::Result::Element::Facet.new(f, @query) }
+  end
+
+  def empty?
+    self.hits.size < 1
+  end
+
+  def previous_start_doc
+    diff = start_doc.to_i - docs_per_page.to_i
+    diff < 1 ? "1" : diff.to_s
+  end
+  alias :prev_start_doc :previous_start_doc
+
+  def next_start_doc
+    sum = start_doc.to_i + docs_per_page.to_i
+    sum > total_docs.to_i ? start_doc : sum.to_s
+  end
+
+  def last_start_doc
+    (((total_docs.to_i-1) / docs_per_page.to_i) * docs_per_page.to_i + 1).to_s
+  end
+
+  def total_pages
+    (((total_docs.to_i-1) / docs_per_page.to_i) + 1).to_s
+  end
+
+  def current_page
+    (((start_doc.to_i-1) / docs_per_page.to_i) + 1).to_s
+  end
+
+  def start_doc_for_page(page)
+    return "1" if page.to_i <= 1
+    return self.last_start_doc if page.to_i >= self.total_pages.to_i
+    (docs_per_page.to_i * (page.to_i - 1) + 1).to_s
+  end
+
+  def next_page_query_string()
+    "startDoc=#{self.next_start_doc}&docsPerPage=#{self.docs_per_page}"
+  end
+
+  def previous_page_query_string()
+    "startDoc=#{self.previous_start_doc}&docsPerPage=#{self.docs_per_page}"
+  end
+  alias :prev_page_query_string :previous_page_query_string
+
+end

data/lib/xtf/result/element.rb

@@ -0,0 +1,13 @@
+module XTF
+  module Result
+    module Element
+    end
+  end
+end
+$:.unshift(File.dirname(__FILE__))
+require 'element/base'
+require 'element/doc_hit'
+require 'element/group'
+require 'element/facet'
+require 'element/result'
+#Dir[File.dirname(__FILE__) + "/element/*.rb"].each { |file| require(file) }

data/lib/xtf/result.rb

@@ -0,0 +1,6 @@
+module XTF
+  module Result
+  end
+end
+$:.unshift(File.dirname(__FILE__))
+require 'result/element'

data/lib/xtf/ruby/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module XTF
+  module Ruby
+    VERSION = "1.0.0"
+  end
+end

data/lib/xtf/ruby.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "ruby/version"
+
+module XTF
+  module Ruby
+    class Error < StandardError; end
+    # placeholder
+  end
+end

data/lib/xtf/search/element/all_docs.rb

@@ -0,0 +1,23 @@
+# This class is used inside a +Query+ to retrieve all docs. It's primary purpose is
+# for use with +Facet+s:
+#
+#   query = Query.new
+#   query.content << AllDocs.new
+#   query.content << Facet.new('word')
+#
+class XTF::Search::Element::AllDocs
+
+  attr_reader :tag_name
+
+  def initialize
+    @tag_name = "all_docs"
+    super
+  end
+
+  def to_xml_node
+    XTF::XML::Element.new(self.tag_name.to_s.camelize(:lower))
+  end
+  def to_xml
+    to_xml_node.to_s
+  end
+end

data/lib/xtf/search/element/and.rb

@@ -0,0 +1,13 @@
+class XTF::Search::Element::And < XTF::Search::Element::Clause
+  attribute_keys BASE_ATTRIBUTE_KEYS, :fields, :use_proximity, :slop
+
+  def initialize(*args)
+    @tag_name = "and"
+    params = args[0] || {}
+    raise ArgumentError, "Provide :field or :fields, but not both" if params.key?(:field) && params.key?(:fields)
+    raise ArgumentError, ":fields requires :slop" if params.key?(:fields) && !params.key?(:slop)
+    raise ArgumentError, ":slop requires :fields" if params.key?(:slop) && !params.key?(:fields)
+    super
+  end
+
+end

data/lib/xtf/search/element/base.rb

@@ -0,0 +1,32 @@
+class XTF::Search::Element::Base
+  BASE_ATTRIBUTE_KEYS = [:field, :max_snippets, :boost]
+
+  def self.attribute_keys(*args)
+    array = args.flatten
+    list = array.inspect
+    class_eval(%Q{def attribute_keys() #{list} end}, __FILE__, __LINE__)
+    array.each do |k|
+      attr_accessor k
+    end
+  end
+
+  attribute_keys *BASE_ATTRIBUTE_KEYS
+
+  attr_reader   :tag_name
+
+  # Takes a +Hash+ of attributes and sets them. Silently ignores erroneous keys.
+  def initialize(*args)
+    params = args[0]
+    attribute_keys.each { |k| self.__send__("#{k}=", params[k]) if params.key?(k) } if params
+  end
+
+  # Returns a +Hash+ of the attributes listed in +ATTRIBUTE_KEYS+ with their values.
+  # The keys are +Symbol+s.
+  def attributes
+    self.attribute_keys.inject({}) do |hash, key|
+      hash[key] = self.__send__(key) if self.__send__(key)
+      hash
+    end
+  end
+
+end

data/lib/xtf/search/element/clause.rb

@@ -0,0 +1,57 @@
+class XTF::Search::Element::Clause < XTF::Search::Element::Base
+  VALID_TAG_NAMES = %w{phrase exact and or or_near orNear not near range}
+
+  # an Array that contains any number of clauses and/or terms
+  attr_accessor :content
+
+  # convenience to create a +Term+ from a +String+ and insert it into +content+
+  attr_accessor :term
+
+  attr_accessor :section_type #available on all elements except <not> and <facet>
+
+  # This is a factory method for creating subclasses directly from +Clause+.
+  # The tag_name may be passed as the first argument or as the value to the key
+  # +:tag_name+ or +'tag_name'+
+  def self.create(*args)
+    tag_name = args.shift.to_s if args[0].is_a?(String) || args[0].is_a?(Symbol)
+    params = (args[0] || {}).symbolize_keys
+    tag_name = params.delete(:tag_name) unless tag_name
+
+    raise ArgumentError, "need tag_name for XTF::Search::Element::Clause" unless tag_name
+    raise ArgumentError, "tag_name #{tag_name} not valid for XTF::Search::Element::Clause. Must be one of: #{VALID_TAG_NAMES.join(', ')}" unless VALID_TAG_NAMES.include?(tag_name)
+
+    klass = eval("XTF::Search::Element::#{tag_name.to_s.camelize}") # scope the name to avoid conflicts, especially with Range
+    klass.new(params)
+  end
+
+  def initialize(*args)
+    params = args[0] || {}
+    self.content = params.delete(:content) || []
+    self.term = params.delete(:term) if params.has_key?(:term)
+    super(params)
+
+    raise ArgumentError, "need tag_name for XTF::Search::Element::Clause (maybe you should call Clause.create(:tag_name) ? )" unless @tag_name
+    raise ArgumentError, "tag_name #{@tag_name} not valid for XTF::Search::Element::Clause. Must be one of: #{VALID_TAG_NAMES.join(', ')}" unless VALID_TAG_NAMES.include?(@tag_name)
+  end
+
+  # Accepts a +Term+ or a +String+ which is converted to a +Term+ and adds it to the +content+.
+  def term=(value)
+    self.content << (value.is_a?(XTF::Search::Element::Term) ? value : XTF::Search::Element::Term.new(value))
+  end
+
+  def content=(value)
+    value = [value] unless value.is_a?(Array)
+    @content = value
+  end
+
+  # TODO add section_type
+  def to_xml_node
+    xml = XTF::XML::Element.new self.tag_name.camelize(:lower)
+    self.attributes.each_pair { |key, value| xml.attributes[key.to_s.camelize(:lower)] = value if value}
+    self.content.each {|node| xml.add_element(node.to_xml_node)}
+    xml
+  end
+  def to_xml
+    to_xml_node.to_s
+  end
+end

data/lib/xtf/search/element/exact.rb

@@ -0,0 +1,8 @@
+class XTF::Search::Element::Exact < XTF::Search::Element::Phrase
+
+  def initialize(*args)
+    super
+    @tag_name = "exact"
+  end
+
+end

data/lib/xtf/search/element/facet.rb

@@ -0,0 +1,26 @@
+class XTF::Search::Element::Facet < XTF::Search::Element::Base
+  attribute_keys :field, :select, :sort_groups_by, :sort_docs_by, :include_empty_groups
+
+  # can take a String or Symbol as first argument for required attribute #field
+  def initialize(*args)
+    @tag_name = "facet"
+    @field = args.shift.to_s if args[0].is_a?(String) or args[0].is_a?(Symbol)
+    params = args[0] || {}
+    raise ArgumentError, "supply field as first argument or as attribute of Hash, but not both!" if @field && params.key?(:field)
+
+    @field = params.delete(:field) unless @field
+    raise ArgumentError, "field is required." unless @field
+
+    super
+  end
+
+  def to_xml_node
+    xml = XTF::XML::Element.new(self.tag_name)
+    self.attributes.each_pair { |key, value| xml.attributes[key.to_s.camelize(:lower)] = value if value}
+    xml
+  end
+  def to_xml
+    to_xml_node.to_s
+  end
+
+end

data/lib/xtf/search/element/near.rb

@@ -0,0 +1,17 @@
+class XTF::Search::Element::Near < XTF::Search::Element::Clause
+  attribute_keys BASE_ATTRIBUTE_KEYS, :slop
+
+  # +slop+ is required. You can pass it in as the first argument or in the attributes +Hash+
+  # with the key +:slop+.
+  def initialize(*args)
+    @tag_name = "near"
+    @slop = args.shift.to_s if args[0].is_a?(String) || args[0].is_a?(Integer)
+    params = args[0] || {}
+    raise ArgumentError, "supply slop as first argument or as attribute of Hash, but not both!" if @slop && params.key?(:slop)
+
+    @slop = params.delete(:slop) unless @slop
+    raise ArgumentError, "slop is required." unless @slop
+
+    super
+  end
+end

data/lib/xtf/search/element/not.rb

@@ -0,0 +1,7 @@
+class XTF::Search::Element::Not < XTF::Search::Element::Clause
+  def initialize(*args)
+    @tag_name = "not"
+    super
+  end
+
+end

data/lib/xtf/search/element/or.rb

@@ -0,0 +1,13 @@
+class XTF::Search::Element::Or < XTF::Search::Element::Clause
+  attribute_keys BASE_ATTRIBUTE_KEYS, :fields, :slop
+
+  def initialize(*args)
+    @tag_name = "or"
+    params = args[0] || {}
+    raise ArgumentError, "Provide :field or :fields, but not both" if params.key?(:field) && params.key?(:fields)
+    raise ArgumentError, ":fields requires :slop" if params.key?(:fields) && !params.key?(:slop)
+    raise ArgumentError, ":slop requires :fields" if params.key?(:slop) && !params.key?(:fields)
+    super
+  end
+
+end

data/lib/xtf/search/element/or_near.rb

@@ -0,0 +1,11 @@
+# Extends +Near+, as they are identical except for +tag_name+
+class XTF::Search::Element::OrNear < XTF::Search::Element::Near
+  attribute_keys BASE_ATTRIBUTE_KEYS, :slop
+
+  # +slop+ is required. You can pass it in as the first argument or in the attributes +Hash+
+  # with the key +:slop+.
+  def initialize(*args)
+    @tag_name = "orNear"
+    super
+  end
+end

data/lib/xtf/search/element/phrase.rb

@@ -0,0 +1,28 @@
+class XTF::Search::Element::Phrase < XTF::Search::Element::Clause
+  # Takes a +String+ and breaks it up into +Term+s:
+  attr_accessor :phrase
+
+  def initialize(*args)
+    @tag_name = "phrase"
+    params = args[0] || {}
+    _phrase = params.delete(:phrase)
+    super(params)
+    self.phrase = _phrase if _phrase
+  end
+
+  # If the last term is a wildcard, then append it to the previous term.
+  def phrase=(terms)
+    raise ArgumentError unless terms.is_a?(String)
+    terms = terms.split(XTF::Search::Constants.phrase_delimiters)
+    terms.first.gsub!(/^"/, "")
+    terms.shift if terms.first == ""
+    terms.last.gsub!(/"$/,"")
+    terms.pop if terms.last == ""
+    if terms.last == "*"
+      terms.pop
+      terms.last << "*"
+    end
+    terms.each { |t| self.content << XTF::Search::Element::Term.new(t) }
+  end
+
+end

data/lib/xtf/search/element/query.rb

@@ -0,0 +1,42 @@
+class XTF::Search::Element::Query < XTF::Search::Element::Base
+
+  STYLE_DEFAULT = "style/crossQuery/resultFormatter/default/resultFormatter.xsl"
+  INDEX_PATH_DEFAULT = "index"
+
+  attribute_keys :index_path, :style, :sort_docs_by, :start_doc, :max_docs, :term_limit, :work_limit,
+                 :max_context, :max_snippets, :term_mode, :field, :normalize_scores, :explain_scores
+
+  attr_accessor :content # one Term or Clause, spellcheck, and any number of facet tags all in an array
+
+  def initialize(*args)
+    @tag_name = 'query'
+    params = args[0] || {}
+    self.content = params.delete(:content) || []
+    super(params)
+
+    @style ||= STYLE_DEFAULT
+    @index_path ||= INDEX_PATH_DEFAULT
+  end
+
+  # Accepts a +Term+ or a +String+ which is converted to a +Term+ and adds it to the +content+.
+  def term=(value)
+    self.content << (value.is_a?(XTF::Search::Element::Term) ? value : XTF::Search::Element::Term.new(value))
+  end
+
+  def content=(value)
+    value = [value] unless value.is_a?(Array)
+    @content = value
+  end
+
+  def to_xml_node
+    xml = XTF::XML::Element.new(self.tag_name)
+    self.attributes.each_pair { |key, value| xml.attributes[key.to_s.camelize(:lower)] = value if value}
+    # TODO validate only one term or clause present?
+    self.content.each {|node| xml.add_element(node.to_xml_node)}
+    xml
+  end
+  def to_xml
+    to_xml_node.to_s
+  end
+
+end

data/lib/xtf/search/element/range.rb

@@ -0,0 +1,44 @@
+class XTF::Search::Element::Range < XTF::Search::Element::Clause
+
+  attribute_keys BASE_ATTRIBUTE_KEYS, :inclusive, :numeric
+
+  attr_accessor :lower, :upper
+
+  # +lower+ and +upper+ may be passed as the first and second arguments.
+  # If one is present, then both must be. Otherwise, they may be passed as
+  # part of the attributes +Hash+ with the keys +:lower+ and +:upper+.
+  # An +ArgumentError+ will be raised if they are not provided.
+  def initialize(*args)
+    @tag_name = "range"
+
+    # retrieve lower and upper if passed as first two arguments
+    @lower = args.shift.to_s if args[0].is_a?(String) || args[0].is_a?(Integer)
+    @upper = args.shift.to_s if args[0].is_a?(String) || args[0].is_a?(Integer)
+    raise ArgumentError, "If you provide --lower-- as first argument, you must provide --upper-- as second." if @lower && !@upper
+
+    params = args[0] || {}
+    raise ArgumentError, "You have provided --lower-- and --upper-- as both arguments and attributes! Pass them as one or the other, but not both." if @lower && (params[:lower] || params[:upper])
+
+    @lower = params[:lower] && params[:lower].to_s unless @lower
+    @upper = params[:upper] && params[:upper].to_s unless @upper
+
+    raise ArgumentError, "You must provide --lower-- and --upper-- as the first two arguments to new() or as members of the attributes Hash." unless @lower && @upper
+
+    super
+  end
+
+  # TODO add section_type
+  def to_xml_node
+    xml = XTF::XML::Element.new self.tag_name.camelize(:lower)
+    self.attributes.each_pair { |key, value| xml.attributes[key.to_s.camelize(:lower)] = value if value}
+    lnode = XTF::XML::Element.new("lower")
+    lnode.text = self.lower
+    unode = XTF::XML::Element.new("upper")
+    unode.text = self.upper
+    xml.add_element(lnode)
+    xml.add_element(unode)
+    xml
+  end
+
+
+end

data/lib/xtf/search/element/result_data.rb

@@ -0,0 +1,18 @@
+class XTF::Search::Element::ResultData
+  attr_accessor :value
+  attr_reader :tag_name
+
+  def initialize(data=nil)
+    @tag_name = "resultData"
+    @value = data
+  end
+
+  def to_xml_node
+    xml = XTF::XML::Element.new(self.tag_name)
+    xml.text = self.value
+    xml
+  end
+  def to_xml
+    to_xml_node.to_s
+  end
+end

data/lib/xtf/search/element/section_type.rb

@@ -0,0 +1,19 @@
+class XTF::Search::Element::SectionType
+
+  attr_accessor :content # one Term or Clause
+  attr_reader :tag_name
+
+  def initialize(content = nil)
+    @tag_name = "sectionType"
+    @content = content
+  end
+
+  def to_xml_node
+    xml = XTF::XML::Element.new("sectionType")
+    xml.add_element(self.content.to_xml_node) if self.content
+    xml
+  end
+  def to_xml
+    to_xml_node.to_s
+  end
+end

data/lib/xtf/search/element/term.rb

@@ -0,0 +1,51 @@
+# Models a single XTF Term. However, if the term is surrounded by double-quotes, then
+# a Phrase will be emitted for to_xml_node().
+
+class XTF::Search::Element::Term < XTF::Search::Element::Base
+  attr_accessor :value
+  attr_accessor :section_type
+
+  # Should a phrase be parsed? Defaults to +true+
+  attr_accessor :parse_phrase
+
+  # +new+ accepts an optional first argument for +value+ as well as an optional
+  # first or second argument +Hash+ of the +Term+'s +attributes+.
+  # +value+ may be passed as the first argument or in attributes +Hash+ with key +:value+.
+  # +section_type+ may be passed in the attributes +Hash+ with key +:section_type+.
+  def initialize(*args)
+    @tag_name = "term"
+    @value = args.shift if args[0].kind_of?(String)
+    params = args[0] || {}
+    @value = params.delete(:value) unless @value
+    @section_type = params.delete(:section_type)
+    @parse_phrase = params.key?(:parse_phrase) ? params.delete(:parse_phrase) : false
+    super
+    @value.strip! unless @value.nil?
+  end
+
+  # For convenience, if the Term's value matches /[\-\s\\\/.,;:]+/, it will be parsed as a Phrase.
+  # Double quotes on either end will be removed.
+  #
+  # "this phrase" woud yield:
+  #
+  #  <phrase>
+  #     <term>this</term
+  #     <term>phrase</term
+  #   </phrase>
+  #
+  def to_xml_node
+    if self.parse_phrase && self.value =~ XTF::Search::Constants.phrase_delimiters
+      phrase = XTF::Search::Element::Phrase.new(self.attributes)
+      phrase.phrase = self.value
+      phrase.to_xml_node
+    else
+      xml = XTF::XML::Element.new(self.tag_name)
+      self.attributes.each_pair { |key, value| xml.attributes[key.to_s.camelize(:lower)] = value if value}
+      xml.text = self.value
+      xml
+    end
+  end
+  def to_xml
+    to_xml_node.to_s
+  end
+end

data/lib/xtf/search/element.rb

@@ -0,0 +1,15 @@
+module XTF
+  module Search
+    module Element
+    end
+  end
+end
+
+$:.unshift(File.dirname(__FILE__))
+require 'element/base'
+require 'element/section_type'
+require 'element/result_data'
+require 'element/clause'
+require 'element/near'
+require 'element/phrase'
+Dir[File.dirname(__FILE__) + "/element/*.rb"].each { |file| require(file) }

data/lib/xtf/search.rb

@@ -0,0 +1,11 @@
+module XTF
+  module Search
+    class Constants
+      def self.phrase_delimiters
+        /[\-\s\\\/.,;:()]+/
+      end
+    end
+  end
+end
+$:.unshift(File.dirname(__FILE__))
+require 'search/element'

data/lib/xtf/xml.rb

@@ -0,0 +1,85 @@
+# Code in this file is derived from Apache's Solr-Ruby project.
+
+module XTF::XML
+end
+
+begin
+
+  # If we can load rubygems and libxml-ruby...
+  require 'rubygems'
+  require 'xml/libxml'
+
+  class XML::Attributes
+    def size
+      length
+    end
+  end
+
+  # Some Hpricot-like convenience methods for LibXml
+  class XML::Document
+    def self.parse_string(xml)
+      xml_parser = XML::Parser.string(xml)
+      xml_parser.parse
+    end
+  end
+
+  # then make a few modifications to XML::Node so it can stand in for REXML::Element
+  class XML::Node
+    # element.add_element(another_element) should work
+    alias_method :add_element, :<<
+
+    # element.attributes['blah'] should work
+    # def attributes
+    #   self
+    # end
+
+    def size
+      self.attributes.length
+    end
+    alias :length :size
+
+    # element.text = "blah" should work
+    def text=(x)
+      self << x.to_s
+    end
+
+    def text
+      self.content
+    end
+
+    def at(xpath)
+      self.find_first(xpath)
+    end
+
+    # find the array of child nodes matching the given xpath
+    # TODO add these to Rexml?
+    def search(xpath)
+      results = self.find(xpath).to_a
+      if block_given?
+        results.each do |result|
+          yield result
+        end
+      end
+      return results
+    end
+
+    def inner_xml
+      child.to_s
+    end
+    alias inner_html inner_xml
+
+    def inner_text
+      self.content
+    end
+  end #XML::Node
+
+  # And use XML::Node for our XML generation
+  XTF::XML::Element = XML::Node
+#   raise LoadError
+rescue LoadError => e # If we can't load either rubygems or libxml-ruby
+
+  # Just use REXML.
+  require 'rexml/document'
+  XTF::XML::Element = REXML::Element
+
+end