activedocument 0.6.2 → 1.0

data/lib/ActiveDocument/active_document.rb

@@ -17,7 +17,7 @@ require 'rubygems'
 require 'nokogiri'
 require 'yaml'
 require 'ActiveDocument/mark_logic_http'
-require 'ActiveDocument/mark_logic_query_builder'
+require 'ActiveDocument/corona_interface'
 require 'ActiveDocument/search_results'
 require 'ActiveDocument/finder'
 require "ActiveDocument/inheritable"
@@ -68,7 +68,7 @@ module ActiveDocument
     inheritable_attributes_list :my_namespaces, :my_default_namespace, :root, :my_attribute_namespaces, :my_default_attribute_namespaces
     @my_namespaces = Hash.new
     @my_default_namespace = nil
-    attr_reader :document, :uri, :my_namespaces, :my_default_namespace, :root, :my_attribute_namespaces, :my_default_attribute_namespaces
+    attr_reader :document, :uri, :my_default_namespace, :my_namespaces, :root, :my_attribute_namespaces, :my_default_attribute_namespaces
 
 
     # create a new instance with an optional xml string to use for constructing the model
@@ -76,14 +76,20 @@ module ActiveDocument
       @document = Nokogiri::XML(xml_string) do |config|
         config.noblanks
       end
-      if !xml_string.empty? then
+      if !xml_string.empty? and self.class.my_root.nil? then
         @root = @document.root.name
+      else
+        @root = self.class.my_root
       end
       @uri = uri
     end
 
     def to_s
-      @document.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_DECLARATION)
+      if @document
+        @document.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_DECLARATION)
+      else
+        super.to_s
+      end
     end
 
     # saves this document to the repository. If _uri_ is provided then that will be the value used for the uri.
@@ -92,11 +98,12 @@ module ActiveDocument
     def save(uri = nil)
       doc_uri = (uri || @uri)
       if doc_uri then
-        @@ml_http.send_xquery(@@xquery_builder.save(self, doc_uri))
+        response_array = ActiveDocument::CoronaInterface.save(doc_uri)
+        uri_array = response_array[:uri]
+        @@ml_http.send_corona_request(uri_array[0], uri_array[1], self.document.to_s)
       else
         raise ArgumentError, "uri must not be nil", caller
       end
-
     end
 
     # Returns the root element for this object
@@ -128,7 +135,7 @@ module ActiveDocument
         end
         access_element $1
       elsif method =~ /^(\w*)=$/ && arguments.length == 1 # methods with no '.' in them and ending in '='
-        set_element($1, arguments)
+        set_element($1, arguments[0])
       else
         super
       end
@@ -140,8 +147,8 @@ module ActiveDocument
 
       def namespace_for_element(element)
         namespace = nil
-        if !@my_namespaces.nil? && @my_namespaces[element]
-          namespace = @my_namespaces[element]
+        if !@my_namespaces.nil? && @my_namespaces[element.to_sym]
+          namespace = @my_namespaces[element.to_sym]
         else
           namespace = @my_default_namespace unless @my_default_namespace.nil?
         end
@@ -150,52 +157,110 @@ module ActiveDocument
 
       def namespace_for_attribute(attribute)
         namespace = nil
-        if !@my_attribute_namespaces.nil? && @my_attribute_namespaces[attribute]
-          namespace = @my_attribute_namespaces[attribute]
+        if !@my_attribute_namespaces.nil? && @my_attribute_namespaces[attribute.to_sym]
+          namespace = @my_attribute_namespaces[attribute.to_sym]
         else
           namespace = @my_default_attribute_namespace unless @my_default_attribute_namespace.nil?
         end
         namespace
       end
 
+
+      # Sets the hash of elements to namespace prefixes. All prefixes should have already been registered with
+      # the framework via the ActiveDocument::DataBaseConfiguration class. Otherwise, errors will likely occur at runtime
+      # @param namespace_hash [A hash where they keys are element names as strings and the values are namespace
+      # prefixes as strings]
+      # @return [the resultant hash]
       def namespaces(namespace_hash)
         @my_namespaces = namespace_hash
+        @my_namespaces
       end
 
+      # Sets the hash of attributes to namespace prefixes. All prefixes should have already been registered with
+      # the framework via the ActiveDocument::DataBaseConfiguration class. Otherwise, errors will likely occur at runtime
+      # @param namespace_hash [A hash where they keys are element names as strings and the values are namespace
+      # prefixes as strings]
+      # @return [the resultant hash]
       def attribute_namespaces(namespace_hash)
         @my_attribute_namespaces = namespace_hash
+        @my_attribute_namespaces
       end
 
