activedocument 0.1

data/lib/ActiveDocument/active_document.rb

@@ -0,0 +1,225 @@
+#   Copyright 2010 Mark Logic, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+
+require 'ActiveDocument/mark_logic_http'
+require 'rubygems'
+require 'nokogiri'
+require 'yaml'
+require 'ActiveDocument/mark_logic_query_builder'
+require 'ActiveDocument/search_results'
+require 'ActiveDocument/finder'
+require "ActiveDocument/inheritable"
+
+# The ActiveXML module is used as a namespace for all classes relating to the ActiveXML functionality.
+# ActiveXML::Base is the class that should be extended in order to make use of this functionality in your own
+# domain objects.
+#
+module ActiveDocument
+
+  # Developers should extend this class to create their own domain classes
+  # -------------------
+  #  = Usage
+  # -------------------
+  # == Dynamic Finders
+  # ActiveDocument::Base provides extensive methods for finding matching documents based on a variety of criteria.
+  # === Find By Element
+  # Accessed via find_by_ELEMENT method where Element = the name of your element. Executes a search for all documents
+  # with an element ELEMENT that contains the value passed in to the method call.
+  # The signature of this dynamic finder is:
+  # <tt>find_by_ELEMENT(value, root [optional], element_namespace [optional], root_namespace [optional])</tt>
+  #
+  # Parameters details are as follows:
+  # <b>Value:</b> the text to be found within the given element. This is a mandatory parameter
+  # <b>Namespace:</b> The namespace in which the element being searched occurs. This is an optional element. If provided,
+  # it will be used in the search and will override any default values. If no namespace if provided then the code will
+  # attempt to dynamically determine the namespace. First, if the element name is contained in the namespaces hash
+  # then that namespace is used. If the element name is not found then the _default_namespace_
+  # is used. If there is no default namespace, then no namespace is used.
+  # -------------------
+  #  == Dynamic Accessors
+  # In addition to the ability to access the underlying XML document (as a Nokogiri XML Document) you have the ability
+  # to access the XML as attributes of your domain object via dynamic attribute accessors (eg. domain_object.element_name) The rules for using accessors
+  # are as follows:
+  #  1. If the element_name is a simple type (i.e. text node with no children <tt><example>text</exmample></tt>)
+  #     1. If there is only one occurence of the element, return its text value
+  #     2. If there are multiple occurences of the element, return a list of each text value
+  #  2. If the element_name is a complex type (e.g. <tt><example><text>hi</text></example></tt>)
+  #     1. If there is only one ocurence of the element then return it as a Nokoguri Element
+  #     2. If there are multiple occurences of the element, return a list of Nokoguri Elements
+  #
+  # More complex dynamic accessors are also supported. They still adhere to the rules above, but instead of just looking
+  # for an element anywhere in the document, you can be more specific. For example, domain_object.chapter.paragraph
+  # will find all paragraph elements that are children of chapter elements.
+  # -------------------
+  class Base < Finder
+    include ClassLevelInheritableAttributes
+    inheritable_attributes_list :namespaces, :default_namespace, :root
+    @namespaces = Hash.new
+    @default_namespace = String.new
+    attr_reader :document, :uri
+
+
+    # create a new instance with an optional xml string to use for constructing the model
+    def initialize(xml_string = nil, uri = nil)
+      unless xml_string.nil?
+        @document = Nokogiri::XML(xml_string) do |config|
+          config.noblanks
+        end
+      end
+      @root = self.class.to_s
+      @uri = uri
+    end
+
+    # Returns the root element for this object
+    def root
+      @root
+    end
+
+    # Sets the root element for this object
+    def root=(value)
+      @root = value
+    end
+
+    # enables the dynamic finders
+    def method_missing(method_id, *arguments, &block)
+      @@log.debug("ActiveDocument::Base at line #{__LINE__}: method called is #{method_id} with arguments #{arguments}")
+      method = method_id.to_s
+      if method =~ /^(\w*)$/ # methods with no '.' in them and not ending in '='
+        if arguments.length > 0
+          super
+        end
+        access_element $1
+      end
+    end
+
+    def access_element(element)
+      xpath = ""
+      xpath = "//" unless self.instance_of? PartialResult
+      namespace = self.class.namespace_for_element(element)
+      element = "ns:#{element}" unless namespace.nil? || namespace.empty?
+      xpath << element
+      if namespace.nil?
+        nodes = @document.xpath(xpath)
+      else
+        nodes = @document.xpath(xpath, {'ns' => namespace})
+      end
+      evaluate_nodeset(nodes)
+
+    end
+
+
+    def evaluate_nodeset(result_nodeset)
+      if result_nodeset.length == 1 # found one match
+        if result_nodeset[0].children.length == 1 and result_nodeset[0].children[0].type == Nokogiri::XML::Node::TEXT_NODE
+          result_nodeset[0].text
+        elsif result_nodeset[0].children.length >1 # we are now dealing with complex nodes
+          PartialResult.new(result_nodeset)
+        end
+      elsif result_nodeset.length >1 # multiple matches
+        if result_nodeset.all? {|node| node.children.length == 1} and result_nodeset.all? {|node| node.children[0].type == Nokogiri::XML::Node::TEXT_NODE}
+          # we have multiple simple text nodes
+          result_nodeset.collect {|node| node.text}
+        else
+          # we have multiple complex elements
+          PartialResult.new(result_nodeset)
+        end
+      end
+    end
+
+    class PartialResult < self
+      def initialize(nodeset)
+        @document = nodeset
+        @root = nodeset[0].name
+      end
+
+      def to_s
+        @document.to_s
+      end
+
+
+    end
+
+    class << self
+      attr_reader :namespaces, :default_namespace, :root
+
+      def namespaces(namespace_hash)
+        @namespaces = namespace_hash
+      end
+
+      def add_namespace(element, uri)
+        @namespaces[element.to_s] == uri
+      end
+
+      def remove_namespace(element)
+        @namespaces.delete element
+      end
+
+      def default_namespace(namespace)
+        @default_namespace = namespace # todo should this just be an entry in namespaces?
+      end
+
+      # enables the dynamic finders
+      def method_missing(method_id, *arguments, &block)
+        @@log.debug("ActiveDocument::Base at line #{__LINE__}: method called is #{method_id} with arguments #{arguments}")
+        method = method_id.to_s
+        # identify element search methods
+        if method =~ /find_by_(.*)$/ and arguments.length > 0
+          value = arguments[0]
+          element = $1.to_sym
+          if arguments[1]
+            root = arguments[1]
+          else
+            root = @root
+          end
+          if arguments[2]
+            element_namespace = arguments[2]
+          else
+            element_namespace = namespace_for_element(element)
+          end
+          if arguments[3]
+            root_namespace = arguments[3]
+          else
+            root_namespace = namespace_for_element(root)
+          end
+          execute_finder(element, value, root, element_namespace, root_namespace)
+        end
+
+      end
+
+      # Returns an ActiveXML object representing the requested information
+      def load(uri)
+        self.new(@@ml_http.send_xquery(@@xquery_builder.load(uri)), uri)
+      end
+
+      # Finds all documents of this type that contain the word anywhere in their structure
+      def find_by_word(word, root=@root, namespace=@default_namespace)
+        SearchResults.new(@@ml_http.send_xquery(@@xquery_builder.find_by_word(word, root, namespace)))
+      end
+
+      def namespace_for_element(element)
+        namespace = nil
+        if @namespaces[element]
+          namespace = @namespaces[element]
+        else
+          namespace = @default_namespace unless @default_namespace.nil?
+        end
+        namespace
+      end
+    end # end inner class
+
+  end # end class
+
+
+end # end module

