jruby-existdb 0.4

data/lib/existdb/embedded.rb

@@ -0,0 +1,84 @@
+module ExistDB
+  class Embedded
+    include Singleton
+
+    attr_accessor :username, :password, :url, :properties
+
+    def initialize
+      @username ||= 'admin'
+      @password ||= ''
+      @properties ||= {'create-database' => 'true'}
+      @url ||= "exist:///db"
+
+      at_exit do
+        stop if running?
+      end
+    end
+
+    def start
+      return false if running?
+      @impl = org.exist.xmldb.DatabaseImpl.new
+      @properties.each{ |key, value| @impl.setProperty(key.to_s, value.to_s) }
+      org.xmldb.api.DatabaseManager.registerDatabase(@impl)
+      @base_collection = @impl.getCollection(@url, @username, @password)
+      @database_instance_manager = @base_collection.getService('DatabaseInstanceManager', '1.0')
+      @collection_manager = @base_collection.getService('CollectionManager', '1.0')
+
+      @running = true
+    end
+
+    def running?
+      @running
+    end
+
+    alias :started? :running? 
+
+    def stop
+      return false if stopped?
+      @database_instance_manager.shutdown
+      @running = false
+      true
+    end
+
+    def stopped?
+        not running?
+    end
+
+    def db
+      raise InstanceNotRunning if stopped?
+      ClassWrap[ @base_collection ]
+    end
+
+    def inspect
+      "#<#{self.class}:#{self.hash.to_s(16)} #{running? ? 'running' : 'stopped'}>"
+    end
+
+    def xquery_service
+      raise InstanceNotRunning if stopped?
+      ClassWrap[ @base_collection.getService('XQueryService', '1.0') ]
+    end
+
+    # org.exist.storage.BrokerPool
+    def broker_pool
+      raise InstanceNotRunning if stopped?
+      org.exist.storage.BrokerPool.getInstance(@impl.getName)
+    end
+
+    # org.exist.storage.txn.Txn
+    def transaction # :yields: transaction
+      raise InstanceNotRunning if stopped?
+      mgr = broker_pool.getTransactionManager
+      txn = mgr.beginTransaction
+      begin
+        yield txn
+        mgr.commit(txn)
+      rescue
+        mgr.abort(txn)
+        raise
+      end
+    end
+
+    class InstanceNotRunning < Exception; end
+  end
+
+end

data/lib/existdb/index_factory.rb

@@ -0,0 +1,120 @@
+module ExistDB
+    module IndexFactory
+        class << self
+            def configure(*opts, &block)
+                cfg = IndexFactory.new(*opts, &block)
+                cfg.configure
+            end
+        end
+
+        # Example:
+        # ExistDB::IndexFactory.configure do
+        #   collection '/db/PartList'
+        #   range 'qtyOnHand' => Fixnum, 'qtyOnOrder' => Fixnum
+        #   lucene '//part', 'name', 'description'
+        # end
+
+        class IndexFactory
+
+            include Meta
+
+            attr_writer :collection
+
+            def initialize(*options, &block)
+                initialize_with_options(options, [:collection])
+                self.instance_eval(&block)
+            end
+
+            def to_s
+                wrapper do
+                    ranges.to_s + lucenes.to_s
+                end
+            end
+
+            def range(*targets)
+                @ranges ||= Array.new
+                targets.each do |target|
+                    if target.is_a?(Hash) then
+                        target.each do |key, value|
+                            tgt_name = key.to_s
+                            tgt_type = tgt_name.index('/') ? 'path' : 'qname'
+                            index_type = type_convert(value)
+                            @ranges << %|<create #{tgt_type}="#{tgt_name}" type="#{index_type}"/>|
+                        end
+                    elsif target.respond_to?(:to_s) then
+                        tgt_name = target.to_s
+                        tgt_type = tgt_name.index('/') ? 'path' : 'qname'
+                        @ranges << %|<create #{tgt_type}="#{tgt_name}"/>|
+                    end
+                end
+            end
+
+            def lucene(*targets)
+                @lucenes ||= Array.new
+                targets.each do |target|
+                    if target.is_a?(Hash) then
+                        target.each do |key, value|
+                            tgt_name = key.to_s
+                            tgt_type = tgt_name.index('/') ? 'path' : 'qname'
+                            index_type = type_convert(value)
+                            @lucenes << %|<text #{tgt_type}="#{tgt_name}" type="#{index_type}"/>|
+                        end
+                    elsif target.respond_to?(:to_s) then
+                        tgt_name = target.to_s
+                        tgt_type = tgt_name.index('/') ? 'path' : 'qname'
+                        @lucenes << %|<text #{tgt_type}="#{tgt_name}"/>|
+                    end
+                end
+            end
+
+            def collection(col = nil)
+                @collection = col if col
+                return @collection
+            end
+
+            def configure
+                raise "Specify a collection" unless @collection
+                col = collection.create_collection(configuration_collection_name)
+                res = Resource.new(:parent => col, :name => configuration_file, :xml => to_s)
+            end
+
+            private
+
+            def ranges
+                @ranges && @ranges.join('')
+            end
+
+            def lucenes
+                if @lucenes then
+                    %|<lucene><analyzer class="org.apache.lucene.analysis.standard.StandardAnalyzer"/><analyzer id="ws" class="org.apache.lucene.analysis.WhitespaceAnalyzer"/>#{ @lucenes.join('') }</lucene>|
+                end
+            end
+
+            def wrapper
+                %|<collection xmlns="http://exist-db.org/collection-config/1.0"><index>| +
+                yield +
+                %|</index></collection>|
+            end
+
+            def type_convert(data_type)
+                data_type = data_type.to_s
+                {
+                    'String' => 'xs:string',
+                    'Fixnum' => 'xs:int',
+                    'Bignum' => 'xs:int',
+                    'Numeric' => 'xs:int',
+                    'Float' => 'xs:float'
+                }[data_type]
+            end
+
+            def configuration_file
+                'collection.xconf'
+            end
+
+            def configuration_collection_name
+                "/db/system/config#{@collection}" if @collection
+            end
+
+        end
+    end
+end

