activedocument 0.5 → 0.6

data/lib/ActiveDocument/active_document.rb

@@ -221,7 +221,12 @@ module ActiveDocument
           else
             root_namespace = namespace_for_element(root)
           end
-          execute_attribute_finder(element, attribute, value, root, element_namespace, attribute_namespace, root_namespace)
+          if arguments[6]
+            options = arguments[6]
+          else
+            options = nil
+          end
+          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
@@ -240,7 +245,14 @@ module ActiveDocument
           else
             root_namespace = namespace_for_element(root)
           end
-          execute_finder(element, value, root, element_namespace, root_namespace)
+          if arguments[4]
+            options = arguments[4]
+          else
+            options = nil
+          end
+          execute_finder(element, value, root, element_namespace, root_namespace, options)
+        else
+          super
         end
 
       end

data/lib/ActiveDocument/finder.rb

@@ -49,14 +49,14 @@ module ActiveDocument
       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)
+    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))
     end
 
-      def self.execute_attribute_finder(element, attribute, value, root = nil, element_namespace = nil, attribute_namespace = nil, root_namespace = nil)
-      xquery = @@xquery_builder.find_by_attribute(element, attribute, value, root, element_namespace, attribute_namespace, root_namespace)
+      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))
     end

data/lib/ActiveDocument/mark_logic_query_builder.rb

@@ -11,7 +11,7 @@
 #   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
@@ -26,77 +26,47 @@ module ActiveDocument
 
     def save(document, uri)
       xquery = <<-GENERATED
-            xdmp:document-insert(
-         "#{uri}",
-	 #{document.to_s},
-         xdmp:default-permissions(),
-         xdmp:default-collections())
-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, namespace)
+    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";
+        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>)"
+      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)
+    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("word:#{value}",
-        <options xmlns="http://marklogic.com/appservices/search">
+        search:search('find_by_element:\"#{value}\"',
       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
+      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)
-      # todo should the searchable expression portion be refactored?
+
+    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("word:#{value}",
-        <options xmlns="http://marklogic.com/appservices/search">
+        import module namespace search = "http://marklogic.com/appservices/search" at "/MarkLogic/appservices/search/search.xqy";
+        search:search("attribute:#{value}",
       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>
-          <attribute ns="#{attribute_namespace unless attribute_namespace.nil?}" name="#{attribute}"/>
-          <element ns="#{element_namespace unless element_namespace.nil?}" name="#{element}"/>
-        </word>
-        </constraint></options>)
-      CONSTRAINT
+      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)
@@ -106,23 +76,36 @@ GENERATED
         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})
+      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),"*")
+        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

data/lib/ActiveDocument/mark_logic_search_options.rb

@@ -13,26 +13,45 @@
 #   limitations under the License.
 
 
-# MarkLogicSearchOptions 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
+  # MarkLogicSearchOptions 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 - Used for creating searches on the value of an element
+  #   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"}
+  # * word_constraints - Used for creating searches for a word within an element value. This is a #Hash of word constaint names to their options
+  #   this is a #Hash of value constraint names to their options.
+  #   e.g. search_options_object.word_constraints["Region"] = {"namespace" => "http://wits.nctc.gov", "element" => "Region"}
+  # * range_constraints - Used for searching for a range of values, also for creating facets or doing co-occurents.
+  #   This is a #hash of range_constraint names to their options
+  #   e.g. search_options_object.range_constraints["Facility Type"] = {"namespace" => "http://wits.nctc.gov", "element" => "FacilityType", "type" => "xs:string", "collation" => "http://marklogic.com/collation/"}
+  # * directory_constraint - Used for specifying that the search should only executed for this directory, to the depth
+  #   specified in directory_depth
+  # * searchable_expression - An expression to be searched. Whatever expression is specified is returned from the search.
+  #   This is provided as a hash where the key is the element name and the value is the element's namespace. If there is no
+  #   namespace then nil or "" should be passed as the value. eg search_options_object.searchable_expression["element"] = "namespace" or
+  #   search_options_object.searchable_expression["element"] = "" if there is no namespace for element
   class MarkLogicSearchOptions
