active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/fixture_exporter.rb

@@ -1,33 +0,0 @@
-module ActiveFedora
-  module FixtureExporter
-
-    def self.export_to_path(pid, path, extra_params={})
-      foxml = export(pid, extra_params)
-      name = "#{pid.gsub(":","_")}.foxml.xml"
-      filename = File.join(path, name)
-      file = File.new(filename,"w")
-      file.syswrite(foxml)
-      filename
-    end
-
-    def self.export(pid, extra_params={})
-      extra_params = {:format=>:foxml, :context=>:archive}.merge!(extra_params)
-      if extra_params[:format].kind_of?(String)
-        format = extra_params[:format]
-      else
-        format = case extra_params[:format]
-          when :atom then "info:fedora/fedora-system:ATOM-1.1"
-          when :atom_zip then "info:fedora/fedora-system:ATOMZip-1.1"
-          when :mets then "info:fedora/fedora-system:METSFedoraExt-1.1"
-          when :foxml then "info:fedora/fedora-system:FOXML-1.1"
-          else "info:fedora/fedora-system:FOXML-1.1"
-        end
-      end
-
-      ActiveFedora::Base.connection_for_pid(pid).export(:pid=>pid, :format=>format, :context=>extra_params[:context].to_s)
-    end
-
-
-  end
-end
-

data/lib/active_fedora/fixture_loader.rb

@@ -1,48 +0,0 @@
-module ActiveFedora
-  class FixtureLoader
-    attr_accessor :path
-
-    def initialize(path)
-      self.path = path
-    end 
-
-    def filename_for_pid(pid)
-      File.join(path, "#{pid.gsub(":","_")}.foxml.xml")
-    end
-
-    def self.delete(pid)
-      begin
-        ActiveFedora::Base.find(pid, cast: true).delete
-        1
-      rescue ActiveFedora::ObjectNotFoundError
-        ActiveFedora::Base.logger.debug "The object #{pid} has already been deleted (or was never created)." if ActiveFedora::Base.logger
-        0
-      rescue Errno::ECONNREFUSED => e
-        ActiveFedora::Base.logger.debug "Can't connect to Fedora! Are you sure jetty is running?" if ActiveFedora::Base.logger
-       0
-      end
-    end
-
-    def reload(pid)
-      self.class.delete(pid)
-      import_and_index(pid)
-    end
-
-    def import_and_index(pid)
-      body = self.class.import_to_fedora(filename_for_pid(pid), pid)
-      self.class.index(pid)
-      body
-    end
-
-    def self.index(pid)
-      ActiveFedora::Base.find(pid).update_index
-    end
-
-    def self.import_to_fedora(filename, pid='0')
-      file = File.new(filename, "r")
-      result = ActiveFedora::Base.connection_for_pid(pid).ingest(:file=>file.read)
-      raise "Failed to ingest the fixture." unless result
-      result.body
-    end
-  end
-end

data/lib/active_fedora/rdf/identifiable.rb