-      def add_namespace(element, uri)
-        @my_namespaces[element.to_s] == uri
+      # Adds an element / namespace prefix pair to the existing hash. All prefixes should have already been registered with
+      # the framework via the ActiveDocument::DataBaseConfiguration class. Otherwise, errors will likely occur at runtime
+      # @param element [The element]
+      # @param prefix [the namespace prefix to be associated with the element]
+      # @return [the resultant updated hash of elements to namespace prefixes]
+      def add_namespace(element, prefix)
+        @my_namespaces[element.to_s] = prefix
+        @my_namespaces
       end
 
-      def add_attribute_namespace(attribute, uri)
-        @my_attribute_namespaces[attribute.to_s] == uri
+      # Adds an attribute / namespace prefix pair to the existing hash. All prefixes should have already been registered with
+      # the framework via the ActiveDocument::DataBaseConfiguration class. Otherwise, errors will likely occur at runtime
+      # @param attribute [The attribute]
+      # @param prefix [the namespace prefix to be associated with the attribute]
+      # @return [the resultant updated hash of attributes to namespace prefixes]
+      def add_attribute_namespace(attribute, prefix)
+        @my_attribute_namespaces[attribute.to_s] = prefix
+        @my_attribute_namespaces
       end
 
+      # Removes an element / namespace prefix pair from the existing hash. #todo what about the corona config?
+      # @param element [the element to be removed)]
+      # @return [the resultant updated hash of elements to namespace prefixes]
       def remove_namespace(element)
-        @my_namespaces.delete element
+        @my_namespaces.delete element.to_s
+        @my_namespaces
       end
 
+      # Removes an attribute / namespace prefix pair from the existing hash. #todo what about the corona config?
+      # @param attribute [the attribute to be removed)]
+      # @return [the resultant updated hash of attributes to namespace prefixes]
       def remove_attribute_namespace(attribute)
-        @my_attribute_namespaces.delete attribute
+        @my_attribute_namespaces.delete attribute.to_s
+        @my_attribute_namespaces
+      end
+
+      # defines the default namespace prefix to be used for all otherwise unspecified elements. The prefix should have
+      # already been registered with the framework via the ActiveDocument::DataBaseConfiguration class. Otherwise,
+      # errors will likely occur at runtime
+      # @param prefix [the registered namespace prefix for all otherwise unspecified elements]
+      # @return [the default element namespace prefix]
+      def default_namespace(prefix)
+        @my_default_namespace = prefix
+        @my_default_namespace
       end
 
-      def default_namespace(namespace)
-        @my_default_namespace = namespace # todo should this just be an entry in namespaces?
+      # defines the default namespace prefix to be used for all otherwise unspecified attributes. The prefix should have
+      # already been registered with the framework via the ActiveDocument::DataBaseConfiguration class. Otherwise,
+      # errors will likely occur at runtime
+      # @param prefix [the registered namespace prefix for all otherwise unspecified attributes]
+      # @return [the default attribute namespace prefix]
+      def default_attribute_namespace(prefix)
+        @my_default_attribute_namespace = prefix
+        @my_default_attribute_namespace
       end
 
+      # sets the root element of the document. If not set it will default to the classname
       def root(root)
         @root = root
       end
 
-      def default_attribute_namespace(namespace)
-        @my_default_attribute_namespace = namespace # todo should this just be an entry in namespaces?
+      def my_root
+        @root
       end
 
+
       def delete(uri)
-        @@ml_http.send_xquery(@@xquery_builder.delete(uri))
+        doc_uri = (uri || @uri)
+        if doc_uri then
+          response_array = ActiveDocument::CoronaInterface.delete(doc_uri)
+          uri_array = response_array[:uri]
+          @@ml_http.send_corona_request(uri_array[0], uri_array[1])
+        else
+          raise ArgumentError, "uri must not be nil", caller
+        end
       end
 
       # enables the dynamic finders
@@ -235,7 +300,7 @@ module ActiveDocument
           execute_attribute_finder(element, attribute, value, root, element_namespace, attribute_namespace, root_namespace, options)
         elsif method =~ /find_by_(.*)$/ and arguments.length > 0 # identify element search methods
           value = arguments[0]
-          element = $1.to_sym
+          element = $1 # todo: this used to be converted to a symbol. Make sure that keeping it as a string doesn't break something
           if arguments[1]
             root = arguments[1]
           else
@@ -249,7 +314,7 @@ module ActiveDocument
           if arguments[3]
             root_namespace = arguments[3]
           else
-            root_namespace = namespace_for_element(root)
+            root_namespace = namespace_for_element(root) unless root.nil?
           end
           if arguments[4]
             options = arguments[4]
