active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/rspec_matchers/match_fedora_datastream_matcher.rb

@@ -1,41 +0,0 @@
-# RSpec matcher to spec delegations.
-
-RSpec::Matchers.define :match_fedora_datastream do |method|
-  match do |object|
-    @method = method
-    @object = object
-    if @expected_xml.nil?
-      raise(
-        ArgumentError,
-        "match_fedora_datastream(<datastream_name>).with(<expected_xml>)"
-      )
-    end
-    expected = Nokogiri::XML(@expected_xml)
-
-    base_url = ActiveFedora.config.credentials[:url]
-    @fedora_datastream_url = File.join(
-      base_url, 'objects', @object.pid.to_s,'datastreams', @method, 'content'
-    )
-
-    response = RestClient.get(@fedora_datastream_url)
-
-    actual = Nokogiri::XML(response.body)
-
-    EquivalentXml.equivalent?(expected, actual, :normalize_whitespace => true)
-  end
-
-  chain(:with) { |expected_xml| @expected_xml = expected_xml }
-
-  description do
-    "#{@object.class} PID=#{@object.pid} datastream: #{@method.inspect} matches Fedora"
-  end
-
-  failure_message_for_should do |text|
-    "expected #{@object.class} PID=#{@object.pid} datastream: #{@method.inspect} to match Fedora"
-  end
-
-  failure_message_for_should_not do |text|
-    "expected #{@object.class} PID=#{@object.pid} datastream: #{@method.inspect} to NOT match Fedora"
-  end
-
-end

data/lib/active_fedora/rubydora_connection.rb

@@ -1,35 +0,0 @@
-require 'rubydora'
-
-module ActiveFedora
-  class RubydoraConnection
-    
-    attr_accessor :options, :connection
-
-    def initialize(params={})
-      params = params.dup
-      self.options = params
-      connect
-    end
-
-    def connect(force=false)
-      return unless @connection.nil? or force
-      @connection = Rubydora.connect options
-
-      Rubydora::Transaction.after_rollback do |options|
-        begin
-          case options[:method]
-            when :ingest
-              solr = ActiveFedora::SolrService.instance.conn
-              solr.delete_by_id(options[:pid])
-              solr.commit
-            else
-              ActiveFedora::Base.find(options[:pid]).update_index
-          end
-        rescue
-          # no-op
-        end
-
-      end
-    end
-  end
-end

data/lib/active_fedora/semantic_node.rb

