ruby-fedora 0.1.2 → 0.9.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,95 @@
+module ActiveFedora
+  class Datastream < Fedora::Datastream
+    
+    attr_accessor :dirty, :last_modified, :fields
+  
+    def initialize(attrs = nil)
+      @fields={}
+      @dirty = false
+      super
+    end
+    
+    def content
+      result = Fedora::Repository.instance.fetch_custom(self.attributes[:pid], "datastreams/#{self.dsid}")
+      #self.last_modified = last_modified_in_repository
+      return result
+    end
+  
+    def content=(content)
+      self.blob = content
+    end
+    
+    def pid
+      self.attributes[:pid]
+    end
+  
+    def pid=(pid)
+      self.attributes[:pid] = pid
+    end
+    
+    def dsid=(dsid)
+      self.attributes[:dsID] = dsid
+      self.attributes[:dsid] = dsid
+    end
+    def to_param
+      dsid.gsub(/\./, '%2e')
+    end
+    
+    def dirty?
+      @dirty
+    end
+  
+    def save
+      before_save
+      result = Fedora::Repository.instance.save(self)
+      after_save
+      result
+    end
+    
+    def before_save
+      #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
+      puts "PID: #{self.pid} ,  DSID: #{self.dsid}"
+      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
+      return true
+      #@last_modified == self.last_modified_in_repository ? true : raise(ActiveFedora::DatastreamConcurrencyException.new, "Someone else has changed this datastream in Fedora while you were working on it.")
+    end
+    
+  end
+  
+  class DatastreamConcurrencyException < Exception
+  end
+end

data/lib/active_fedora/fedora_object.rb

@@ -0,0 +1,84 @@
+require 'ruby-fedora'
+require "rexml/document"
+
+require 'active_fedora/datastream'
+require 'active_fedora/relationship'
+
+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,97 @@
+require "rexml/document"
+require "rexml/element"
+require "solr"
+
+module ActiveFedora
+  class MetadataDatastream < Datastream
+    attr_accessor :fields
+
+    def initialize(attrs=nil)
+      super
+      @fields={}
+    end
+    
+    def save
+      self.set_blob_for_save
+      super
+    end
+    
+    def set_blob_for_save
+      self.blob = self.to_xml
+    end
+
+    def to_solr(solr_doc = Solr::Document.new)
+      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 />"))
+      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)
+      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
+    
+    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
+
+    def self.fields
+      @@classFields
+    end
+
+    protected
+
+    def generate_solr_symbol(field_name, field_type)
+      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,94 @@
+require 'active_fedora/semantic_node'
+require 'active_fedora/fedora_object'
+
+module ActiveFedora
+  module Model 
+    extend ActiveFedora::FedoraObject
+    
+    attr_accessor :properties
+    
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+    
+    def add_metadata
+    end
+    
+    def datastream
+    end
+    
+    
+    #
+    # Class Methods
+    #
+    
+    module ClassMethods
+    
+      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
+
+      #this just takes raw solr queries
+      def solr_search(query, args={})
+          SolrService.instance.conn.query(query, args)
+      end
+
+
+      #  this is supposed to behave more like a finder.
+      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
+
+      def create_property_getter(property)
+        class_eval <<-END
+          def #{property.name}
+            attribute_get("#{property.name}")
+          end
+          END
+      end
+
+      def create_property_setter(property)
+        class_eval <<-END
+          def #{property.name}=(value)
+            attribute_set("#{property.name}", value)
+          end
+          END
+      end
+
+      def attribute_set(name, value)
+        #instance_variable_set(properties[":#{name}"].instance_variable_name)
+        instance_variable_set("@#{name}", value)
+      end
+
+      def attribute_get(name)
+        #instance_variable_get(properties[":#{name}"].instance_variable_name)
+        instance_variable_get("@#{name}")
+      end
+
+    end
+
+  end
+end

data/lib/active_fedora/property.rb

@@ -0,0 +1,15 @@
+module ActiveFedora
+  class Property
+    
+    attr_accessor :name, :instance_variable_name
+    
+    def initialize(model, name, type, options = {})
+      @name = name
+      @instance_variable_name = "@#{@name}"
+    end
+    
+    def field
+    end
+    
+  end
+end

data/lib/active_fedora/qualified_dublin_core_datastream.rb

@@ -0,0 +1,72 @@
+require "rexml/document"
+require "rexml/element"
+
+
+module ActiveFedora
+  class QualifiedDublinCoreDatastream < MetadataDatastream
+    DCTERMS = [
+      :contributor, :coverage, :creator,  :description, :format, :identifier, :language, :publisher, :relation,  :source, :title, :abstract, :accessRights, :accrualMethod, :accrualPeriodicity, :accrualPolicy, :alternative, :audience, :available, :bibliographicCitation, :conformsTo, :contributor, :coverage, :created, :creator, :date, :dateAccepted, :dateCopyrighted, :dateSubmitted, :description, :educationLevel, :extent, :format, :hasFormat, :hasPart, :hasVersion, :identifier, :instructionalMethod, :isFormatOf, :isPartOf, :isReferencedBy, :isReplacedBy, :isRequiredBy, :issued, :isVersionOf, :language, :license, :mediator, :medium, :modified, :provenance, :publisher, :references, :relation, :replaces, :requires, :rights, :rightsHolder, :source, :spatial, :subject, :tableOfContents, :temporal, :type, :valid
+    ]
+    DCTERMS.freeze
+    
+    def initialize(attrs=nil)
+      super
+      DCTERMS.each do |el|
+        field el, :string, :multiple=>true
+      end
+      self
+    end
+    
+    def set_blob_for_save
+      self.blob = self.to_dc_xml
+    end
+   def self.from_xml(tmpl, el)
+     tmpl.fields.each do |z|
+       fname = z.first
+       fspec = z.last
+       node = "dcterms:#{fspec[:xml_node] ? fspec[:xml_node] : fname}"
+       attr_modifier= "[@xsi:type='#{fspec[:encoding]}']" if fspec[:encoding]
+       query = "./foxml:datastreamVersion[last()]/foxml:xmlContent/dc/#{node}#{attr_modifier}"
+       el.elements.each(query) do |f|
+          tmpl.send("#{fname}_append", f.text)
+        end
+
+     end
+     tmpl.instance_variable_set(:@dirty, false)
+     tmpl
+   end
+
+   def to_dc_xml
+     xml = REXML::Document.new("<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'/>")
+     fields.each do |field_name,field_info|
+       el = REXML::Element.new("dcterms:#{field_name.to_s}")
+       if field_info.class == Hash
+         field_info.each do |k, v|
+           case k
+           when :element_attrs
+            v.each{|k,v| el.add_attribute(k.to_s, v.to_s)}
+           when :values, :type
+             # do nothing to the :values array
+           when :xml_node
+             el.name = "dcterms:#{v}"
+           when :encoding, :encoding_scheme
+             el.add_attribute("xsi:type", v)
+           when :multiple
+             next
+           else
+             el.add_attribute(k.to_s, v)
+           end
+         end
+         field_info = field_info[:values]
+       end
+       field_info.each do |val|
+         el = el.clone
+         el.text = val.to_s
+         xml.root.elements.add(el)
+       end
+     end
+     return xml.to_s
+   end
+
+  end
+end