jena 1.0.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f91dbc086c7e3e00243ac6cdfb40da948d9cdfab151c8346b8737644f433973c
+  data.tar.gz: 2f68d1a78ddbee9db1c7e30c74d0db0a0c61683e0aa6d8f9a82d1b222e5134b8
+SHA512:
+  metadata.gz: ed6a6deb306e5d48d85ab343d2673c31e3c74bcd48d1f6d3f8998d7cf7f0a1dfcaf6aa1e2bbf6fc65231816bcfdf8fd98e0b190b19a8989fb701ebbe3d47131f
+  data.tar.gz: d8965607bcbbf6a7e1af44cd569b1f7e37fdf7b1cbf9467327829798151f6cd9a60be35d7542bee322f374ca95ee3760a5fc9b0254697883fd1dac2811dc8031

data/.gitignore

@@ -0,0 +1,10 @@
+.*
+*~
+*.gem
+*.xml
+javalib
+pkg
+rdoc
+pkg
+temp
+downloads

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gem "rake", group: :test
+gem "minitest", group: :test
+gem "pry", group: :test

data/Gemfile.lock

@@ -0,0 +1,29 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    ffi (1.9.23-java)
+    method_source (0.9.0)
+    minitest (5.11.3)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry (0.11.3-java)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+      spoon (~> 0.0)
+    rake (12.3.1)
+    spoon (0.0.6)
+      ffi
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  minitest
+  pry
+  rake
+
+BUNDLED WITH
+   1.16.1

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,78 @@
+# Gem wrapper for Apache Jena
+
+This Gem provides convenience access to the [Apache Jena](http://jena.apache.org)
+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.13.0) including TDB.
+
+* 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 now includes TDB modules, those modules no longer need to be built locally.
+
+To build the gem itself:
+
+    $ rake build
+    jena-jruby 0.8.1 built to pkg/jena-jruby-0.8.1-java.gem.
+
+or
+
+    $ gem build jena-jruby.gemspec
+    Successfully built RubyGem
+    Name: jena-jruby
+    Version: 0.8.1
+    File: jena-jruby-0.8.1-java.gem
+
+To run the tests:
+
+    $ bundle exec rake test
+    Run options: --seed 45483
+
+    # Running:
+
+    ................
+
+    Finished in 0.351000s, 45.5840 runs/s, 142.4501 assertions/s.
+
+    16 runs, 50 assertions, 0 failures, 0 errors, 0 skips

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_jena

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'rubygems'
+require 'fileutils'
+require 'open-uri'
+
+require 'jena_jruby/version.rb'
+
+LATEST_JENA="http://www-us.apache.org/dist/jena/binaries/apache-jena-#{Jena::JENA_VERSION}.zip"
+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
+  puts 'Download completed.'
+else
+  puts 'Data file already exists, skipping download.'
+end
+
+raise 'Program `unzip\' is not present in the operation system.' if `unzip`.empty?
+`unzip -jo #{OUTPUT} **/lib/*.jar -d javalib`
+
+puts "Writing lib/jena_jruby/jars.rb ..."
+r = File.open( 'lib/jena_jruby/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,30 @@
+# -*- encoding: utf-8 -*-
+lib = File::expand_path('../lib/', __FILE__)
+$:.unshift(lib) unless $:.include?(lib)
+
+require 'jena_jruby/version.rb'
+
+# ensure we have the javalibs
+update = File::expand_path('../bin/update_jena', __FILE__)
+Kernel::load update, true
+
+Gem::Specification.new do |s|
+  s.name        = 'jena'
+  s.version     = Jena::JENA_JRUBY_GEM_VERSION
+  s.platform    = Gem::Platform.new('java')
+  s.authors     = ['Ian Dickinson', 'Bruno Ferreira', 'Fábio Almeida']
+  s.email       = %w( ian@epimorphics.com chalkos@chalkos.net phabio_almeida@hotmail.com )
+  s.licenses    = 'Apache-2.0'
+  s.homepage    = 'https://github.com/lysferd/jena-jruby'
+  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 = %w( lib javalib )
+
+  s.extra_rdoc_files = %w( README.md )
+end
+

data/lib/jena_jruby/jars.rb

@@ -0,0 +1,33 @@
+require 'commons-csv-1.5'
+require 'slf4j-log4j12-1.7.25'
+require 'jena-tdb2-3.6.0'
+require 'slf4j-api-1.7.25'
+require 'jena-tdb-3.6.0'
+require 'xercesImpl-2.11.0'
+require 'log4j-1.2.17'
+require 'jena-arq-3.6.0'
+require 'jcl-over-slf4j-1.7.25'
+require 'jackson-annotations-2.9.0'
+require 'httpclient-4.5.3'
+require 'jena-rdfconnection-3.6.0'
+require 'commons-cli-1.4'
+require 'collection-0.7'
+require 'commons-codec-1.11'
+require 'commons-io-2.6'
+require 'jena-cmds-3.6.0'
+require 'jena-dboe-transaction-3.6.0'
+require 'jena-dboe-index-3.6.0'
+require 'jena-shaded-guava-3.6.0'
+require 'httpclient-cache-4.5.3'
+require 'xml-apis-1.4.01'
+require 'jena-core-3.6.0'
+require 'jackson-core-2.9.0'
+require 'jackson-databind-2.9.0'
+require 'jena-dboe-trans-data-3.6.0'
+require 'jena-base-3.6.0'
+require 'httpcore-4.4.6'
+require 'libthrift-0.10.0'
+require 'jsonld-java-0.11.1'
+require 'jena-iri-3.6.0'
+require 'commons-lang3-3.4'
+require 'jena-dboe-base-3.6.0'

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,109 @@
+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
+      def types
+        Jena::Node.types self
+      end
+    end
+  end
+
+  module ComHpHplJenaRdfModelImpl
+    class ResourceImpl
+      # Return the resource types
+      def types
+        Jena::Node.types self
+      end
+
+      # 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,205 @@
+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-nil 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 )
+      describe_qe( setup_query_execution( m, query, options ) )
+    end
+
+    # Perform a describe query using the given query execution object, and
+    # return the resulting model
+    def self.describe_qe( qexec )
+      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
+
+    # Return a model from a describe query against a remote SPARQL endpoint
+    def self.service_describe( url, query )
+      describe_qe( sparql_service( url, query ) )
+    end
+
+    # Format a given value in a manner suitable for inclusion in a SPARQL query
+    def self.sparql_format( value )
+      if value.is_a? Core::Resource
+        value.is_anon ? "_:#{value.get_id.to_string.gsub(/[^[[:alnum:]]]/, '_')}" : "<#{value.get_uri}>"
+      elsif value.is_a? Core::Literal
+        if dt = value.get_datatype_uri
+          "\"#{value.get_lexical_form}\"^^<#{dt}>"
+        else
+          "\"#{value.to_string}\""
+        end
+      elsif value.to_s =~ /\A(file|http):\/\//
+        "<#{value}>"
+      elsif value.to_s =~ /\A[-_[[:alnum:]]]*:/
+        # looks like a qname
+        value.to_s
+      else
+        # guess
+        "\"#{value.to_s}\""
+      end
+    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 )
+      bindings = as_bindings( option( options, :bindings, nil ) )
+
+      bindings ? QueryExecutionFactory.create( q, m, bindings ) : QueryExecutionFactory.create( q, m )
+    end
+
+  end
+end

