active_fedora-datastreams 0.1.0

data/lib/active_fedora/datastreams/version.rb

@@ -0,0 +1,5 @@
+module ActiveFedora
+  module Datastreams
+    VERSION = "0.1.0".freeze
+  end
+end

data/lib/active_fedora/nom_datastream.rb

@@ -0,0 +1,71 @@
+require "nom"
+
+module ActiveFedora
+  class NomDatastream < File
+    include Datastreams::NokogiriDatastreams
+
+    def self.set_terminology(options = {}, &block)
+      @terminology_options = options || {}
+      @terminology = block
+    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_missing?(*args)
+      ng_xml.respond_to?(*args)
+    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

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

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

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

@@ -0,0 +1,9 @@
+require 'rdf/ntriples'
+
+module ActiveFedora
+  class NtriplesRDFDatastream < RDFDatastream
+    def serialization_format
+      :ntriples
+    end
+  end
+end

data/lib/active_fedora/rdf/rdf_datastream.rb

@@ -0,0 +1,164 @@
+module ActiveFedora
+  class RDFDatastream < File
+    include ActiveTriples::NestedAttributes
+    include RDF::DatastreamIndexing
+    include ActiveTriples::Properties
+    include ActiveTriples::Reflection
+
+    delegate :rdf_subject, :set_value, :get_values, :attributes=, to: :resource
+
+    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