active-fedora 11.0.0.rc6 → 11.0.0.rc7

data/lib/active_fedora/nom_datastream.rb

@@ -1,73 +0,0 @@
-require "nom"
-
-module ActiveFedora
-  class NomDatastream < File
-    include Datastreams::NokogiriDatastreams
-    extend Deprecation
-
-    def self.set_terminology(options = {}, &block)
-      @terminology_options = options || {}
-      @terminology = block
-    end
-
-    def initialize(*args)
-      super
-      Deprecation.warn(NomDatastream, "NomDatastream is deprecated and will be removed in ActiveFedora 11")
-    end
-
-    class << self
-      attr_reader :terminology_options
-    end
-
-    class << self
-      attr_reader :terminology
-    end
-
-    def self.decorate_ng_xml(xml)
-      xml.set_terminology terminology_options, &terminology
-      xml.nom!
-      xml
-    end
-
-    def serialize!
-      self.content = @ng_xml.to_s if @ng_xml
-    end
-
-    def to_solr
-      solr_doc = {}
-
-      ng_xml.terminology.flatten.select { |x| x.options[:index] }.each do |term|
-        term.values.each do |v|
-          Array(term.options[:index]).each do |index_as|
-            solr_doc[index_as] ||= []
-            solr_doc[index_as] << if v.is_a? Nokogiri::XML::Node
-                                    v.text
-                                  else
-                                    v
-                                  end
-          end
-        end
-      end
-
-      solr_doc
-    end
-
-    def method_missing(method, *args, &block)
-      if ng_xml.respond_to? method
-        ng_xml.send(method, *args, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to?(*args)
-      super || self.class.terminology.respond_to?(*args)
-    end
-
-    protected
-
-      def default_mime_type
-        'text/xml'
-      end
-  end
-end

data/lib/active_fedora/om_datastream.rb

@@ -1,118 +0,0 @@
-require "om"
-
-module ActiveFedora
-  class OmDatastream < File
-    # before_save do
-    #   if content.blank?
-    #     ActiveFedora::Base.logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
-    #     false
-    #   end
-    # end
-
-    include OM::XML::Document
-    include OM::XML::TerminologyBasedSolrizer # this adds support for calling .to_solr
-    include Datastreams::NokogiriDatastreams
-    extend Deprecation
-
-    alias om_term_values term_values unless method_defined?(:om_term_values)
-    alias om_update_values update_values unless method_defined?(:om_update_values)
-
-    def initialize(*args)
-      super
-      Deprecation.warn(OmDatastream, "OmDatastream is deprecated and will be removed in ActiveFedora 11")
-    end
-
-    def default_mime_type
-      'text/xml'
-    end
-
-    # Indicates that this datastream has metadata content.
-    # @return true
-    def metadata?
-      true
-    end
-
-    # Return a hash suitable for indexing in solr. Every field name is prefixed with the
-    # value returned by the +prefix+ method.
-    def to_solr(solr_doc = {}, opts = {})
-      prefix = self.prefix(opts[:name])
-      solr_doc.merge super({}).each_with_object({}) { |(key, value), new| new[[prefix, key].join] = value }
-    end
-
-    # Update field values within the current datastream using {#update_values}, which is a wrapper for {http://rdoc.info/gems/om/1.2.4/OM/XML/TermValueOperators#update_values-instance_method OM::TermValueOperators#update_values}
-    # Ignores any fields from params that this datastream's Terminology doesn't recognize
-    #
-    # @param [Hash] params The params specifying which fields to update and their new values.  The syntax of the params Hash is the same as that expected by
-    #         term_pointers must be a valid OM Term pointers (ie. [:name]).  Strings will be ignored.
-    # @param [Hash] _opts This is not currently used by the datastream-level update_indexed_attributes method
-    #
-    # Example:
-    #   @mods_ds.update_indexed_attributes( {[{":person"=>"0"}, "role"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"} })
-    #   => {"person_0_role"=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}}
-    #
-    #   @mods_ds.to_xml # (the following is an approximation)
-    #   <mods>
-    #     <mods:name type="person">
-    #     <mods:role>
-    #       <mods:roleTerm>role1</mods:roleTerm>
-    #     </mods:role>
-    #     <mods:role>
-    #       <mods:roleTerm>role2</mods:roleTerm>
-    #     </mods:role>
-    #     <mods:role>
-    #       <mods:roleTerm>role3</mods:roleTerm>
-    #     </mods:role>
-    #     </mods:name>
-    #   </mods>
-    def update_indexed_attributes(params = {}, _opts = {})
-      if self.class.terminology.nil?
-        raise "No terminology is set for this OmDatastream class.  Cannot perform update_indexed_attributes"
-      end
-      # remove any fields from params that this datastream doesn't recognize
-      # make sure to make a copy of params so not to modify hash that might be passed to other methods
-      current_params = params.clone
-      current_params.delete_if do |term_pointer, new_values|
-        if term_pointer.is_a?(String)
-          ActiveFedora::Base.logger.warn "WARNING: #{self.class.name} ignoring {#{term_pointer.inspect} => #{new_values.inspect}} because #{term_pointer.inspect} is a String (only valid OM Term Pointers will be used).  Make sure your html has the correct field_selector tags in it." if ActiveFedora::Base.logger
-          true
-        else
-          !self.class.terminology.has_term?(*OM.destringify(term_pointer))
-        end
-      end
-
-      result = {}
-      result = update_values(current_params) unless current_params.empty?
-
-      result
-    end
-
-    def get_values(field_key, _default = [])
-      term_values(*field_key)
-    end
-
-    def find_by_terms(*termpointer)
-      super
-    end
-
-    # Update values in the datastream's xml
-    # This wraps {http://rdoc.info/gems/om/1.2.4/OM/XML/TermValueOperators#update_values-instance_method OM::TermValueOperators#update_values} so that returns an error if we have loaded from solr since datastreams loaded that way should be read-only
-    #
-    # @example Updating multiple values with a Hash of Term pointers and values
-    #   ds.update_values( {[{":person"=>"0"}, "role", "text"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, [{:person=>1}, :family_name]=>"Andronicus", [{"person"=>"1"},:given_name]=>["Titus"],[{:person=>1},:role,:text]=>["otherrole1","otherrole2"] } )
-    #   => {"person_0_role_text"=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, "person_1_role_text"=>{"0"=>"otherrole1", "1"=>"otherrole2"}}
-    def update_values(params = {})
-      raise "can't modify frozen #{self.class}" if frozen?
-      ng_xml_will_change!
-      result = om_update_values(params)
-      result
-    end
-
-    protected
-
-      # The string to prefix all solr fields with. Override this method if you want
-      # a prefix other than the default
-      def prefix(path)
-        path ? "#{path.underscore}__" : ''
-      end
-  end
-end

data/lib/active_fedora/qualified_dublin_core_datastream.rb

@@ -1,158 +0,0 @@
-module ActiveFedora
-  # This class represents a Qualified Dublin Core Datastream. A special case of ActiveFedora::OmDatastream
-  # The implementation of this class defines the terms from the Qualified Dublin Core specification.
-  # This implementation features customized xml generators and deserialization routines to handle the
-  # Fedora Dublin Core XML datastreams structure.
-  #
-  # Fields can still be overridden if more specificity is desired (see ActiveFedora::File#fields method).
-  class QualifiedDublinCoreDatastream < OmDatastream
-    attr_accessor :fields
-    class_attribute :class_fields
-    self.class_fields = []
-
-    set_terminology do |t|
-      t.root(path: "dc", xmlns: "http://purl.org/dc/terms/")
-    end
-
-    define_template :creator do |xml, name|
-      xml.creator do
-        xml.text(name)
-      end
-    end
-
-    # A frozen array of Dublincore Terms.
-    DCTERMS = [
-      :abstract,
-      :accessRights,
-      :accrualMethod,
-      :accrualPeriodicity,
-      :accrualPolicy,
-      :alternative,
-      :audience,
-      :available,
-      :bibliographicCitation,
-      :conformsTo,
-      :contributor,
-      :coverage,
-      :created,
-      :creator,
-      :date,
-      :dateAccepted,
-      :dateCopyrighted,
-      :dateSubmitted,
-      :description,
-      :educationLevel,
-      :extent,
-      :hasFormat,
-      :hasPart,
-      :hasVersion,
-      :identifier,
-      :instructionalMethod,
-      :isFormatOf,
-      :isPartOf,
-      :isReferencedBy,
-      :isReplacedBy,
-      :isRequiredBy,
-      :isVersionOf,
-      :issued,
-      :language,
-      :license,
-      :mediator,
-      :medium,
-      :modified,
-      :provenance,
-      :publisher,
-      :references,
-      :relation,
-      :replaces,
-      :requires,
-      :rights,
-      :rightsHolder,
-      :source,
-      :spatial,
-      :subject,
-      :tableOfContents,
-      :temporal,
-      :title,
-      :type,
-      :valid
-    ].freeze # removed :format
-    DCTERMS.freeze
-
-    # Constructor. this class will call self.field for each DCTERM. In short, all DCTERMS fields will already exist
-    # when this method returns. Each term is marked as a multivalue string.
-    def initialize(string_or_url = nil)
-      super
-      self.fields = {}
-      DCTERMS.each do |el|
-        field el, :string, multiple: true
-      end
-    end
-
-    # This method generates the various accessor and mutator methods on self for the datastream metadata attributes.
-    # each field will have the 2 magic methods:
-    #   name=(arg)
-    #   name
-    #
-    #
-    # 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)
-    #
-    #
-    # There is quite a good example of this class in use in spec/examples/oral_history.rb
-    #
-    # !! Careful: If you declare two fields that correspond to the same xml node without any qualifiers to differentiate them,
-    # you will end up replicating the values in the underlying datastream, resulting in mysterious dubling, quadrupling, etc.
-    # whenever you edit the field's values.
-    def field(name, tupe = nil, opts = {})
-      @fields[name.to_s.to_sym] = { type: tupe, values: [] }.merge(opts)
-      # add term to template
-      self.class.class_fields << name.to_s
-      # add term to terminology
-      return if self.class.terminology.has_term?(name.to_sym)
-      om_term_opts = { xmlns: "http://purl.org/dc/terms/", namespace_prefix: "dcterms", path: opts[:path] }
-      term = OM::XML::Term.new(name.to_sym, om_term_opts, self.class.terminology)
-      self.class.terminology.add_term(term)
-      term.generate_xpath_queries!
-    end
-
-    def update_indexed_attributes(params = {}, opts = {})
-      # if the params are just keys, not an array, make then into an array.
-      new_params = {}
-      params.each do |key, val|
-        if key.is_a? Array
-          new_params[key] = val
-        else
-          new_params[[key.to_sym]] = val
-        end
-      end
-      super(new_params, opts)
-    end
-
-    def self.xml_template
-      Nokogiri::XML::Document.parse("<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'/>")
-    end
-
-    def to_solr(solr_doc = {}, _opts = {}) # :nodoc:
-      @fields.each do |field_key, field_info|
-        things = send(field_key)
-        next unless things
-        field_symbol = ActiveFedora.index_field_mapper.solr_name(field_key, type: field_info[:type])
-        things.val.each do |val|
-          ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val)
-        end
-      end
-      solr_doc
-    end
-  end
-end

data/lib/active_fedora/rdf/datastream_indexing.rb

@@ -1,49 +0,0 @@
-module ActiveFedora::RDF
-  module DatastreamIndexing
-    extend ActiveSupport::Concern
-
-    def to_solr(solr_doc = {}, opts = {}) # :nodoc:
-      super.tap do |new_doc|
-        solrize_rdf_assertions(opts[:name], new_doc)
-      end
-    end
-
-    module ClassMethods
-      def indexer
-        ActiveFedora::RDF::IndexingService
-      end
-
-      def index_config
-        @index_config ||= ActiveFedora::Indexing::Map.new
-      end
-    end
-
-    protected
-
-      def indexing_service
-        @indexing_service ||= self.class.indexer.new(self)
-      end
-
-      # Serialize the datastream's RDF relationships to solr
-      # @param [String] file_path used to prefix the keys in the solr document
-      # @param [Hash] solr_doc @default an empty Hash
-      def solrize_rdf_assertions(file_path, solr_doc = {})
-        solr_doc.merge! indexing_service.generate_solr_document(prefix_method(file_path))
-      end
-
-      # Returns a function that takes field name and returns a solr document key
-      def prefix_method(file_path)
-        ->(field_name) { apply_prefix(field_name, file_path) }
-      end
-
-      def apply_prefix(name, file_path)
-        prefix(file_path) + name.to_s
-      end
-
-      # The string to prefix all solr fields with. Override this method if you want
-      # a prefix other than the default
-      def prefix(path)
-        path ? "#{path.underscore}__" : ''
-      end
-  end
-end