@@ -1,66 +0,0 @@
-##
-# This module is included to allow for an ActiveFedora::Base object to be set as the class_name for a Resource.
-# Enables functionality like:
-#   base = ActiveFedora::Base.new('oregondigital:1')
-#   base.title = 'test'
-#   base.save
-#   subject.descMetadata.set = base
-#   subject.descMetadata.set # => <ActiveFedora::Base>
-#   subject.descMetadata.set.title # => 'test'
-module ActiveFedora::RDF::Identifiable
-  extend ActiveSupport::Concern
-  delegate :parent, :dump, :query, :rdf_type, :to => :resource
-
-  ##
-  # Defines which resource defines this ActiveFedora object.
-  # This is required for ActiveFedora::Rdf::Resource#set_value to append graphs.
-  # If there is no RdfResource, make a dummy one and freeze its graph.
-  def resource
-    return self.send(self.class.resource_datastream).resource unless self.class.resource_datastream.nil?
-    klass = Class.new(ActiveTriples::Resource)
-    klass.send(:include, ActiveFedora::RDF::Persistence)
-    klass.new(ActiveFedora::RDF::Persistence::BASE_URI + self.pid).freeze
-  end
-
-  module ClassMethods
-    ##
-    # Returns the datastream whose ActiveFedora::Rdf::Resource is used
-    # for the identifiable object. This supports delegating methods to
-    # the Resource and #from_uri.  Defaults to :descMetadata if it
-    # responds to #rdf_subject, otherwise looks for the first
-    # registered datastream that does.
-    def resource_datastream(ds=nil)
-      @resource_datastream ||= ds ? ds : nil
-      return @resource_datastream unless @resource_datastream.nil?
-      return :descMetadata if self.ds_specs['descMetadata'][:type].respond_to? :rdf_subject
-      self.ds_specs.each do |dsid, conf|
-        return dsid.to_sym if conf[:type].respond_to? :rdf_subject
-      end
-      nil
-    end
-
-    ##
-    # Finds the appropriate ActiveFedora::Base object given a URI from a graph.
-    # Expected by the API in ActiveFedora::Rdf::Resource
-    # @TODO: Generalize this.
-    # @see ActiveFedora::Rdf::Resource.from_uri
-    # @param [RDF::URI] uri URI that is being looked up.
-    def from_uri(uri,_)
-      begin
-        ActiveFedora::Base.find(pid_from_subject(uri))
-      rescue ActiveFedora::ObjectNotFoundError
-        self.ds_specs[resource_datastream.to_s][:type].resource_class.new(uri)
-      end
-    end
-
-    ##
-    # Finds the pid of an object from its RDF subject, override this
-    # for URI configurations not of form base_uri + pid
-    # @param [RDF::URI] uri URI to convert to pid
-    def pid_from_subject(uri)
-      base_uri = self.ds_specs[resource_datastream.to_s][:type].resource_class.base_uri if resource_datastream
-      base_uri = base_uri || ActiveFedora::RDF::Persistence::BASE_URI
-      uri.to_s.gsub(base_uri, "")
-    end
-  end
-end

data/lib/active_fedora/rdf/project_hydra.rb

@@ -1,12 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'rdf'
-class ActiveFedora::RDF::ProjectHydra < ::RDF::StrictVocabulary("http://projecthydra.org/ns/relations#")
-  property :hasProfile,
-    label: "Has Profile".freeze,
-    subPropertyOf: "info:fedora/fedora-system:def/relations-external#fedoraRelationship".freeze,
-    type: "rdf:Property".freeze
-  property :isGovernedBy,
-    label: "Is Governed By".freeze,
-    subPropertyOf: "info:fedora/fedora-system:def/relations-external#fedoraRelationship".freeze,
-    type: "rdf:Property".freeze
-end

data/lib/active_fedora/rdf/rdfxml_rdf_datastream.rb

@@ -1,13 +0,0 @@
-require 'rdf/rdfxml'
-
-module ActiveFedora
-  class RdfxmlRDFDatastream < RDFDatastream
-    def serialization_format
-      :rdfxml 
-    end
-
-    def self.default_attributes
-      super.merge(:mimeType => 'text/xml')
-    end
-  end
-end

data/lib/active_fedora/rdf_xml_writer.rb

@@ -1,49 +0,0 @@
-require 'rdf/rdfxml'
-
-module ActiveFedora
-# This class ensures that the RELS-EXT datastream is always serialized
-# with an rdf:Description container for the properties
-# the default behavior for RDF:RDFXML::Writer is to change that element if
-# an rdf:type assertion is present; this is incompatible with Fedora 3
-  class RDFXMLWriter < ::RDF::RDFXML::Writer
-    # Display a subject.
-    #
-    # If the Haml template contains an entry matching the subject's rdf:type URI, that entry will be used as the template for this subject and it's properties.
-    #
-    # @example Displays a subject as a Resource Definition:
-    #     <div typeof="rdfs:Resource" about="http://example.com/resource">
-    #       <h1 property="dc:title">label</h1>
-    #       <ul>
-    #         <li content="2009-04-30T06:15:51Z" property="dc:created">2009-04-30T06:15:51+00:00</li>
-    #       </ul>
-    #     </div>
-    #
-    # @param [RDF::Resource] subject
-    # @param [Hash{Symbol => Object}] options
-    # @option options [:li, nil] :element(:div)
-    #   Serialize using &lt;li&gt; rather than template default element
-    # @option options [RDF::Resource] :rel (nil)
-    #   Optional @rel property
-    # @return [Nokogiri::XML::Element, {Namespace}]
-    #
-    def subject(subject, options = {})
-      return if is_done?(subject)
-
-      subject_done(subject)
-
-      properties = properties_for_subject(subject)
-      typeof = type_of(properties[::RDF.type.to_s], subject)
-      prop_list = order_properties(properties)
-
-      add_debug {"subject: #{curie.inspect}, typeof: #{typeof.inspect}, props: #{prop_list.inspect}"}
-
-      render_opts = {:typeof => typeof, :property_values => properties}.merge(options)
-
-      render_subject_template(subject, prop_list, render_opts)
-    end
-
-    def type_of(type, subject)
-      ""
-    end
-  end
-end