data/lib/existdb/meta.rb

@@ -0,0 +1,41 @@
+module ExistDB
+  module Meta
+    # Metaprogramming conviences
+
+    def initialize_with_options(options, ordered_options)
+      # Usage: 
+      #  class MyClass
+      #    include Meta
+      #    attr_accessor :opt1, :opt2
+      #    def initialize(*options)
+      #      initialize_with_options(options, [:opt1, :opt2])
+      #    end
+      #  end
+      #
+      # obj = MyClass.new(:opt1 => 'foo', :opt2 => 'bar')
+      # # OR
+      # obj = MyClass.new('foo', 'bar')
+      # # MyClass.new now accepts named or ordered params!
+      named_or_ordered_options(options, ordered_options).each do |key, value|
+        if key.is_a?(Symbol) or key.is_a?(String) then
+          key = "#{key}=".to_sym
+          self.send(key, value) if self.respond_to?(key)
+        end
+      end
+      
+    end
+
+    def named_or_ordered_options(options, ordered_options)
+      hash = Hash.new
+      options.each_with_index do |option, i|
+        if option.is_a?(Hash) then
+          hash.merge!(option)
+        else
+          key = ordered_options[i]
+          hash[key] = option
+        end
+      end
+      return hash
+    end
+  end
+end

data/lib/existdb/resource/base.rb

@@ -0,0 +1,84 @@
+module ExistDB
+    module Resource
+        
+        class << self
+            def new(*options)
+                if options.size == 1 and not options.first.is_a?(Hash) then
+                    obj = options.first
+                    ClassWrap[obj]
+                else
+                    if options.any?{|opt| opt.is_a?(Hash) && ( opt[:xml] || opt[:type] == 'XMLResource' ) } then
+                        Xml.new(*options)
+                    elsif options.any?{|opt| opt.is_a?(Hash) && ( opt[:binary] || opt[:type] == 'BinaryResource' ) } then
+                        Binary.new(*options)
+                    end
+                end
+            end
+        end
+
+        class Base
+            extend ClassWrappingForwardable
+            delegate_to_java(
+                :content= => :setContent,
+                :content => :getContent,
+                :length => :getContentLength,
+                :created => :getCreationTime,
+                :last_modified => :getLastModificationTime,
+                :resource_type => :getResourceType,
+                :parent => :getParentCollection,
+                :name => :getId
+            )
+            alias :to_s :content
+            alias :size :length
+
+            def initialize(*opts)
+                options = Hash.new
+                if opts.size == 1 and not opts.first.is_a?(Hash) then
+                    @obj = opts.first
+                else
+                    opts.each do |opt|
+                        if opt.is_a?(Hash) then
+                           options.merge!(opt)
+                        end
+                    end
+
+                    collection = ClassUnwrap[ options[:parent] ]
+                    data = nil
+                    if options[:binary]
+                        type = "BinaryResource"
+                        data = options[:binary]
+                    elsif options[:xml]
+                        type = "XMLResource"
+                        data = options[:xml]
+                    else
+                        type = options[:type]
+                        data = options[:content]
+                    end
+                    type ||= "XMLResource"
+                    
+                    @obj = collection.createResource(options[:name], type)
+                    if data then
+                        self.content = data
+                        self.save
+                    end
+                end
+
+            end
+
+            def inspect
+                "#<#{self.class}:0x#{self.hash.to_s(16)} name=#{self.name.inspect}>"
+            end
+
+            def save
+                collection = @obj.getParentCollection
+                collection.storeResource( @obj )
+                true
+            end
+
+            def delete
+                parent.delete(self)
+            end
+
+        end
+    end
+end

