jrdspace 0.0.10 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5374a48462982af2dd2b668f131d141b04cdee5
-  data.tar.gz: 7569318017512c64a43db11edcaa0a4cfb0b9008
+  metadata.gz: c5db7f77a3d11787aba5287f24399b892124e5bb
+  data.tar.gz: bb17539e3e32642d8d8d2826fec7e496d638ba88
 SHA512:
-  metadata.gz: 9c7636089366716a41e9e8d267534561f7edb4ff8efdfaf1e5391f176cab6643bca26e55268a40c9e3e1d33b0ec2515e54f7be9a6922888c00ad3602ff534043
-  data.tar.gz: 9083ad89bf0161c5b61a447f1c2590e4639c16f1bf3179beb541a1c3443d48c3ce36f949746415b5e46ce0b8f968aba6666e80412f0ad2ad232b88a8f7df2759
+  metadata.gz: c076098fdff1062aef6d13e7b04817d9f967c5e30390c5e8d151265c24893fffa1634ec1142c6e0d625c448589cb0211ea4670c02f08e375794d1475b2a678e0
+  data.tar.gz: 46f5ce896a3bc98ff427fb78cacc37c796dc2017be8cbe01947c6b174538e8be0bd68bb3d0644bdd8b7f54825b832bf6437ab58cf59f2eb16ad464e23a744d15

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Jacob Brown
+Copyright (c) 2016 Monika Mevenkamp
 
 MIT License
 

data/README.md