data/lib/active_fedora/relationship_graph.rb

@@ -1,101 +0,0 @@
-module ActiveFedora
-  class RelationshipGraph
-
-    attr_accessor :relationships, :dirty
-
-    def initialize 
-      self.dirty = false
-      self.relationships = Hash.new { |h, k| h[k] = [] }
-    end
-
-    def has_predicate?(predicate)
-      relationships.has_key? uri_predicate(predicate)
-    end
-    
-    def add(predicate, object, literal=false)
-      uri = uri_predicate(predicate)
-      unless has_predicate? uri
-        relationships[uri] = []
-      end
-      object = ::RDF::Literal.new(object) if literal
-      unless relationships[uri].include?(object)
-        @dirty = true
-        relationships[uri] << object
-      end
-    end
-
-    # Remove the statement matching the predicate and object
-    # @param predicate [Symbol, URI] the predicate to delete
-    # @param object the object to delete, if nil, all statements with this predicate are deleted.
-    def delete(predicate, object = nil)
-      uri = uri_predicate(predicate)
-      return unless has_predicate? uri 
-      if object.nil?
-        @dirty = true
-        relationships.delete(uri)
-        return
-      end
-      if relationships[uri].include?(object)
-        @dirty = true
-        relationships[uri].delete(object)
-      end
-      if object.respond_to?(:internal_uri) && relationships[uri].include?(object.internal_uri)
-        @dirty = true
-        relationships[uri].delete(object.internal_uri)
-      elsif object.is_a? String 
-        relationships[uri].delete_if{|obj| obj.respond_to?(:internal_uri) && obj.internal_uri == object}
-      end
-    end
-
-    def [](predicate)
-      uri = uri_predicate(predicate)
-      relationships[uri]
-    end
-    
-    def to_graph(subject_uri)
-      # need to destroy relationships and rewrite it.
-      subject =  ::RDF::URI.new(subject_uri)
-      graph = ::RDF::Graph.new
-      relationships.each do |predicate, values|
-        values.each do |object|
-          graph.insert build_statement(subject,  predicate, object)
-        end
-      end
-
-      graph
-    end
-
-    # Create an RDF statement
-    # @param uri a string represending the subject
-    # @param predicate [Symbol, URI] a predicate
-    # @param target an object to store
-    def build_statement(uri, predicate, target)
-      raise "Not allowed anymore" if uri == :self
-      target = target.internal_uri if target.respond_to? :internal_uri
-      subject =  ::RDF::URI.new(uri)  #TODO cache
-      if target.is_a? ::RDF::Literal or target.is_a? ::RDF::Resource
-        object = target
-      else
-        begin
-          target_uri = (target.is_a? URI) ? target : URI.parse(target)
-          if target_uri.scheme.nil?
-            raise ArgumentError, "Invalid target \"#{target}\". Must have namespace."
-          end
-          if target_uri.to_s =~ /\A[\w\-]+:[\w\-]+\Z/
-            raise ArgumentError, "Invalid target \"#{target}\". Target should be a complete URI, and not a pid."
-          end
-        rescue URI::InvalidURIError
-          raise ArgumentError, "Invalid target \"#{target}\". Target must be specified as a literal, or be a valid URI."
-        end
-        object = ::RDF::URI.new(target)
-      end
-      ::RDF::Statement.new(subject, uri_predicate(predicate), object)
-    
-    end
-
-    def uri_predicate(predicate)
-      return predicate if predicate.kind_of? ::RDF::URI
-      ActiveFedora::Predicates.find_graph_predicate(predicate)
-    end
-  end
-end

