ruby-fedora 0.1.2 → 0.9.0

data/Manifest.txt

@@ -1,3 +1,5 @@
+COPYING.LESSER.txt
+COPYING.txt
 History.txt
 License.txt
 Manifest.txt
@@ -5,30 +7,27 @@ README.txt
 Rakefile
 config/hoe.rb
 config/requirements.rb
-lib/ruby-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
 lib/fedora/base.rb
 lib/fedora/connection.rb
 lib/fedora/datastream.rb
 lib/fedora/fedora_object.rb
 lib/fedora/formats.rb
+lib/fedora/generic_search.rb
 lib/fedora/repository.rb
-lib/active-fedora.rb
-lib/active_fedora/base.rb
-lib/ambition/adapters/active_fedora.rb
-lib/ambition/adapters/active_fedora/base.rb
-lib/ambition/adapters/active_fedora/query.rb
-lib/ambition/adapters/active_fedora/select.rb
-lib/ambition/adapters/active_fedora/slice.rb
-lib/ambition/adapters/active_fedora/sort.rb
-script/destroy
-script/generate
-script/txt2html
+lib/ruby-fedora.rb
+lib/util/class_level_inheritable_attributes.rb
 setup.rb
-tasks/deployment.rake
-tasks/environment.rake
-tasks/website.rake
-website/index.html
-website/index.txt
-website/javascripts/rounded_corners_lite.inc.js
-website/stylesheets/screen.css
-website/template.rhtml
+solr/config/schema.xml

data/README.txt

@@ -29,6 +29,11 @@ To run the active-fedora specs, install the following gems:
  
 Then run "rake spec"
 
+== Package a new gem from ruby_fedora source
+
+rake pkg
+
+
 == TODO
 
- - remove anything in test/* that are no longer relevant
+ - remove anything in test/* that are no longer relevant

data/Rakefile

@@ -1,5 +1,9 @@
 require 'config/requirements'
 require 'config/hoe' # setup Hoe + all gem configuration
+require 'rake/clean'
 
 Dir['tasks/**/*.rake'].each { |rake| load rake }
+CLEAN.include('**/*.orig')
+
+task :default=>:spec
 

data/config/hoe.rb

@@ -31,7 +31,7 @@ end
 REV = nil 
 # UNCOMMENT IF REQUIRED: 
 # REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
-VERS = RubyFedora::VERSION::STRING + (REV ? ".#{REV}" : "")
+VERS = Fedora::VERSION::STRING + (REV ? ".#{REV}" : "")
 RDOC_OPTS = ['--quiet', '--title', 'RubyFedora documentation',
     "--opname", "index.html",
     "--line-numbers", 
@@ -65,4 +65,4 @@ end
 CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
 PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
 hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
-hoe.rsync_args = '-av --delete --ignore-errors'
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -2,9 +2,16 @@ require 'fileutils'
 include FileUtils
 
 require 'rubygems'
-%w[rake hoe newgem rubigen].each do |req_gem|
+%w[rake hoe rubigen facets extlib xml-simple solr-ruby mime-types activeresource].each do |req_gem|
+  case req_gem
+    when "solr-ruby": req_file_name = "solr"
+    when "mime-types": req_file_name = "mime/types"
+    when "xml-simple": req_file_name = "xmlsimple"
+    when "activeresource": req_file_name = "active_resource"
+    else req_file_name = req_gem
+  end
   begin
-    require req_gem
+    require req_file_name
   rescue LoadError
     puts "This Rakefile requires the '#{req_gem}' RubyGem."
     puts "Installation: gem install #{req_gem} -y"

data/lib/active_fedora.rb

@@ -0,0 +1,41 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) unless
+  $LOAD_PATH.include?(File.dirname(__FILE__)) ||
+  $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
+  # Currently using ExtLib::Assertions.  Could just pull that method into this code base...
+  gem 'extlib', '>=0.9.5'
+  require 'extlib'
+  
+  module ActiveFedora #:nodoc:
+    module VERSION #:nodoc:
+      unless defined? MAJOR
+      MAJOR = 0
+      MINOR = 9
+      TINY  = 0
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+
+  def self.repository
+    #RubyFedora::Repository.instance == nil? FedoraRepository.register(Repository.default_name) | Repository.instance
+  end
+
+end
+
+
+require 'active_fedora/base'
+require 'active_fedora/model'
+require 'active_fedora/property'
+require 'active_fedora/metadata_datastream'
+require 'active_fedora/qualified_dublin_core_datastream'
+require 'active_fedora/fedora_object'
+require 'active_fedora/semantic_node'
+require 'active_fedora/rels_ext_datastream'
+require 'active_fedora/solr_service'
+require 'active_fedora/content_model'
+
+
+
+
+

data/lib/active_fedora/base.rb

@@ -1,22 +1,292 @@
+require 'ruby-fedora'
+require "rexml/document"
+
+require 'util/class_level_inheritable_attributes'
+require 'active_fedora/datastream'
+require 'active_fedora/relationship'
+require 'active_fedora/model'
+
+
 module ActiveFedora
+
   class Base
-    def self.establish_connection(spec)
+    include MediaShelfClassLevelInheritableAttributes
+    ms_inheritable_attributes  :ds_specs
+    include Model
+    include SemanticNode
+    def new_object?
+      @new_object
+    end
+
+    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
+    def self.has_metadata(args, &block)
+      @ds_specs ||= Hash.new
+      @ds_specs[args[:name]]= [args[:type], block]
+    end
+
+    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
+
+    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
+      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
+      @datastreams ||= Hash.new
+    end
+
+    def datastreams_xml
+      datastreams_xml = XmlSimple.xml_in(Fedora::Repository.instance.fetch_custom(self.pid, :datastreams))
+    end
+
+    def add_datastream(datastream)
+      datastream.pid = self.pid
+      datastreams[datastream.dsid] = datastream
+      return true
+    end
+    # Adds datastream to the object.  Saves the datastream to fedora upon adding.
+    def add(datastream)
+      warn "Warning: ActiveFedora::Base.add has been deprected.  Use add_datastream"
+      add_datastream(datastream)
     end
     
-    def initialize(attrs = nil)
+    def metadata_streams
+      results = []
+      datastreams.each_value do |ds|
+        if ds.kind_of?(ActiveFedora::MetadataDatastream) 
+          results<<ds
+        end
+      end
+      return results
     end
     
-    def self.find_objects(*args)
-      puts args.inspect
+    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
     
-    def create
+    # DC Datastream
+    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
+      @inner_object
+    end
+
+    def pid
+      @inner_object.pid
     end
     
-    def update
+    def to_param
+      self.pid
+    end
+    def internal_uri
+      "info:fedora/#{pid}"
     end
     
-    def save
+    def state
+      @inner_object.state
+    end
+
+    def owner_id
+      @inner_object.owner_id
+    end
+
+    def create_date
+      @inner_object.create_date unless new_object?
+    end
+
+    def modified_date
+      @inner_object.modified_date unless new_object?
+    end
+
+    def errors
+      @inner_object.errors
+    end
+    
+    def label
+      @inner_object.label
+    end
+    def self.deserialize(doc)
+      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
+
+    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
+    
+    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
+
+    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
+    def update_index
+      solr_doc = self.to_solr
+      SolrService.instance.conn.update(solr_doc)
+    end
+
+    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
+
+    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
+end