@@ -266,7 +331,13 @@ module ActiveDocument
       # Returns an ActiveXML object representing the requested information. If no document exists at that uri then
       # a LoadException is thrown
       def load(uri)
-        document = @@ml_http.send_xquery(@@xquery_builder.load(uri))
+        response_array = ActiveDocument::CoronaInterface.load(uri)
+        uri_array = response_array[:uri]
+        begin
+          document = @@ml_http.send_corona_request(uri_array[0], uri_array[1])
+        rescue Net::HTTPServerException => exception
+          raise LoadException, "File #{uri} not found", caller
+        end
         if document.empty?
           raise LoadException, "File #{uri} not found", caller
         end
@@ -275,9 +346,10 @@ module ActiveDocument
 
       # Finds all documents of this type that contain the word anywhere in their structure
       def find_by_word(word, root=@root, namespace=@my_default_namespace)
-        xquery = @@xquery_builder.find_by_word(word, root, namespace)
-        @@log.info("ActiveDocument.execute_find_by_word at line #{__LINE__}: #{xquery}")
-        SearchResults.new(@@ml_http.send_xquery(xquery))
+        response_array = ActiveDocument::CoronaInterface.find_by_word(word, root, namespace)
+        uri_array = response_array[:uri]
+        @@log.info("ActiveDocument.execute_find_by_word at line #{__LINE__}: #{response_array}")
+        SearchResults.new(@@ml_http.send_corona_request(uri_array[0], uri_array[1], nil, response_array[:post_parameters]))
       end
 
     end # end inner class
@@ -394,7 +466,7 @@ module ActiveDocument
 
   end
 
-  # end class
+# end class
 
   class ActiveDocumentException < Exception
 

data/lib/ActiveDocument/corona_interface.rb