data/lib/jena_jruby/statement_utils.rb

@@ -0,0 +1,11 @@
+
+module Jena::Model::Sta
+
+  ESPACE_CHAR = "\s"
+
+  #alias old_get_local_name get_local_name
+  def formatted_name
+    return self.get_local_name.gsub /_/, ESPACE_CHAR
+  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. If the given
+    def self.uuid_resource( model = nil )
+      (model || 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,4 @@
+module Jena
+  JENA_VERSION='3.6.0' unless constants.include?(:JENA_VERSION)
+  JENA_JRUBY_GEM_VERSION='1.0.0' unless constants.include?(:JENA_JRUBY_GEM_VERSION)
+end

data/lib/jena_jruby.rb

@@ -0,0 +1,107 @@
+require 'java'
+require 'jena_jruby/jars'
+require 'builder'
+
+# Make a selection of key Jena classes available in a convenient module
+module Jena
+  include_package org.apache.jena
+
+  # Import classes under org.apache.jena.*
+  module Model
+    include_package org.apache.jena.rdf.model
+    include_package org.apache.jena.rdf.model.impl
+  end
+
+  module XML
+    include_package org.apache.jena.rdfxml.xmlinput
+    include_package org.apache.jena.rdfxml.impl
+    include_package org.apache.jena.xmlinput.states
+    include_package org.apache.jena.xmloutput
+    include_package org.apache.jena.xmloutput.impl
+  end
+
+  module Listener
+    include_package org.apache.jena.rdf.listeners
+  end
+
+  module Datatypes
+    include_package org.apache.jena.datatypes
+
+    module XSD
+      include_package org.apache.jena.xsd
+      include_package org.apache.jena.xsd.impl
+    end
+  end
+
+  module Enhanced
+    include_package org.apache.jena.enhanced
+  end
+
+  module Graph
+    include_package org.apache.jena.graph
+    include_package org.apache.jena.graph.compose
+    include_package org.apache.jena.graph.impl
+  end
+
+  module Mem
+    include_package org.apache.jena.mem
+  end
+
+  module Util
+    include_package org.apache.jena.util
+    include_package org.apache.jena.util.iterator
+  end
+
+  module Shared
+    include_package org.apache.jena.shared
+    include_package org.apache.jena.shared.impl
+    include_package org.apache.jena.shared.uuid
+  end
+
+  module Vocab
+    include_package org.apache.jena.vocabulary
+  end
+
+  module Query
+    include_package org.apache.jena.query
+  end
+
+  module Ontology
+    include_package org.apache.jena.ontology
+    include_package org.apache.jena.ontology.impl
+  end
+
+  module TDB
+    include_package org.apache.jena.tdb
+  end
+
+  module Reasoner
+    include_package org.apache.jena.reasoner
+    include_package org.apache.jena.reasoner.rulesys
+    include_package org.apache.jena.reasoner.rulesys.builtins
+    include_package org.apache.jena.reasoner.rulesys.impl
+    include_package org.apache.jena.reasoner.transitiveReasoner
+  end
+
+  module Assembler
+    include_package org.apache.jena.assembler
+    include_package org.apache.jena.assembler.assemblers
+
+    module Exceptions
+      include_package org.apache.jena.assembler.exceptions
+    end
+  end
+
+  module System
+    include_package org.apache.system
+  end
+end
+
+%w[
+  version
+  utils
+  query_utils
+  node_utils
+  statement_utils
+  namespace
+].each {|f| require "jena_jruby/#{f}"}

data/test/node_utils_test.rb

@@ -0,0 +1,80 @@
+$LOAD_PATH.push "#{File.dirname(__FILE__)}/../lib"
+$LOAD_PATH.push "#{File.dirname(__FILE__)}/../javalib"
+
+require "minitest/autorun"
+require "jena_jruby"
+
+class NodeUtilsTest < Minitest::Test
+
+  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 = create_typed_literal( 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
+
+  :private
+
+  def create_typed_literal( v )
+    method = @m.java_method( :createTypedLiteral, [java.lang.Object] )
+    method.call( v )
+  end
+
+end

data/test/query_utils_test.rb

@@ -0,0 +1,125 @@
+$LOAD_PATH.push "#{File.dirname(__FILE__)}/../lib"
+$LOAD_PATH.push "#{File.dirname(__FILE__)}/../javalib"
+
+require "minitest/autorun"
+require "jena_jruby"
+
+class QueryUtilsTest < Minitest::Test
+
+  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
+
+  # SPARQL formatting tests
+  def test_sparql_format
+    assert_equal "<http://foo.bar>", Jena::Query.sparql_format( @m.create_resource( "http://foo.bar" ))
+    assert_equal '"foo"', Jena::Query.sparql_format( @m.create_literal( "foo" ))
+
+    tl = create_typed_literal( 42 )
+    assert_equal '"42"^^<http://www.w3.org/2001/XMLSchema#long>', Jena::Query.sparql_format( tl )
+
+    assert_equal "foo:bar", Jena::Query.sparql_format( "foo:bar" )
+    assert_equal "<http://foo.bar>", Jena::Query.sparql_format( "http://foo.bar" )
+    assert Jena::Query.sparql_format( @m.create_resource ).match( /_:([[:alnum:]]*)/ )
+  end
+
+  def create_typed_literal( v )
+    method = @m.java_method( :createTypedLiteral, [java.lang.Object] )
+    method.call( v )
+  end
+
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: jena
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: java
+authors:
+- Ian Dickinson
+- Bruno Ferreira
+- Fábio Almeida
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2018-05-30 00:00:00.000000000 Z
+dependencies: []
+description: A simple packaging of Apache Jena for JRuby
+email:
+- ian@epimorphics.com
+- chalkos@chalkos.net
+- phabio_almeida@hotmail.com
+executables:
+- update_jena
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/update_jena
+- javalib/collection-0.7.jar
+- javalib/commons-cli-1.4.jar
+- javalib/commons-codec-1.11.jar
+- javalib/commons-csv-1.5.jar
+- javalib/commons-io-2.6.jar
+- javalib/commons-lang3-3.4.jar
+- javalib/httpclient-4.5.3.jar
+- javalib/httpclient-cache-4.5.3.jar
+- javalib/httpcore-4.4.6.jar
+- javalib/jackson-annotations-2.9.0.jar
+- javalib/jackson-core-2.9.0.jar
+- javalib/jackson-databind-2.9.0.jar
+- javalib/jcl-over-slf4j-1.7.25.jar
+- javalib/jena-arq-3.6.0.jar
+- javalib/jena-base-3.6.0.jar
+- javalib/jena-cmds-3.6.0.jar
+- javalib/jena-core-3.6.0.jar
+- javalib/jena-dboe-base-3.6.0.jar
+- javalib/jena-dboe-index-3.6.0.jar
+- javalib/jena-dboe-trans-data-3.6.0.jar
+- javalib/jena-dboe-transaction-3.6.0.jar
+- javalib/jena-iri-3.6.0.jar
+- javalib/jena-rdfconnection-3.6.0.jar
+- javalib/jena-shaded-guava-3.6.0.jar
+- javalib/jena-tdb-3.6.0.jar
+- javalib/jena-tdb2-3.6.0.jar
+- javalib/jsonld-java-0.11.1.jar
+- javalib/libthrift-0.10.0.jar
+- javalib/log4j-1.2.17.jar
+- javalib/slf4j-api-1.7.25.jar
+- javalib/slf4j-log4j12-1.7.25.jar
+- javalib/xercesImpl-2.11.0.jar
+- javalib/xml-apis-1.4.01.jar
+- 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/statement_utils.rb
+- lib/jena_jruby/utils.rb
+- lib/jena_jruby/version.rb
+- test/node_utils_test.rb
+- test/query_utils_test.rb
+homepage: https://github.com/lysferd/jena-jruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- javalib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.6.13
+signing_key:
+specification_version: 4
+summary: JRuby wrapper for Apache Jena
+test_files:
+- test/node_utils_test.rb
+- test/query_utils_test.rb