data/lib/ActiveDocument/finder.rb

@@ -0,0 +1,100 @@
+#   Copyright 2010 Mark Logic, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+require 'ActiveDocument/mark_logic_http'
+require 'ActiveDocument/mark_logic_query_builder'
+require 'rubygems'
+require 'nokogiri'
+require 'ActiveDocument/search_results'
+require 'logger'
+
+module ActiveDocument
+
+  class Finder
+
+
+    @@xquery_builder = ActiveDocument::MarkLogicQueryBuilder.new
+
+    def self.config(yaml_file)
+      config = YAML.load_file(yaml_file)
+      @@ml_http = ActiveDocument::MarkLogicHTTP.new(config['uri'], config['user_name'], config['password'])
+      configure_logger(config)
+    end
+
+    # enables the dynamic finders
+    def self.method_missing(method_id, *arguments, &block)
+      @@log.debug("ActiveDocument::Finder at line #{__LINE__}: method called is #{method_id} with arguments #{arguments}")
+      method = method_id.to_s
+      # identify finder methods
+      if method =~ /find_by_(.*)$/ and arguments.length > 0
+        namespace = arguments[1] if arguments.length == 2
+        execute_finder($1.to_sym, arguments[0], nil, namespace)
+      else
+        puts "missed"
+      end
+    end
+
+    def self.execute_finder(element, value, root = nil, element_namespace = nil, root_namespace = nil)
+      xquery = @@xquery_builder.find_by_element(element, value, root, element_namespace, root_namespace)
+      @@log.info("Finder.execute_finder at line #{__LINE__}: #{xquery}")
+      SearchResults.new(@@ml_http.send_xquery(xquery))
+    end
+
+    def self.search(search_string, start = 1, page_length = 10, options = nil)
+      if start.nil? : start = 1 end
+      if page_length.nil? : page_length = 10 end
+      search_text = @@xquery_builder.search(search_string, start, page_length, options)
+      SearchResults.new(@@ml_http.send_xquery(search_text)) # todo support options node
+    end
+    private
+
+    def self.configure_logger(config)
+
+      begin
+        log_location = if config['logger']['file']
+          config['logger']['file']
+        else
+          STDERR
+        end
+        log_level = case config['logger']['level']
+          when "debug" then
+            Logger::DEBUG
+          when "info" then
+            Logger::INFO
+          when "warn" then
+            Logger::WARN
+          when "error" then
+            Logger::ERROR
+          when "fatal" then
+            Logger::FATAL
+          else
+            Logger::WARN
+        end
+
+        rotation  = if config['logger']['rotation']
+          config['logger']['rotation']
+        else
+          "daily"
+        end
+        file = open(log_location, File::WRONLY | File::APPEND | File::CREAT)
+        @@log = Logger.new(file, rotation)
+        @@log.level = log_level
+      rescue StandardError => oops
+        @@log = Logger.new(STDERR)
+        @@log.level = Logger::WARN
+      end
+    end
+  end
+
+end

data/lib/ActiveDocument/inheritable.rb

@@ -0,0 +1,25 @@
+module ClassLevelInheritableAttributes
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def inheritable_attributes_list(*args)
+      @inheritable_attributes_list ||= [:inheritable_attributes_list]
+      @inheritable_attributes_list += args
+      args.each do |arg|
+        class_eval %(
+          class << self; attr_accessor :#{arg} end
+        )
+      end
+      @inheritable_attributes_list
+    end
+
+    def inherited(subclass)
+      @inheritable_attributes_list.each do |inheritable_attribute|
+        instance_var = "@#{inheritable_attribute}"
+        subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+      end
+    end
+  end
+end

data/lib/ActiveDocument/mark_logic_http.rb

@@ -0,0 +1,97 @@
+#   Copyright 2010 Mark Logic, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+require 'net/http'
+require 'uri'
+require 'digest/md5'
+
+module Net
+  module HTTPHeader
+    @@nonce_count = -1
+    CNONCE = Digest::MD5.new.update("%x" % (Time.now.to_i + rand(65535))).hexdigest
+
+    def digest_auth(user, password, response)
+      # based on http://segment7.net/projects/ruby/snippets/digest_auth.rb
+      @@nonce_count += 1
+
+      response['www-authenticate'] =~ /^(\w+) (.*)/
+
+      params = {}
+      $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+
+      a_1 = "#{user}:#{params['realm']}:#{password}"
+      a_2 = "#{@method}:#{@path}"
+      request_digest = ''
+      request_digest << Digest::MD5.new.update(a_1).hexdigest
+      request_digest << ':' << params['nonce']
+      request_digest << ':' << ('%08x' % @@nonce_count)
+      request_digest << ':' << CNONCE
+      request_digest << ':' << params['qop']
+      request_digest << ':' << Digest::MD5.new.update(a_2).hexdigest
+
+      header = []
+      header << "Digest username=\"#{user}\""
+      header << "realm=\"#{params['realm']}\""
+
+      header << "qop=#{params['qop']}"
+
+      header << "algorithm=MD5"
+      header << "uri=\"#{@path}\""
+      header << "nonce=\"#{params['nonce']}\""
+      header << "nc=#{'%08x' % @@nonce_count}"
+      header << "cnonce=\"#{CNONCE}\""
+      header << "response=\"#{Digest::MD5.new.update(request_digest).hexdigest}\""
+
+      @header['Authorization'] = header
+    end
+  end
+end
+
+module ActiveDocument
+
+  class MarkLogicHTTP
+
+    def initialize(uri, user_name, password)
+      @url = URI.parse(uri)
+      @user_name = user_name
+      @password = password
+    end
+
+    def send_xquery(xquery)
+      if xquery.nil? or xquery.empty? then
+        return nil
+      end
+      req = authenticate()
+      req.set_form_data({'request'=>"#{xquery}"})
+      res = Net::HTTP.new(@url.host, @url.port).start {|http| http.request(req) }
+      case res
+        when Net::HTTPSuccess, Net::HTTPRedirection
+#          puts res.body
+          res.body
+        else
+          res.error!
+      end
+    end
+
+    private
+    def authenticate
+      req = Net::HTTP::Post.new(@url.path)
+      Net::HTTP.start(@url.host, @url.port) do |http|
+        res = http.head(@url.request_uri)
+        req.digest_auth(@user_name, @password, res)
+      end
+      return req
+    end
+  end
+end