@@ -0,0 +1,186 @@
+#   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_search_options'
+module ActiveDocument
+
+  #todo create a configuration class for logging info and such
+
+  # CoronaInterface methods always return a hash. This hash will always contain at least a uri key with associated
+  # value
+  class CoronaInterface
+
+    def self.load(uri)
+      {:uri => ["/store?uri=#{uri}", :get]}
+    end
+
+    # @param uri the uri of the record to be deleted
+    # @return A hash containing the necessary return values. This hash contains:
+    # uri: an array where the first element is the uri to be used for the REST call and the second element is the
+    # http verb
+    def self.delete(uri)
+      {:uri => ["/store?uri=#{uri}", :delete]}
+    end
+
+    # @param uri the uri of the record to be saved
+    # @return A hash containing the necessary return values. This hash contains:
+    # uri: an array where the first element is the uri to be used for the REST call and the second element is the
+    # http verb
+    def self.save(uri)
+      {:uri => ["/store?uri=#{uri}", :put]}
+    end
+
+    # This method does a full text search
+    # @return A hash containing the necessary return values. This hash contains:
+    # uri: an array where the first element is the uri to be used for the REST call and the second element is the
+    # http verb
+    # post_parameters: a hash of all post parameters to be submitted
+    def self.find_by_word(word, root, root_namespace, options = nil)
+      #todo deal with paging
+      response = Hash.new
+      post_parameters = Hash.new
+      options = self.setup_options(options, root, root_namespace)
+      unless root.nil?
+        if root_namespace.nil?
+          root_expression = root
+        else
+          root_expression = options.searchable_expression[root_namespace] + ":" + root unless root_namespace.nil?
+        end
+      end
+      structured_query = "{\"underElement\":\"#{root_expression}\",\"query\":{\"wordAnywhere\":\"#{word}\"}}"
+      response[:uri] = ["/search", :post]
+      post_parameters[:structuredQuery] = structured_query
+      post_parameters[:outputFormat] = "xml"
+      post_parameters[:include] = "snippet"
+      post_parameters[:include] = "confidence"
+      if options.directory_constraint
+        if options.directory_depth == 1
+          post_parameters[:inDirectory] = options.directory_constraint
+        else
+          post_parameters[:underDirectory] = options.directory_constraint
+        end
+      end
+      response[:post_parameters] = post_parameters
+      response
+    end
+
+    def self.find_by_element(element, value, root, element_namespace, root_namespace, options = nil)
+      response = Hash.new
+      post_parameters = Hash.new
+      options = self.setup_options(options, root, root_namespace)
+      unless root.nil?
+        if root_namespace.nil?
+          root_expression = root
+        else
+          root_expression = options.searchable_expression[root_namespace] + ":" + root unless root_namespace.nil?
+        end
+      end
+      element_qname = element.to_s
+      element_qname.insert(0, element_namespace + ":") unless element_namespace.nil?
+      # todo this query is the more permissive contains. Deal with more restrictive equals as well
+      structured_query = "{\"element\":\"#{element_qname}\", \"contains\":\"#{value}\"}"
+      response[:uri] = ["/search", :post]
+      post_parameters[:structuredQuery] = structured_query
+      post_parameters[:outputFormat] = "xml"
+      post_parameters[:include] = "snippet"
+      post_parameters[:include] = "confidence"
+      if options.directory_constraint
+        if options.directory_depth == 1
+          post_parameters[:inDirectory] = options.directory_constraint
+        else
+          post_parameters[:underDirectory] = options.directory_constraint
+        end
+      end
+      response[:post_parameters] = post_parameters
+      response
+    end
+
+    def self.find_by_attribute(element, attribute, value, root, element_namespace, attribute_namespace, root_namespace, options = nil)
+      response = Hash.new
+      post_parameters = Hash.new
+      options = self.setup_options(options, root, root_namespace)
+      unless root.nil?
+        if root_namespace.nil?
+          root_expression = root
+        else
+          root_expression = options.searchable_expression[root_namespace] + ":" + root unless root_namespace.nil?
+        end
+      end
+      element_qname = element
+      element_qname.insert(0, element_namespace + ":") unless element_namespace.nil?
+      attribute_qname = attribute.to_s
+      attribute_qname.insert(0, attribute_namespace + ":") unless attribute_namespace.nil?
+      # todo this query is the more permissive contains. Deal with more restrictive equals as well
+      structured_query = "{\"element\":\"#{element_qname}\",\"attribute\":\"#{attribute_qname}\", \"contains\":\"#{value}\"}"
+      response[:uri] = ["/search", :post]
+      post_parameters[:structuredQuery] = structured_query
+      post_parameters[:outputFormat] = "xml"
+      post_parameters[:include] = "snippet"
+      post_parameters[:include] = "confidence"
+      if options.directory_constraint
+        if options.directory_depth == 1
+          post_parameters[:inDirectory] = options.directory_constraint
+        else
+          post_parameters[:underDirectory] = options.directory_constraint
+        end
+      end
+      response[:post_parameters] = post_parameters
+      response
+    end
+
+    def self.search(search_text, start, page_length, options)
+      if options && options.directory_constraint
+        directory_string = nil
+        if options.directory_depth == 1
+          directory_string = "&inDirectory=" + options.directory_constraint
+        else
+          directory_string = "&underDirectory=" +options.directory_constraint
+        end
+      end
+      ["/search?stringQuery=#{search_text}&start=#{start}&end=#{start + page_length -1}&outputFormat=xml&include=snippet&include=confidence#{directory_string}", :get]
+    end
+
+    def self.co_occurrence(element1, element1_namespace, element2, element2_namespace, query)
+      #  Not supported by Corona at this time
+    end
+
+    def self.declare_namespace(prefix, uri)
+      ["/manage/namespace/#{prefix}?uri=#{uri}", :post]
+    end
+
+    # @param uri [The uri for which the matching, if any, prefix should be found]
+    # @return [An array where the first item is the string uri for the request and the second item is the http verb]
+    def self.lookup_namespace(uri)
+      ["/manage/namespace/#{uri}", :get]
+    end
+
+    def self.delete_all_namespaces
+      ["/manage/namespaces/", :delete]
+    end
+
+    private
+
+    def self.setup_options(options, root, root_namespace)
+      if options then
+        search_options = options
+      else
+        search_options = ActiveDocument::MarkLogicSearchOptions.new
+      end
+      if (search_options.searchable_expression.empty?)
+        search_options.searchable_expression[root_namespace] = root unless root.nil?
+      end
+      return search_options
+    end
+
+  end # end class
+end # end module

data/lib/ActiveDocument/database_configuration.rb

