jrdspace 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca7f654c183e530d9bd2944d86932e9e236431ca
+  data.tar.gz: c1b7462812097642881381c0380e55498f88ae2f
+SHA512:
+  metadata.gz: 59590638b4618cc7ccba03f43a6d044506b24d64974d5d113031f965eedcf1d1f438529ae14dd093a40734787b69b951c05b6b9e20bfc558f70bd79f38ac430f
+  data.tar.gz: 457c84e7d6172faf9383637f9164ded2a9c75e3811743ad392bbc1710d9e8d68baecbaf4416ebacff7549c2eb34e7897f073f131b912462f5e6ca20ef470643c

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jacob Brown
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,114 @@
+# jrdspace
+
+jrdsapce is implemented in JRuby. 
+
+It provides a simple mechanism to connect to a [DSpace](https://github.com/DSpace/DSpace) installation and to access and manipulate the Java Objects managed by classes from the dspace-api package. 
+
+jrdspace contains an interactive console and therefore enables quick experimentation. 
+
+The companion project [cli-dspace](https://github.com/akinom/dspace-cli)  contains utilities that make use of jrdspace.
+
+## Installation
+
+### Prerequisite
+ * JRuby  [Get Started](http://jruby.org/getting-started)
+ * Package Manager  [Bundler](http://bundler.io/)
+ * optional - but useful [RMV](https://rvm.io/)
+
+### Installation 
+
+Add the gem to your projects Gemfile: 
+```
+gem 'jrdspace'      # pull from rubygems 
+
+gem 'jrdspace', :git => 'https://github.com/akinom/dspace-jruby', :branch => 'master`
+
+```
+
+Install the gem:
+```
+bundle install
+```
+
+##  Usage 
+
+To use in scripts simply include the following 
+```
+require 'dspace' 
+DSpace.load(dspace_install_dir) 
+```
+
+## Interactive Usage 
+
+The included idspace command starts an interactive console.
+
+```
+bundle exec idspace 
+> DSpace.load          # load DSpace jars and configurations 
+> DSpace.help          # lists all static methods of classes in jrdspace 
+```
+
+Use Tab completion to see available methods 
+
+# Get Started 
+
+Connect to your dspace database and configurations 
+
+```
+DSpace.load                                  # load DSpace jars and configurations from ENV[DSPACE_HOME] 
+                                             # or from /dspcae if DSPACE_HOME is undefined
+DSpace.load("/home/you/installs/dspace")     # load from /home/you/installs/dspace
+```
+
+The load method sets the environment up by reading configurations from the dspace.cfg file and by requiring all jar files from the ${dspace.dir}/lib directory.  After a succesfull load you can start using Java classes by importing them, for example: 
+```
+ java_import org.dspace.content.Item;
+``` 
+The included classes DSpace, DCommunity, DCollection, ... from [lib/dspace](lib/dspace) provide convenience methods, such as retrieving all Communities  or the Group with a given name: 
+```
+DCommunity.all
+DSpace.fromString('GROUP.name')
+```
+
+If you want to make changes you can 'login' 
+
+```
+DSpace.login               # login with ENV['USER']
+DSpace.login ('netid')     # login with given netid
+```
+
+Remember to call the commit method if you want to save changes
+
+```
+DSpace.commit 
+```
+
+
+Find Dspace stuff:
+
+```
+DSpace.fromHandle ('xxxxx/yyy')      
+DSpace.fromString ('ITEM.124')      
+DSpace.fromString ('GROUP.Anonymous')      
+DSpace.fromString ('EPERSON.a_netid')   
+DCommunity.all 
+DGroup.find('group_name')
+```
+These methods use the relevant Java classes to locate the objects and return nil or a reference to the Java object found. All public Java methods can be called on returned references. 
+
+The following prints a rudimentary community report:
+```
+DCommunity.all.each { |c| puts [c.getCollections.length, c.getHandle, c.getName].join("\t") }
+```
+
+Java objects can be converted to corresponding jrdspace objects, so that the additional functionality implemented by jrdspace classes becomes available. 
+For example all jrdspace objects implement the parents and policies method:
+```
+dso = DSpace.fromHandle('xxxxx/zzz') 
+DSpace.create(dso).parents
+DSpace.create(dso).policies
+```
+
+
+# Thanks 
+Thank you https://github.com/kardeiz/dscriptor to set me on the path to jruby with dspace 

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/idspace

@@ -0,0 +1,10 @@
+#!/usr/bin/env jruby
+
+require "bundler/setup"
+require "dspace"
+
+require "irb"
+
+puts "DSpace.load   - to connect to dspave installation"
+puts "DSpace.help   - for basic help info"
+IRB.start

data/dspace.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dspace/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jrdspace"
+  spec.version       = DSpace::VERSION
+  spec.authors       = ["Monika Mevenkamp"]
+  spec.email         = ["monikam@princeton.edu"]
+
+  spec.summary       =  %q{Jruby classes that interact with the dspace-api Java classes - v5}
+  spec.description   =  %q{jrdspace enables scripting of the dspace-api Java objects in a DSpace installation; it includes an interactive console}
+  spec.homepage      = "https://github.com/akinom/dspace-jruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency  'jar'
+  spec.add_dependency  'json'
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/dspace.rb

@@ -0,0 +1,9 @@
+require 'dspace/dspace'
+require 'dspace/dso'
+require 'dspace/deperson'
+require 'dspace/dgroup'
+require 'dspace/dcollection'
+require 'dspace/dcommunity'
+require 'dspace/ditem'
+require 'dspace/dbitstream'
+

data/lib/dspace/dbitstream.rb

@@ -0,0 +1,9 @@
+class DBitstream
+include DSO
+
+  def self.all()
+    java_import org.dspace.content.Bitstream;
+    return Bitstream.findAll(DSpace.context)
+  end
+
+end

data/lib/dspace/dbundle.rb

@@ -0,0 +1,4 @@
+class DBundle
+include DSO
+
+end

data/lib/dspace/dcollection.rb

@@ -0,0 +1,29 @@
+class DCollection
+  include DSO
+
+  def self.all()
+    java_import org.dspace.content.Collection;
+    return Collection.findAll(DSpace.context)
+  end
+
+  def self.findAll(name)
+    java_import org.dspace.content.Collection;
+    self.all.select do |c|
+      c.getName == name
+    end
+  end
+
+  def report()
+    rpt = dso_report
+    rpt[:name] = @obj.getName();
+    group = @obj.getSubmitters();
+    rpt[:submitters] = DGroup.new(group).report if group
+    [1, 2, 3].each do |i|
+      group = @obj.getWorkflowGroup(i);
+      if (group) then
+        rpt["workflow_group_#{i}".to_sym] = DGroup.new(group).report;
+      end
+    end
+    return rpt;
+  end
+end

data/lib/dspace/dcommunity.rb

@@ -0,0 +1,25 @@
+class DCommunity
+  include DSO
+
+  def self.all()
+    java_import org.dspace.content.Community;
+    return Community.findAll(DSpace.context)
+  end
+
+  def self.findAll(name)
+    java_import org.dspace.content.Community;
+    self.all.select do |c|
+      c.getName == name
+    end
+  end
+
+  def report
+    rpt = dso_report
+    list =  @obj.getSubcommunities.collect {|sc| DCommunity.new(sc).report }
+    rpt[:subcomunities] = list unless list.empty?
+    list =  @obj.getCollections.collect {|sc| DCollection.new(sc).report }
+    rpt[:collections] = list unless list.empty?
+    return rpt;
+  end
+
+end

data/lib/dspace/deperson.rb

@@ -0,0 +1,42 @@
+class DEperson
+  include DSO
+
+  def self.all()
+    java_import org.dspace.eperson.EPerson;
+    return EPerson.findAll(DSpace.context, 1)
+  end
+
+  def self.create(netid, first, last, email)
+    java_import org.dspace.eperson.EPerson;
+    raise "must give a netid value" unless netid
+    raise "must give a first and last name" unless (first and last)
+    p = EPerson.findByNetid(DSpace.context, netid)
+    raise "netid #{netid} already in use" unless p.nil?
+
+    @dso = EPerson.create(DSpace.context)
+    @dso.first_name = first;
+    @dso.last_name = last;
+    @dso.netid = netid;
+    @dso.email = email
+    @dso.canLogIn = true;
+    @dso.update;
+    puts "Created #{@dso}"
+    return @dso;
+  end
+
+  def self.find(netid_or_email)
+    java_import org.dspace.eperson.EPerson;
+    raise "must give a netid_or_email value" unless netid_or_email
+    return EPerson.findByNetid(DSpace.context, netid_or_email) || EPerson.findByEmail(DSpace.context, netid_or_email)
+  end
+
+  def groups
+    java_import org.dspace.eperson.Group;
+    return Group.allMemberGroups(DSpace.context, @obj);
+  end
+
+  def group_names
+    groups.collect { |g| g.getName}.sort
+  end
+
+end

data/lib/dspace/dgroup.rb

@@ -0,0 +1,67 @@
+class DGroup
+  include DSO
+
+  ADMIN_ID = 1;
+  ANONYMOUS_ID = 0;
+
+  def self.all
+    java_import org.dspace.eperson.Group;
+    Group.findAll(DSpace.context, 1);
+  end
+
+  def self.find(name_or_id)
+    java_import org.dspace.eperson.Group;
+    if (name_or_id.class == String)
+      return Group.findByName(DSpace.context, name_or_id);
+    else
+      return Group.find(DSpace.context, name_or_id)
+    end
+  end
+
+  def self.find_or_create(name)
+    raise "must give a name " unless name
+    group = self.find(name);
+    if (group.nil?) then
+      group = Group.create(DSpace.context);
+      group.setName(name)
+      group.update();
+      puts "Created #{group.toString()}"
+    else
+      puts "Exists #{group.toString()}"
+    end
+    return group;
+  end
+
+  def members
+    list = [];
+    @dso.getMembers.each do |m|
+      list << m;
+    end
+    @dso.getMemberGroups.each do |m|
+      list << m;
+    end
+    return list;
+  end
+
+  def addMember(addGrouNameOrNetid)
+    add = DGroup.find(addGrouNameOrNetid)
+    if (add.nil?) then
+        add = DEperson.find(addGrouNameOrNetid);
+    end 
+    raise "no such netid or group #{addGrouNameOrNetid}" if add.nil?
+    @dso.addMember(add);
+    @dso.update
+    return @dso;
+  end
+
+  def report
+    rpt = dso_report
+    @obj.getMemberGroups.each do |m|
+      rpt[m.toString] = DGroup.new(m).report
+    end
+    list = @obj.getMembers()
+    rpt['epersons'] = list.collect { |p| DEperson.new(p).report  } unless list.empty?
+    return rpt;
+  end
+
+end

data/lib/dspace/ditem.rb

@@ -0,0 +1,75 @@
+class DItem
+  include DSO;
+
+  def self.iter
+    java_import org.dspace.content.Item;
+    Item.findAll(DSpace.context);
+  end
+
+  def self.all
+    java_import org.dspace.content.Item;
+    list = []
+    stp = iter
+    while (i = stp.next)
+      list << i
+    end
+    return list
+  end
+
+  def self.inside(restrict_to_dso)
+    java_import org.dspace.storage.rdbms.DatabaseManager
+    java_import org.dspace.storage.rdbms.TableRow
+
+    return [] if restrict_to_dso.nil?
+    return [restrict_to_dso] if restrict_to_dso.getType == DSpace::ITEM
+    return [] if restrict_to_dso.getType != DSpace::COLLECTION and restrict_to_dso.getType != DSpace::COMMUNITY
+
+    sql = "SELECT ITEM_ID FROM ";
+    if (restrict_to_dso.getType() == DSpace::COLLECTION) then
+      sql = sql + "  Collection2Item CO WHERE  CO.Collection_Id = #{restrict_to_dso.getID}"
+    else
+      # must be COMMUNITY
+      sql = sql + " Community2Item CO  WHERE CO.Community_Id = #{restrict_to_dso.getID}"
+    end
+    puts sql;
+
+    tri = DatabaseManager.query(DSpace.context, sql)
+    dsos = [];
+    while (i = tri.next())
+      item =  DSpace.find('ITEM', i.getIntColumn("item_id"))
+      dsos << item
+    end
+    tri.close
+    return dsos
+  end
+
+  def bitstreams(bundle = "ORIGINAL")
+    bundle = @obj.getBundles.select { |b| b.getName() == bundle }[0]
+    if (not bundle.nil?) then
+      return bundle.getBitstreams
+    end
+    return [];
+  end
+
+  def self.install(collection, metadata_hash)
+    java_import org.dspace.content.InstallItem;
+    java_import org.dspace.content.WorkspaceItem;
+    java_import org.dspace.content.Item;
+
+    wi = WorkspaceItem.create(DSpace.context, collection, false)
+    item = wi.getItem
+    metadata_hash.each do |key,value|
+      (schema, element,qualifier) = key.split('.')
+      if (value.class == Array ) then
+        value.each do |val|
+          item.addMetadata(schema, element, qualifier, nil, val);
+        end
+      else
+        item.addMetadata(schema, element, qualifier, nil, value);
+      end
+    end
+    InstallItem.installItem(DSpace.context, wi);
+    return item;
+  end
+
+end

data/lib/dspace/dso.rb

@@ -0,0 +1,57 @@
+require 'json'
+
+module DSO
+
+  def initialize(dobj)
+    raise "must pass non null obj" unless dobj
+    type = DSpace.const_get self.class.name[1..-1].upcase
+    @obj = dobj
+    raise "#{dobj} is not a #{type} object" unless @obj.getType == type
+  end
+
+  def dso
+    return @obj
+  end
+
+  def parents
+    moms = [];
+    p = @obj.getParentObject()
+    while p do
+      moms << p;
+      p = p.getParentObject();
+    end
+    return moms;
+  end
+
+  def dso_report
+    rpt = {};
+    rpt[:name] = @obj.getName
+    rpt[:obj] = @obj.toString()
+    if (@obj.getHandle()) then
+      rpt[:handle] = @obj.getHandle()
+    end
+    if (@obj.getParentObject()) then
+      rpt[:parent] = @obj.getParentObject().to_s
+    end
+    return rpt;
+  end
+
+  def report
+    dso_report
+  end
+
+  def policies()
+    java_import org.dspace.authorize.AuthorizeManager
+    pols = AuthorizeManager.getPolicies(DSpace.context, @obj)
+    pols.collect do |p|
+      pp = p.getEPerson
+      pg = p.getGroup
+      hsh = { :action => p.getAction()}
+      hsh[:person] = pp.getName if pp
+      hsh[:group] = pg.getName if pg
+      hsh
+    end
+  end
+
+end
+

data/lib/dspace/dspace.rb

@@ -0,0 +1,187 @@
+module DSpace
+  ROOT = File.expand_path('../..', __FILE__)
+  @@config = nil;
+
+  BITSTREAM = 0;
+  BUNDLE = 1;
+  ITEM = 2;
+  COLLECTION = 3;
+  COMMUNITY = 4;
+  SITE = 5;
+  GROUP = 6;
+  EPERSON = 7;
+
+  def self.objTypeId(type_str_or_int)
+    obj_typ = Constants.typeText.find_index type_str_or_int
+    if  obj_typ.nil? then
+      obj_typ = Integer(type_str_or_int)
+      raise "no such object typ #{type_str_or_int}" unless Constants.typeText[obj_typ]
+    end
+    return obj_typ;
+  end
+
+  def self.objTypeStr(type_str_or_int)
+    return type_str_or_int  if Constants.typeText.find_index type_str_or_int
+    obj_typ_id = Integer(type_str_or_int)
+    raise "no such object type #{type_str_or_int}" unless Constants.typeText[obj_typ_id]
+    return Constants.typeText[obj_typ_id];
+  end
+
+  def self.load(dspace_dir = nil)
+    if (@@config.nil?) then
+      @@config = Config.new(dspace_dir || ENV['DSPACE_HOME'] || "/dspace")
+      self.context # initialize context now
+      java_import org.dspace.handle.HandleManager;
+      java_import org.dspace.core.Constants
+      java_import org.dspace.content.DSpaceObject
+      return true
+    else
+      puts "Already loaded #{@@config.dspace_cfg}"
+    end
+    return false
+  end
+
+  def self.context
+    raise "must call load to initialize" if @@config.nil?
+    raise "should never happen" if @@config.context.nil?
+    return @@config.context
+  end
+
+  def self.login(netid)
+    self.context.setCurrentUser(DEperson.find(netid))
+    return nil
+  end
+
+  def self.commit
+    self.context.commit
+  end
+
+  def self.create(dso)
+    raise "dso must not be nil" if dso.nil?
+    klass =  Object.const_get  "D" + dso.class.name.gsub(/.*::/,'')
+    klass.send :new, dso
+  end
+
+  def self.fromString(type_id_or_handle)
+    splits = type_id_or_handle.split('.')
+    if (2 == splits.length) then
+      self.find(splits[0], splits[1])
+    else
+      self.fromHandle(type_id_or_handle)
+    end
+  end
+
+  def self.fromHandle(handle)
+    return HandleManager.resolve_to_object(DSpace.context, handle);
+  end
+
+  def self.find(type_str_or_int, identifier)
+    type_str = DSpace.objTypeStr(type_str_or_int)
+    type_id = DSpace.objTypeId(type_str)
+    int_id = identifier.to_i
+    obj = DSpaceObject.find(DSpace.context, type_id, int_id)
+    if obj.nil? and klass.methods.include? :find
+      klass = Object.const_get "D" + type_str.capitalize
+      obj = klass.send :find, identifier
+    end
+    return obj
+  end
+
+  def self.findByMetadataValue(fully_qualified_metadata_field, value_or_nil, restrict_to_type)
+      java_import org.dspace.content.MetadataSchema
+      java_import org.dspace.content.MetadataField
+      java_import org.dspace.storage.rdbms.DatabaseManager
+      java_import org.dspace.storage.rdbms.TableRow
+
+      (schema, element, qualifier) = fully_qualified_metadata_field.split('.')
+      schm = MetadataSchema.find(DSpace.context, schema)
+      raise "no such metadata schema: #{schema}" if schm.nil?
+      field = MetadataField.find_by_element(DSpace.context, schm.getSchemaID, element, qualifier)
+      raise "no such metadata field #{fully_qualified_metadata_field}" if field.nil?
+
+      sql = "SELECT MV.resource_id, MV.resource_type_id  FROM MetadataValue MV";
+      sql = sql + " where MV.metadata_field_id= #{field.getFieldID} "
+      if (not value_or_nil.nil?) then
+        sql = sql + " AND MV.text_value LIKE '#{value_or_nil}'"
+      end
+      if (restrict_to_type) then
+        sql = sql + " AND MV.resource_type_id = #{objTypeId(restrict_to_type)}"
+      end
+
+      tri = DatabaseManager.queryTable(DSpace.context, "MetadataValue",   sql)
+      dsos = [];
+      while (iter = tri.next())
+        dsos << self.find(iter.getIntColumn("resource_type_id"), iter.getIntColumn("resource_id") )
+      end
+      tri.close
+      return dsos
+    end
+
+
+  def self.kernel
+    @@config.kernel;
+  end
+
+  def self.help( klasses = [ DSpace, DCommunity, DCollection, DItem, DGroup])
+    klasses.each do |klass|
+      klass.singleton_methods.sort.each do |mn|
+        m = klass.method(mn)
+        plist = m.parameters.collect { |p|
+          if (p[0] == :req) then
+            "#{p[1].to_s}"
+          else
+            "[ #{p[1].to_s} ]"
+          end
+        }
+        puts "#{klass.name}.#{mn.to_s} (#{plist.join(", ")})"
+      end
+    end
+    return nil
+  end
+
+  class Config
+    def initialize(dspace_home)
+      @dspace_dir = dspace_home
+      puts "Using #{@dspace_dir}"
+      @dspace_cfg = "#{@dspace_dir}/config/dspace.cfg";
+      @dspace_jars ||= Dir[File.join(@dspace_dir, 'lib/*.jar')]
+      @context = nil;
+      @kernel = nil;
+    end
+
+    def dspace_dir
+      @dspace_dir || raise('dspace_dir is undefined');
+    end
+
+    def dspace_cfg
+      @dspace_cfg || raise('dspace.cfg is undefined');
+    end
+
+    def context
+      init
+      return @context
+    end
+
+    def init
+      if @context.nil? then
+        puts "Loading jars"
+        @dspace_jars.each do |jar|
+          require jar
+        end
+        puts "Loading #{@dspace_cfg}"
+        org.dspace.core.ConfigurationManager.load_config(@dspace_cfg)
+
+        kernel_impl = org.dspace.servicemanager.DSpaceKernelInit.get_kernel(nil)
+        if not kernel_impl.is_running then
+          puts "Starting new DSpaceKernel"
+          kernel_impl.start(@dspace_dir)
+        end
+        @kernel = kernel_impl;
+
+        @context = org.dspace.core.Context.new()
+      end
+    end
+  end
+
+end
+

data/lib/dspace/version.rb

@@ -0,0 +1,3 @@
+module DSpace
+    VERSION = "0.0.5"
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: jrdspace
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Monika Mevenkamp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: jrdspace enables scripting of the dspace-api Java objects in a DSpace
+  installation; it includes an interactive console
+email:
+- monikam@princeton.edu
+executables:
+- idspace
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/idspace
+- dspace.gemspec
+- lib/dspace.rb
+- lib/dspace/dbitstream.rb
+- lib/dspace/dbundle.rb
+- lib/dspace/dcollection.rb
+- lib/dspace/dcommunity.rb
+- lib/dspace/deperson.rb
+- lib/dspace/dgroup.rb
+- lib/dspace/ditem.rb
+- lib/dspace/dso.rb
+- lib/dspace/dspace.rb
+- lib/dspace/version.rb
+homepage: https://github.com/akinom/dspace-jruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Jruby classes that interact with the dspace-api Java classes - v5
+test_files: []