jruby-existdb 0.4

data/lib/existdb.rb

@@ -0,0 +1,74 @@
+require 'java' 
+require 'uri'
+require 'cgi' # For HTML Escaping
+require 'find'
+require 'fileutils'
+require 'singleton'
+require 'forwardable'
+require 'date'
+require 'time'
+
+$LOAD_PATH << File.dirname(__FILE__)
+
+module ExistDB
+  class SystemProperties
+    class << self
+      def home_directory
+        defined?(EXIST_HOME) && EXIST_HOME || ENV['EXIST_HOME'] || '/var/spool/existdb'
+      end
+      
+      def log_directory
+        defined?(EXIST_LOG) && EXIST_LOG || ENV['EXIST_LOG'] || '/var/log/existdb'
+      end
+
+      def data_directory
+        home_directory + '/data'
+      end
+
+      def init
+        java.lang.System.setProperty('exist.home', home_directory)
+        java.lang.System.setProperty('exist.logdir', log_directory)
+      end
+
+      def autocreate_config_files
+        # Copy the config files to the places where eXist will eXpect them.
+        # the log4j.xml file should be on your classpath to ensure proper logging
+        [ 'conf.xml', 'log4j.xml' ].each do |config_file|
+            src = "#{File.dirname(__FILE__)}/../#{config_file}"
+            dest = "#{home_directory}/#{config_file}"
+            FileUtils.copy(src, dest) if not File.exists?(dest)
+        end
+      end
+
+      def autocreate_data_directory
+        FileUtils.mkdir_p data_directory
+      end
+
+    end
+    init
+    autocreate_data_directory
+    autocreate_config_files
+  end
+end
+
+# Load eXistDB jars
+Find.find( File.dirname(__FILE__) + '/jars' ) do |path|
+  next if File.extname(path) != '.jar'
+  require path
+end
+
+require 'existdb/classwrap.rb'
+require 'existdb/collection.rb'
+
+require 'existdb/resource/base.rb'
+require 'existdb/resource/xml.rb'
+require 'existdb/resource/binary.rb'
+require 'existdb/resource_set.rb'
+
+require 'existdb/xquery_service.rb'
+require 'existdb/meta.rb'
+require 'existdb/embedded.rb'
+require 'existdb/xql_factory.rb'
+require 'existdb/index_factory.rb'
+require 'existdb/dom/mapper.rb'
+require 'existdb/dom/active_record.rb'

data/lib/existdb/classwrap.rb