@@ -0,0 +1,71 @@
+#   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 "yaml"
+require 'ActiveDocument/mark_logic_http'
+require 'ActiveDocument/corona_interface'
+require "ActiveDocument/finder"
+module ActiveDocument
+
+  # This class is used to manage the configuration of MarkLogic. It can create, list and change / delete a variety of
+  # configuration options including indexes namespaces and fields
+  class DatabaseConfiguration
+
+    attr_reader :namespaces
+
+    # @param yaml_file [The yaml file containing the configuration information for the server connection]
+    def self.initialize(yaml_file)
+      config = YAML.load_file(yaml_file)
+      @@ml_http = ActiveDocument::MarkLogicHTTP.new(config['uri'], config['user_name'], config['password'])
+      @@namespaces = Hash.new
+    end
+
+
+    # @param namespaces [a Hash of namespaces prefixes to namespaces]
+    def self.define_namespaces(namespaces)
+      namespaces.keys.each do |key|
+        corona_array = ActiveDocument::CoronaInterface.declare_namespace(key, namespaces[key])
+        @@ml_http.send_corona_request(corona_array[0], corona_array[1])
+      end
+    end
+
+    # @param prefix [The prefix for which you wish to find a matching namespace]
+    # @return The matching namespace as a string or nil if there is no matching namespace for the prefix
+    def self.lookup_namespace(prefix)
+      corona_array = ActiveDocument::CoronaInterface.lookup_namespace(prefix)
+      begin
+        @@ml_http.send_corona_request(corona_array[0], corona_array[1])
+      rescue Exception => exception
+        if exception.response.code == "404"
+          nil #return nil when no namespace is found
+        else
+          raise exception
+        end
+      end
+    end
+
+    def self.delete_all_namespaces
+      corona_array = ActiveDocument::CoronaInterface.delete_all_namespaces
+      begin
+        @@ml_http.send_corona_request(corona_array[0], corona_array[1])
+      rescue Exception => exception
+        if exception.response && exception.response.code == "404"
+          nil
+        else
+          raise exception
+        end
+      end
+    end
+
+  end
+end

data/lib/ActiveDocument/facets.rb

@@ -0,0 +1,12 @@
+class Facets
+  
+  @facets = Hash.new
+  @results_document.xpath("/search:response/search:facet").each do |facet|
+    name = facet.xpath("./@name").to_s
+    detail = Hash.new
+    @facets[name] = detail
+    facet.xpath("search:facet-value").each do |facet_value|
+      detail[facet_value.xpath("./@name").to_s] = facet_value.xpath("./@count").to_s
+    end
+  end
+end

data/lib/ActiveDocument/finder.rb

@@ -14,8 +14,8 @@
 
 require 'rubygems'
 require 'nokogiri'
-require 'ActiveDocument/mark_logic_query_builder'
 require 'ActiveDocument/mark_logic_http'
+require 'ActiveDocument/corona_interface'
 require 'ActiveDocument/search_results'
 require 'logger'
 
@@ -24,8 +24,6 @@ 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'])
@@ -50,27 +48,29 @@ module ActiveDocument
     end
 
     def self.execute_finder(element, value, root = nil, element_namespace = nil, root_namespace = nil, options = nil)
-      xquery = @@xquery_builder.find_by_element(element, value, root, element_namespace, root_namespace, options)
-      @@log.info("Finder.execute_finder at line #{__LINE__}: #{xquery}")
-      SearchResults.new(@@ml_http.send_xquery(xquery))
+      response_array = ActiveDocument::CoronaInterface.find_by_element(element, value, root, element_namespace, root_namespace, options)
+      uri_array = response_array[:uri]
+      @@log.info("ActiveDocument.execute_element_finder at line #{__LINE__}: #{response_array}")
+      SearchResults.new(@@ml_http.send_corona_request(uri_array[0], uri_array[1], nil, response_array[:post_parameters]))
     end
 
-      def self.execute_attribute_finder(element, attribute, value, root = nil, element_namespace = nil, attribute_namespace = nil, root_namespace = nil, options = nil)
-      xquery = @@xquery_builder.find_by_attribute(element, attribute, value, root, element_namespace, attribute_namespace, root_namespace, options)
-      @@log.info("Finder.execute_attribute_finder at line #{__LINE__}: #{xquery}")
-      SearchResults.new(@@ml_http.send_xquery(xquery))
+    def self.execute_attribute_finder(element, attribute, value, root = nil, element_namespace = nil, attribute_namespace = nil, root_namespace = nil, options = nil)
+      response_array = ActiveDocument::CoronaInterface.find_by_attribute(element, attribute, value, root, element_namespace, attribute_namespace, root_namespace, options)
+      uri_array = response_array[:uri]
+      @@log.info("ActiveDocument.execute_attribute_find_by_word at line #{__LINE__}: #{response_array}")
+      SearchResults.new(@@ml_http.send_corona_request(uri_array[0], uri_array[1], nil, response_array[:post_parameters]))
     end
 
     def self.search(search_string, start = 1, page_length = 10, options = nil)
       start ||= 1
       page_length ||= 10