data/lib/active_fedora/reload_on_save.rb

@@ -1,16 +0,0 @@
-module ActiveFedora #:nodoc:
-  # = Active Fedora Reload On Save
-  module ReloadOnSave
-
-    attr_writer :reload_on_save
-
-    def reload_on_save?
-      !!@reload_on_save
-    end
-
-    def refresh
-      self.reload if reload_on_save?
-    end
-  end
-end
-

data/lib/active_fedora/rels_ext_datastream.rb

@@ -1,100 +0,0 @@
-require 'uri'
-require 'rdf/rdfxml'
-require 'active_fedora/rdf_xml_writer'
-
-module ActiveFedora
-  class RelsExtDatastream < Datastream
-    
-    attr_accessor :model
-    delegate :relationships, to: :model
-
-    def self.default_attributes
-      super.merge(:controlGroup => 'X', :mimeType => 'application/rdf+xml')
-    end
-    
-    def changed?
-      model.relationships_are_dirty? or super
-    end
-
-    def metadata?
-      true
-    end
-
-    def serialize!
-      self.content = to_rels_ext() if model.relationships_are_dirty?
-      model.relationships_are_not_dirty!
-    end
-    
-    # Populate a RelsExtDatastream object based on the "datastream" content 
-    # Assumes that the datastream contains RDF XML from a Fedora RELS-EXT datastream 
-    # @param [String] xml the "rdf" node 
-    # @param [ActiveFedora::Datastream] tmpl the Datastream object that you are populating
-    def self.from_xml(xml, tmpl) 
-      if (xml.nil?)
-        ### maybe put the template here?
-      else
-        ensure_predicates_exist!(xml)
-        tmpl.model.relationships = xml
-        tmpl
-      end
-    end
-
-    # Creates a RELS-EXT datastream for insertion into a Fedora Object
-    def to_rels_ext()
-      xml = ActiveFedora::RDFXMLWriter.buffer do |writer|
-        writer.prefixes.merge! ActiveFedora::Predicates.predicate_namespaces
-        relationships.each_statement do |statement|
-          writer << statement
-        end
-      end
-      xml
-    end
-
-    def self.ensure_predicates_exist!(xml)
-      statements = Nokogiri::XML(xml).xpath('//rdf:Description/*', 'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
-      predicates = statements.collect { |e| { :prefix => e.namespace.prefix, :uri => e.namespace.href, :predicate => e.name } }.uniq
-      predicates.each do |pred|
-        unless Predicates.predicate_mappings[pred[:uri]]
-          Predicates.predicate_mappings[pred[:uri]] = {}
-          if pred[:prefix] and not Predicates.predicate_namespaces.has_value?(pred[:uri])
-            Predicates.predicate_namespaces[pred[:prefix].to_sym] = pred[:uri]
-          end
-        end
-        ns = Predicates.predicate_mappings[pred[:uri]]
-        unless ns.invert[pred[:predicate]]
-          ns["#{pred[:prefix]}_#{pred[:predicate].underscore}".to_sym] = pred[:predicate]
-        end
-      end
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # This is utilized by ActiveFedora::Base.load_instance_from_solr to load 
-    # the relationships hash using the Solr document passed in instead of from the RELS-EXT datastream
-    # in Fedora.  Utilizes solr_name method (provided by Solrizer::FieldMapper) to map solr key to
-    # relationship predicate. 
-    #
-    # ====Warning
-    #  Solr must be synchronized with RELS-EXT data in Fedora.
-    def from_solr(solr_doc)
-      #cycle through all possible predicates
-      model.relationships_loaded = true
-      Predicates.predicate_mappings.each_pair do |namespace,predicates|
-        predicates.keys.each do |predicate|
-          predicate_symbol = ActiveFedora::SolrService.solr_name(predicate, :symbol)
-          value = (solr_doc[predicate_symbol].nil? ? solr_doc[predicate_symbol.to_s]: solr_doc[predicate_symbol]) 
-          unless value.nil? 
-            if value.is_a? Array
-              value.each do |obj|
-                model.add_relationship(predicate, obj)
-              end
-            else
-              model.add_relationship(predicate, value)
-            end
-          end
-        end
-      end
-      @load_from_solr = true
-    end
-  end
-end