@@ -1,164 +0,0 @@
-module ActiveFedora
-  module SemanticNode 
-    extend ActiveSupport::Concern
-
-    attr_accessor :relationships_loaded
-    attr_accessor :load_from_solr, :subject
-
-    def assert_kind_of(n, o,t)
-      raise "Assertion failure: #{n}: #{o} is not of type #{t}" unless o.kind_of?(t)
-    end
-
-    def clear_relationships
-      @relationships_loaded = false
-      @object_relations = nil
-    end
-
-    def object_relations
-      load_relationships if !relationships_loaded
-      @object_relations ||= RelationshipGraph.new
-    end
-
-    def relationships_are_dirty?
-      object_relations.dirty
-    end
-    alias relationships_are_dirty relationships_are_dirty?
-
-    def relationships_are_not_dirty!
-      object_relations.dirty = false
-    end
-
-    def relationships=(xml)
-      ::RDF::RDFXML::Reader.new(xml) do |reader|
-        reader.each_statement do |statement|
-          literal = statement.object.kind_of?(::RDF::Literal)
-          object = literal ? statement.object.value : statement.object.to_str
-          object_relations.add(statement.predicate, object, literal)
-        end
-      end
-      # Adding the relationships to the graph causes the graph to be marked as dirty,
-      # so now we assert that the graph is in sync
-      relationships_are_not_dirty!
-    end
-
-    # Add a relationship to the Object.
-    # @param [Symbol, String] predicate
-    # @param [URI, ActiveFedora::Base] target Either a string URI or an object that is a kind of ActiveFedora::Base 
-    # TODO is target ever a AF::Base anymore?
-    def add_relationship(predicate, target, literal=false)
-      #raise ArgumentError, "predicate must be a symbol. You provided `#{predicate.inspect}'" unless predicate.class.in?([Symbol, String])
-      object_relations.add(predicate, target, literal)
-      rels_ext.content_will_change! if object_relations.dirty
-    end
-
-    # Clears all relationships with the specified predicate
-    # @param predicate
-    def clear_relationship(predicate)
-      relationships(predicate).each do |target|
-        object_relations.delete(predicate, target) 
-      end
-      rels_ext.content_will_change! if object_relations.dirty
-    end
-
-    # Checks that this object is matches the model class passed in.
-    # It requires two steps to pass to return true
-    #   1. It has a hasModel relationship of the same model
-    #   2. kind_of? returns true for the model passed in
-    # This method can most often be used to detect if an object from Fedora that was created
-    # with a different model was then used to populate this object.
-    # @param [Class] model_class the model class name to check if an object conforms_to that model
-    # @return [Boolean] true if this object conforms to the given model name
-    def conforms_to?(model_class)
-      if self.kind_of?(model_class)
-        #check has model and class match
-        mod = relationships.first(:predicate=>Predicates.find_graph_predicate(:has_model))
-        if mod
-          expected = self.class.to_class_uri
-          if mod.object.to_s == expected
-            return true
-          else
-            raise "has_model relationship check failed for model #{model_class} raising exception, expected: '#{expected}' actual: '#{mod.object.to_s}'"
-          end
-        else
-          raise "has_model relationship does not exist for model #{model_class} check raising exception"
-        end
-      else
-        raise "kind_of? check failed for model #{model_class}, actual #{self.class} raising exception"
-      end
-      return false
-    end
-
-    #
-    # Remove a Rels-Ext relationship from the Object.
-    # @param predicate
-    # @param obj Either a string URI or an object that responds to .pid 
-    def remove_relationship(predicate, obj, literal=false)
-      object_relations.delete(predicate, obj)
-      object_relations.dirty = true
-      rels_ext.content_will_change!
-    end
-
-    # If no arguments are supplied, return the whole RDF::Graph.
-    # if a predicate is supplied as a parameter, then it returns the result of quering the graph with that predicate
-    def relationships(*args)
-      load_relationships unless relationships_loaded
-
-      if args.empty?
-        raise "Must have internal_uri" unless internal_uri
-        return object_relations.to_graph(internal_uri)
-      end
-      rels = object_relations[args.first] || []
-      rels.map {|o| o.respond_to?(:internal_uri) ? o.internal_uri : o }.compact   #TODO, could just return the object
-    end
-
-    def load_relationships
-      @relationships_loaded = true
-      content = rels_ext.content
-      return unless content.present?
-      RelsExtDatastream.from_xml content, rels_ext
-    end
-
-    def ids_for_outbound(predicate)
-      (object_relations[predicate] || []).map do |o|
-        o = o.to_s if o.kind_of? ::RDF::Literal
-        o.kind_of?(String) ? self.class.pid_from_uri(o) : o.pid
-      end
-    end
-
-    # @return [String] the internal fedora URI
-    def internal_uri
-      self.class.internal_uri(pid)
-    end
-
-    module ClassMethods
-      # Returns a suitable uri object for :has_model
-      # Should reverse Model#from_class_uri
-      def to_class_uri(attrs = {})
-        if self.respond_to? :pid_suffix
-          pid_suffix = self.pid_suffix
-        else
-          pid_suffix = attrs.fetch(:pid_suffix, ContentModel::CMODEL_PID_SUFFIX)
-        end
-        if self.respond_to? :pid_namespace
-          namespace = self.pid_namespace
-        else
-          namespace = attrs.fetch(:namespace, ContentModel::CMODEL_NAMESPACE)
-        end
-        "info:fedora/#{namespace}:#{ContentModel.sanitized_class_name(self)}#{pid_suffix}" 
-      end
-
-      # @param [String] pid the fedora object identifier
-      # @return [String] a URI represented as a string
-      def internal_uri(pid)
-        "info:fedora/#{pid}"
-      end
-
-      # @param [String] uri a uri (as a string)
-      # @return [String] the pid component of the URI
-      def pid_from_uri(uri)
-        uri.gsub("info:fedora/", "")
-      end
-
-    end
-  end
-end