-      search_text = @@xquery_builder.search(search_string, start, page_length, options)
-      SearchResults.new(@@ml_http.send_xquery(search_text))
+      corona_array = ActiveDocument::CoronaInterface.search(search_string, start, page_length, options)
+      SearchResults.new(@@ml_http.send_corona_request(corona_array[0], corona_array[1]))
     end
 
     # returns a hash where the key is the terms of the co-occurrence separated by a | and the value is the frequency count
     def self.co_occurrence(element1, element1_namespace, element2, element2_namespace, query)
-      pairs = @@ml_http.send_xquery(@@xquery_builder.co_occurrence(element1, element1_namespace, element2, element2_namespace, query)).split("*")
+      pairs = @@ml_http.send_xquery(ActiveDocument::CoronaInterface.co_occurrence(element1, element1_namespace, element2, element2_namespace, query)).split("*")
       pair_hash = Hash.new
       pairs.each do |p|
         temp = p.split("|")
@@ -85,30 +85,30 @@ module ActiveDocument
 
       begin
         log_location = if config['logger']['file']
-          config['logger']['file']
-        else
-          STDERR
-        end
+                         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
+                      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

data/lib/ActiveDocument/mark_logic_http.rb

@@ -68,30 +68,53 @@ module ActiveDocument
       @password = password
     end
 
-    def send_xquery(xquery)
-      if xquery.nil? or xquery.empty? then
-        return nil
+# @param uri [the uri endpoint for the request]
+# @param body [the optional body]
+# @param verb [The HTTP verb to be used]
+# @param post_fields [a hash of post fields. They key should be the field name and the value is the field value]
+# @return [nil if there if no uri or it is an empty string. Otherwise, returns the http response]
+    def send_corona_request(uri, verb=:get, body="", post_fields=nil)
+      return nil if uri.nil? or uri.empty?
+      target_url = @url + URI.escape(uri)
+      http = Net::HTTP.new(target_url.host, target_url.port)
+      if target_url.query
+        endpoint = target_url.path + "?" + target_url.query
+      else
+        endpoint = target_url.path
       end
-      req = authenticate()
-      req.set_form_data({'request'=>"#{xquery}"})
-      res = Net::HTTP.new(@url.host, @url.port).start {|http| http.request(req) }
+      case verb
+        when :post
+          req = Net::HTTP::Post.new(endpoint)
+          req.set_form_data(post_fields) unless post_fields.nil?
+          #puts URI.decode_www_form(req.body)
+        when :put
+          req = Net::HTTP::Put.new(endpoint)
+        when :get
+          req = Net::HTTP::Get.new(endpoint)
+        when :delete
+          req = Net::HTTP::Delete.new(endpoint)
+        else
+          req = Net::HTTP::Get.new(endpoint) # safe default
+      end
+      if ((! body.nil?) and (verb == :put or verb == :post) ) then
+        if (req.body.nil?) then req.body = body
+        else
+          req.body << body
+        end
+      end
+      res = http.head(target_url.request_uri)
+      #puts "body::::: #{req.body}" unless verb == :put
+      req.digest_auth(@user_name, @password, res)
+      res = http.request(req)
       case res
         when Net::HTTPSuccess, Net::HTTPRedirection
-#          puts res.body
+          #puts res.body
           res.body
         else
-          res.error!
+          #puts req.path
+          raise 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/search_match.rb

@@ -30,8 +30,8 @@ module ActiveDocument
     def to_s
       value = @node.xpath("./node()").to_s
       begin
-        value[/<search:highlight>/] = ""
-        value[/<\/search:highlight>/] = ""
+        value[/<span class="hit">/] = ""
+        value[/<\/span>/] = ""
       rescue IndexError
       end
       return value
@@ -41,8 +41,8 @@ module ActiveDocument
       value = @node.xpath("./node()").to_s
       unless highlight_tag.nil?
         begin
-          value[/<search:highlight>/] = "<#{highlight_tag}>"
-          value[/<\/search:highlight>/] = "</#{highlight_tag}>"
+          value[/<span class="hit">/] = "<#{highlight_tag}>"
+          value[/<\/span>/] = "</#{highlight_tag}>"
         rescue IndexError
           value
         end

data/lib/ActiveDocument/search_result.rb

@@ -24,52 +24,53 @@ module ActiveDocument
       @node = node
     end
 
-    def index
-      Integer(@node.xpath("./@index").to_s)
-    end
+    #def index
+    #  Integer(@node.xpath("./@index").to_s)
+    #end
 
     def uri
-      @node.xpath("./@uri").to_s
+      @node.xpath("./corona:result/corona:uri").text.to_s
     end
 
-    def path
-      @node.xpath("./@path").to_s
-    end
+    #def path
+    #  @node.xpath("./@path").to_s
+    #end
 
