jena-jruby 0.3.0-java

data/.gitignore

@@ -0,0 +1,7 @@
+.loadpath
+.project
+javalib
+downloads/
+pkg
+.buildpath
+rdoc

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+#gem "sinatra", "1.2.0a", :require => false
+gem "builder"
+

data/Gemfile.lock

@@ -0,0 +1,10 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  builder

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2011 Epimorphics Ltd
+
+   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.

data/README.md

@@ -0,0 +1,101 @@
+# Gem wrapper for Apache Jena
+
+This Gem provides convenience access to the [Apache Jena](http://incubator.apache.org/jena)
+RDF platform. Jena is a widely used Java platform for parsing, storing, manipulating,
+querying and publishing semantic web data and linked data. This gem provides a single
+dependency so that JRuby programs can access all of the capabilities of Jena, including TDB,
+conveniently from JRuby.
+
+This gem provides the following benefits:
+
+* a single dependency which includes all of the `.jar` files for the latest release
+of Jena (currently 2.7.0) and TDB (currently 0.9.0)
+
+* import of some of the key classes used by Jena-based programs into a `Jena::`
+module, to make code more compact
+
+* some additional utility and convenience methods
+
+## Using the gem
+
+Once installed, just add to your code:
+
+    require 'jena_jruby'
+
+or add a suitable dependency to your bundle spec.
+
+## Access to Jena from Java
+
+Create a model:
+
+    m = Jena::Core::ModelFactory.create_default_model
+
+(note that JRuby automagically converts Java CamelCase names to Ruby lower_case names)
+
+Add a statement:
+
+    jruby-1.6.5 :003 > m = Jena::Core::ModelFactory.create_default_model
+     => #<Java::ComHpHplJenaRdfModelImpl::ModelCom:0x135a4815>
+    jruby-1.6.5 :004 > s = Jena::Core::ResourceFactory.create_resource "http://example.org/s"
+     => #<Java::ComHpHplJenaRdfModelImpl::ResourceImpl:0x7b0f62cb>
+    jruby-1.6.5 :005 > o = Jena::Core::ResourceFactory.create_resource "http://example.org/o"
+     => #<Java::ComHpHplJenaRdfModelImpl::ResourceImpl:0x4879c985>
+    jruby-1.6.5 :006 > p = Jena::Core::ResourceFactory.createProperty "http://example.org/p"
+     => #<Java::ComHpHplJenaRdfModelImpl::PropertyImpl:0x3f7cd159>
+    jruby-1.6.5 :007 > m.add s,p,o
+     => #<Java::ComHpHplJenaRdfModelImpl::ModelCom:0x135a4815>
+    jruby-1.6.5 :009 > m.toString
+     => "<ModelCom   {http://example.org/s @http://example.org/p http://example.org/o} | >"
+
+## Building and installing the gem
+
+Since `jena-jruby` now includes TDB, the easiest way to get the full set of jars necessary
+to support Jena is to use Maven to list the dependencies declared in the TDB `pom.xml`.
+For convenience, this is packaged in a bash script:
+
+    ian@rowan-15 $ export JENA_TDB_ROOT=~/whereever/you/have/the/tdb/source
+    # note: defaults to ~/workspace/apache-jena-tdb
+
+    ian@rowan-15 $ cd ~/workspace/jena-jruby/
+    ian@rowan-15 $ bin/update_jars_maven
+    Changing to TDB directory /home/ian/workspace/apache-jena-tdb
+    ~/workspace/apache-jena-tdb ~/workspace/jena-jruby
+    Cleaning old versions and recompiling ...
+    [INFO] Scanning for projects...
+    [INFO] ------------------------------------------------------------------------
+    [INFO] Building TDB
+    [INFO]    task-segment: [clean, install]
+    [INFO] ------------------------------------------------------------------------
+      .. lots of maven output ..
+    [INFO] ------------------------------------------------------------------------
+    [INFO] BUILD SUCCESSFUL
+    [INFO] ------------------------------------------------------------------------
+    [INFO] Total time: 17 seconds
+    [INFO] Finished at: Thu Jan 05 00:18:09 GMT 2012
+    [INFO] Final Memory: 68M/718M
+    [INFO] ------------------------------------------------------------------------
+    Collecting dependencies ...
+    [INFO] Scanning for projects...
+    [INFO] Searching repository for plugin with prefix: 'dependency'.
+    [INFO] ------------------------------------------------------------------------
+    [INFO] Building TDB
+    [INFO]    task-segment: [dependency:copy-dependencies]
+    [INFO] ------------------------------------------------------------------------
+    [INFO] [dependency:copy-dependencies {execution: default-cli}]
+    [INFO] Copying icu4j-3.4.4.jar to /home/ian/workspace/apache-jena-tdb/target/dependency/icu4j-3.4.4.jar
+      .. more maven output ..
+    [INFO] ------------------------------------------------------------------------
+    [INFO] BUILD SUCCESSFUL
+    [INFO] ------------------------------------------------------------------------
+    [INFO] Total time: 2 seconds
+    [INFO] Finished at: Thu Jan 05 00:18:12 GMT 2012
+    [INFO] Final Memory: 35M/349M
+    [INFO] ------------------------------------------------------------------------
+    ~/workspace/jena-jruby
+    Changing directory back to /home/ian/workspace/jena-jruby
+    Copying deps to ./javalib
+    Creating log4j config
+
+    ian@rowan-15 $ rake build
+    rake/rdoctask is deprecated.  Use rdoc/task instead (in RDoc 2.4.2+)
+    jena-jruby 0.3.0 built to pkg/jena-jruby-0.3.0-java.gem

data/Rakefile

@@ -0,0 +1,37 @@
+require 'bundler'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+####################################################
+# Testing
+####################################################
+
+Rake::TestTask.new(:test) do |t|
+    t.libs << "test" << "."
+    t.test_files = FileList['test/*test.rb']
+    # t.verbose = true
+end
+
+namespace :test do
+
+  desc 'Measures test coverage'
+  task :coverage do
+    rm_f "profiling"
+#    rcov = "rcov --rails --aggregate coverage.data --text-summary -Ilib"
+    rcov = "rcov -I ./test -i '^lib/' -x 'rvm|\.js$|\.html$' --profile --sort coverage"
+    system("#{rcov} test/*_test.rb")
+    system("gnome-open profiling/index.html")
+  end
+
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('lib/rdf_renderer/VERSION') ? File.read('lib/rdf_renderer/VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "RDF Renderer #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/bin/update_jars_maven

@@ -0,0 +1,32 @@
+#!/bin/bash
+# Collect the .jar files necessary to build the gem by running
+# maven in the context of TDB
+# Execute in root directory of jena_jruby
+
+# Default TDB location
+# Can be overridden by exporting JENA_TDB_ROOT
+tdb_root=${JENA_TDB_ROOT:-~/workspace/apache-jena-tdb}
+
+echo "Changing to TDB directory $tdb_root"
+pushd $tdb_root
+
+echo "Cleaning old versions and recompiling ..."
+mvn -DskipTests=true clean install
+
+echo "Collecting dependencies ..."
+mvn dependency:copy-dependencies
+
+popd
+echo "Changing directory back to `pwd`"
+echo "Copying deps to ./javalib"
+mkdir -p javalib
+rm -f javalib/*.jar
+cp $tdb_root/target/dependency/*.jar javalib
+cp $tdb_root/target/jena-tdb-*SNAPSHOT.jar $tdb_root/target/tdb-*{0,1,2,3,4,5,6,7,8,9}.jar javalib  2>/dev/null
+rm -f javalib/*test*.jar
+
+echo "Creating log4j config"
+jar -cf javalib/log4j-config.jar log4j.xml
+
+
+

data/bin/update_jena

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path("../lib", __FILE__)
+require 'rubygems'
+require 'fileutils'
+require 'open-uri'
+load 'lib/jruby_jena/version.rb'
+
+LATEST_JENA="http://sourceforge.net/projects/jena/files/Jena/Jena-#{Jena::JENA_VERSION}/jena-#{Jena::JENA_VERSION}.zip/download"
+OUTPUT="downloads/jena-#{Jena::JENA_VERSION}.zip"
+
+FileUtils.mkdir_p "downloads"
+
+unless File.exist? OUTPUT
+  puts "Downloading Jena #{Jena::JENA_VERSION}..."
+  open( LATEST_JENA ) do |url|
+    File.open( OUTPUT,"wb" ) do |file|
+      file.puts url.read
+    end
+  end
+end
+
+`unzip -jo #{OUTPUT} **/lib/*.jar -x '**/lib/junit*.jar' '**/lib/*tests.jar' -d javalib`
+
+puts "Writing lib/jruby_jena/jars.rb ..."
+r = File.open( 'lib/jruby_jena/jars.rb', 'w' )
+Dir.glob( 'javalib/*.jar' ).each do |f|
+  f =~ /javalib\/(.*)\.jar/
+  r << "require '#{$1}'\n"
+end
+r.close

data/jena-jruby.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("./lib", __FILE__)
+load "lib/jena_jruby/version.rb"
+
+Gem::Specification.new do |s|
+  s.name        = "jena-jruby"
+  s.version     = Jena::JENA_JRUBY_GEM_VERSION
+  s.platform    = Gem::Platform.new("java")
+  s.authors     = ["Ian Dickinson"]
+  s.email       = ["ian@epimorphics.com"]
+  s.homepage    = ""
+  s.summary     = %q{JRuby wrapper for Apache Jena}
+  s.description = %q{A simple packaging of Apache Jena for JRuby}
+
+  s.files         = `git ls-files`.split("\n").reject { |f| f.include? '/dev/' }
+  s.files.concat( Dir.glob 'javalib/*.jar' )
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+#  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib", "javalib"]
+
+  s.extra_rdoc_files = ["README.md"]
+
+  s.add_dependency( 'haml' )
+  s.add_dependency( 'builder' )
+end

data/lib/jena_jruby/jars.rb

@@ -0,0 +1,19 @@
+%w[
+commons-codec-1.5
+hamcrest-core-1.1
+httpclient-4.1.2
+httpcore-4.1.3
+icu4j-3.4.4
+jena-arq-2.9.0-incubating
+jena-core-2.7.0-incubating
+jena-iri-0.9.0-incubating
+jena-tdb-0.9.0-incubating-SNAPSHOT
+junit-4.9
+log4j-1.2.16
+slf4j-api-1.6.4
+slf4j-log4j12-1.6.4
+xercesImpl-2.10.0
+xml-apis-1.4.01
+log4j-config
+].each {|jar| require jar}
+

data/lib/jena_jruby/namespace.rb

@@ -0,0 +1,34 @@
+module Jena
+  module Vocab
+
+    # A namespace is an object for resolving identifiers in scope denoted
+    # by a base URI to a full URI. For example,
+    #
+    #    rdfs = Namespace.new( "http://www.w3.org/2000/01/rdf-schema#" )
+    #    rdfs.comment # => "http://www.w3.org/2000/01/rdf-schema#comment"
+    #
+    # There is no checking that the resolved name is known in the defined
+    # namespace (e.g. <tt>rdfs.commnet</tt> will work without a warning)
+    class Namespace
+      attr_reader :ns
+
+      # Initialize this namespace with the given root URI. E.g, for RDFS,
+      # this would be
+      #    rdfs = Namespace.new( "http://www.w3.org/2000/01/rdf-schema#" )
+      def initialize( ns )
+        @ns = ns
+      end
+
+      :private
+
+      def method_missing( name, *args)
+        prop = !args.empty? && args.first
+        n = "#{@ns}#{name}"
+        prop ? Jena::Core::ResourceFactory.createProperty(n) : Jena::Core::ResourceFactory.createResource(n)
+      end
+    end
+
+    # A namespace object for the SKOS vocabulary, which is not built-in to Jena
+    SKOS = Namespace.new( "http://www.w3.org/2004/02/skos/core#" )
+  end
+end

data/lib/jena_jruby/node_utils.rb

@@ -0,0 +1,107 @@
+module Jena
+  # A collection of utilities for manipulating Jena RDF Resources
+  # and Literals, collectively known as RDFNodes.
+  module Node
+    # Return the types of a node, which will be an array of the RDF types
+    # for a resource, or an array of the (zero or one) datatypes if the
+    # node is a literal. Ensures that the returned array includes the default_type
+    # f default_type is non-nil
+    def self.types( node, default_type = nil )
+      return self.resource_types( node, default_type ) if node.resource?
+      self.literal_types( node, default_type )
+    end
+
+    # Return the values of `rdf:type` for the given resource
+    def self.resource_types( node, default_type = nil )
+      types = []
+      node.each_property( Jena::Vocab::RDF.type ) {|stmt| types << stmt.getObject}
+      with_default_type( types, default_type )
+    end
+
+    # Return an array of the datatype of the given literal, if defined,
+    # and including the default_type if non-nil
+    def self.literal_types( node, default_type = nil )
+      types = node.getDatatype ? [node.getDatatype] : []
+      with_default_type( types, default_type )
+    end
+
+    :private
+
+    def self.with_default_type( types, default_type )
+      types << default_type if default_type && !types.include?( default_type )
+      types
+    end
+  end
+end
+
+
+# Add some Ruby-friendly method names to common Jena classes
+module Java
+  module ComHpHplJenaEnhanced
+    class EnhNode
+      alias resource? isResource
+      alias literal? isLiteral
+
+      def types
+        Jena::Node.types self
+      end
+    end
+  end
+
+  module ComHpHplJenaRdfModelImpl
+    class ResourceImpl
+      # Yield to the given block for each statement of this resource with predicate
+      # `property`. If `property` is nil, yield to the block for every statement whose
+      # subject is this resource.
+      def each_property( property = nil, &block )
+        listProperties( property ).each( &block )
+      end
+
+      # Return a list of the values of the given properties of this resource. Each property
+      # may be specified as a +Property+ object, a string denoting the URI, or a string
+      # denoting the URI in <tt>prefix:name</tt> format, which will be expanded using the
+      # prefix table attached to the resource's model
+      def property_values( props = nil, model = nil )
+        model ||= getModel
+        return [] unless model
+
+        values = []
+        resolve_properties( props, model ).each do |p|
+          model.listStatements( self, p, nil ).each do |stmt|
+            values << stmt.getObject
+          end
+        end
+        values
+      end
+
+      # Return a list of Jena +Property+ objects corresponding to the list of property
+      # names +props+. Each member of +props+ is either
+      # * a +Property+ object, which is returned unchanged
+      # * a URI string, which is converted to a +Property+
+      # * an abbreviated URI in <tt>prefix:name</tt> form, which is expanded using the prefixes
+      #   defined in the current model before being converted to a +Property+ object
+      #
+      # In the special case of <tt>props = nil</tt>, the returned list is all of the distinct
+      # properties attached to this resource
+      def resolve_properties( props = nil, model = nil )
+        props = [props] unless props.is_a? Array
+        model ||= self.getModel
+
+        unless props
+          return model.listStatements( self, nil, nil ).map {|stmt| stmt.getPredicate} .uniq
+        end
+
+        props.map do |p|
+          case
+          when p.is_a?( Jena::Core::Property )
+            p
+          when model
+            model.getProperty( model.expandPrefix( p ) )
+          else
+            Jena::Core::ResourceFactory.getProperty( p )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jena_jruby/query_utils.rb

@@ -0,0 +1,175 @@
+module Jena
+  module Query
+    # Perform a SPARQL select query against the given model. Returns
+    # an array of result objects, where each result is a Hash from
+    # query variable name to value.
+    #
+    # By default, all variables from the query are returned. To return
+    # just a subset of the query variables, pass the variable name(s) as
+    # the last argument to the call.
+    #
+    # Various options are supported:
+    # * `:ns` - a `PrefixMapping` or hash of prefixes to URI's
+    # * `:bindings` - a `QuerySolutionMap` or hash of existing var name to value pairs
+    #
+    # == Examples
+    #     Jena.querySelect( m, 'select * where {?s ?p ?o}' )
+    #     Jena.querySelect( m, 'select * where {?s ?p ?o}', {}, "s" )
+    #     Jena.querySelect( m, 'select * where {?s ?p foo:bar}',
+    #       {:ns => {"foo", "http://example.com/foo#"}}, "s" )
+    #
+    # @param m [Model] The model to run the query against
+    # @param query [String] The query to run
+    # @param options [Hash] Options (see above)
+    # @param *vars [String] Optional variables to project from results
+    # @return [Array] Non-empty array of hashes, one per result
+    def self.select( m, query, options = nil, *vars )
+      results = []
+      select_each( m, query, options, *vars ) {|soln| results << soln}
+      results
+    end
+
+    # Perform a select query as per {#select}, but returns only the first
+    # result, if defined, or nil
+    def self.select_first( m, query, options = nil, *vars )
+      qexec = setup_query_execution( m, query, options )
+      result = nil
+
+      begin
+        rs = qexec.execSelect
+        result = project_variables( rs.next, *vars ) if rs.hasNext
+      ensure
+        qexec.close
+      end
+
+      result
+    end
+
+    # Perform a select query as per {#select}, but rather than accumulate
+    # an array of results, we yield to the associated block with each solution
+    def self.select_each( m, query, options = nil, *vars, &block )
+      select_each_qe( setup_query_execution( m, query, options ), *vars, &block )
+    end
+
+    # Perform a select query using the given query execution, yielding to the
+    # associated block for each solution
+    def self.select_each_qe( qexec, *vars )
+      begin
+        qexec.execSelect.each do |soln|
+          yield( project_variables( soln, *vars ) )
+        end
+      ensure
+        qexec.close
+      end
+    end
+
+    # Perform a SPARQL describe query. Options as per {#select},
+    # but this call returns a `Model`.
+    #
+    # @param m [Model] The model to run the query against
+    # @param query [String] The query to run
+    # @param options [Hash] Options (see above)
+    # @return [Array] Non-empty array of hashes, one per result
+    def self.describe( m, query, options = nil )
+      qexec = setup_query_execution( m, query, options )
+
+      begin
+        return qexec.execDescribe
+      ensure
+        qexec.close
+      end
+    end
+
+    # Project variables from a result set entry, returning a `Hash` of variable
+    # names to values
+    def self.project_variables( soln, *vars )
+      nn = Hash.new
+
+      vs = vars || []
+      soln.varNames.each {|v| vs << v} if vs.empty?
+
+      vs.each {|v| nn[v.to_sym] = soln.get( v )}
+
+      nn
+    end
+
+    # Return the given bindings object as a `QuerySolutionsMap`. Convert a
+    # hash to a `QuerySolutionsMap` if necessary
+    def self.as_bindings( b )
+      return nil unless b
+      return b if b.is_a? com.hp.hpl.jena.query.QuerySolutionMap
+      qsm = com.hp.hpl.jena.query.QuerySolutionMap.new
+      b.each_pair do |k,v|
+        qsm.add k, v
+      end
+      qsm
+    end
+
+    # A mutable collection of well-known namespace prefixes, which can
+    # be used as a basis for building up a larger collection
+    def self.useful_prefixes
+      pm = com.hp.hpl.jena.shared.impl.PrefixMappingImpl.new
+      pm.setNsPrefixes( com.hp.hpl.jena.shared.PrefixMapping.Standard )
+      pm
+    end
+
+    # Return true if a string represents a valid SPARQL query.
+    def self.valid?( query_string, syntax = Jena::Query::Syntax.syntaxSPARQL_11 )
+      q = Jena::Query::QueryFactory.create
+
+      begin
+        Jena::Query::QueryFactory.parse( q, query_string, nil, syntax )
+        return true
+      rescue
+      end
+
+      false
+    end
+
+    # Return a QueryExecution for executing the given query against a
+    # remote SPARQL service endpoint
+    def self.sparql_service( url, query )
+      Jena::Query::QueryExecutionFactory.sparqlService( url, query )
+    end
+
+    # Return a list of the solutions to executing the given select query
+    # against the given remote SPARQL endpoint
+    def self.service_select( url, query, *vars )
+      results = []
+      select_each_qe( sparql_service( url, query ), *vars ) {|soln| results << soln}
+      results
+    end
+
+    # Yield to the associated block for each solution to the given query against
+    # the given SPARQL service endpoint URL
+    def self.service_select_each( url, query, *vars, &block )
+      select_each_qe( sparql_service( url, query ), *vars, &block )
+    end
+
+    :private
+
+    def self.option( options, opt, default )
+      if has_option?( options, opt ) then options[opt] else default end
+    end
+
+    def self.has_option?( options, opt )
+      options && options.has_key?( opt )
+    end
+
+    # Common part of setting up a query execution
+    def self.setup_query_execution( m, query, options )
+      q = com.hp.hpl.jena.query.Query.new
+
+      q.setPrefixMapping has_option?( options, :ns ) ? Util::as_prefix_map( options[:ns] ) : useful_prefixes
+
+      baseURI = option( options, :baseURI, nil )
+      syntax = option( options, :syntax, com.hp.hpl.jena.query.Syntax.syntaxSPARQL_11 )
+
+      QueryFactory.parse( q, query, baseURI, syntax )
+      qexec = QueryExecutionFactory.create( q, m, as_bindings( option( options, :bindings, nil ) ) )
+
+      qexec
+    end
+
+  end
+end

data/lib/jena_jruby/utils.rb

@@ -0,0 +1,27 @@
+module Jena
+  module Util
+    # Return the given prefix map object as a `PrefixMapping`. Convert a hash
+    # to a `PrefixMapping` if necessary
+    def self.as_prefix_map( map )
+      return nil unless map
+      return map if map.is_a? com.hp.hpl.jena.shared.PrefixMapping
+      pm = com.hp.hpl.jena.shared.impl.PrefixMappingImpl.new
+      map.each_pair do |k,v|
+        pm.setNsPrefix k.to_s, v.to_s
+      end
+      pm
+    end
+
+    # Return a new resource URN made from a UUID
+    def self.uuid_resource
+      Core::ResourceFactory.createResource( Util::JenaUUID.factory.generate.asURN )
+    end
+
+    # Return the current time as a literal
+    def self.now
+      cal = java.util.Calendar.getInstance
+      cal.setTime( java.util.Date.new )
+      Core::ResourceFactory.createTypedLiteral( cal )
+    end
+  end
+end

data/lib/jena_jruby/version.rb

@@ -0,0 +1,5 @@
+module Jena
+  JENA_VERSION='2.6.5-SNAPSHOT'
+  TDB_VERSION='0.8.11-SNAPSHOT'
+  JENA_JRUBY_GEM_VERSION='0.3.0'
+end

data/lib/jena_jruby.rb

@@ -0,0 +1,182 @@
+require 'java'
+require 'jena_jruby/jars'
+require 'builder'
+
+# Short names for commonly used Java packages
+module Jena
+  JENA = "com.hp.hpl.jena"
+end
+
+# Make a selection of key Jena classes available in a convenient module
+module Jena
+  module Core
+    java_import com.hp.hpl.jena.rdf.model.Alt
+    java_import com.hp.hpl.jena.rdf.model.AnonId
+    java_import com.hp.hpl.jena.rdf.model.Bag
+    java_import com.hp.hpl.jena.rdf.model.Container
+    java_import com.hp.hpl.jena.rdf.model.InfModel
+    java_import com.hp.hpl.jena.rdf.model.Literal
+    java_import com.hp.hpl.jena.rdf.model.ModelChangedListener
+    java_import com.hp.hpl.jena.rdf.model.ModelFactory
+    java_import com.hp.hpl.jena.rdf.model.ModelGetter
+    java_import com.hp.hpl.jena.rdf.model.ModelGraphInterface
+    java_import com.hp.hpl.jena.rdf.model.Model
+    java_import com.hp.hpl.jena.rdf.model.ModelMaker
+    java_import com.hp.hpl.jena.rdf.model.ModelReader
+    java_import com.hp.hpl.jena.rdf.model.ModelSource
+    java_import com.hp.hpl.jena.rdf.model.NodeIterator
+    java_import com.hp.hpl.jena.rdf.model.NsIterator
+    java_import com.hp.hpl.jena.rdf.model.Property
+    java_import com.hp.hpl.jena.rdf.model.RDFErrorHandler
+    java_import com.hp.hpl.jena.rdf.model.RDFList
+    java_import com.hp.hpl.jena.rdf.model.RDFNode
+    java_import com.hp.hpl.jena.rdf.model.RDFReader
+    java_import com.hp.hpl.jena.rdf.model.RDFVisitor
+    java_import com.hp.hpl.jena.rdf.model.RDFWriter
+    java_import com.hp.hpl.jena.rdf.model.ReifiedStatement
+    java_import com.hp.hpl.jena.rdf.model.ResIterator
+    java_import com.hp.hpl.jena.rdf.model.ResourceFactory
+    java_import com.hp.hpl.jena.rdf.model.Resource
+    java_import com.hp.hpl.jena.rdf.model.RSIterator
+    java_import com.hp.hpl.jena.rdf.model.Schema
+    java_import com.hp.hpl.jena.rdf.model.Selector
+    java_import com.hp.hpl.jena.rdf.model.Seq
+    java_import com.hp.hpl.jena.rdf.model.SimpleSelector
+    java_import com.hp.hpl.jena.rdf.model.StatementBoundary
+    java_import com.hp.hpl.jena.rdf.model.Statement
+    java_import com.hp.hpl.jena.rdf.model.StatementTripleBoundary
+    java_import com.hp.hpl.jena.rdf.model.StmtIterator
+  end
+
+  module Util
+    java_import com.hp.hpl.jena.util.CharEncoding
+    java_import com.hp.hpl.jena.util.CollectionFactory
+    java_import com.hp.hpl.jena.util.FileManager
+    java_import com.hp.hpl.jena.util.FileUtils
+    java_import com.hp.hpl.jena.util.IteratorCollection
+    java_import com.hp.hpl.jena.util.LocationMapper
+    java_import com.hp.hpl.jena.util.LocatorClassLoader
+    java_import com.hp.hpl.jena.util.LocatorFile
+    java_import com.hp.hpl.jena.util.Locator
+    java_import com.hp.hpl.jena.util.LocatorURL
+    java_import com.hp.hpl.jena.util.LocatorZip
+    java_import com.hp.hpl.jena.util.Metadata
+    java_import com.hp.hpl.jena.util.ModelLoader
+    java_import com.hp.hpl.jena.util.ModelQueryUtil
+    java_import com.hp.hpl.jena.util.MonitorGraph
+    java_import com.hp.hpl.jena.util.MonitorModel
+    java_import com.hp.hpl.jena.util.OneToManyMap
+    java_import com.hp.hpl.jena.util.PrintUtil
+    java_import com.hp.hpl.jena.util.QueryMapper
+    java_import com.hp.hpl.jena.util.ResourceUtils
+    java_import com.hp.hpl.jena.util.SystemUtils
+    java_import com.hp.hpl.jena.util.Tokenizer
+    java_import com.hp.hpl.jena.util.TypedStream
+    java_import com.hp.hpl.jena.util.URIref
+    java_import com.hp.hpl.jena.shared.Command
+    java_import com.hp.hpl.jena.shared.Lock
+    java_import com.hp.hpl.jena.shared.LockMRSW
+    java_import com.hp.hpl.jena.shared.LockMutex
+    java_import com.hp.hpl.jena.shared.LockNone
+    java_import com.hp.hpl.jena.shared.PrefixMapping
+    java_import com.hp.hpl.jena.shared.RandomOrderGraph
+    java_import com.hp.hpl.jena.shared.ReificationStyle
+    java_import com.hp.hpl.jena.shared.uuid.JenaUUID
+    java_import com.hp.hpl.jena.shared.uuid.UUIDFactory
+  end
+
+  module Vocab
+    java_import com.hp.hpl.jena.vocabulary.DB
+    java_import com.hp.hpl.jena.vocabulary.DC_10
+    java_import com.hp.hpl.jena.vocabulary.DC_11
+    java_import com.hp.hpl.jena.vocabulary.DC
+    java_import com.hp.hpl.jena.vocabulary.DCTerms
+    java_import com.hp.hpl.jena.vocabulary.DCTypes
+    java_import com.hp.hpl.jena.vocabulary.LocationMappingVocab
+    java_import com.hp.hpl.jena.vocabulary.OntDocManagerVocab
+    java_import com.hp.hpl.jena.vocabulary.OntEventsVocab
+    java_import com.hp.hpl.jena.vocabulary.OWL2
+    java_import com.hp.hpl.jena.vocabulary.OWL
+    java_import com.hp.hpl.jena.vocabulary.RDF
+    java_import com.hp.hpl.jena.vocabulary.RDFS
+    java_import com.hp.hpl.jena.vocabulary.RDFSyntax
+    java_import com.hp.hpl.jena.vocabulary.ReasonerVocabulary
+    java_import com.hp.hpl.jena.vocabulary.ResultSet
+    java_import com.hp.hpl.jena.vocabulary.RSS
+    java_import com.hp.hpl.jena.vocabulary.VCARD
+    java_import com.hp.hpl.jena.vocabulary.XSD
+  end
+
+  module Query
+    java_import com.hp.hpl.jena.query.ARQ
+    java_import com.hp.hpl.jena.query.DatasetFactory
+    java_import com.hp.hpl.jena.query.Dataset
+    java_import com.hp.hpl.jena.query.DataSource
+    java_import com.hp.hpl.jena.query.QueryExecutionFactory
+    java_import com.hp.hpl.jena.query.QueryExecution
+    java_import com.hp.hpl.jena.query.QueryFactory
+    java_import com.hp.hpl.jena.query.Query
+    java_import com.hp.hpl.jena.query.QuerySolution
+    java_import com.hp.hpl.jena.query.QuerySolutionMap
+    java_import com.hp.hpl.jena.query.QueryVisitor
+    java_import com.hp.hpl.jena.query.ResultSetFactory
+    java_import com.hp.hpl.jena.query.ResultSetFormatter
+    java_import com.hp.hpl.jena.query.ResultSet
+    java_import com.hp.hpl.jena.query.ResultSetRewindable
+    java_import com.hp.hpl.jena.query.SortCondition
+    java_import com.hp.hpl.jena.query.Syntax
+  end
+
+  module Ont
+    java_import com.hp.hpl.jena.ontology.AllDifferent
+    java_import com.hp.hpl.jena.ontology.AllValuesFromRestriction
+    java_import com.hp.hpl.jena.ontology.AnnotationProperty
+    java_import com.hp.hpl.jena.ontology.BooleanClassDescription
+    java_import com.hp.hpl.jena.ontology.CardinalityQRestriction
+    java_import com.hp.hpl.jena.ontology.CardinalityRestriction
+    java_import com.hp.hpl.jena.ontology.ComplementClass
+    java_import com.hp.hpl.jena.ontology.DataRange
+    java_import com.hp.hpl.jena.ontology.DatatypeProperty
+    java_import com.hp.hpl.jena.ontology.EnumeratedClass
+    java_import com.hp.hpl.jena.ontology.FunctionalProperty
+    java_import com.hp.hpl.jena.ontology.HasValueRestriction
+    java_import com.hp.hpl.jena.ontology.Individual
+    java_import com.hp.hpl.jena.ontology.IntersectionClass
+    java_import com.hp.hpl.jena.ontology.InverseFunctionalProperty
+    java_import com.hp.hpl.jena.ontology.MaxCardinalityQRestriction
+    java_import com.hp.hpl.jena.ontology.MaxCardinalityRestriction
+    java_import com.hp.hpl.jena.ontology.MinCardinalityQRestriction
+    java_import com.hp.hpl.jena.ontology.MinCardinalityRestriction
+    java_import com.hp.hpl.jena.ontology.ObjectProperty
+    java_import com.hp.hpl.jena.ontology.OntClass
+    java_import com.hp.hpl.jena.ontology.OntDocumentManager
+    java_import com.hp.hpl.jena.ontology.OntModel
+    java_import com.hp.hpl.jena.ontology.OntModelSpec
+    java_import com.hp.hpl.jena.ontology.Ontology
+    java_import com.hp.hpl.jena.ontology.OntProperty
+    java_import com.hp.hpl.jena.ontology.OntResource
+    java_import com.hp.hpl.jena.ontology.OntTools
+    java_import com.hp.hpl.jena.ontology.Profile
+    java_import com.hp.hpl.jena.ontology.ProfileRegistry
+    java_import com.hp.hpl.jena.ontology.QualifiedRestriction
+    java_import com.hp.hpl.jena.ontology.Restriction
+    java_import com.hp.hpl.jena.ontology.SomeValuesFromRestriction
+    java_import com.hp.hpl.jena.ontology.SymmetricProperty
+    java_import com.hp.hpl.jena.ontology.TransitiveProperty
+    java_import com.hp.hpl.jena.ontology.UnionClass
+  end
+
+  module TDB
+    java_import com.hp.hpl.jena.tdb.TDB
+    java_import com.hp.hpl.jena.tdb.TDBLoader
+    java_import com.hp.hpl.jena.tdb.TDBFactory
+  end
+end
+
+%w[
+  version
+  utils
+  query_utils
+  node_utils
+  namespace
+].each {|f| require "jena_jruby/#{f}"}

data/log4j.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE log4j:configuration PUBLIC "log4j.dtd"
+"http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd">
+
+
+<log4j:configuration>
+    <appender name="stdout" class="org.apache.log4j.ConsoleAppender">
+        <layout class="org.apache.log4j.PatternLayout">
+            <param name="ConversionPattern" value="%d{ABSOLUTE} %5p %c{1}:%L - %m%n"/>
+        </layout>
+    </appender>
+    <logger name="com.epimorphics">
+      <level value="info"/>
+    </logger>
+    <root>
+        <priority value="info"></priority>
+        <appender-ref ref="stdout"/>
+    </root>
+</log4j:configuration>

data/test/node_utils_test.rb

@@ -0,0 +1,71 @@
+$LOAD_PATH.push "#{File.dirname(__FILE__)}/../lib"
+require "rubygems"
+require "test/unit"
+require "jena_jruby"
+
+class NodeUtilsTest < Test::Unit::TestCase
+
+  def setup
+    @m = Jena::Core::ModelFactory.createDefaultModel
+    @r0 = @m.createResource "http://example.org/foo#r0"
+    @r1 = @m.createResource "http://example.org/foo#r1"
+    @m.add @r0, Jena::Vocab::RDFS.comment, "this is a test"
+    @m.add @r0, Jena::Vocab::RDF.type, @r1
+  end
+
+  def teardown
+  end
+
+  def test_resource_types
+    assert_equal [@r1], @r0.types
+    assert_equal [], @r1.types
+  end
+
+  def test_literal_types
+    lit = @m.createTypedLiteral( 10 )
+    types = lit.types
+    assert_equal "http://www.w3.org/2001/XMLSchema#long", types.first.getURI
+    assert_equal 1, types.length
+
+    lit = @m.createLiteral( "foo" )
+    types = lit.types
+    assert_equal 0, types.length
+  end
+
+  def test_default_type
+    assert_equal [@r1, Jena::Vocab::RDF::Property], Jena::Node.types( @r0, Jena::Vocab::RDF::Property )
+    assert_equal [Jena::Vocab::RDF::Property], Jena::Node.types( @r1, Jena::Vocab::RDF::Property )
+
+    assert_equal [:dummy], Jena::Node.types( @m.createLiteral( "foo" ), :dummy )
+  end
+
+  def test_resolve_properties
+    p = @m.createProperty( "http://example.com/p" )
+    assert_equal [p], @r0.resolve_properties( [p] )
+    assert_equal [p], @r0.resolve_properties( ["http://example.com/p"] )
+    @m.setNsPrefix( "eg", "http://example.com/" )
+    assert_equal [p], @r0.resolve_properties( ["eg:p"] )
+  end
+
+  def test_property_values
+    assert_equal [@r1], @r0.property_values( Jena::Vocab::RDF.type )
+    assert_equal [@r1], @r0.property_values( Jena::Vocab::RDF.type.getURI )
+    @m.setNsPrefix( "rdf", Jena::Vocab::RDF.getURI )
+    assert_equal [@r1], @r0.property_values( "rdf:type" )
+  end
+
+  def test_property_values_with_explicit_model
+    @m.setNsPrefix( "rdf", Jena::Vocab::RDF.getURI )
+
+    # r is not attached to any model
+    r = Jena::Core::ResourceFactory.createResource( @r0.getURI )
+
+    assert_equal [], r.property_values( Jena::Vocab::RDF.type )
+    assert_equal [], r.property_values( Jena::Vocab::RDF.type.getURI )
+    assert_equal [], r.property_values( "rdf:type" )
+
+    assert_equal [@r1], r.property_values( Jena::Vocab::RDF.type, @m )
+    assert_equal [@r1], r.property_values( Jena::Vocab::RDF.type.getURI, @m )
+    assert_equal [@r1], r.property_values( "rdf:type", @m )
+  end
+end

data/test/query_utils_test.rb

@@ -0,0 +1,105 @@
+$LOAD_PATH.push "#{File.dirname(__FILE__)}/../lib"
+require "rubygems"
+require "test/unit"
+require "jena_jruby"
+
+class QueryUtilsTest < Test::Unit::TestCase
+
+  def setup
+    @m = Jena::Core::ModelFactory.createDefaultModel
+    @r0 = @m.createResource "http://example.org/foo#r0"
+    @m.add @r0, Jena::Vocab::RDFS.comment, "this is a test"
+  end
+
+  def teardown
+  end
+
+  def test_as_prefix_map_0
+    pm = com.hp.hpl.jena.shared.impl.PrefixMappingImpl.new
+    assert_same pm, Jena::Util.as_prefix_map( pm )
+  end
+
+  def test_as_prefix_map_1
+    map = {"foo" => "http://foo.bar"}
+    pm = Jena::Util.as_prefix_map map
+    assert_equal "http://foo.bar", pm.getNsPrefixURI( "foo" )
+  end
+
+  def test_as_bindings_0
+    qsm = Jena::Query::QuerySolutionMap.new
+    assert_same qsm, Jena::Query.as_bindings( qsm )
+  end
+
+  def test_as_bindings_1
+    r = Jena::Core::ResourceFactory.createResource "http://foo.bar#"
+    b = {"r" => r}
+    assert_equal r, Jena::Query.as_bindings( b ).get( "r" )
+  end
+
+  # Generic form of select
+  def test_select_0
+    result = Jena::Query.select @m, "select * {?s ?p ?o}", nil
+    assert_equal 1, result.size
+
+    assert_equal @r0, result[0][:s]
+    assert_equal Jena::Vocab::RDFS.comment, result[0][:p]
+    assert_equal "this is a test", result[0][:o].getLexicalForm
+  end
+
+  # Project variables from select
+  def test_select_1
+    result = Jena::Query.select @m, "select * {?s ?p ?o}", nil, "s"
+    assert_equal 1, result.size
+
+    assert_equal @r0, result[0][:s]
+    assert ! result[0].has_key?( :p )
+    assert ! result[0].has_key?( :o )
+
+    result = Jena::Query.select @m, "select * {?s ?p ?o}", nil, :s
+    assert_equal 1, result.size
+
+    assert_equal @r0, result[0][:s]
+  end
+
+  # Use namespaces in query select
+  def test_select_2
+    ns = {:foo => "http://example.org/foo#"}
+
+    result = Jena::Query.select @m, "select * {foo:r0 ?p ?o}", {:ns => ns}
+    assert_equal 1, result.size
+
+    assert ! result[0].has_key?( :s )
+    assert_equal Jena::Vocab::RDFS.comment, result[0][:p]
+    assert_equal "this is a test", result[0][:o].getLexicalForm
+  end
+
+  # Use variable bindings in query select
+  def test_select_3
+    b = {:s => @r0}
+
+    r1 = @m.createResource "http://example.org/foo#r1"
+    @m.add r1, Jena::Vocab::RDFS.comment, "this is another test"
+
+    result = Jena::Query.select @m, "select * {?s ?p ?o}", {:bindings => b}
+    assert_equal 1, result.size
+
+    assert_equal @r0, result[0][:s]
+  end
+
+  # Get only one result
+  def test_select_first
+    @m.add @r0, Jena::Vocab::RDFS.comment, "this is another test"
+
+    result = Jena::Query.select @m, "select * {?s ?p ?o}"
+    assert_equal 2, result.size
+
+    result = Jena::Query.select @m, "select * {?s ?p 42}"
+    assert_equal 0, result.size
+
+    result = Jena::Query.select_first @m, "select * {?s ?p ?o}"
+    assert_equal @r0, result[:s]
+
+    result = Jena::Query.select_first @m, "select * {?s ?p 42}"
+    assert_nil result
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: jena-jruby
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.3.0
+platform: java
+authors: 
+  - Ian Dickinson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-05 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: haml
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: builder
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id002
+description: A simple packaging of Apache Jena for JRuby
+email: 
+  - ian@epimorphics.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - README.md
+files: 
+  - .gitignore
+  - Gemfile
+  - Gemfile.lock
+  - LICENSE
+  - README.md
+  - Rakefile
+  - bin/update_jars_maven
+  - bin/update_jena
+  - jena-jruby.gemspec
+  - lib/jena_jruby.rb
+  - lib/jena_jruby/jars.rb
+  - lib/jena_jruby/namespace.rb
+  - lib/jena_jruby/node_utils.rb
+  - lib/jena_jruby/query_utils.rb
+  - lib/jena_jruby/utils.rb
+  - lib/jena_jruby/version.rb
+  - log4j.xml
+  - test/node_utils_test.rb
+  - test/query_utils_test.rb
+  - javalib/commons-codec-1.5.jar
+  - javalib/jena-iri-0.9.0-incubating.jar
+  - javalib/jena-tdb-0.9.0-incubating-SNAPSHOT.jar
+  - javalib/jena-core-2.7.0-incubating.jar
+  - javalib/httpclient-4.1.2.jar
+  - javalib/xercesImpl-2.10.0.jar
+  - javalib/slf4j-api-1.6.4.jar
+  - javalib/junit-4.9.jar
+  - javalib/slf4j-log4j12-1.6.4.jar
+  - javalib/icu4j-3.4.4.jar
+  - javalib/xml-apis-1.4.01.jar
+  - javalib/log4j-1.2.16.jar
+  - javalib/hamcrest-core-1.1.jar
+  - javalib/log4j-config.jar
+  - javalib/httpcore-4.1.3.jar
+  - javalib/jena-arq-2.9.0-incubating.jar
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+  - javalib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.13
+signing_key: 
+specification_version: 3
+summary: JRuby wrapper for Apache Jena
+test_files: []
+
+has_rdoc: