active-fedora 1.0.0

data/lib/active_fedora/content_model.rb

@@ -0,0 +1,22 @@
+module ActiveFedora
+  class ContentModel < Base
+    CMODEL_NAMESPACE = "afmodel"
+    CMODEL_PID_SUFFIX = ""
+    
+    attr_accessor :pid_suffix, :namespace
+    
+    def initialize(attrs={})
+      @pid_suffix = attrs.has_key?(:pid_suffix) ? attrs[:pid_suffix] : CMODEL_PID_SUFFIX
+      @namespace = attrs.has_key?(:namespace) ? attrs[:namespace] : CMODEL_NAMESPACE
+      super
+    end
+    
+    def self.pid_from_ruby_class(klass,attrs={})
+      sanitized_class_name = klass.name.gsub(/(::)/, '_')
+      pid_suffix = attrs.has_key?(:pid_suffix) ? attrs[:pid_suffix] : CMODEL_PID_SUFFIX
+      namespace = attrs.has_key?(:namespace) ? attrs[:namespace] : CMODEL_NAMESPACE   
+      return "#{namespace}:#{sanitized_class_name}#{pid_suffix}" 
+    end
+    
+  end
+end

data/lib/active_fedora/datastream.rb

@@ -0,0 +1,109 @@
+require 'fedora/datastream'
+module ActiveFedora
+
+  #This class represents a Fedora datastream
+  class Datastream < Fedora::Datastream
+    
+    attr_accessor :dirty, :last_modified, :fields
+  
+    def initialize(attrs = nil)
+      @fields={}
+      @dirty = false
+      super
+    end
+    
+    #Return the xml content representing this Datastream from Fedora
+    def content
+      result = Fedora::Repository.instance.fetch_custom(self.attributes[:pid], "datastreams/#{self.dsid}")
+      return result
+    end
+  
+    #set this Datastream's content
+    def content=(content)
+      self.blob = content
+    end
+    
+    #get this datastreams identifier
+    def pid
+      self.attributes[:pid]
+    end
+  
+    #set this datastreams parent identifier
+    def pid=(pid)
+      self.attributes[:pid] = pid
+    end
+    
+    #set this datastreams identifier (note: sets both dsID and dsid)
+    def dsid=(dsid)
+      self.attributes[:dsID] = dsid
+      self.attributes[:dsid] = dsid
+    end
+
+    #compatibility method for rails' url generators. This method will 
+    #urlescape escape dots, which are apparently
+    #invalid characters in a dsid.
+    def to_param
+      dsid.gsub(/\./, '%2e')
+    end
+    
+    #has this datastream been modified since it was last saved?
+    def dirty?
+      @dirty
+    end
+  
+    #saves this datastream into fedora.
+    def save
+      before_save
+      result = Fedora::Repository.instance.save(self)
+      after_save
+      result
+    end
+    
+    def before_save # :nodoc:
+      #check_concurrency
+    end
+    def self.from_xml(tmpl, el)
+      el.elements.each("foxml:xmlContent/fields") do |f|
+        tmpl.send("#{f.name}_append", f.text)
+      end
+      tmpl.instance_variable_set(:@dirty, false)
+      tmpl
+    end
+    
+    def after_save
+      self.dirty = false
+    end
+    
+    # returns a datetime in the standard W3C DateTime Format.  
+    # ie 2008-10-17T00:17:18.194Z
+    def last_modified_in_repository
+      # A hack to get around the fact that you can't call getDatastreamHistory 
+      # or API-M getDatasreams on Fedora 3.0 REST API  
+      # grabs the CREATED attribute off of the last foxml:datastreamVersion 
+      # within the appropriate datastream node in the objectXML
+      if self.pid != nil
+        object_xml = Fedora::FedoraObject.object_xml(self.pid).gsub("\n     ","")
+        datastream_xml = REXML::Document.new(object_xml).root.elements["foxml:datastream[@ID='#{self.dsid}']"]
+        
+        puts datastream_xml.length
+        if datastream_xml.length > 3
+          datastream_xml.elements.each do |el|
+            puts el.inspect
+          end
+        end
+        
+        datastream_xml.elements[datastream_xml.length - 2].attributes["CREATED"]
+      else
+        return nil
+      end
+    end
+    
+    def check_concurrency # :nodoc:
+      return true
+    end
+    
+  end
+  
+  class DatastreamConcurrencyException < Exception # :nodoc:
+  end
+end

data/lib/active_fedora/fedora_object.rb

