activedocument 0.2.2 → 0.3

data/lib/ActiveDocument/active_document.rb

@@ -65,35 +65,47 @@ module ActiveDocument
   # -------------------
   class Base < Finder
     include ClassLevelInheritableAttributes
-    inheritable_attributes_list :namespaces, :default_namespace, :root
-    @namespaces = Hash.new
-    @default_namespace = String.new
-    attr_reader :document, :uri
+    inheritable_attributes_list :my_namespaces, :my_default_namespace, :root
+    @my_namespaces = Hash.new
+    @my_default_namespace = String.new
+    attr_reader :document, :uri, :my_namespaces, :my_default_namespace, :root
 
 
     # 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
+    def initialize(xml_string = "", uri = "nil")
+      @document = Nokogiri::XML(xml_string) do |config|
+        config.noblanks
+      end
+      if !xml_string.empty? then
+        @root = @document.root.name
       end
-      @root = self.class.to_s
       @uri = uri
     end
 
+    def to_s
+      @document.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_DECLARATION)
+    end
+
+    # saves this document to the repository. If _uri_ is provided then that will be the value used for the uri.
+    # If no uri was passed in then the existing value or the uri is used, unless uri is nil in which case an exception
+    # will be thrown
+    def save(uri = nil)
+      doc_uri = (uri || @uri)
+      if doc_uri then
+        @@ml_http.send_xquery(@@xquery_builder.save(self, doc_uri))
+      else
+        raise ArgumentError, "uri must not be nil", caller
+      end
+
+    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)
+    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 '='
@@ -101,77 +113,47 @@ module ActiveDocument
           super
         end
         access_element $1
+      elsif method =~ /^(\w*)=$/ && arguments.length == 1 # methods with no '.' in them and ending in '='
+        set_element($1, arguments)
       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
 
+    class << self
+      attr_reader :namespaces, :default_namespace, :root
 
-    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}
+      def namespace_for_element(element)
+        namespace = nil
+        if !@my_namespaces.nil? && @my_namespaces[element]
+          namespace = @my_namespaces[element]
         else
-          # we have multiple complex elements
-          PartialResult.new(result_nodeset)
+          namespace = @my_default_namespace unless @my_default_namespace.nil?
         end
-      end
-    end
-
-    class PartialResult < self
-      def initialize(nodeset)
-        @document = nodeset
-        @root = nodeset[0].name
-      end
-
-      def to_s
-        @document.to_s
+        namespace
       end
 
-
-    end
-
-    class << self
-      attr_reader :namespaces, :default_namespace, :root
-
       def namespaces(namespace_hash)
-        @namespaces = namespace_hash
+        @my_namespaces = namespace_hash
       end
 
       def add_namespace(element, uri)
-        @namespaces[element.to_s] == uri
+        @my_namespaces[element.to_s] == uri
       end
 
       def remove_namespace(element)
-        @namespaces.delete element
+        @my_namespaces.delete element
       end
 
       def default_namespace(namespace)
-        @default_namespace = namespace # todo should this just be an entry in namespaces?
+        @my_default_namespace = namespace # todo should this just be an entry in namespaces?
+      end
+
+      def delete(uri)
+        @@ml_http.send_xquery(@@xquery_builder.delete(uri))
       end
 
       # enables the dynamic finders
-      def method_missing(method_id, *arguments, &block)
+      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
@@ -198,28 +180,126 @@ module ActiveDocument
 
       end
 
-      # Returns an ActiveXML object representing the requested information
+      # Returns an ActiveXML object representing the requested information. If no document exists at that uri then an
+      # empty domain object is created and returned
       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)
+      def find_by_word(word, root=@root, namespace=@my_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]
+
+    end # end inner class
+
+
+    class PartialResult < self
+      # todo should this contain a reference to its parent?
+      def initialize(nodeset, parent)
+        @document = nodeset
+        @root = nodeset[0].name
+        @my_namespaces = parent.class.my_namespaces
+        @my_default_namespace = parent.class.my_default_namespace
+      end
+
+      # returns the number of Nodes in the underlying _NodeSet_
+      def length
+        @document.length
+      end
+
+      # provides access to the child nodes
+      def children
+        @document.children
+      end
+
+      # provides access to an indexed node
+      def [](index)
+        @document[index]
+      end
+
+    end
+
+    private
+    def namespace_for_element(element)
+      namespace = nil
+      ns = @my_namespaces || self.class.my_namespaces
+      default_ns = @my_default_namespace || self.class.my_default_namespace
+      if !ns.nil? && ns[element]
+        namespace = ns[element]
+      else
+        namespace = default_ns unless default_ns.nil?
+      end
+      namespace
+    end
+
+    def xpath_for_element(element)
+      xpath = String.new
+      xpath = "//" unless self.instance_of? PartialResult
+      namespace = namespace_for_element(element)
+      element = "ns:#{element}" unless namespace.nil? || namespace.empty?
+      xpath << element
+      return xpath, namespace
+    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
         else
-          namespace = @default_namespace unless @default_namespace.nil?
+          PartialResult.new(result_nodeset, self)
+        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, self)
         end
-        namespace
       end
-    end # end inner class
+    end
+
+    def set_element(element, value)
+      # element.chop!
+      xpath, namespace = xpath_for_element(element)
+      if namespace.nil?
+        node = @document.xpath(xpath)
+      else
+        node = @document.xpath(xpath, {'ns' => namespace})
+      end
+      if node[0].child.type == Nokogiri::XML::Node::TEXT_NODE
+        node[0].child.content = value
+      else
+        raise ArgumentError, "You can't modify a complex node", caller
+      end
+    end
+
+    def access_element(element)
+      xpath, namespace = xpath_for_element(element)
+      if namespace.nil?
+        nodes = @document.xpath(xpath)
+      else
+        nodes = @document.xpath(xpath, {'ns' => namespace})
+      end
+      evaluate_nodeset(nodes)
+
+    end
+
+
+  end
+
+  # end class
+
+  class ActiveDocumentException < Exception
+
+  end
+
+  class PersistenceException < ActiveDocumentException
 
-  end # end class
+  end
 
 
 end # end module

data/lib/ActiveDocument/mark_logic_query_builder.rb

@@ -20,6 +20,21 @@ module ActiveDocument
       "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, namespace)
       xquery = <<GENERATED

data/lib/ActiveDocument/search_result.rb

@@ -58,6 +58,10 @@ module ActiveDocument
       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])
+    end
+
     def realize(klass)
       klass.load(uri)
     end

data/lib/ActiveDocument/search_results.rb

@@ -70,6 +70,10 @@ module ActiveDocument
       @results_document.xpath("/search:response/search:result").each {|node| yield SearchResult.new(node)}
     end
 
+    def [](index)
+      @results_document[index]
+    end
+
   end
 
 end

metadata

@@ -4,9 +4,8 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: "0.3"
 platform: ruby
 authors: 
 - Clark D. Richey, Jr.
@@ -14,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-08 00:00:00 -04:00
+date: 2010-06-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency