active-fedora 1.0.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-02-04
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,19 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+lib/active_fedora.rb
+lib/active-fedora.rb
+lib/active_fedora/base.rb
+lib/active_fedora/content_model.rb
+lib/active_fedora/datastream.rb
+lib/active_fedora/fedora_object.rb
+lib/active_fedora/metadata_datastream.rb
+lib/active_fedora/model.rb
+lib/active_fedora/property.rb
+lib/active_fedora/qualified_dublin_core_datastream.rb
+lib/active_fedora/relationship.rb
+lib/active_fedora/rels_ext_datastream.rb
+lib/active_fedora/semantic_node.rb
+lib/active_fedora/solr_service.rb
+solr/config/schema.xml

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on afed-regem, see http://afed-regem.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,48 @@
+= afed-regem
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIXME full name
+
+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/lib/active-fedora.rb

@@ -0,0 +1 @@
+require 'active_fedora'

data/lib/active_fedora.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+gem 'ruby-fedora'
+gem 'solr-ruby'
+module ActiveFedora #:nodoc:
+  VERSION='1.0.0'
+end
+
+
+
+Dir[File.join(File.dirname(__FILE__), 'lib/active_fedora')+'/**/*.rb'].each{|x| "requiring #{x}";require x}

data/lib/active_fedora/base.rb

@@ -0,0 +1,362 @@
+require 'util/class_level_inheritable_attributes'
+require 'active_fedora/model'
+require 'active_fedora/semantic_node'
+module ActiveFedora
+
+  # This class ties together many of the lower-level modules, and
+  # implements something akin to an ActiveRecord-alike interface to
+  # fedora. If you want to represent a fedora object in the ruby
+  # space, this is the class you want to extend.
+  #
+  # =The Basics
+  #   class Oralhistory < ActiveFedora::Base
+  #     has_metadata :name => "properties", :type => ActiveFedora::MetadataDatastream do |m|
+  #       m.field "narrator",  :string
+  #       m.field "narrator",  :text
+  #     end
+  #   end
+  #
+  # The above example creates a FedoraObject with a metadata datastream named "properties", which is composed of a 
+  # narrator and bio field.
+  #
+  # Datastreams defined with +has_metadata+ are accessed via the +datastreams+ member hash.
+  #
+  # =Implementation
+  # This class is really a facade for a basic Fedora::FedoraObject, which is stored internally.
+  class Base
+    include MediaShelfClassLevelInheritableAttributes
+    ms_inheritable_attributes  :ds_specs
+    include Model
+    include SemanticNode
+
+    # Has this object been saved?
+    def new_object?
+      @new_object
+    end
+
+    # Constructor. If +attrs+  does  not comtain +:pid+, we assume we're making a new one,
+    # and call off to the Fedora Rest API for the next available Fedora pid, and mark as new object.
+    # 
+    # If there is a pid, we're re-hydrating an existing object, and new object is false. Once the @inner_object is stored,
+    # we configure any defined datastreams.
+    def initialize(attrs = {})
+      unless attrs[:pid]
+        attrs = attrs.merge!({:pid=>Fedora::Repository.instance.nextid})  
+        @new_object=true
+      else
+        @new_object=false;
+      end
+      @inner_object = Fedora::FedoraObject.new(attrs)
+      @datastreams = {}
+      configure_defined_datastreams
+    end
+
+    #This method is used to specify the details of a datastream. 
+    #args must include :name. Note that this method doesn't actually
+    #execute the block, but stores it at the class level, to be executed
+    #by any future instantiations.
+    def self.has_metadata(args, &block)
+      @ds_specs ||= Hash.new
+      @ds_specs[args[:name]]= [args[:type], block]
+    end
+
+    #Saves a Base object, and any dirty datastreams, then updates 
+    #the Solr index for this object.
+    def save
+      # If it's a new object, set the conformsTo relationship for Fedora CMA
+      if new_object? 
+        add_relationship(:conforms_to, ActiveFedora::ContentModel.pid_from_ruby_class(self.class))
+      end
+      @new_object =false
+      Fedora::Repository.instance.save(@inner_object)
+      datastreams_in_memory.each do |k,ds|
+        if ds.dirty? || ds.new_object? 
+          if ds.kind_of?(ActiveFedora::MetadataDatastream) 
+            metadata_is_dirty = true
+          end
+          ds.save
+        end
+        self.update_index if metadata_is_dirty == true 
+      end
+    end
+
+    #Deletes a Base object, also deletes the info indexed in Solr, and 
+    #the underlying inner_object.
+    def delete
+      Fedora::Repository.instance.delete(@inner_object)
+      escaped_pid = self.pid.gsub(/(:)/, '\\:')
+      SolrService.instance.conn.delete(escaped_pid)
+    end
+
+    # Returns all known datastreams for the object.  If the object has been 
+    # saved to fedora, the persisted datastreams will be included.
+    # Datastreams that have been modified in memory are given preference over 
+    # the copy in Fedora.
+    def datastreams
+      if @new_object
+        @datastreams = datastreams_in_memory
+      else
+        @datastreams = datastreams_in_fedora.merge(datastreams_in_memory)
+      end
+
+    end
+
+    def datastreams_in_fedora #:nodoc:
+      mds = {}
+      self.datastreams_xml['datastream'].each do |ds|
+        ds.merge!({:pid => self.pid, :dsID => ds["dsid"]})
+        if ds["dsid"] == "RELS-EXT" 
+          mds.merge!({ds["dsid"] => ActiveFedora::RelsExtDatastream.new(ds)})
+        else
+          mds.merge!({ds["dsid"] => ActiveFedora::Datastream.new(ds)})
+        end
+        mds[ds["dsid"]].new_object = false
+      end
+      mds
+    end
+
+    def datastreams_in_memory #:ndoc:
+      @datastreams ||= Hash.new
+    end
+
+    #return the datastream xml representation direclty from Fedora
+    def datastreams_xml
+      datastreams_xml = XmlSimple.xml_in(Fedora::Repository.instance.fetch_custom(self.pid, :datastreams))
+    end
+
+    # Adds datastream to the object.  Saves the datastream to fedora upon adding.
+    def add_datastream(datastream)
+      datastream.pid = self.pid
+      datastreams[datastream.dsid] = datastream
+      return true
+    end
+    def add(datastream) # :nodoc:
+      warn "Warning: ActiveFedora::Base.add has been deprected.  Use add_datastream"
+      add_datastream(datastream)
+    end
+    
+    #return all datastreams of type ActiveFedora::MetadataDatastream
+    def metadata_streams
+      results = []
+      datastreams.each_value do |ds|
+        if ds.kind_of?(ActiveFedora::MetadataDatastream) 
+          results<<ds
+        end
+      end
+      return results
+    end
+    
+    #return all datastreams not of type ActiveFedora::MetadataDatastream 
+    #(that aren't Dublin Core or RELS-EXT streams either)
+    def file_streams
+      results = []
+      datastreams.each_value do |ds|
+        if !ds.kind_of?(ActiveFedora::MetadataDatastream) 
+          dsid = ds.dsid
+          if dsid != "DC" && dsid != "RELS-EXT"
+            results<<ds
+          end
+        end
+      end
+      return results
+    end
+    
+    # Return the Dublin Core (DC) Datastream. You can also get at this via 
+    # the +datastreams["DC"]+.
+    def dc
+      #dc = REXML::Document.new(datastreams["DC"].content)
+      return  datastreams["DC"] 
+    end
+
+    # Returns the RELS-EXT Datastream
+    # Tries to grab from in-memory datastreams first
+    # Failing that, attempts to load from Fedora and addst to in-memory datastreams
+    # Failing that, creates a new RelsExtDatastream and adds it to the object
+    def rels_ext
+      if !datastreams.has_key?("RELS-EXT") 
+        add_datastream(ActiveFedora::RelsExtDatastream.new)
+      end
+      return datastreams["RELS-EXT"]
+    end
+
+    # @returns Hash of relationships, as defined by SemanticNode
+    # Rely on rels_ext datastream to track relationships array
+    # Overrides accessor for relationships array used by SemanticNode.
+    def relationships
+      return rels_ext.relationships
+    end
+
+    # Add a Rels-Ext relationship to the Object.
+    # @param predicate
+    # @param object Either a string URI or an object that responds to .pid 
+    def add_relationship(predicate, obj)
+      #predicate = ActiveFedora::RelsExtDatastream.predicate_lookup(predicate)
+      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj)
+      rels_ext.add_relationship(r)
+      rels_ext.dirty = true
+    end
+
+
+    def inner_object # :nodoc
+      @inner_object
+    end
+
+    #return the pid of the Fedora Object
+    def pid
+      @inner_object.pid
+    end
+    
+    #For Rails compatibility with url generators.
+    def to_param
+      self.pid
+    end
+    #return the internal fedora URI
+    def internal_uri
+      "info:fedora/#{pid}"
+    end
+    
+    #return the state of the inner object
+    def state 
+      @inner_object.state
+    end
+
+    #return the owner id
+    def owner_id
+      @inner_object.owner_id
+    end
+
+    #return the create_date of the inner object (unless it's a new object)
+    def create_date
+      @inner_object.create_date unless new_object?
+    end
+
+    #return the modification date of the inner object (unless it's a new object)
+    def modified_date
+      @inner_object.modified_date unless new_object?
+    end
+
+    #return the error list of the inner object (unless it's a new object)
+    def errors
+      @inner_object.errors
+    end
+    
+    #return the label of the inner object (unless it's a new object)
+    def label
+      @inner_object.label
+    end
+
+
+    def self.deserialize(doc) #:nodoc:
+      pid = doc.elements['/foxml:digitalObject'].attributes['PID']
+      proto = self.new(:pid=>pid)
+      proto.datastreams.each do |name,ds|
+        doc.elements.each("//foxml:datastream[@ID='#{name}']") do |el|
+          proto.datastreams[name]=ds.class.from_xml(ds, el)
+        end
+      end
+      proto
+    end
+
+    #Return a hash of all available metadata fields for all 
+    #ActiveFedora::MetadataDatastream datastreams, as well as 
+    #system_create_date, system_modified_date, active_fedora_model_field, 
+    #and the object id.
+    def fields
+      fields = {:id => {:values => [pid]}, :system_create_date => {:values => [self.create_date]}, :system_modified_date => {:values => [self.modified_date]}, :active_fedora_model_field => {:values => [self.class.inspect]}}
+      datastreams.values.each do |ds|        
+        fields.merge!(ds.fields) if ds.kind_of?(ActiveFedora::MetadataDatastream)
+      end
+      return fields
+    end
+    
+    #Returns the xml version of this object as a string.
+    def to_xml(xml=REXML::Document.new("<xml><fields/><content/></xml>"))
+      fields_xml = xml.root.elements['fields']
+      {:id => pid, :system_create_date => self.create_date, :system_modified_date => self.modified_date, :active_fedora_model_field => self.class.inspect}.each_pair do |attribute_name, value|
+        el = REXML::Element.new(attribute_name.to_s)
+        el.text = value
+        fields_xml << el
+      end
+      datastreams.each_value do |ds|        
+        ds.to_xml(fields_xml) if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::RelsExtDatastream)
+      end
+      return xml.to_s
+    end
+
+    #Return a Solr::Document version of this object.
+    def to_solr(solr_doc = Solr::Document.new)
+      solr_doc << {:id => pid, :system_create_date => self.create_date, :system_modified_date => self.modified_date, :active_fedora_model_field => self.class.inspect}
+      datastreams.each_value do |ds|
+        solr_doc = ds.to_solr(solr_doc) if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::RelsExtDatastream)
+      end
+      return solr_doc
+    end
+
+    # Updates Solr index with self.
+    def update_index
+      SolrService.instance.conn.update(self.to_solr)
+    end
+
+    # An ActiveRecord-ism to udpate metadata values.
+    #
+    # Passing a hash into this method will attempt to set the values into the 
+    # appropriate fields (for all datastreams, which means a.name and b.name 
+    # fields are _both_ overwritten)
+    def update_attributes(params={})
+      params.each do |k,v|
+        datastreams.values.each do |d|
+          if d.fields[k.to_sym]
+            d.send("#{k}_values=", v)
+          end
+        end
+      end
+    end
+
+    # A convenience method  for updating indexed attributes.  The passed in hash
+    # must look like this : 
+    #   {{:name=>{"0"=>"a","1"=>"b"}}
+    #
+    # This will result in any datastream field of name :name having the value [a,b]
+    #
+    # An index of -1 will insert a new value. any existing value at the relevant index 
+    # will be overwritten.
+    #
+    # As in update_attributes, this overwrites _all_ available fields.
+    #
+    def update_indexed_attributes(params={})
+      params.each do |key,value|
+        datastreams.each do |dsn, dstream|
+          if dstream.fields[key.to_sym]
+            aname="#{key}_values"
+            curval = dstream.send("#{aname}")
+            cpv=value.dup#copy this, we'll need the original for the next ds
+            cpv.delete_if do |y,z| 
+              if curval[y.to_i] and y.to_i > -1
+                curval[y.to_i]=z
+                true
+              else
+                false
+              end
+            end 
+            cpv.each { |y,z| curval<<z}#just append everything left
+            dstream.send("#{aname}=", curval) #write it back to the ds
+          end
+        end
+      end
+
+    end
+
+    private
+    def configure_defined_datastreams
+      if self.class.ds_specs
+        self.class.ds_specs.each do |name,ar|
+          ds = ar.first.new(:dsid=>name)
+          ar.last.call(ds)
+          self.add_datastream(ds)
+        end
+      end
+    end
+
+
+  end
+end