data/lib/active_fedora/rdf/ntriples_rdf_datastream.rb

@@ -1,13 +0,0 @@
-require 'rdf/ntriples'
-
-module ActiveFedora
-  class NtriplesRDFDatastream < RDFDatastream
-    def serialization_format
-      :ntriples
-    end
-
-    def deprecation_warning
-      Deprecation.warn(NtriplesRDFDatastream, "NtriplesRDFDatastream is deprecated and will be removed in ActiveFedora 11", caller(2))
-    end
-  end
-end

data/lib/active_fedora/rdf/rdf_datastream.rb

@@ -1,173 +0,0 @@
-module ActiveFedora
-  class RDFDatastream < File
-    include ActiveTriples::NestedAttributes
-    include RDF::DatastreamIndexing
-    include ActiveTriples::Properties
-    include ActiveTriples::Reflection
-    extend Deprecation
-
-    delegate :rdf_subject, :set_value, :get_values, :attributes=, to: :resource
-    def initialize(*args)
-      super
-      deprecation_warning
-    end
-
-    def deprecation_warning
-      Deprecation.warn(RDFDatastream, "RDFDatastream is deprecated and will be removed in ActiveFedora 11", caller(2))
-    end
-
-    class << self
-      def rdf_subject(&block)
-        return @subject_block = block if block_given?
-
-        @subject_block ||= ->(ds) { parent_uri(ds) }
-      end
-
-      # Trim the last segment off the URI to get the parents uri
-      def parent_uri(ds)
-        m = /^(.*)\/[^\/]*$/.match(ds.uri)
-        if m
-          m[1]
-        else
-          ::RDF::URI.new(nil)
-        end
-      end
-
-      ##
-      # @param [Class] klass an object to set as the resource class, Must be a descendant of
-      # ActiveTriples::Resource and include ActiveFedora::RDF::Persistence.
-      #
-      # @return [Class] the object resource class
-      def resource_class(klass = nil)
-        if klass
-          raise ArgumentError, "#{self} already has a resource_class #{@resource_class}, cannot redefine it to #{klass}" if @resource_class && klass != @resource_class
-          raise ArgumentError, "#{klass} must be a subclass of ActiveTriples::Resource" unless klass < ActiveTriples::Resource
-        end
-
-        @resource_class ||= begin
-                              klass = Class.new(klass || ActiveTriples::Resource)
-                              klass.send(:include, RDF::Persistence)
-                              klass
-                            end
-      end
-    end
-
-    before_save do
-      if content.blank?
-        ActiveFedora::Base.logger.warn "Cowardly refusing to save a datastream with empty content: #{inspect}" if ActiveFedora::Base.logger
-        if ActiveSupport.respond_to?(:halt_callback_chains_on_return_false)
-          # For Rails 5+
-          throw :abort
-        else
-          # For Rails <= 4
-          false
-        end
-      end
-    end
-
-    def parent_uri
-      self.class.parent_uri(self)
-    end
-
-    def metadata?
-      true
-    end
-
-    def content
-      serialize
-    end
-
-    def content=(new_content)
-      resource.clear!
-      resource << deserialize(new_content)
-      content
-    end
-
-    def uri=(uri)
-      super
-      resource.set_subject!(parent_uri) if empty_or_blank_subject?
-    end
-
-    def content_changed?
-      return false unless instance_variable_defined? :@resource
-      return true if empty_or_blank_subject? # can't be serialized because a subject hasn't been assigned yet.
-      @content = serialize
-      super
-    end
-
-    def empty_or_blank_subject?
-      resource.rdf_subject.node? || resource.rdf_subject.value.blank?
-    end
-
-    def freeze
-      @resource.freeze
-    end
-
-    ##
-    # The resource is the RdfResource object that stores the graph for
-    # the datastream and is the central point for its relationship to
-    # other nodes.
-    #
-    # set_value, get_value, and property accessors are delegated to this object.
-    def resource
-      @resource ||= begin
-                      klass = self.class.resource_class
-                      klass.properties.merge(self.class.properties).each do |_prop, config|
-                        klass.property(config.term,
-                                       predicate: config.predicate,
-                                       class_name: config.class_name)
-                      end
-                      klass.accepts_nested_attributes_for(*nested_attributes_options.keys) unless nested_attributes_options.blank?
-                      uri_stub = self.class.rdf_subject.call(self)
-
-                      r = klass.new(uri_stub)
-                      r.datastream = self
-                      r << deserialize
-                      r
-                    end
-    end
-
-    alias graph resource
-
-    def refresh_attributes
-      @resource = nil
-    end
-
-    ##
-    # This method allows for delegation.
-    # This patches the fact that there's no consistent API for allowing delegation - we're matching the
-    # OmDatastream implementation as our "consistency" point.
-    # @TODO: We may need to enable deep RDF delegation at one point.
-    def term_values(*values)
-      send(values.first)
-    end
-
-    def update_indexed_attributes(hash)
-      hash.each do |fields, value|
-        fields.each do |field|
-          send("#{field}=", value)
-        end
-      end
-    end
-
-    def serialize
-      resource.set_subject!(parent_uri) if parent_uri && rdf_subject.node?
-      resource.dump serialization_format
-    end
-
-    def deserialize(data = nil)
-      return ::RDF::Graph.new if new_record? && data.nil?
-      data ||= remote_content
-
-      # Because datastream_content can return nil, we should check that here.
-      return ::RDF::Graph.new if data.nil?
-
-      data.force_encoding('utf-8')
-      ::RDF::Graph.new << ::RDF::Reader.for(serialization_format).new(data)
-    end
-
-    def serialization_format
-      raise "you must override the `serialization_format' method in a subclass"
-    end
-  end
-end