data/lib/active_fedora/service_definitions.rb

@@ -1,88 +0,0 @@
-module ActiveFedora
-module ServiceDefinitions
-  def self.included(mod)
-    # check that it's an AF base
-    if mod.ancestors.include? ActiveFedora::Base
-      mod.extend(ClassMethods)
-      model_uri = mod.to_class_uri
-    # load ContentModel, pull Sdef pointers
-      begin
-        cmodel = ActiveFedora::ContentModel.find(mod.to_class_uri)
-        sdef_pids = cmodel.ids_for_outbound(:has_service).collect { |uri|
-          uri.split('/')[-1]
-        }
-      rescue
-        sdef_pids = []
-      end
-      unless sdef_pids.include? "fedora-system:3"
-        sdef_pids << "fedora-system:3"
-      end
-      sdef_pids.each { |sdef_pid| mod.has_service_definition sdef_pid }
-    end
-  end
-  def self.sdef_config
-    @@methods ||= begin
-      if defined? Rails
-        config_path = Rails.root.join('config','service_mappings.yml')
-      else
-        config_path = 'config/service_mappings.yml'
-      end
-      YAML::load(File.open(config_path))[:service_mapping]
-    end
-    @@methods
-  end
-  def self.lookup_method(sdef_uri, method_name)
-    sdef_pid = sdef_uri.split('/')[-1]
-    begin
-      sdef = sdef_config[sdef_pid]
-      return nil unless sdef
-      result = nil
-      sdef.each { |key, value| result = key if method_name == value }
-    rescue
-      return nil
-    end
-    return result
-  end
-
-  module ClassMethods
-    def sdef_pids
-      @sdef_pids ||= []
-    end
-    def has_service_definition sdef_uri
-      sdef_pid = sdef_uri.split('/')[-1]
-      unless sdef_pids.include? sdef_pid
-        self.add_sdef_methods! sdef_pid
-        sdef_pids << sdef_pid
-      end
-    end
-    # iterate over SDef pointers, identify symbols in yaml map
-    # inject methods by symbol key
-    def add_sdef_methods! sdef_pid
-      unless sdef_pid == "fedora-system:3"
-        content = ActiveFedora::Base.connection_for_pid(sdef_pid).datastream_dissemination(:pid=>sdef_pid, :dsid=>"METHODMAP")
-        method_map = Nokogiri::XML.parse(content)
-        methods = method_map.xpath('//fmm:Method').collect { |method|
-          method["operationName"]
-        }
-      else
-        methods = ["viewObjectProfile","viewMethodIndex","viewItemIndex","viewDublinCore"]
-      end
-      methods.each { |method|
-        add_method!(sdef_pid, method)
-      }
-    end
-    def add_method!(sdef_pid, method_name)
-      # find method_key
-      method_key = ServiceDefinitions.lookup_method(sdef_pid, method_name)
-      if method_key and not method_defined? method_key
-        define_method(method_key) { |*args, &block|
-            opts = args[0] || {}
-            opts = opts.merge({:pid => pid, :sdef => sdef_pid, :method => method_name })
-          # dispatch to the dissemination method on restAPI client
-            ActiveFedora::Base.connection_for_pid(pid).dissemination opts, &block
-        }
-      end
-    end
-  end
-end
-end

data/lib/active_fedora/sharding.rb