@@ -0,0 +1,78 @@
+module ActiveFedora
+  
+  #
+  # This is a module replacing the ActiveFedora::Base class.
+  #
+  module FedoraObject
+    def initialize
+      @inner_object = Fedora::FedoraObject.new
+      Fedora::Repository.instance.save @inner_object
+    end
+
+    def save
+      Fedora::Repository.instance.save(@inner_object)
+    end
+
+    def delete
+      Fedora::Repository.instance.delete(@inner_object)
+    end
+
+    def datastreams
+      datastreams = {}
+      self.datastreams_xml['datastream'].each do |ds|
+        ds.merge!({:pid => self.pid, :dsID => ds["dsid"]})
+        datastreams.merge!({ds["dsid"] => ActiveFedora::Datastream.new(ds)})
+      end
+      return datastreams
+    end
+
+    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
+      datastream.save
+    end
+
+    # DC Datastream
+    def dc
+      #dc = REXML::Document.new(datastreams["DC"].content)
+      return datastreams["DC"]
+    end
+
+    # RELS-EXT Datastream
+    def rels_ext
+      if !datastreams.has_key?("RELS-EXT")
+        add(ActiveFedora::RelsExtDatastream.new)
+      end
+        
+      return datastreams["RELS-EXT"]
+    end
+
+    def inner_object
+      @inner_object
+    end
+
+    def pid
+      @inner_object.pid
+    end
+
+    def state
+      @inner_object.state
+    end
+
+    def owner_id
+      @inner_object.owner_id
+    end
+
+    def errors
+      @inner_object.errors
+    end
+
+  end
+
+
+
+end

data/lib/active_fedora/metadata_datastream.rb

@@ -0,0 +1,120 @@
+module ActiveFedora
+  #this class represents a MetadataDatastream, a special case of ActiveFedora::Datastream
+  class MetadataDatastream < Datastream
+    attr_accessor :fields
+
+    #constructor, calls up to ActiveFedora::Datastream's constructor
+    def initialize(attrs=nil)
+      super
+      @fields={}
+    end
+    
+    # sets the blob, which in this case is the xml version of self, then calls ActiveFedora::Datastream.save
+    def save
+      self.set_blob_for_save
+      super
+    end
+    
+    def set_blob_for_save # :nodoc:
+      self.blob = self.to_xml
+    end
+
+    def to_solr(solr_doc = Solr::Document.new) # :nodoc:
+      fields.each do |field_key, field_info|
+        if field_info.has_key?(:values) && !field_info[:values].nil?
+          field_symbol = generate_solr_symbol(field_key, field_info[:type])
+          field_info[:values].each do |val|             
+            solr_doc << Solr::Field.new(field_symbol => val)
+          end
+        end
+      end
+
+      return solr_doc
+    end
+    
+    def to_xml(xml = REXML::Document.new("<fields />")) #:nodoc:
+      fields.each_pair do |field,field_info|
+        el = REXML::Element.new("#{field.to_s}")
+          if field_info[:element_attrs]
+            field_info[:element_attrs].each{|k,v| el.add_attribute(k.to_s, v.to_s)}
+          end
+        field_info[:values].each do |val|
+          el = el.clone
+          el.text = val.to_s
+          if xml.class == REXML::Document
+            xml.root.elements.add(el)
+          else
+            xml.add(el)
+          end
+        end
+      end
+      return xml.to_s
+    end
+    def self.from_xml(tmpl, el) # :nodoc:
+      el.elements.each("./foxml:datastreamVersion[last()]/foxml:xmlContent/fields/node()")do |f|
+          tmpl.send("#{f.name}_append", f.text)
+      end
+      tmpl.send(:dirty=, false)
+      tmpl
+    end
+    
+    # This method generates the various accessor and mutator methods on self for the datastream metadata attributes.
+    # each field will have the 3 magic methods:
+    #   name_values=(arg) 
+    #   name_values 
+    #   name_append(arg)
+    #
+    #
+    # Calling any of the generated methods marks self as dirty.
+    #
+    # 'tupe' is a datatype, currently :string, :text and :date are supported.
+    #
+    # opts is an options hash, which  will affect the generation of the xml representation of this datastream.
+    #
+    # Currently supported modifiers: 
+    # For +QualifiedDublinCorDatastreams+:
+    #   :element_attrs =>{:foo=>:bar} -  hash of xml element attributes
+    #   :xml_node => :nodename  - The xml node to be used to represent this object (in dcterms namespace)
+    #   :encoding=>foo, or encodings_scheme  - causes an xsi:type attribute to be set to 'foo'
+    #   :multiple=>true -  mark this field as a multivalue field (on by default)
+    #
+    #At some point, these modifiers will be ported up to work for any +ActiveFedora::MetadataDatastream+.
+    #
+    #There is quite a good example of this class in use in spec/examples/oral_history.rb
+    def field(name, tupe, opts={})
+      @fields[name.to_s.to_sym]={:type=>tupe, :values=>[]}.merge(opts)
+      eval <<-EOS
+        def #{name}_values=(arg)
+          @fields["#{name.to_s}".to_sym][:values]=[arg].flatten
+          self.dirty=true
+        end
+        def #{name}_values
+          @fields["#{name}".to_sym][:values]
+        end
+        def #{name}_append(arg)
+          @fields["#{name}".to_sym][:values] << arg
+          self.dirty =true
+        end
+      EOS
+    end
+
+    #get the field list
+    def self.fields
+      @@classFields
+    end
+
+    protected
+
+    def generate_solr_symbol(field_name, field_type) # :nodoc:
+      if field_name.to_s[-field_type.to_s.length - 1 .. -1] == "_#{field_type.to_s}"
+        return field_name.to_sym
+      elsif field_type == :string
+        return "#{field_name.to_s}_field".to_sym
+      else
+        return "#{field_name.to_s}_#{field_type.to_s}".to_sym
+      end
+    end
+
+  end
+
+end