@@ -0,0 +1,70 @@
+module ExistDB
+
+    class ClassUnwrap
+        class << self
+            def [](obj)
+                if obj.is_a?(Array) then
+                    return obj.map{ |o| ClassUnwrap[o] }
+                else
+                    obj.instance_variable_get(:@obj) || obj
+                end
+            end
+        end
+    end
+    
+    class ClassWrap
+        class << self
+            def [](java_obj)
+                return nil if java_obj.nil?
+                if java_obj.is_a?(Fixnum) or java_obj.is_a?(String) then
+                    return java_obj
+                end
+                klass = map[java_obj.class]
+                if klass then
+                    if klass.is_a?(Proc) then
+                        return klass.call(java_obj)
+                    else
+                        return klass.new(java_obj)
+                    end
+                else
+                    raise "I don't know how to wrap [#{java_obj.class}]"
+                end
+            end
+
+            def map
+                {
+                    Java::OrgExistXmldb::LocalCollection => Collection,
+                    Java::OrgExistXmldb::LocalXPathQueryService => XQueryService,
+                    Java::OrgExistXmldb::LocalResourceSet => ResourceSet,
+                    Java::OrgExistXmldb::LocalXMLResource => Resource::Xml,
+                    Java::OrgExistXmldb::LocalBinaryResource => Resource::Binary,
+                    Java::OrgExistXmldb::FullXmldbURI => Proc.new { |obj| obj.toString },
+                    Java::JavaUtil::Date => Proc.new { |obj| Time.parse( obj.to_s ) },
+                    Java::OrgExistXquery::PathExpr => Proc.new { |obj| obj }
+                }
+            end
+        end
+    end
+
+    module ClassWrappingForwardable
+        def delegate_to_java(*opts)
+            opts.each do |opt|
+                if opt.is_a?(Hash) then
+                    opt.each do |to, from|
+                        module_eval "
+                            def #{to}(*opts)
+                                ClassWrap[ @obj.#{from}( *ClassUnwrap[ opts ] ) ]
+                            end
+                        "
+                    end
+                else
+                    module_eval "
+                        def #{opt}(*opts)
+                            ClassWrap[ @obj.#{opt}( *ClassUnwrap[ opts ] ) ]
+                        end
+                    "
+                end
+            end
+        end
+    end
+end

data/lib/existdb/collection.rb

@@ -0,0 +1,98 @@
+module ExistDB
+    class Collection
+
+        extend ClassWrappingForwardable
+        delegate_to_java :name, :path, :uri, :parent => :getParentCollection, :to_s => :name
+        
+        def initialize(java_obj)
+            @obj = java_obj
+        end
+
+        def collections
+            child_collection_names.map{|name|
+                collection(name)
+            }
+        end
+
+        def collection(name)
+            Collection.new( @obj.getChildCollection(name) ) if child_collection_names.include?(name)
+        end
+
+        def resources
+            resource_names.map{ |name|
+                resource(name)
+            }
+        end
+
+        def resource(name)
+            Resource.new( @obj.getResource(name) ) if resource_names.include?(name)
+        end
+
+        # Supports relative paths including slashes
+        # e.g. 'foo/bar/baz'
+        # Wish I could figure out how to do absolute paths from here...
+        def [](path)
+            (myconcern, remainder) = path.split('/', 2)
+            if myconcern.nil? or myconcern == '' then
+                return nil
+            elsif myconcern == '..' then
+                target = parent
+            else
+                target = collection(myconcern) || resource(myconcern)
+            end
+
+            if target.nil? then
+                return nil
+            elsif remainder then
+                return target[remainder]
+            else
+                return target
+            end
+        end
+
+        def delete(resource = nil)
+            if resource.nil? then
+                collection_manager.removeCollection(@obj.uri)
+            else
+                @obj.removeResource( ClassUnwrap[ resource ] )
+            end
+            true
+        end
+
+        def xquery
+            ClassWrap[ @obj.getService('XQueryService', '1.0') ]
+        end
+
+        def create_collection(path)
+            if path =~ /^\// then
+                ClassWrap[ collection_manager.createCollection( path ) ]
+            else
+                ClassWrap[ collection_manager.createCollection( self.path + '/' + path ) ]
+            end
+        end
+
+        def store_url(url, name)
+            url = url.to_s.gsub(/&(?!amp;)/, '&')
+            xquery.query("xmldb:store( '#{self.uri}', '#{name}', doc(#{url.inspect})  )")
+        end
+
+        def inspect
+            "#<#{self.class}:0x#{self.hash.to_s(16)} name=#{self.name.inspect}>"
+        end
+
+        def child_collection_names
+            @obj.getChildCollections.collect
+        end
+
+        def resource_names
+            @obj.getResources.collect
+        end
+
+        private
+
+        def collection_manager
+            @obj.getService('CollectionManager','1.0')
+        end
+
+    end
+end

data/lib/existdb/dom/active_record.rb

@@ -0,0 +1,82 @@
+module ExistDB
+    module Dom
+        
+        # Inspired by Rails ActiveRecord
+        # Because we cannot make assumptions about the structure of XML this must inspect the dom when descending into each node.
+        # For large well structured documents a mapper pattern where the structure is defined in the class would be more efficient.
+
+        class ActiveRecord
+
+            module NodeArray
+                def [](*opts)
+                    raw = super
+                    if raw.is_a?(Array) then
+                        return raw.map{|obj| convert(obj) }
+                    else
+                        return convert(raw)
+                    end
+                end
+
+                def each
+                    super do |obj|
+                        yield convert(obj)
+                    end
+                end
+            end
+
+            module Convertible
+                private
+
+                def convert(obj)
+                    @cache ||= Hash.new
+                    if @cache[obj] then
+                        return @cache[obj]
+                    else
+                        if obj.getFirstChild.getNodeName == '' then
+                            @cache[obj] = obj.getNodeValue
+                        else
+                            @cache[obj] = ActiveRecord.new(obj)
+                        end
+                        return @cache[obj]
+                    end
+                end
+            end
+
+
+            include org.w3c.dom.Node
+            include Convertible
+
+            def initialize(resource)
+                @dom = resource.respond_to?(:dom) ? resource.dom : resource
+                @children = Hash.new
+                @raw = Hash.new
+                @dom.getChildNodes.each do |child|
+                    name = child.getNodeName.to_s.to_sym
+                    next if respond_to?(name)
+                    @raw[name] ||= Array.new
+                    @raw[name] << child
+                end
+
+                @raw.each_key do |name|
+                    if @raw[name].size > 1 then
+                        @raw[name].extend(NodeArray, Convertible)
+                        self.instance_eval %{
+                            def #{name}
+                                @raw[#{name.inspect}]
+                            end
+                        }
+                    else
+                        @raw[name] = @raw[name].first
+                        self.instance_eval %{
+                            def #{name}
+                                convert( @raw[#{name.inspect}] )
+                            end
+                        }
+                    end
+                end
+
+            end
+
+        end
+    end
+end

data/lib/existdb/dom/mapper.rb

@@ -0,0 +1,285 @@
+
+module ExistDB
+    module Dom
+
+        # Inspired by HappyMapper
+
+        module Mapper
+            def self.included(base)
+                base.instance_variable_set("@attributes", Hash.new)
+                base.instance_variable_set("@elements", Hash.new)
+                base.extend ClassMethods
+            end
+
+            def initialize(resource)
+                @dom = resource.respond_to?(:dom) ? resource.dom : resource
+                @cache = Hash.new
+            end
+
+            private
+
+            def get_element(tag_name)
+                @cache[tag_name] ||= self.class.get_element(tag_name, @dom)
+            end
+
+            def get_elements(tag_name, klass)
+                @cache[tag_name] ||= self.class.get_elements(tag_name, klass, @dom)
+            end
+
+            def get_attribute(tag_name)
+                @cache[tag_name] ||= self.class.get_attribute(tag_name, @dom)
+            end
+
+            def set_element(tag_name, value)
+                @cache.delete(tag_name)
+                self.class.set_element(@dom, tag_name, value)
+            end
+
+            def set_attribute(tag_name, value)
+                @cache.delete(tag_name)
+                self.class.set_attribute(@dom, tag_name, value)
+            end
+
+            module ClassMethods
+
+                def attribute(name, type = String, options = {})
+                    a = Attribute.new(name, type, options)
+                    @attributes ||= Hash.new
+                    @attributes[a.tag] = a
+                    self.class_eval %{
+                        def #{a.method_name}
+                            get_attribute(#{a.tag.inspect})
+                        end
+                        
+                        def #{a.method_name}=(value)
+                            set_attribute(#{a.tag.inspect}, value)
+                        end
+                    }
+                end
+
+                def attributes
+                    @attributes.values
+                end
+
+                def element(name, type = String, options = {}, &block)
+                    e = Element.new(name, type, options)
+                    @elements ||= Hash.new
+                    @elements[e.tag] = e
+
+                    if (type.respond_to?(:is_dom_mapper?) and type.is_dom_mapper?) or block_given? then # Nested elements
+                        if block_given? then # Anonymous Mapper Class
+                            klass = self.class_eval %{
+                                @@#{e.method_name}_klass = Class.new do
+                                    include ExistDB::Dom::Mapper
+                                end
+                            }
+                            klass.instance_eval &block
+                        else
+                            self.class_eval %{
+                                @@#{e.method_name}_klass = #{type}
+                            }
+                        end
+                        self.class_eval %{
+                            def #{e.method_name}
+                                get_elements(#{e.tag.inspect}, @@#{e.method_name}_klass)
+                            end
+                        }
+                    else # No nested elements
+                        self.class_eval %{
+                            def #{e.method_name}
+                                get_element(#{e.tag.inspect})
+                            end
+                            
+                            def #{e.method_name}=(value)
+                                set_element(#{e.tag.inspect}, value)
+                            end
+                        }
+                    end
+                end
+
+                def elements
+                    @elements.values
+                end
+
+                def get_element(tag_name, dom)
+                    e = @elements[tag_name]
+                    child = getFirstChildByTagName(dom, tag_name)
+                    return e.type_cast( child.getNodeValue ) if child.respond_to?(:getNodeValue)
+                    return nil
+                end
+
+                def get_elements(tag_name, klass, dom)
+                    children = dom.getElementsByTagName(tag_name)
+                    size = children.getLength
+                    if size == 1 then
+                        klass.new(children.item(0))
+                    elsif size > 1 then
+                        0..size.map{ |i| klass.new(children.item(i)) }
+                    end
+                end
+
+                def get_attribute(tag_name, dom)
+                    a = @attributes[tag_name]
+                    value = dom.getAttributes.getNamedItem(tag_name).getValue rescue nil
+                    a.type_cast( value )
+                end
+
+                def set_element(dom, tag_name, value)
+                    parent = dom
+                    node = getFirstChildByTagName(dom, tag_name)
+                    
+                    if node.nil? then
+                        doc = parent.getOwnerDocument
+                        node = doc.createElement( tag_name.to_s )
+                        parent.appendChild(node)
+                    end
+
+                    child = node.getChildNodes.select{ |child| 
+                        child.getNodeType == org.w3c.dom.Node.TEXT_NODE }.first
+                    text = org.exist.dom.TextImpl.new( value.to_s.to_java_string )
+                    if child then
+                        ExistDB::Embedded.instance.transaction do |transaction|
+                            text.setOwnerDocument( node.getOwnerDocument )
+                            node.updateChild(transaction, child, text)
+                        end
+                    else
+                        node.appendChild(text)
+                    end
+                    return value
+                end
+                
+                def set_attribute(dom, tag_name, value)
+                    attr = dom.getAttributes.getNamedItem(tag_name)
+                    new_attr = org.exist.dom.AttrImpl.new(
+                        org.exist.dom.QName.new( tag_name.to_s.to_java_string ),
+                        value.to_s.to_java_string )
+                    ExistDB::Embedded.instance.transaction do |transaction|
+                        if attr then
+                            new_attr.setOwnerDocument( dom.getOwnerDocument )
+                            dom.updateChild(transaction, attr, new_attr)
+                        else
+                            dom.appendChild(new_attr)
+                        end
+                    end
+                    return value
+                end
+
+                def tag(new_tag_name)
+                    @tag_name = new_tag_name.to_s unless new_tag_name.nil? || new_tag_name.to_s.empty?
+                end
+
+                def tag_name
+                    @tag_name ||= to_s.split('::').last.downcase
+                end
+
+                def parse(resource, options = {})
+
+                    if options[:single] then
+                        return new(resource)
+                    else
+                        xpath = options[:xpath]
+                        xpath ||= "//#{options[:tag]}" if options[:tag]
+                        xpath ||= "//#{options[:name]}" if options[:name]
+                        xpath ||= "//#{tag_name}"
+
+                        resource_set = resource.xquery(xpath)
+                        return resource_set.map{ |res| new(res) }
+                    end
+
+                end
+
+                def find(*options)
+                    xql = XQLFactory::XQLFactory.new(*options)
+
+                    if xql.node_xpath.nil? then
+                        xql.node_xpath = "//#{tag_name}"
+                    end
+
+                    if xql.doc.is_a?(Resource::Xml) then
+                        xql.doc.xquery(xql.xquery).map{ |res| new(res) }
+                    elsif xql.doc.is_a?(ResourceSet) then
+                        xql.doc.join.xquery(xql.xquery).map{ |res| new(res) }
+                    elsif xql.doc.is_a?(String) and Embedded.instance.running?
+                        Embedded.instance.xquery_service.query(xql.xquery).map{ |res| new(res) }
+                    else
+                        nil
+                    end
+                end
+
+                def find_by_xquery(resource, query)
+                    nodes = resource.xquery(query)
+                    nodes.map{ |node| new(node) }
+                end
+
+                def is_dom_mapper?
+                    true
+                end
+
+                private
+
+                def getFirstChildByTagName(dom, tag_name)
+                    dom.getChildNodes.each do |child|
+                        next if not child.respond_to?(:getTagName) or child.getTagName != tag_name
+                        return child
+                        break
+                    end
+                    return nil
+                end
+
+            end
+
+            class Boolean; end
+
+            class Item
+                attr_accessor :name, :type, :tag, :options, :method_name
+                def initialize(name, type, o={})
+                    self.name = name.to_s
+                    self.method_name = self.name.tr('-','_')
+                    self.type = type
+                    self.tag = o[:tag] || name.to_s
+                    self.options = { :single => true }.merge(o.merge(:name => self.name))
+
+                    @xml_type = self.class.to_s.split('::').last.downcase
+                end
+
+                def type_cast(value, type = self.type)
+                    begin
+                        if type == String then value.to_s
+                        elsif type == Float then value.to_f
+                        elsif type == Time then
+                            Time.parse(value.to_s) rescue Time.at(value.to_i)
+                        elsif type == Date then Date.parse(value.to_s)
+                        elsif type == DateTime then DateTime.parse(value.to_s)
+                        elsif type == Boolean then
+                            ['true','t','1','y','yes'].include?(value.to_s.downcase)
+                        elsif type == Integer then
+                            # ganked from datamapper, and happymapper
+                            value_to_i = value.to_i
+                            if value_to_i == 0 && value != '0'
+                                value_to_s = value.to_s
+                                begin
+                                    Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
+                                rescue ArgumentError
+                                    nil
+                                end
+                            else
+                                value_to_i
+                            end
+                        else
+                            value
+                        end
+                    rescue
+                        value
+                    end
+                end
+            
+            end
+
+            class Element < Item; end
+
+            class Attribute < Item; end
+
+        end
+
+    end
+end