-    attr_accessor :return_facets, :value_constraints, :word_constraints, :range_constraints
+    attr_accessor :return_facets, :value_constraints, :word_constraints, :attribute_constraints, :range_constraints, :directory_constraint, :directory_depth, :searchable_expression
 
     def initialize
       @return_facets = true;
       @value_constraints = Hash.new
       @word_constraints = Hash.new
+      @attribute_constraints = Hash.new
       @range_constraints = Hash.new
+      @searchable_expression = Hash.new
+      @directory_depth = 1
     end
 
-
     # outputs the object in correctly formatted XML suitable for use in a search
     def to_s
       constraints = String.new
+      additional_query = String.new
+      searchable_path = String.new
+
       @value_constraints.each do |key, value|
         constraints << <<-XML
         <constraint name="#{key.gsub(/\s/, '_')}">
@@ -53,6 +72,17 @@ module ActiveDocument
         XML
       end
 
+      @attribute_constraints.each do |constraint_name, attribute_constraint|
+        constraints << <<-XML
+        <constraint name="#{constraint_name.gsub(/\s/, '_')}">
+          <word>
+            <attribute ns="#{attribute_constraint.attribute_namespace unless attribute_constraint.attribute_namespace.nil?}" name="#{attribute_constraint.attribute}"/>
+          <element ns="#{attribute_constraint.element_namespace unless attribute_constraint.element_namespace.nil?}" name="#{attribute_constraint.element}"/>
+          </word>
+        </constraint>
+        XML
+      end
+
       @range_constraints.each do |key, value|
         constraints << <<-XML
         <constraint name="#{key.gsub(/\s/, '_')}">
@@ -75,15 +105,35 @@ module ActiveDocument
         constraints << "</range></constraint>"
       end
 
-      value = <<-XML
-      <options xmlns="http://marklogic.com/appservices/search">
-      <return-facets>#{@return_facets}</return-facets>
-      XML
+      # serialize the additional query information
+      if @directory_constraint
+        additional_query = "<additional-query>{cts:directory-query(\"#{directory_constraint}\", \"#{directory_depth}\")}</additional-query>"
+      end
+
+      # serialize the searchable_expression
+      if @searchable_expression.size > 0
+        searchable_path << "<searchable-expression"
+        searchable_path << "  xmlns:a=\"#{@searchable_expression.keys[0]}\"" unless @searchable_expression.keys[0].nil? or @searchable_expression.keys[0].empty?
+        searchable_path << '>/'
+        searchable_path << "a:" unless @searchable_expression.keys[0].nil? or @searchable_expression.keys[0].empty?
+        searchable_path << "#{@searchable_expression.values[0]}</searchable-expression>"
+      end
+
+      value = "<options xmlns=\"http://marklogic.com/appservices/search\">"
+      unless additional_query.empty?
+        value << additional_query
+      end
 
       # add in constraints
       unless constraints.empty?
         value << constraints
       end
+      value << "<return-facets>#{@return_facets}</return-facets>"
+
+      # output the searchable expression
+      unless searchable_path.empty?
+        value << searchable_path
+      end
       # close the options node
       value << "</options>"
 
@@ -108,6 +158,18 @@ module ActiveDocument
         XML
       end
     end
+
+    class AttributeConstraint
+      attr_reader :attribute_namespace, :attribute, :element_namespace, :element
+
+      def initialize (attribute_namespace, attribute, element_namespace, element)
+        @attribute_namespace = attribute_namespace
+        @attribute = attribute
+        @element_namespace = element_namespace
+        @element = element
+      end
+    end
+
   end
 
 end

metadata

@@ -4,8 +4,8 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
-  version: "0.5"
+  - 6
+  version: "0.6"
 platform: ruby
 authors: 
 - Clark D. Richey, Jr.
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-22 00:00:00 -07:00
+date: 2010-11-03 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency