active-fedora 9.13.0 → 10.0.0.beta1

data/config/predicate_mappings.yml

@@ -1,51 +0,0 @@
-# The default namespace maps to the default namespace for generating relationships from solr
-:default_namespace: info:fedora/fedora-system:def/relations-external#
-
-# namespace mappings--- 
-# you can add specific mappings for your institution by providing the following:
-#   namespace_uri:
-#     :relationship_symbol: relationship_identifier
-# 
-# For example, if you have the following element in your relationships:
-#  
-#  <oai:itemID>oai:example.edu:changeme:500</oai:itemID>
-# 
-# With the last two lines of this file uncommented, the relationships hash of your object will include:
-#   :oai_item_id => ["info:fedora/oai:example.edu:changeme:500"]
-#
-:predicate_mapping:
-  info:fedora/fedora-system:def/relations-external#:
-    :conforms_to: conformsTo
-    :has_annotation: hasAnnotation
-    :has_collection_member: hasCollectionMember
-    :has_constituent: hasConstituent
-    :has_dependent: hasDependent
-    :has_derivation: hasDerivation
-    :has_description: hasDescription
-    :has_equivalent: hasEquivalent
-    :has_metadata: hasMetadata
-    :has_member: hasMember
-    :has_model: hasModel
-    :has_part: hasPart
-    :has_subset: hasSubset
-    :has_topic: hasTopic
-    :is_annotation_of: isAnnotationOf
-    :is_constituent_of: isConstituentOf
-    :is_dependent_of: isDependentOf
-    :is_derivation_of: isDerivationOf
-    :is_description_of: isDescriptionOf
-    :is_member_of: isMemberOf
-    :is_member_of_collection: isMemberOfCollection
-    :is_metadata_for: isMetadataFor
-    :is_part_of: isPartOf
-    :is_subset_of: isSubsetOf
-    :is_topic_of: isTopicOf
-  http://fedora.info/definitions/v4/model#:
-    :is_contractor_of: isContractorOf
-    :is_deployment_of: isDeploymentOf
-    :has_service: hasService
-    :has_model: hasModel
-  http://www.openarchives.org/OAI/2.0/: 
-    :oai_item_id: itemID
-  http://projecthydra.org/ns/relations#:
-    :is_governed_by: isGovernedBy

data/lib/active_fedora/attributes/om_attribute.rb

@@ -1,26 +0,0 @@
-module ActiveFedora
-  # Class for attributes that are delegated to an OmDatastream
-
-  class OmAttribute < StreamAttribute
-    # @param [ActiveFedora::Base] obj the object that has the attribute
-    # @param [Object] v value to write to the attribute
-    def writer(obj, v)
-      ds = file_for_attribute(obj, delegate_target)
-      obj.mark_as_changed(field) if obj.value_has_changed?(field, v)
-      terminology = at || [field]
-      ds.send(:update_indexed_attributes, terminology => v)
-    end
-
-    # @param [ActiveFedora::Base] obj the object that has the attribute
-    # @param [Object] opts extra options that are passed to the target reader
-    def reader(obj, *opts)
-      ds = file_for_attribute(obj, delegate_target)
-      terminology = at || [field]
-      if terminology.length == 1 && opts.present?
-        ds.send(terminology.first, *opts)
-      else
-        ds.send(:term_values, *terminology)
-      end
-    end
-  end
-end

data/lib/active_fedora/attributes/rdf_datastream_attribute.rb

@@ -1,44 +0,0 @@
-module ActiveFedora
-  # Class for attributes that are delegated to a RDFDatastream
-
-  class RdfDatastreamAttribute < StreamAttribute
-    # @param [ActiveFedora::Base] obj the object that has the attribute
-    # @param [Object] v value to write to the attribute
-    def writer(obj, v)
-      node = file_for_attribute(obj, delegate_target)
-      obj.mark_as_changed(field) if obj.value_has_changed?(field, v)
-      term = if at
-               vals = at.dup
-               while vals.length > 1
-                 node = node.send(vals.shift)
-                 node = node.build if node.empty?
-                 node = node.first
-               end
-               vals.first
-             else
-               field
-             end
-      node.send("#{term}=", v)
-    end
-
-    # @param [ActiveFedora::Base] obj the object that has the attribute
-    def reader(obj)
-      node = file_for_attribute(obj, delegate_target)
-      term = if at
-               vals = at.dup
-               while vals.length > 1
-                 node = node.send(vals.shift)
-                 node = if node.empty?
-                          node.build
-                        else
-                          node.first
-                        end
-               end
-               vals.first
-             else
-               field
-             end
-      node.send(term)
-    end
-  end
-end

data/lib/active_fedora/attributes/stream_attribute.rb

@@ -1,43 +0,0 @@
-module ActiveFedora
-  # Abstract class for attributes that are delegated to a serialized representation such as a NonRDFSource
-  #
-  # @abstract
-  # @attr [String] delegate_target
-  # @attr [String] at
-  # @attr [String] target_class
-
-  class StreamAttribute < DelegatedAttribute
-    attr_accessor :delegate_target, :at, :target_class
-
-    # @param [Symbol] field the field to find or create
-    # @param [Hash] args
-    # @option args [String] :delegate_target the path to the delegate
-    # @option args [Class] :klass the class to create
-    # @option args [true,false] :multiple (false) true for multi-value fields
-    # @option args [Array<Symbol>] :at path to a deep node
-    def initialize(field, args = {})
-      super
-      self.delegate_target  = args.fetch(:delegate_target)
-      self.target_class     = args.fetch(:klass)
-      self.at               = args.fetch(:at, nil)
-    end
-
-    # Gives the primary solr name for a column. If there is more than one indexer on the field definition, it gives the first
-    def primary_solr_name
-      @datastream ||= target_class.new
-      raise NoMethodError, "the file '#{target_class}' doesn't respond to 'primary_solr_name'" unless @datastream.respond_to?(:primary_solr_name)
-      @datastream.primary_solr_name(field, delegate_target)
-    end
-
-    def type
-      raise NoMethodError, "the file '#{target_class}' doesn't respond to 'type'" unless target_class.respond_to?(:type)
-      target_class.type(field)
-    end
-
-    private
-
-      def file_for_attribute(obj, delegate_target)
-        obj.attached_files[delegate_target] || raise(ArgumentError, "Undefined file: `#{delegate_target}' in property #{field}")
-      end
-  end
-end

data/lib/active_fedora/datastream.rb

@@ -1,9 +0,0 @@
-module ActiveFedora
-  class Datastream < File
-    extend Deprecation
-
-    def self.inherited(child)
-      Deprecation.warn child, "ActiveFedora::Datastream is deprecated and will be removed in active-fedora 10.0. Use ActiveFedora::File instead"
-    end
-  end
-end

data/lib/active_fedora/model.rb

@@ -1,31 +0,0 @@
-module ActiveFedora
-  # = ActiveFedora
-  # This module mixes various methods into the including class,
-  # much in the way ActiveRecord does.
-  module Model
-    # @deprecated
-    # Convenience method for getting class constant based on a string
-    # @example
-    #   ActiveFedora::Model.class_from_string("Om")
-    #   => Om
-    #   ActiveFedora::Model.class_from_string("ActiveFedora::RdfNode::TermProxy")
-    #   => ActiveFedora::RdfNode::TermProxy
-    # @example Search within ActiveFedora::RdfNode for a class called "TermProxy"
-    #   ActiveFedora::Model.class_from_string("TermProxy", ActiveFedora::RdfNode)
-    #   => ActiveFedora::RdfNode::TermProxy
-    def self.class_from_string(*args)
-      Deprecation.warn("ActiveFedora::Model.class_from_string has been deprecated and will be removed in ActiveFedora 10.0. Use ActiveFedora::ModelClassifier.class_from_string instead")
-      ActiveFedora::ModelClassifier.class_from_string(*args)
-    end
-
-    # @deprecated
-    # Takes a Fedora URI for a cModel, and returns a
-    # corresponding Model if available
-    # This method should reverse ClassMethods#to_class_uri
-    # @return [Class, False] the class of the model or false, if it does not exist
-    def self.from_class_uri(model_value)
-      Deprecation.warn("ActiveFedora::Model.from_class_uri has been deprecated and will be removed in ActiveFedora 10.0. Use ActiveFedora::ModelClassifier.from_class_uri instead")
-      ActiveFedora::ModelClassifier.new(Array(model_value)).best_model
-    end
-  end
-end

data/lib/active_fedora/predicates.rb

@@ -1,122 +0,0 @@
-module ActiveFedora
-  module Predicates
-    def self.short_predicate(predicate)
-      # for this regex to short-circuit correctly, namespaces must be sorted into descending order by length
-      if match = /^(#{Predicates.predicate_mappings.keys.sort.reverse.join('|')})(.+)$/.match(predicate.to_str)
-        namespace = match[1]
-        predicate = match[2]
-        Predicates.predicate_mappings[namespace].invert[predicate]
-      elsif predicate.is_a? ::RDF::URI
-        predicate.to_s.split('/', 4).last.gsub(/(\/|#)/, '_').underscore
-      else
-        raise "Unable to parse predicate: #{predicate}"
-      end
-    end
-
-    def self.find_graph_predicate(predicate)
-      Deprecation.warn("find_graph_predicate has been deprecated and will be removed in ActiveFedora 10.0")
-      # TODO, these could be cached
-      case predicate
-      when :has_model, "hasModel", :hasModel
-        xmlns = "http://fedora.info/definitions/v4/model#"
-        begin
-          rel_predicate = predicate_lookup(predicate, xmlns)
-        rescue UnregisteredPredicateError
-          xmlns = nil
-          rel_predicate = nil
-        end
-      else
-        xmlns = "info:fedora/fedora-system:def/relations-external#"
-        begin
-          rel_predicate = predicate_lookup(predicate, xmlns)
-        rescue UnregisteredPredicateError
-          xmlns = nil
-          rel_predicate = nil
-        end
-      end
-
-      unless xmlns && rel_predicate
-        rel_predicate, xmlns = find_predicate(predicate)
-      end
-
-      vocabularies[xmlns][rel_predicate]
-    end
-
-    def self.vocabularies(vocabs = {})
-      Deprecation.warn("vocabularies has been deprecated and will be removed in ActiveFedora 10.0")
-      @vocabularies ||= vocabs
-      predicate_mappings.keys.each do |ns|
-        @vocabularies[ns] = ::RDF::Vocabulary.new(ns) unless @vocabularies.key? ns
-      end
-      @vocabularies
-    end
-
-    # If predicate is a symbol, looks up the predicate in the predicate_mappings
-    # If predicate is not a Symbol, returns the predicate untouched
-    # @raise UnregisteredPredicateError if the predicate is a symbol but is not found in the predicate_mappings
-    def self.predicate_lookup(predicate, namespace = "info:fedora/fedora-system:def/relations-external#")
-      if predicate.class == Symbol
-        if predicate_mappings[namespace].key?(predicate)
-          return predicate_mappings[namespace][predicate]
-        else
-          raise ActiveFedora::UnregisteredPredicateError
-        end
-      end
-      predicate
-    end
-
-    def self.predicate_config=(value)
-      unless value.nil? || (value.is_a?(Hash) && [:predicate_mapping, :default_namespace].all? { |key| value.key? key })
-        raise TypeError, "predicate_config must specify :predicate_mapping and :default_namespace"
-      end
-      @@predicate_config = value
-    end
-
-    def self.predicate_config
-      @@predicate_config ||= ActiveFedora.predicate_config
-    end
-
-    def self.predicate_namespaces
-      Deprecation.warn("predicate_namespaces has been deprecated and will be removed in ActiveFedora 10.0")
-      predicate_config[:predicate_namespaces] ||= {}
-    end
-
-    def self.predicate_mappings
-      predicate_config[:predicate_mapping]
-    end
-
-    def self.default_predicate_namespace
-      predicate_config[:default_namespace]
-    end
-
-    def self.find_predicate(predicate)
-      predicate_mappings.each do |namespace, predicates|
-        if predicates.fetch(predicate, nil)
-          return predicates[predicate], namespace
-        end
-      end
-      raise ActiveFedora::UnregisteredPredicateError, "Unregistered predicate: #{predicate.inspect}"
-    end
-
-    # Add/Modify predicates without destroying the other predicate configs
-    #
-    # @example
-    #  ActiveFedora::Predicates.set_predicates({
-    #                                              "http://projecthydra.org/ns/relations#"=>{has_profile:"hasProfile"},
-    #                                              "info:fedora/fedora-system:def/relations-external#"=>{
-    #                                                  references:"references",
-    #                                                  has_derivation: "cameFrom"
-    #                                              },
-    #                                          })
-    def self.set_predicates(new_predicates)
-      predicate_config = ActiveFedora::Predicates.predicate_config
-      new_predicates.each_pair do |ns, predicate_confs|
-        predicate_config[:predicate_mapping][ns] ||= {}
-        predicate_confs.each_pair do |property, value|
-          predicate_config[:predicate_mapping][ns][property] = value
-        end
-      end
-      predicate_config
-    end
-  end
-end

data/lib/active_fedora/simple_datastream.rb

@@ -1,92 +0,0 @@
-module ActiveFedora
-  # This class represents a simple xml datastream.
-  class SimpleDatastream < OmDatastream
-    extend Deprecation
-    class_attribute :class_fields
-    attr_accessor :fields
-    self.class_fields = []
-
-    set_terminology do |t|
-      t.root(path: "fields", xmlns: nil)
-    end
-
-    define_template :creator do |xml, name|
-      xml.creator do
-        xml.text(name)
-      end
-    end
-
-    # 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(digital_object = nil, dsid = nil, options = {}, &block)
-      Deprecation.warn(SimpleDatastream, "ActiveFedora::SimpleDatastream is deprecated and will be removed in ActiveFedora 10.0")
-      self.fields = {}
-      super
-    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
-    #
-    #
-    # 'datatype' is a datatype, currently :string, :integer 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 +SimpleDatastream+:
-    #   :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, datatype = :string, opts = {})
-      @fields[name.to_s.to_sym] = { type: datatype, 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)
-      term = OM::XML::Term.new(name.to_sym, { type: datatype }, self.class.terminology)
-      self.class.terminology.add_term(term)
-      term.generate_xpath_queries!
-    end
-
-    def update_indexed_attributes(params = {}, opts = {})
-      raise "can't modify frozen #{self.class}" if frozen?
-      # 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("<fields/>")
-    end
-
-    def to_solr(solr_doc = {}, _opts = {}) # :nodoc:
-      @fields.each do |field_key, field_info|
-        next if field_key == :location ## FIXME HYDRA-825
-        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.to_s)
-        end
-      end
-      solr_doc
-    end
-  end
-end

data/spec/fixtures/rails_root/config/predicate_mappings.yml

@@ -1,31 +0,0 @@
-:default_namespace: info:fedora/fedora-system:def/relations-external#
-
-:predicate_mapping:
-  info:fedora/fedora-system:def/relations-external#: 
-    :is_derivation_of: isDerivationOf
-    :is_metadata_for: isMetadataFor
-    :is_member_of_collection: isMemberOfCollection
-    :has_derivation: hasDerivation
-    :is_annotation_of: isAnnotationOf
-    :is_constituent_of: isConstituentOf
-    :is_dependent_of: isDependentOf
-    :has_collection_member: hasCollectionMember
-    :has_annotation: hasAnnotation
-    :has_constituent: hasConstituent
-    :has_dependent: hasDependent
-    :is_part_of: isPartOf
-    :has_equivalent: hasEquivalent
-    :is_subset_of: isSubsetOf
-    :is_description_of: isDescriptionOf
-    :is_member_of: isMemberOf
-    :has_model: hasModel
-    :conforms_to: conformsTo
-    :has_metadata: hasMetadata
-    :has_subset: hasSubset
-    :has_description: hasDescription
-    :has_part: hasPart
-    :has_member: hasMember
-  http://fedora.info/definitions/v4/model#:
-    :has_model: hasModel
-#  http://www.openarchives.org/OAI/2.0/: 
-#    :oai_item_id: itemID