data/lib/existdb/resource/binary.rb

@@ -0,0 +1,21 @@
+module ExistDB
+    module Resource
+        class Binary < Base
+
+            def content=(data)
+                bytes = data.to_s.to_java_bytes
+                @obj.setContent(bytes)
+            end
+
+            def content
+                to_io.read
+            end
+
+            def to_io
+                input_stream = @obj.getStreamContent
+                return Java.java_to_ruby(org.jruby.RubyIO.new(JRuby.runtime, input_stream).java_object)
+            end
+
+        end
+    end
+end

data/lib/existdb/resource/xml.rb

@@ -0,0 +1,23 @@
+module ExistDB
+    module Resource
+        class Xml < Base
+
+            def xquery(*opts)
+                parent.xquery.query(self, *opts)
+            end
+
+            def compile(*opts)
+                parent.xquery.compile(*opts)
+            end
+
+            def execute(*opts)
+                parent.xquery.execute(self, *opts)
+            end
+
+            def dom
+                @obj.getContentAsDOM
+            end
+
+        end
+    end
+end

data/lib/existdb/resource_set.rb

@@ -0,0 +1,34 @@
+module ExistDB
+    class ResourceSet
+
+        include Enumerable
+        extend ClassWrappingForwardable
+        delegate_to_java(
+            :size => :getSize,
+            :[] => :getResource,
+            :join => :getMembersAsResource,
+            :add => :addResource
+        )
+
+        def initialize(java_obj)
+            @obj = java_obj
+        end
+
+        def each
+            for i in (0 .. (size - 1))
+                yield self[i]
+            end
+        end
+
+        class << self
+            def [](*resources)
+                set = new( org.exist.xmldb.MapResourceSet.new )
+                resources.each do |resource|
+                    set.add(resource)
+                end
+                return set
+            end
+        end
+
+    end
+end

data/lib/existdb/xql_factory.rb