data/lib/active_fedora/model.rb

@@ -0,0 +1,125 @@
+require 'active_fedora/fedora_object'
+module ActiveFedora
+  # = ActiveFedora
+  # This module mixes various methods into the including class,
+  # much in the way ActiveRecord does.  
+  module Model 
+    extend ActiveFedora::FedoraObject
+
+    attr_accessor :properties
+
+    def self.included(klass) # :nodoc:
+      klass.extend(ClassMethods)
+    end
+
+    def add_metadata
+    end
+
+    def datastream
+    end
+
+
+    #
+    # =Class Methods
+    # These methods are mixed into the inheriting class.
+    #
+    # Accessor and mutator methods are dynamically generated based 
+    # on the contents of the @@field_spec hash, which stores the 
+    # field specifications recorded during invocation of has_metadata.
+    #
+    # Each metadata field will generate 3 methods:
+    #
+    #   fieldname_values
+    #     *returns the current values array for this field
+    #   fieldname_values=(val) 
+    #     *store val as the values array. val 
+    #     may be a single string, or an array of strings 
+    #     (single items become single element arrays).
+    #   fieldname_append(val)
+    #     *appends val to the values array.
+    module ClassMethods
+
+      # Load an instance with the following pid. Note that you can actually
+      # pass an pid into this method, regardless of Fedora model type, and
+      # ActiveFedora will try to parse the results into the current type
+      # of self, which may or may not be what you want.
+      def load_instance(pid)
+        Fedora::Repository.instance.find_model(pid, self)
+      end
+
+      # Takes :all or a pid as arguments
+      # Returns an Array of objects of the Class that +find+ is being 
+      # called on
+      def find(args)
+        if args == :all
+          escaped_class_name = self.name.gsub(/(:)/, '\\:')
+          q = "active_fedora_model_field:#{escaped_class_name}"
+        elsif args.class == String
+          escaped_id = args.gsub(/(:)/, '\\:')
+          q = "id:#{escaped_id}"
+        end
+        hits = SolrService.instance.conn.query(q).hits 
+        results = hits.map do |hit|
+          obj = Fedora::Repository.instance.find_model(hit["id"], self)
+        end
+        results.first
+      end
+
+      #Sends a query directly to SolrService
+      def solr_search(query, args={})
+        SolrService.instance.conn.query(query, args)
+      end
+
+
+      #  If query is :all, this method will query Solr for all instances
+      #  of self.type (based on active_fedora_model_field as indexed
+      #  by Solr). If the query is any other string, this method simply does
+      #  a pid based search (id:query). 
+      #
+      #  Note that this method does _not_ return ActiveFedora::Model 
+      #  objects, but rather an array of SolrResults.
+      #
+      #  Args is an options hash, which is passed into the SolrService 
+      #  connection instance.
+      def find_by_solr(query, args={})
+        if query == :all
+          escaped_class_name = self.name.gsub(/(:)/, '\\:')
+          SolrService.instance.conn.query("active_fedora_model_field:#{escaped_class_name}", args)
+        elsif query.class == String
+          escaped_id = query.gsub(/(:)/, '\\:')          
+          SolrService.instance.conn.query("id:#{escaped_id}", args)
+        end
+      end
+
+
+      #wrapper around instance_variable_set, sets @name to value
+      def attribute_set(name, value)
+        instance_variable_set("@#{name}", value)
+      end
+
+      #wrapper around instance_variable_get, returns current value of @name
+      def attribute_get(name)
+        #instance_variable_get(properties[":#{name}"].instance_variable_name)
+        instance_variable_get("@#{name}")
+      end
+
+    end
+    def create_property_getter(property) # :nodoc:
+
+      class_eval <<-END
+          def #{property.name}
+            attribute_get("#{property.name}")
+          end
+          END
+    end
+
+    def create_property_setter(property)# :nodoc:
+      class_eval <<-END
+          def #{property.name}=(value)
+            attribute_set("#{property.name}", value)
+          end
+          END
+    end
+
+  end
+end