data/lib/ActiveDocument/mark_logic_query_builder.rb

@@ -0,0 +1,76 @@
+#   Copyright 2010 Mark Logic, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module ActiveDocument
+
+  class MarkLogicQueryBuilder
+
+    def load(uri)
+      "fn:doc('#{uri}')"
+    end
+
+    # This method does a full text search
+    def find_by_word(word, root, namespace)
+      xquery = <<GENERATED
+import module namespace search = "http://marklogic.com/appservices/search"at "/MarkLogic/appservices/search/search.xqy";
+search:search("#{word}",
+<options xmlns="http://marklogic.com/appservices/search">
+GENERATED
+      unless root.nil?
+        xquery << "<searchable-expression"
+
+        xquery << "  xmlns:a=\"#{namespace}\"" unless namespace.nil? or namespace.empty?
+        xquery << '>/'
+        xquery << "a:" unless namespace.nil? or namespace.empty?
+        xquery << "#{root}</searchable-expression>"
+      end
+      xquery << "</options>)"
+    end
+
+    def find_by_element(element, value, root = nil, element_namespace = nil, root_namespace = nil)
+      xquery = <<GENERATED
+import module namespace search = "http://marklogic.com/appservices/search"at "/MarkLogic/appservices/search/search.xqy";
+search:search("word:#{value}",
+<options xmlns="http://marklogic.com/appservices/search">
+GENERATED
+      unless root.nil?
+        xquery << "<searchable-expression"
+        xquery << "  xmlns:a=\"#{root_namespace}\"" unless root_namespace.nil?
+        xquery << '>/'
+        xquery << "a:" unless root_namespace.nil?
+        xquery << "#{root}</searchable-expression>)"
+      end
+      xquery << <<CONSTRAINT
+<constraint name="word">
+<word>
+<element ns="#{element_namespace unless element_namespace.nil?}" name="#{element}"/>
+</word>
+</constraint></options>)
+CONSTRAINT
+    end
+
+    def search(search_text, start, page_length, options)
+      if options.nil?
+        option = '()'
+      else
+        option = options.to_s
+      end
+      <<-GENERATED
+      import module namespace search = "http://marklogic.com/appservices/search"at "/MarkLogic/appservices/search/search.xqy";
+      search:search("#{search_text}",#{option},#{start}, #{page_length})
+      GENERATED
+    end
+
+  end # end class
+end # end module

data/lib/ActiveDocument/search_match.rb

@@ -0,0 +1,54 @@
+#   Copyright 2010 Mark Logic, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+require 'rubygems'
+require 'nokogiri'
+
+module ActiveDocument
+  class SearchMatch
+    include Enumerable
+
+    def initialize(node)
+      @node = node
+    end
+
+    def path
+      @node.xpath("./@path").to_s
+    end
+
+    def to_s
+      value = @node.xpath("./node()").to_s
+      begin
+        value[/<search:highlight>/] = ""
+        value[/<\/search:highlight>/] = ""
+      rescue IndexError
+      end
+      return value
+    end
+
+    def highlighted_match(highlight_tag = nil)
+      value = @node.xpath("./node()").to_s
+      unless highlight_tag.nil?
+        begin
+          value[/<search:highlight>/] = "<#{highlight_tag}>"
+          value[/<\/search:highlight>/] = "</#{highlight_tag}>"
+        rescue IndexError
+          value
+        end
+
+      end
+      return value
+    end
+  end
+end

data/lib/ActiveDocument/search_options.rb

@@ -0,0 +1,59 @@
+#   Copyright 2010 Mark Logic, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+
+# SearchOptions allow you to control exactly how the ActiveDocument::Finder#search method behaves and what additional
+# information may be returned in the ActiveDocument::SearchResults object
+# == Attributes
+# * return_facets - if true then facet information is returned in the resultant ActiveDocument::SearchResults object. Default is true
+# * value_constraints - this is a #Hash of value constraint names to their options. e.g. search_options_object.value_constraints["Region"] = {"namespace" => "http://wits.nctc.gov", "element" => "Region"}
+module ActiveDocument
+  class SearchOptions
+    attr_accessor :return_facets, :value_constraints
+
+    def initialize
+      @return_facets = true;
+      @value_constraints = Hash.new
+    end
+
+
+    # outputs the object in correctly formatted XML suitable for use in a search
+    def to_s
+      value_constraints = String.new
+      @value_constraints.each do |key, value|
+        value_constraints << <<-XML
+        <constraint name="#{key}">
+          <value>
+            <element ns="#{value["namespace"]}" name="#{value["element"]}"/>
+          </value>
+        </constraint>
+        XML
+      end
+
+      value = <<-XML
+      <options xmlns="http://marklogic.com/appservices/search">
+      <return-facets>#{@return_facets}</return-facets>
+      XML
+
+      # add in constraints
+      unless value_constraints.empty?
+        value << value_constraints
+      end
+
+      # close the options node
+      value << "</options>"
+
+    end
+  end
+end

data/lib/ActiveDocument/search_result.rb

@@ -0,0 +1,65 @@
+#   Copyright 2010 Mark Logic, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+require 'rubygems'
+require 'nokogiri'
+require 'ActiveDocument/search_match'
+
+module ActiveDocument
+  class SearchResult
+    include Enumerable
+
+    def initialize(node)
+      @node = node
+    end
+
+    def index
+      Integer(@node.xpath("./@index").to_s)
+    end
+
+    def uri
+      @node.xpath("./@uri").to_s
+    end
+
+    def path
+      @node.xpath("./@path").to_s
+    end
+
+    def score
+      Float(@node.xpath("./@score").to_s)
+    end
+
+    def confidence
+      Float(@node.xpath("./@confidence").to_s)
+    end
+
+    def fitness
+      Integer(@node.xpath("./@fitness").to_s)
+    end
+
+    def each(&block)
+      @node.xpath("./search:snippet/search:match").each {|node| yield SearchMatch.new(node)}
+    end
+
+    def root_type
+      full_path = @node.xpath("./search:snippet/search:match")[1].xpath("./@path").to_s
+      root = full_path.match(/:[[:alpha:]]+\//) # find the first :something/ which should indicate the root
+      root.to_s.delete(":/") # remove the : and / to get the root element name
+    end
+
+    def realize(klass)
+      klass.load(uri)
+    end
+  end
+end

data/lib/ActiveDocument/search_results.rb

@@ -0,0 +1,65 @@
+#   Copyright 2010 Mark Logic, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+require 'rubygems'
+require 'nokogiri'
+require 'ActiveDocument/search_result'
+
+module ActiveDocument
+  class SearchResults
+    include Enumerable
+
+    def initialize(results)
+      @results_document = Nokogiri::XML(results)
+    end
+
+    def total
+      Integer(@results_document.xpath("/search:response/@total").to_s)
+    end
+
+    def start
+      Integer(@results_document.xpath("/search:response/@start").to_s)
+    end
+
+    def page_length
+      Integer(@results_document.xpath("/search:response/@page-length").to_s)
+    end
+
+    def search_text
+      @results_document.xpath("/search:response/search:qtext/text()").to_s
+    end
+
+    def query_resolution_time
+      @results_document.xpath("/search:response/search:metrics/search:query-resolution-time/text()").to_s
+    end
+
+    def snippet_resolution_time
+      @results_document.xpath("/search:response/search:metrics/search:snippet-resolution-time/text()").to_s
+    end
+
+    def facet_resolution_time
+      @results_document.xpath("/search:response/search:metrics/search:facet-resolution-time/text()").to_s
+    end
+
+    def total_time
+      @results_document.xpath("/search:response/search:metrics/search:total-time/text()").to_s
+    end
+
+    def each(&block)
+      @results_document.xpath("/search:response/search:result").each {|node| yield SearchResult.new(node)}
+    end
+
+  end
+
+end

data/lib/active_document.rb

@@ -0,0 +1,10 @@
+require 'ActiveDocument/active_document'
+require 'ActiveDocument/finder'
+require 'ActiveDocument/inheritable'
+require 'ActiveDocument/mark_logic_http'
+require 'ActiveDocument/mark_logic_query_builder'
+require 'ActiveDocument/search_match'
+require 'ActiveDocument/search_options'
+require 'ActiveDocument/search_result'
+require 'ActiveDocument/search_results'
+

data/lib/activedocument.rb

@@ -0,0 +1 @@
+require 'active_document'

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: activedocument
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Clark D. Richey, Jr.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-02 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 1
+        version: 1.4.1
+  type: :runtime
+  version_requirements: *id001
+description: Object Mapper for XML Database. Initially setup for connection to MarkLogic
+email: clark@clarkrichey.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/active_document.rb
+- lib/ActiveDocument/active_document.rb
+- lib/ActiveDocument/finder.rb
+- lib/ActiveDocument/inheritable.rb
+- lib/ActiveDocument/mark_logic_http.rb
+- lib/ActiveDocument/mark_logic_query_builder.rb
+- lib/ActiveDocument/search_match.rb
+- lib/ActiveDocument/search_options.rb
+- lib/ActiveDocument/search_result.rb
+- lib/ActiveDocument/search_results.rb
+- lib/activedocument.rb
+has_rdoc: true
+homepage: http://github.com/crichey/ActiveDocument
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Object Mapper for XML Database
+test_files: []
+