@@ -0,0 +1,191 @@
+module ExistDB
+  module XQLFactory
+
+    class << self
+
+      # Shorthand for ExistDB::XQLFactory::XQLFactory.new( options ).xquery
+
+      def Build(*opts, &block)
+        XQLFactory.new(*opts, &block).xquery
+      end
+    end
+
+    # This is used by the XQLFactory for remapping nodes
+    #
+    # This could possibly be simplified by using XSLT if there was a Ruby DSL for XSLT
+    #
+    # The primary goal is to keep the barrier to entry low for rubyists who have limited XML experience
+    class Path
+
+      attr_reader :to_s, :to_a
+      def initialize(path)
+        if path.is_a?(String) then
+          @to_s = path
+          @to_a = path.split('/')
+        elsif path.is_a?(Array) then
+          @to_s = path.join('/')
+          @to_a = path
+        end
+      end
+
+      def name
+        @to_a.last
+      end
+
+      def context
+        @to_a[0..-2]
+      end
+
+      def <=>(path)
+        to_a <=> path.to_a
+      end
+
+      def common(path)
+        a = Array.new
+        self.to_a.each_index do |i|
+          if self.to_a[i].nil? or
+          path.to_a[i].nil? or
+          self.to_a[i] != path.to_a[i] then
+            break
+          else
+            a << self.to_a[i]
+          end
+        end
+        a << ''
+        return Path.new(a)
+      end
+
+      def switch_context(path)
+        output = String.new
+        common_path = self.common(path)
+        diff = self.context.size - common_path.context.size
+        if diff > 0 then
+          output << self.context.last(diff).reverse.map{ |node| "</#{node}>"}.join
+        end
+        diff = path.context.size - common_path.context.size
+        if diff > 0 then
+          output << path.context.last(diff).map{ |node| "<#{node}>"}.join
+        end
+        return output
+      end
+
+    end
+
+    # This is an attempt to create a Ruby DSL for the Most Common XQuery use cases.
+    class XQLFactory
+      
+      include Meta
+      attr_accessor :start, :max, :doc, 
+        :node_xpath, :sort, :return_attributes,
+        :return_tag, :node_remap, :search, :ftquery
+
+      # Accepts Ordered or Named Parameters for any of the attr_accessors
+      #
+      # Ordered Options -- :doc, :start, :max, :sort
+      #
+      # E.g.
+      #
+      # <tt>
+      # xql = XQLFactory.new("doc('http://example.com')", 5, 10, :node_xpath => '//a').xquery
+      # </tt>
+      #
+      # Would create an XQuery statement to find the fifth through tenth links on example.com
+      #
+      # See also ExistDB::XQLFactory.Build as a shorthand way of calling this.
+
+      def initialize(*options)
+        initialize_with_options(options, [:doc, :start, :max, :sort])
+        yield self if block_given?
+      end
+
+      def limit_statement
+        if start or max then
+          "let $scope := subsequence($scope, #{start || 1}, #{max || 'count($scope)'})\n"
+        else
+          ''
+        end
+      end
+
+      def sort_statement
+        if sort then
+          if sort.is_a?(String) then
+            "order by $node/#{sort}"
+          elsif sort.is_a?(Hash) then
+            "order by $node/#{sort.keys.first} #{sort_direction(sort.values.first)}"
+          elsif sort.is_a?(Array) then
+            "order by " + sort.map{ |h| "$node/#{h.keys.first} #{sort_direction(h.values.first)}" }.join(', ')
+          end
+        else
+          ''
+        end
+      end
+
+      def sort_direction(dir)
+        dir = dir.to_s.downcase
+        if %w|asc ascending|.include?(dir)
+            return :ascending
+        elsif %|desc descending|.include?(dir)
+            return :descending
+        else
+            return :ascending
+        end
+      end
+
+      def search_statement
+        "[contains(., #{ search.inspect })]" if search
+        "[ft:query(., #{ ftquery.inspect })]" if ftquery
+      end
+
+      def init_statement
+        raise "doc attribute required" if doc.nil? or doc.to_s.empty?
+        raise "node_xpath attribute required" if node_xpath.nil? or node_xpath.empty?
+        "let $scope := for $node in #{doc if doc.is_a?(String)}#{node_xpath}#{search_statement} #{sort_statement} return $node\n"
+      end
+
+      def return_tag
+        @return_tag || 'xml'
+      end
+
+      def return_tag=(tag)
+        @return_tag = tag
+      end
+
+      def return_statement
+        if return_attributes_statement.empty? and @return_tag.nil? then
+          "return $scope"
+        else
+          "return <#{return_tag}#{return_attributes_statement}> { $scope } </#{return_tag}>"
+        end
+      end
+
+      def return_attributes_statement
+        return '' if return_attributes.nil? or return_attributes.empty?
+        ' ' + return_attributes.keys.map{ |key|
+          "#{key}=#{return_attributes[key].to_s.inspect}"
+        }.join(' ')
+      end
+
+      def node_remap_statement
+        return '' if node_remap.nil? or node_remap.empty?
+        output = "let $scope := for $node in $scope return\n"
+        current_context = Path.new('')
+        node_remap.to_a.map{|a|
+          a[1] = Path.new(a[1]); a 
+        }.sort.each do |a|
+          (src_path, dest_path) = a
+          output << current_context.switch_context(dest_path)
+          current_context = dest_path
+          output << "<#{dest_path.name}>{ $node#{src_path} }</#{dest_path.name}>"
+        end
+        output << current_context.switch_context( Path.new('') ) 
+        output << "\n"
+        return output
+      end
+
+      def xquery
+        init_statement + limit_statement + node_remap_statement + return_statement
+      end
+      
+    end
+  end
+end