@@ -1,58 +0,0 @@
-module ActiveFedora
-  module Sharding
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :fedora_connection
-      self.fedora_connection = {}
-    end
-
-    module ClassMethods
-      # Uses {#shard_index} to find or create the rubydora connection for this pid
-      # @param [String] pid the identifier of the object to get the connection for
-      # @return [Rubydora::Repository] The repository that the identifier exists in.
-      def connection_for_pid(pid)
-        idx = shard_index(pid)
-        unless fedora_connection.has_key? idx
-          if ActiveFedora.config.sharded?
-            fedora_connection[idx] = RubydoraConnection.new(ActiveFedora.config.credentials[idx])
-          else
-            fedora_connection[idx] = RubydoraConnection.new(ActiveFedora.config.credentials)
-          end
-        end
-        fedora_connection[idx].connection
-      end
-
-      # This is where your sharding strategy is implemented -- it's how we figure out which shard an object will be (or was) written to.
-      # Given a pid, it decides which shard that pid will be written to (and thus retrieved from).
-      # For a given pid, as long as your shard configuration remains the same it will always return the same value.
-      # If you're not using sharding, this will always return 0, meaning use the first/only Fedora Repository in your configuration.
-      # Default strategy runs a modulo of the md5 of the pid against the number of shards.
-      # If you want to use a different sharding strategy, override this method.  Make sure that it will always return the same value for a given pid and shard configuration.
-      #@return [Integer] the index of the shard this object is stored in
-      def shard_index(pid)
-        if ActiveFedora.config.sharded?
-          Digest::MD5.hexdigest(pid).hex % ActiveFedora.config.credentials.length
-        else
-          0
-        end
-      end
-      
-      ### if you are doing sharding, override this method to do something other than use a sequence
-      # @return [String] the unique pid for a new object
-      def assign_pid(obj)
-        args = {}
-        args[:namespace] = obj.namespace if obj.namespace
-        # TODO: This juggling of Fedora credentials & establishing connections should be handled by 
-        # an establish_fedora_connection method,possibly wrap it all into a fedora_connection method - MZ 06-05-2012
-        if ActiveFedora.config.sharded?
-          credentials = ActiveFedora.config.credentials[0]
-        else
-          credentials = ActiveFedora.config.credentials
-        end
-        fedora_connection[0] ||= ActiveFedora::RubydoraConnection.new(credentials)
-        fedora_connection[0].connection.mint(args)
-      end
-    end
-  end
-end

data/lib/active_fedora/solr_digital_object.rb

@@ -1,68 +0,0 @@
-module ActiveFedora
-  class SolrDigitalObject
-    include DigitalObject::DatastreamBootstrap
-
-    attr_reader :pid, :label, :state, :ownerId, :profile, :datastreams, :solr_doc
-    attr_accessor :original_class
-
-    def initialize(solr_doc, profile_hash, klass=ActiveFedora::Base)
-      @solr_doc = solr_doc
-      @pid = solr_doc[SOLR_DOCUMENT_ID]
-      @profile = {}
-      profile_hash.each_pair { |key,value| @profile[key] = value.to_s if key =~ /^obj/ }
-      @profile['objCreateDate'] ||= Time.now.xmlschema
-      @profile['objLastModDate'] ||= @profile['objCreateDate']
-
-      @datastreams = {}
-      
-      dsids = profile_hash['datastreams'].keys
-      self.original_class = klass
-      missing = dsids - klass.ds_specs.keys
-      missing.each do |dsid|
-        #Initialize the datastreams that are in the solr document, but not found in the classes spec.
-        mime_type = profile_hash['datastreams'][dsid]['dsMIME']
-        ds_class = mime_type =~ /[\/\+]xml$/ ? OmDatastream : Datastream
-        @datastreams[dsid] = ds_class.new(self, dsid)
-      end
-
-      @label = @profile['objLabel']
-      @state = @profile['objState']
-      @ownerId = @profile['objOwnerId']
-    end
-    
-    def freeze
-      @finished = true
-      @profile.freeze
-      @datastreams.freeze
-      class << self
-        #Once this instance is frozen create a repository method just for this one instance.
-        define_method :repository do
-          ActiveFedora::Base.connection_for_pid(self.pid)
-        end
-      end
-      self
-    end
-
-    def fetch(field, default=[])
-      attribute = original_class.defined_attributes[field]
-      field_name = attribute.primary_solr_name
-      raise KeyError, "Tried to fetch `#{field}' from solr, but it isn't indexed." unless field_name
-      val = Array(solr_doc.fetch(field_name, default))
-      case attribute.type
-      when :date
-        val.map{|v| Date.parse v}
-      else
-        val
-      end
-    end
-    
-    def new_record?
-      false
-    end
-
-    def uri
-      "solr:#{pid}"
-    end
-
-  end
-end