ruby-fedora 0.9.0 → 1.0.0

data/lib/active_fedora/content_model.rb

@@ -1,22 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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