-    def score
-      Float(@node.xpath("./@score").to_s)
-    end
+    #def score
+    #  Float(@node.xpath("./@score").to_s)
+    #end
 
     def confidence
-      Float(@node.xpath("./@confidence").to_s)
+      Float(@node.xpath("./corona:result/corona:confidence").text.to_s)
     end
 
-    def fitness
-      Float(@node.xpath("./@fitness").to_s)
-    end
+    #def fitness
+    #  Float(@node.xpath("./@fitness").to_s)
+    #end
 
     def each(&block)
-      nodeset = @node.xpath("./search:snippet/search:match")
+      nodeset = @node.xpath("./corona:result/corona:snippet/span")
       if nodeset.length == 1
         yield SearchMatch.new(nodeset[0])
       else
-        @node.xpath("./search:snippet/search:match").each {|node| yield SearchMatch.new(node)}
+        @node.xpath("./corona:result/corona:snippet/span").each { |node| yield SearchMatch.new(node) }
       end
     end
 
     def root_type
-      full_path = @node.xpath("./search:snippet/search:match")[0].xpath("./@path").to_s
-      root = full_path.match(/:[[:alpha:]]+\/|:[[:alpha:]]+$/) # find the first :something/ which should indicate the root
+      full_path = @node.xpath("./corona:result/corona:snippet/span").xpath("./@path").to_s
+      root = full_path.match(/^\/[[:alpha:]]*((:)[[: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 [](index)
-      SearchMatch.new(@node.xpath("./search:snippet/search:match")[index])
+      SearchMatch.new(@node.xpath("./corona:result/corona:snippet/span")[index])
     end
 
     def length
-      @node.xpath("./search:snippet/search:match").length
+      @node.xpath("./corona:result/corona:snippet/span").length
     end
+
     def realize(klass)
       klass.load(uri)
     end

data/lib/ActiveDocument/search_results.rb

@@ -23,64 +23,39 @@ module ActiveDocument
 
     def initialize(results)
       @results_document = Nokogiri::XML(results)
-      @facets = Hash.new
-      @results_document.xpath("/search:response/search:facet").each do |facet|
-        name = facet.xpath("./@name").to_s
-        detail = Hash.new
-        @facets[name] = detail
-        facet.xpath("search:facet-value").each do |facet_value|
-          detail[facet_value.xpath("./@name").to_s] = facet_value.xpath("./@count").to_s
-        end
-      end
     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)
+      Integer(@results_document.xpath("/corona:response/corona:meta/corona:total/text()").to_s)
     end
 
-    def search_text
-      @results_document.xpath("/search:response/search:qtext/text()").to_s
+    def execution_time
+      Integer(@results_document.xpath("/corona:response/corona:meta/corona:executionTime/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
+    def start
+      Integer(@results_document.xpath("/corona:response/corona:meta/corona:start/text()").to_s)
     end
 
-    def total_time
-      @results_document.xpath("/search:response/search:metrics/search:total-time/text()").to_s
+    def page_length
+      total - start + 1
     end
 
     def each(&block)
-      nodeset = @results_document.xpath("/search:response/search:result")
+      nodeset = @results_document.xpath("/corona:response/corona:results/corona:result")
       if nodeset.length == 1
         yield SearchResult.new(nodeset[0])
       else
-        @results_document.xpath("/search:response/search:result").each {|node| yield SearchResult.new(node)}
+        @results_document.xpath("/corona:response/corona:results/corona:result").each {|node| yield SearchResult.new(node)}
       end
     end
 
     def [](index)
-      SearchResult.new(@results_document.xpath("/search:response/search:result")[index])
+      SearchResult.new(@results_document.xpath("/corona:response/corona:results/corona:result")[index])
     end
 
     def length
-      @results_document.xpath("/search:response/search:result").length
+      @results_document.xpath("/corona:response/corona:results/corona:result").length
     end
 
   end

data/lib/active_document.rb

@@ -2,7 +2,7 @@ require 'ActiveDocument/active_document'
 require 'ActiveDocument/finder'
 require 'ActiveDocument/inheritable'
 require 'ActiveDocument/mark_logic_http'
-require 'ActiveDocument/mark_logic_query_builder'
+require 'ActiveDocument/corona_interface'
 require 'ActiveDocument/search_match'
 require 'ActiveDocument/mark_logic_search_options'
 require 'ActiveDocument/search_result'

metadata

@@ -1,8 +1,11 @@
 --- !ruby/object:Gem::Specification 
 name: activedocument
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.6.2
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
 platform: ruby
 authors: 
 - Clark D. Richey, Jr.
@@ -10,16 +13,20 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-10 00:00:00 Z
+date: 2012-01-04 00:00:00 -05:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: nokogiri
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 1
         version: 1.4.1
   type: :runtime
   version_requirements: *id001
@@ -32,17 +39,20 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/active_document.rb
 - lib/ActiveDocument/active_document.rb
+- lib/ActiveDocument/corona_interface.rb
+- lib/ActiveDocument/database_configuration.rb
+- lib/ActiveDocument/facets.rb
 - lib/ActiveDocument/finder.rb
 - lib/ActiveDocument/inheritable.rb
 - lib/ActiveDocument/mark_logic_http.rb
-- lib/ActiveDocument/mark_logic_query_builder.rb
 - lib/ActiveDocument/mark_logic_search_options.rb
 - lib/ActiveDocument/search_match.rb
 - lib/ActiveDocument/search_result.rb
 - lib/ActiveDocument/search_results.rb
-- lib/active_document.rb
 - lib/activedocument.rb
+has_rdoc: true
 homepage: http://github.com/crichey/ActiveDocument
 licenses: []
 
@@ -52,21 +62,23 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Object Mapper for XML Database

data/lib/ActiveDocument/mark_logic_query_builder.rb

@@ -1,111 +0,0 @@
-#   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_search_options'
-module ActiveDocument
-# todo create new unit tests for this class - the old ones were no good
-  class MarkLogicQueryBuilder
-
-    def load(uri)
-      "fn:doc('#{uri}')"
-    end
-
-    def delete(uri)
-      "xdmp:document-delete('#{uri}')"
-    end
-
-    def save(document, uri)
-      xquery = <<-GENERATED
-         xdmp:document-insert(
-           "#{uri}",
-             #{document.to_s}  ,
-           xdmp:default-permissions(),
-           xdmp:default-collections())
-      GENERATED
-    end
-
-    # This method does a full text search
-    def find_by_word(word, root, root_namespace, options = nil)
-      xquery = <<-GENERATED
-        import module namespace search = "http://marklogic.com/appservices/search" at "/MarkLogic/appservices/search/search.xqy";
-        search:search("#{word}",
-      GENERATED
-     search_options = setup_options(options, root, root_namespace)
-      xquery << search_options.to_s
-      xquery << ')'
-    end
-
-    def find_by_element(element, value, root, element_namespace, root_namespace, options = nil)
-      xquery = <<-GENERATED
-        import module namespace search = "http://marklogic.com/appservices/search"at "/MarkLogic/appservices/search/search.xqy";
-        search:search('find_by_element:\"#{value}\"',
-      GENERATED
-      search_options = setup_options(options, root, root_namespace)
-      search_options.word_constraints["find_by_element"] = {"namespace" => element_namespace, "element" => element}
-      xquery << search_options.to_s
-      xquery << ')'
-    end
-
-
-    def find_by_attribute(element, attribute, value, root, element_namespace, attribute_namespace, root_namespace, options = nil)
-      xquery = <<-GENERATED
-        import module namespace search = "http://marklogic.com/appservices/search" at "/MarkLogic/appservices/search/search.xqy";
-        search:search("attribute:#{value}",
-      GENERATED
-      search_options = setup_options(options, root, root_namespace)
-      attribute_constraint = ActiveDocument::MarkLogicSearchOptions::AttributeConstraint.new(attribute_namespace, attribute, element_namespace, element)
-      search_options.attribute_constraints["attribute"] = attribute_constraint
-      xquery << search_options.to_s
-      xquery << ')'
-    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
-
-    def co_occurrence(element1, element1_namespace, element2, element2_namespace, query)
-      <<-GENERATED
-        declare namespace one = "#{element1_namespace}";
-        declare namespace two = "#{element2_namespace}";
-        import module namespace search = "http://marklogic.com/appservices/search" at "/MarkLogic/appservices/search/search.xqy";
-        let $pairs := cts:element-value-co-occurrences(xs:QName('one:#{element1}'), xs:QName('two:#{element2}'), ('frequency-order', 'fragment-frequency','ordered'), cts:query(search:parse('#{query}')))
-        return
-        for $pair in $pairs
-        return
-          ($pair/cts:value[1]/text(),"|",$pair/cts:value[2]/text(),"|",cts:frequency($pair),"*")
-      GENERATED
-    end
-    private
-    
-    def setup_options(options, root, root_namespace)
-      if options then
-        search_options = options
-      else
-        search_options = ActiveDocument::MarkLogicSearchOptions.new
-      end
-      if (search_options.searchable_expression.empty?)
-        search_options.searchable_expression[root_namespace] = root unless root.nil?
-      end
-      return search_options
-    end
-
-  end # end class
-end # end module