@@ -8,6 +8,8 @@ jrdspace contains an interactive console and therefore enables quick experimenta
 
 The companion project [cli-dspace](https://github.com/akinom/dspace-cli)  contains utilities that make use of jrdspace.
 
+Documentation is also available at [rubydoc.info](http://www.rubydoc.info/github/akinom/dspace-jruby)
+
 ## Installation
 
 ### Prerequisite
@@ -18,6 +20,7 @@ The companion project [cli-dspace](https://github.com/akinom/dspace-cli)  contai
 ### Installation 
 
 Add the gem to your projects Gemfile: 
+
 ```
 gem 'jrdspace'      # pull from rubygems 
 
@@ -26,11 +29,14 @@ gem 'jrdspace', :git => 'https://github.com/akinom/dspace-jruby', :branch => 'ma
 ```
 
 Install the gem:
+
 ```
 bundle install
 ```
 
-Please note that I am still updating this gem ferquently as I discover bugs. So please keep do update frequently with 
+Please note that I am still updating this gem frequently as I discover bugs.
+So please update frequently with 
+
 ```
 bundle update
 ```
@@ -38,6 +44,7 @@ bundle update
 ##  Usage 
 
 To use in scripts simply include the following 
+
 ```
 require 'dspace' 
 DSpace.load(dspace_install_dir) 
@@ -66,13 +73,20 @@ DSpace.load("/home/you/installs/dspace")     # load from /home/you/installs/dspa
 ```
 
 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: 
+The included classes DSpace, DCommunity, DCollection, ... from [lib/dspace](lib/dspace) 
+provide convenience methods, such as retrieving all Communities  finding individual objects: 
+
 ```
 DCommunity.all
-DSpace.fromString('GROUP.name')
+DSpace.fromString ('some/handle')      
+DSpace.fromString ('ITEM.124')      
+DSpace.fromString ('EPERSON.a_netid')   
+DSpace.fromString ('GROUP.Anonymous')      
+DGroup.find('group_name')
 ```
 
 If you want to make changes you can 'login' 
@@ -88,26 +102,15 @@ 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:
+For example all jrdspace objects derived from DSpaceObjects implement the parents and policies method:
+
 ```
 dso = DSpace.fromHandle('xxxxx/zzz') 
 DSpace.create(dso).parents

data/lib/dspace.rb

@@ -1,4 +1,5 @@
 require 'dspace/dspace'
+require 'dspace/dconstants'
 require 'dspace/dso'
 require 'dspace/deperson'
 require 'dspace/dgroup'
@@ -7,5 +8,5 @@ require 'dspace/dcommunity'
 require 'dspace/ditem'
 require 'dspace/dbitstream'
 require 'dspace/dbundle'
-require 'dspace/dworkflowitem'
-require 'dspace/dworkspaceitem'
+require 'dspace/dwork'
+require 'dspace/dmetadata'

data/lib/dspace/dbitstream.rb

@@ -1,14 +1,22 @@
+###
+# This class wraps an org.dspace.content.Bitstream object
 class DBitstream
   include DSO
 
+  ##
+  # return array of all org.dspace.content.Bitstream objects
   def self.all()
     java_import org.dspace.content.Bitstream;
     return Bitstream.findAll(DSpace.context)
   end
 
+  ##
+  # returns nil or the org.dspace.content.Bitstream object with the given id
+  #
+  # id must be an integer
   def self.find(id)
     java_import org.dspace.content.Bitstream;
     return Bitstream.find(DSpace.context, id)
   end
 
-end
+end

data/lib/dspace/dbundle.rb

@@ -1,6 +1,12 @@
+###
+# This class wraps an org.dspace.content.Bitstream object
 class DBundle
   include DSO
 
+  ##
+  # returns nil or the org.dspace.content.Bundle object with the given id
+  #
+  # id must be an integer
   def self.find(id)
     java_import org.dspace.content.Bundle;
     return Bundle.find(DSpace.context, id)

data/lib/dspace/dcollection.rb

@@ -1,35 +1,44 @@
+##
+# This class wraps an org.dspace.content.Collection object
 class DCollection
   include DSO
 
+  ##
+  # return array of all org.dspace.content.Collection objects
   def self.all()
     java_import org.dspace.content.Collection;
     return Collection.findAll(DSpace.context)
   end
 
+  ##
+  # returns nil or the org.dspace.content.Collection object with the given id
+  #
+  # id must be an integer
   def self.find(id)
     java_import org.dspace.content.Collection;
     return Collection.find(DSpace.context, id)
   end
 
-
-  def self.findAll(name)
+  ##
+  #  create and return org.dspace.content.Collection with given name in the given community
+  #
+  # community must be a org.dspace.content.Communiy obj
+  def self.create(name, community)
     java_import org.dspace.content.Collection;
-    self.all.select do |c|
-      c.getName == name
-    end
+    new_col = Collection.create(DSpace.context)
+    new_col.setMetadata("name", name)
+    new_col.update
+    community.addCollection(new_col)
+    return new_col
   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
+  ##
+  # return all items listed by the dspace item iterator
+  def items
+    items, iter  = [], @obj.items
+    while (i = iter.next) do
+      items << i
     end
-    return rpt;
+    items
   end
-end
+end

data/lib/dspace/dcommunity.rb

@@ -1,30 +1,31 @@
+##
+# This class wraps an org.dspace.content.Community object
 class DCommunity
   include DSO
 
+  ##
+  # return array of all org.dspace.content.Community objects
   def self.all()
     java_import org.dspace.content.Community;
     return Community.findAll(DSpace.context)
   end
 
+  ##
+  # returns nil or the org.dspace.content.Community object with the given id
+  #
+  # id must be an integer
   def self.find(id)
     java_import org.dspace.content.Community;
     return Community.find(DSpace.context, id)
   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;
+  ##
+  #  create and return top level org.dspace.content.Community with given name
+  def self.create(name)
+    comm = Community.create(nil, DSpace.context)
+    comm.setMetadata("name", name)
+    comm.update
+    return comm
   end
 
 end

data/lib/dspace/dconstants.rb

@@ -0,0 +1,44 @@
+##
+# This class wraps an org.dspace.content.Community object
+class DConstants
+
+  ##
+  # constants corresponding to those defined in org.dspace.core.Constants
+  BITSTREAM = 0;
+  BUNDLE = 1;
+  ITEM = 2;
+  COLLECTION = 3;
+  COMMUNITY = 4;
+  SITE = 5;
+  GROUP = 6;
+  EPERSON = 7;
+
+  READ = 0;
+  WRITE = 1;
+  DELETE = 2;
+  ADD = 3;
+  REMOVE = 4;
+  WORKFLOW_STEP_1 = 5;
+  WORKFLOW_STEP_2 = 6;
+  WORKFLOW_STEP_3 = 7;
+  WORKFLOW_ABORT = 8;
+  DEFAULT_BITSTREAM_READ = 9;
+  DEFAULT_ITEM_READ = 10;
+  ADMIN = 11;
+
+  
+  ##
+  # returns nil or the org.dspace.content.Community object with the given id
+  #
+  # id must be an integer
+  def self.typeStr(obj_type_id)
+    return org.dspace.core.Constants.typeText[obj_type_id].capitalize
+  end
+
+  ##
+  # return String for given action_id
+  def self.actionStr(action_id)
+      return org.dspace.core.Constants.actionText[action_id]
+  end
+
+end

data/lib/dspace/deperson.rb

@@ -1,11 +1,31 @@
+##
+# This class wraps an org.dspace.eperson.EPerson object
 class DEPerson
   include DSO
 
+  ##
+  # return array of all org.dspace.eperson.EPerson objects
   def self.all()
     java_import org.dspace.eperson.EPerson;
     return EPerson.findAll(DSpace.context, 1)
   end
 
+  ##
+  # returns nil or the org.dspace.eperson.EPerson object with the given netid, email, or id
+  # netid_or_email: must be a string or integer
+  def self.find(netid_email_or_id)
+    java_import org.dspace.eperson.EPerson;
+    raise "must give a netid_or_email value" unless netid_email_or_id
+    if netid_email_or_id.is_a? String then
+      return EPerson.findByNetid(DSpace.context, netid_email_or_id) || EPerson.findByEmail(DSpace.context, netid_email_or_id)
+    end
+    return EPerson.find(DSpace.context, netid_email_or_id)
+  end
+
+  ##
+  # create an org.dspace.eperson.EPerson with the given netid, name and email
+  #
+  # the EPerson is not committed to the database
   def self.create(netid, first, last, email)
     java_import org.dspace.eperson.EPerson;
     raise "must give a netid value" unless netid
@@ -24,19 +44,17 @@ class DEPerson
     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
-
+  ##
+  # return all groups where this user is a member
   def groups
     java_import org.dspace.eperson.Group;
     return Group.allMemberGroups(DSpace.context, @obj);
   end
 
-  def group_names
-    groups.collect { |g| g.getName}.sort
+  ##
+  # convert to string
+  def inspect
+    describe = @obj.getNetid || @obj.getEmail || @obj.getID
+    return "EPERSON.#{describe}"
   end
-
 end

data/lib/dspace/dgroup.rb

@@ -1,14 +1,26 @@
+##
+# This class wraps an org.dspace.eperson.Group object
 class DGroup
   include DSO
 
-  ADMIN_ID = 1;
-  ANONYMOUS_ID = 0;
+  ##
+  # id of administrator group
+  ADMIN_ID = 1
 
+  ##
+  # id of anonymous user group
+  ANONYMOUS_ID = 0
+
+  ##
+  # return array of all org.dspace.eperson.Group objects
   def self.all
     java_import org.dspace.eperson.Group;
     Group.findAll(DSpace.context, 1);
   end
 
+  ##
+  # returns nil or the org.dspace.eperson.Group object with the given name or id
+  # name_or_id: must be a string or integer
   def self.find(name_or_id)
     java_import org.dspace.eperson.Group;
     if (name_or_id.class == String)
@@ -18,6 +30,10 @@ class DGroup
     end
   end
 
+  ##
+  # find and return the existing group with the given name or create and return a new group with the given name
+  #
+  # name must be a string
   def self.find_or_create(name)
     raise "must give a name " unless name
     group = self.find(name);
@@ -32,17 +48,18 @@ class DGroup
     return group;
   end
 
+  ##
+  # return EPerson and Groups that are (direct) require 'faker;members of this DGroup
+  #
+  # name must be a string
   def members
-    list = [];
-    @obj.getMembers.each do |m|
-      list << m;
-    end
-    @obj.getMemberGroups.each do |m|
-      list << m;
-    end
-    return list;
+    return @obj.getMembers + @obj.getMemberGroups
   end
 
+  ##
+  # add a memeber to the group
+  #
+  # group_or_eperson must be a org.dspace.eperson.EPerson or Group object
   def addMember(group_or_eperson)
     raise "must give non nil group_or_eperson" if group_or_eperson.nil?
     @obj.addMember(group_or_eperson);
@@ -50,14 +67,9 @@ class DGroup
     return @obj;
   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| DEerson.new(p).report  } unless list.empty?
-    return rpt;
+  ##
+  # convert to string
+  def inspect
+    return "GROUP.#{@obj.getName}"
   end
-
 end

data/lib/dspace/ditem.rb

@@ -1,37 +1,49 @@
+##
+# This class wraps an org.dspace.content.Item object
 class DItem
   include DSO;
 
+  ##
+  # return org.dspace.content.ItemIterator for all Items
   def self.iter
     java_import org.dspace.content.Item;
     Item.findAll(DSpace.context);
   end
 
-  def self.all
+  ##
+  # return array of all org.dspace.content.Item objects
+  def self.all()
     java_import org.dspace.content.Item;
-    list = []
-    stp = iter
+    list, stp = [], iter
     while (i = stp.next)
       list << i
     end
     return list
   end
 
+  ##
+  # returns nil or the org.dspace.content.Item object with the given id
+  #
+  # id must be an integer
   def self.find(id)
     java_import org.dspace.content.Item;
-    id = id.to_i if id.class == String
     return Item.find(DSpace.context, id)
   end
 
+  ##
+  # returns [] if restrict_to_dso is nil or all items that are contained in the given restrict_to_dso
+  #
+  # restrict_to_dso must be nil, or an instance of org.dspace.content.Item, Collection, or Community
   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
+    return [restrict_to_dso] if restrict_to_dso.getType == DConstants::ITEM
+    return [] if restrict_to_dso.getType != DConstants::COLLECTION and restrict_to_dso.getType != DConstants::COMMUNITY
 
     sql = "SELECT ITEM_ID FROM ";
-    if (restrict_to_dso.getType() == DSpace::COLLECTION) then
+    if (restrict_to_dso.getType() == DConstants::COLLECTION) then
       sql = sql + "  Collection2Item CO WHERE  CO.Collection_Id = #{restrict_to_dso.getID}"
     else
       # must be COMMUNITY
@@ -49,14 +61,21 @@ class DItem
     return dsos
   end
 
+  ##
+  # returns the bitstreams in the given bundle
   def bitstreams(bundle = "ORIGINAL")
-    bundle = @obj.getBundles.select { |b| b.getName() == bundle }[0]
-    if (not bundle.nil?) then
-      return bundle.getBitstreams
+    bundles = bundle.nil? ? @obj.getBundles : @obj.getBundles(bundle)
+    bits = []
+    bundles.each do |b|
+      bits += b.getBitstreams
     end
-    return [];
+    bits
   end
 
+  ##
+  # creata a org.dspace.content.Item with the given metadata in the given collection
+  #
+  # metadata_hash use keys like dc.contributir.author and single string or arrays of values
   def self.install(collection, metadata_hash)
     java_import org.dspace.content.InstallItem;
     java_import org.dspace.content.WorkspaceItem;

data/lib/dspace/dmetadata.rb

@@ -0,0 +1,35 @@
+class DMetadataField
+
+  ##
+  # instantiate a wrapper for the given org.dspace.content.MetadataField
+  def initialize(dobj)
+    raise "must pass non null obj" unless dobj
+    raise "must pass org.dspace.content.MetadataField obj" unless dobj.instance_of? org.dspace.content.MetadataField
+    @obj = dobj
+  end
+
+  ##
+  # returns nil or the org.dspace.content.MetadataField object with the given field_name
+  #
+  # field_name must be a formmatted  string: schema.element[.qualifier]
+  def self.find(fully_qualified_metadata_field)
+    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?
+    return MetadataField.find_by_element(DSpace.context, schm.getSchemaID, element, qualifier)
+  end
+
+  def inspect
+    java_import org.dspace.content.MetadataSchema
+    schema = MetadataSchema.find(DSpace.context, @obj.schemaID)
+    str = "#{schema.getName}.#{@obj.element}"
+    str += ".#{@obj.qualifier}" if @obj.qualifier
+    return str
+  end
+
+end

data/lib/dspace/dso.rb

@@ -1,10 +1,17 @@
+##
+# This module contains methods to be included by classes that wrap objects 
+# that derive from org.dspace.content.DSpaceObject 
 require 'json'
 
 module DSO
 
+  ## 
+  # instanciates a wrapper object for the given dobj, which must derive from org.dspace.content.DSpaceObject
+  # 
+  # the wrapper object's class must be compatible with the type of the given dobj 
   def initialize(dobj)
     raise "must pass non null obj" unless dobj
-    type = DSpace.const_get self.class.name[1..-1].upcase
+    type = DConstants.const_get self.class.name[1..-1].upcase
     @obj = dobj
     raise "#{dobj} is not a #{type} object" unless @obj.getType == type
   end
@@ -23,23 +30,6 @@ module DSO
     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)
@@ -65,10 +55,16 @@ module DSO
     mvs = [];
     while (iter = tri.next())
       field =  MetadataField.find(DSpace.context, iter.getIntColumn("metadata_field_id"))
-      mvs <<  [ DSpace.toString(field), iter.getStringColumn("text_value") ]
+      mvs <<  [ DMetadataField.new(field), iter.getStringColumn("text_value") ]
     end
     tri.close
     return mvs
   end
+
+  def inspect
+    return "nil" if @obj.nil?
+    return "#{@obj.getTypeText}.#{@obj.getID}"
+  end
+
 end
 

data/lib/dspace/dspace.rb

@@ -2,29 +2,35 @@ 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;
 
+  ##
+  # return the name of the wrapper klass that corresponds to the give parameter
+  #
+  # type_str_or_int must be oe of the integer values: BITTREAM .. EPERSON, or the corresponding string
   def self.objTypeStr(type_str_or_int)
-    return type_str_or_int.capitalize if type_str_or_int.class == String and Constants.typeText.find_index type_str_or_int.upcase
-    begin
-      id = Integer(type_str_or_int)
-    rescue
-      raise "no such object type #{type_str_or_int}"
+    if type_str_or_int.class == String and Constants.typeText.find_index type_str_or_int.upcase then
+      klassName = type_str_or_int.capitalize
+    else
+      begin
+        id = Integer(type_str_or_int)
+      rescue
+        raise "no such object type #{type_str_or_int}"
+      end
+      klassName = DConstants.typeStr(id)
     end
-    return Constants.typeText[id].capitalize
+    return "EPerson" if klassName == "Eperson"
+    return klassName
   end
 
+  ##
+  # convert string to corresponding constant: BITSTREAM, BUNDLE, ...
   def self.objTypeId(type_str_or_int)
     obj_typ = Constants.typeText.find_index objTypeStr(type_str_or_int).upcase
   end
 
+  ##
+  # load DSpace configurations and jar files from the dspace_dir directory;
+  # if dspace_dir is nil use the value of the environment variable 'DSPACE_HOME' or if undefined as well default to '/dspace'
   def self.load(dspace_dir = nil)
     if (@@config.nil?) then
       @@config = Config.new(dspace_dir || ENV['DSPACE_HOME'] || "/dspace")
@@ -37,37 +43,58 @@ module DSpace
     return @@config != nil
   end
 
+  ##
+  # return the current org.dspace.core.Context
+  #
+  # this method fails unless it is preceded by a successfull DSPace.load call
   def self.context
     raise "must call load to initialize" if @@config.nil?
     raise "should never happen" if @@config.context.nil?
     return @@config.context
   end
 
+  ##
+  # renew  the current org.dspace.core.Context; this abandons any uncommited database changes
   def self.context_renew
     raise "must call load to initialize" if @@config.nil?
     raise "should never happen" if @@config.context.nil?
     return @@config.context_renew
   end
 
+  ##
+  # set the current dspace user to the one with the given netid
   def self.login(netid)
     self.context.setCurrentUser(DEPerson.find(netid))
     return nil
   end
 
+  ##
+  # commit changes to the database
   def self.commit
     self.context.commit
   end
 
+  ##
+  # commit a wrapper object for the given java object;
+  # the type of the warpper is determined by the class of the given java object
+  #
   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.fromHandle(handle)
-    return HandleManager.resolve_to_object(DSpace.context, handle);
-  end
-
+  ##
+  # return the DSpace object that is identified by the given type and identifier
+  #
+  # type_str_or_int must be oe of the integer values: BITTREAM .. EPERSON, or the corresponding string
+  #
+  # identifier must be an integer or string value uniquely identifying the object
+  #
+  #     DSpace.find(DSpace::COLLECTION, 106)
+  #     DSpace.find("ITEM", 10)
+  #     DSpace.find("GROUP", "Anonymous")
+  #     DSpace.find("EPERSON", "her@there.com")
   def self.find(type_str_or_int, identifier)
     type_str = DSpace.objTypeStr(type_str_or_int)
     type_id = DSpace.objTypeId(type_str)
@@ -82,49 +109,40 @@ module DSpace
 
   def self.fromString(type_id_or_handle)
     #TODO handle MetadataField string
-    splits = type_id_or_handle.split('.')
+    splits = type_id_or_handle.split('.', 2)
     if (2 == splits.length) then
       self.find(splits[0].upcase, splits[1])
     else
-      self.fromHandle(type_id_or_handle)
-    end
-  end
-
-  def self.toString(java_obj)
-    return "nil" unless java_obj
-    klass = java_obj.getClass.getName
-    if (klass == "org.dspace.content.MetadataField") then
-      java_import org.dspace.content.MetadataField
-      java_import org.dspace.content.MetadataSchema
-
-      schema = MetadataSchema.find(DSpace.context, java_obj.schemaID)
-      str = "#{schema.getName}.#{java_obj.element}"
-      str += ".#{java_obj.qualifier}" if java_obj.qualifier
-      str
-    else
-      java_obj.toString
+      return HandleManager.resolve_to_object(DSpace.context, type_id_or_handle);
     end
   end
 
+  ##
+  # get a dspace service by name
   def self.getService(service_name, java_klass)
     org.dspace.utils.DSpace.new().getServiceManager().getServiceByName(service_name,java_klass)
   end
 
+  ##
+  # get the SoltServiveImpl
   def self.getIndexService()
     java_import org.dspace.discovery.SolrServiceImpl;
     self.getService("org.dspace.discovery.IndexingService", SolrServiceImpl)
   end
 
+  ##
+  # if value_or_nil is nil and restrict_to_type is nil return all DSpaceObjects have a value for the
+  # given metadata field
+  #
+  # if value_or_nil is not nil restrict to those whose value is equal to the given paramter
+  #
+  # if restrict_to_typ is not nil, restrict to results of the given type
+  #
+  # restrict_to_type must be one of BITSTREAM, .., EPERSON
+
   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)
+    field = DMetadataField.find(fully_qualified_metadata_field)
     raise "no such metadata field #{fully_qualified_metadata_field}" if field.nil?
 
     sql = "SELECT MV.resource_id, MV.resource_type_id  FROM MetadataValue MV";
@@ -145,11 +163,10 @@ module DSpace
     return dsos
   end
 
-  def self.kernel
-    @@config.kernel;
-  end
-
-  def self.help(klasses = [DSpace, DCommunity, DCollection, DItem, DGroup])
+  ##
+  # print available static methods for the give classes
+  def self.help(klasses = [DCommunity, DCollection, DItem, DBundle, DBitstream, DEPerson,
+                           DWorkflowItem, DWorkspaceItem, DMetadataField, DConstants, DSpace])
     klasses.each do |klass|
       klass.singleton_methods.sort.each do |mn|
         m = klass.method(mn)

data/lib/dspace/dwork.rb

@@ -0,0 +1,77 @@
+##
+# Helper module for DWorkflow and DWorkSpace
+module DWork
+
+  ## 
+  # returns all instances of klass if the obj parameter is nil, otherwise
+  # all instances of klass associated with the the given obj
+  #
+  # klass:: must be  org.dspace.workflow.WorkflowItem and org.dspace.workflow.WorkspaceItem
+  # obj:: nil or instances of org.dspace.content.Item, Collection, or Community
+  def self.findAll(obj, klass)
+    if (obj.nil?) then
+      return klass.findAll(DSpace.context)
+    end
+    if (obj.getType == DConstants::COLLECTION)
+      return klass.findByCollection(DSpace.context, obj)
+    elsif (obj.getType == DConstants::COMMUNITY) then
+      wsis = []
+      obj.getAllCollections.each do |col|
+        wsis += findAll(col)
+      end
+      return wsis
+    elsif (obj.getType == DConstants::ITEM) then
+      wi = klass.findByItem(DSpace.context, obj)
+      # to be consistent return array with the unqiue wokflow item
+      return [wi] if wi
+    elsif (obj.getType == DConstants::EPERSON) then
+      wi = klass.findByEPerson(DSpace.context, obj)
+    end
+    # return empty array if no matching workspace items
+    return []
+  end
+
+end
+
+class DWorkflowItem
+
+  ##
+  # find org.dspace.workflow.WorkflowItem
+  #
+  # id must be an integer
+  def self.find(id)
+    java_import org.dspace.workflow.WorkflowItem
+    return WorkflowItem.find(DSpace.context, id)
+  end
+
+
+  ##
+  # returns all instances of org.dspace.workflow.WorkflowItem if the obj parameter is nil, otherwise
+  # all instances of org.dspace.workflow.WorkflowItem associated with the the given obj
+  def self.findAll(obj)
+    java_import org.dspace.workflow.WorkflowItem
+    return DWork.findAll(obj, WorkflowItem)
+  end
+
+end
+
+class DWorkspaceItem
+
+  ##
+  # find org.dspace.workflow.WorkspaceItem
+  #
+  # id must be an integer
+  def self.find(id)
+    java_import org.dspace.content.WorkspaceItem
+    return WorkspaceItem.find(DSpace.context, id)
+  end
+
+  ##
+  # returns all instances of org.dspace.workflow.WorkspaceItem if the obj parameter is nil, otherwise
+  # all instances of org.dspace.workflow.WorkspaceItem associated with the the given obj
+  def self.findAll(obj)
+    java_import org.dspace.content.WorkspaceItem
+    return DWork.findAll(obj, WorkspaceItem)
+  end
+
+end

data/lib/dspace/version.rb

@@ -1,3 +1,3 @@
 module DSpace
-    VERSION = "0.0.10"
+    VERSION = "0.0.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jrdspace
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.12
 platform: ruby
 authors:
 - Monika Mevenkamp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-24 00:00:00.000000000 Z
+date: 2016-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jar
@@ -84,13 +84,14 @@ files:
 - lib/dspace/dbundle.rb
 - lib/dspace/dcollection.rb
 - lib/dspace/dcommunity.rb
+- lib/dspace/dconstants.rb
 - lib/dspace/deperson.rb
 - lib/dspace/dgroup.rb
 - lib/dspace/ditem.rb
+- lib/dspace/dmetadata.rb
 - lib/dspace/dso.rb
 - lib/dspace/dspace.rb
-- lib/dspace/dworkflowitem.rb
-- lib/dspace/dworkspaceitem.rb
+- lib/dspace/dwork.rb
 - lib/dspace/version.rb
 homepage: https://github.com/akinom/dspace-jruby
 licenses:

data/lib/dspace/dworkflowitem.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env jruby
-require 'dspace'
-
-class DWorkflowItem
-  def self.findAll(obj)
-    java_import org.dspace.workflow.WorkflowItem
-    if (obj.nil?) then
-      return WorkflowItem.findAll(DSpace.context)
-    end
-    if (obj.getType == DSpace::COLLECTION)
-      return WorkflowItem.findByCollection(DSpace.context, obj)
-    elsif (obj.getType == DSpace::COMMUNITY) then
-      flows = []
-      obj.getAllCollections.each do |col|
-        flows += findAll(col)
-      end
-      return flows
-    elsif (obj.getType == DSpace::ITEM) then
-      wi = WorkflowItem.findByItem(DSpace.context, obj)
-      # to be consistent return array with the unqiue wokflow item
-      return [wi] if wi
-    end
-    # return empty array if no matching workflow items
-    return []
-  end
-
-end

data/lib/dspace/dworkspaceitem.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env jruby
-require 'dspace'
-
-class DWorkspaceItem
-  def self.findAll(obj)
-    java_import org.dspace.content.WorkspaceItem
-    if (obj.nil?) then
-      return WorkspaceItem.findAll(DSpace.context)
-    end
-    if (obj.getType == DSpace::COLLECTION)
-      return  WorkspaceItem.findByCollection(DSpace.context, obj)
-    elsif (obj.getType == DSpace::COMMUNITY) then
-      wsis = []
-      obj.getAllCollections.each do |col|
-        wsis += findAll(col)
-      end
-      return wsis
-    elsif (obj.getType == DSpace::ITEM) then
-      wi = WorkspaceItem.findByItem(DSpace.context, obj)
-      # to be consistent return array with the unqiue wokflow item
-      return [wi] if wi
-    end
-    # return empty array if no matching workspace items
-    return []
-  end
-
-end