active-fedora 6.8.0 → 7.0.0.pre1

data/lib/active_fedora/rubydora_connection.rb

@@ -26,7 +26,7 @@ module ActiveFedora
               solr.delete_by_id(options[:pid])
               solr.commit
             else
-              ActiveFedora::Base.find(options[:pid], :cast=>true).update_index
+              ActiveFedora::Base.find(options[:pid]).update_index
           end
         rescue
           # no-op

data/lib/active_fedora/scoping.rb

@@ -0,0 +1,20 @@
+module ActiveFedora
+  module Scoping
+    extend ActiveSupport::Concern
+    included do
+      include Default
+      include Named
+    end
+
+    
+    module ClassMethods
+      def current_scope #:nodoc:
+        Thread.current["#{self}_current_scope"]
+      end
+
+      def current_scope=(scope) #:nodoc:
+        Thread.current["#{self}_current_scope"] = scope
+      end
+    end
+  end
+end

data/lib/active_fedora/scoping/default.rb

@@ -0,0 +1,38 @@
+module ActiveFedora
+  module Scoping
+    module Default
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Returns a scope for the model without the +default_scope+.
+        #
+        #   class Post < ActiveRecord::Base
+        #     def self.default_scope
+        #       where published: true
+        #     end
+        #   end
+        #
+        #   Post.all          # Fires "SELECT * FROM posts WHERE published = true"
+        #   Post.unscoped.all # Fires "SELECT * FROM posts"
+        #
+        # This method also accepts a block. All queries inside the block will
+        # not use the +default_scope+:
+        #
+        #   Post.unscoped {
+        #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
+        #   }
+        #
+        # It is recommended that you use the block form of unscoped because
+        # chaining unscoped with +scope+ does not work. Assuming that
+        # +published+ is a +scope+, the following two statements
+        # are equal: the +default_scope+ is applied on both.
+        #
+        #   Post.unscoped.published
+        #   Post.published
+        def unscoped
+          block_given? ? relation.scoping { yield } : relation
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/scoping/named.rb

@@ -0,0 +1,32 @@
+module ActiveFedora
+  # = Active Fedora \Named \Scopes
+  module Scoping
+    module Named
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Returns an <tt>ActiveFedora::Relation</tt> scope object.
+        #
+        #   posts = Post.all
+        #   posts.size # Fires "select count(*) from  posts" and returns the count
+        #   posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
+        #
+        #   fruits = Fruit.all
+        #   fruits = fruits.where(color: 'red') if options[:red_only]
+        #   fruits = fruits.limit(10) if limited?
+        #
+        # You can define a scope that applies to all finders using
+        # <tt>ActiveRecord::Base.default_scope</tt>.
+        def all
+          if current_scope
+            current_scope.clone
+          else
+            scope = relation
+            scope.default_scoped = true
+            scope
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/semantic_node.rb

@@ -1,15 +1,20 @@
 module ActiveFedora
   module SemanticNode 
     extend ActiveSupport::Concern
-    included do
-      class_attribute  :class_relationships_desc
-    end
-    attr_accessor :relationships_loaded, :load_from_solr, :subject
+    extend Deprecation
+
+    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
@@ -23,9 +28,11 @@ module ActiveFedora
     end
 
     # Add a relationship to the Object.
-    # @param predicate [Symbol]  The short version of the predicate
-    # @param target Either a string URI or an object that is a kind of ActiveFedora::Base 
+    # @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
@@ -77,45 +84,21 @@ module ActiveFedora
       rels_ext.content_will_change!
     end
 
-    def inbound_relationships(response_format=:uri)
-      rel_values = {}
-      inbound_relationship_predicates.each_pair do |name,predicate|
-        objects = self.send("#{name}",{:response_format=>response_format})
-        items = []
-        objects.each do |object|
-          if (response_format == :uri)    
-            #inbound relationships are always object properties
-            items.push(object.internal_uri)
-          else
-            items.push(object)
-          end
-        end
-        unless items.empty?
-          rel_values.merge!({predicate=>items})
-        end
-      end
-      return rel_values  
-    end
-    
-    def outbound_relationships()
-      relationships.statements
-    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 if !relationships_loaded
+      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 }   #TODO, could just return the object
+      rels.map {|o| o.respond_to?(:internal_uri) ? o.internal_uri : o }.compact   #TODO, could just return the object
     end
 
     def load_relationships
-      self.relationships_loaded = true
+      @relationships_loaded = true
       content = rels_ext.content
       return unless content.present?
       RelsExtDatastream.from_xml content, rels_ext
@@ -124,90 +107,55 @@ module ActiveFedora
     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) ? o.gsub("info:fedora/", "") : o.pid
+        o.kind_of?(String) ? self.class.pid_from_uri(o) : o.pid
       end
     end
 
-    # Return hash that persists relationship metadata defined by has_relationship calls
-    # @return [Hash] Hash of relationship subject (:self or :inbound) mapped to nested hashs of each relationship name mapped to another hash relationship options 
-    # @example For the following relationship
-    #
-    #  has_relationship "audio_records", :has_part, :type=>AudioRecord
-    #  
-    #  Results in the following returned by relationships_desc
-    #  {:self=>{"audio_records"=>{:type=>AudioRecord, :singular=>nil, :predicate=>:has_part, :inbound=>false}}}
-    def relationships_desc
-      @relationships_desc ||= self.class.relationships_desc
+    # @returns [String] the internal fedora URI
+    def internal_uri
+      self.class.internal_uri(pid)
     end
 
-    # Return hash of relationship names and predicate pairs (inbound and outbound).
-    # It retrieves this information via the relationships_desc hash in the class.
-    # @return [Hash] A hash of relationship names (inbound and outbound) mapped to predicates used
-    def relationship_predicates
-      return @relationship_predicates if @relationship_predicates
-      @relationship_predicates = {}
-      relationships_desc.each_pair do |subj, names|
-        @relationship_predicates[subj] = {}
-        names.each_pair do |name, args|
-          @relationship_predicates[subj][name] = args[:predicate]
+    module ClassMethods
+      # @param [String,Array] uris a single uri (as a string) or a list of uris to convert to pids
+      # @returns [String] the pid component of the URI
+      def pids_from_uris(uris) 
+        Deprecation.warn(SemanticNode, "pids_from_uris has been deprecated and will be removed in active-fedora 8.0.0", caller)
+        if uris.kind_of? String
+          pid_from_uri(uris)
+        else
+          Array(uris).map {|uri| pid_from_uri(uri)}
         end
       end
-      @relationship_predicates
-    end
-
-    # Return hash of outbound relationship names and predicate pairs
-    # @return [Hash] A hash of outbound relationship names mapped to predicates used
-    def outbound_relationship_predicates
-      relationship_predicates.has_key?(:self) ? relationship_predicates[:self] : {}
-    end
 
-    # Return hash of inbound relationship names and predicate pairs
-    # @return [Hash] A hash of inbound relationship names mapped to predicates used
-    def inbound_relationship_predicates
-      relationship_predicates.has_key?(:inbound) ? relationship_predicates[:inbound] : {}
-    end
+      # 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
+      # @returns [String] a URI represented as a string
+      def internal_uri(pid)
+        "info:fedora/#{pid}"
+      end
 
-    module ClassMethods
-      # Return hash that persists relationship metadata defined by has_relationship calls.  If you implement a child class of ActiveFedora::Base it will inherit
-      # the relationship descriptions defined there by merging in the class
-      # instance variable values.  It will also do this for any level of 
-      # ancestors.
-      # @return [Hash] Hash of relationship subject (:self or :inbound) mapped to nested hashs of each relationship name mapped to another hash relationship options
-      # @example
-      #  For the following relationship
-      #
-      #  has_relationship "audio_records", :has_part, :type=>AudioRecord
-      #  
-      #  Results in the following returned by relationships_desc
-      #  {:self=>{"audio_records"=>{:type=>AudioRecord, :singular=>nil, :predicate=>:has_part, :inbound=>false}}}
-      def relationships_desc
-        #get any relationship descriptions from superclasses
-        if @class_relationships_desc.nil?
-          @class_relationships_desc ||= Hash[:self => {}]
-
-          #get super classes
-          super_klasses = []
-          #insert in reverse order so the child overwrites anything in parent
-          super_klass = self.superclass
-          while !super_klass.nil?
-            super_klasses.insert(0,super_klass)
-            super_klass = super_klass.superclass
-          end
-        
-          super_klasses.each do |super_klass|
-            if super_klass.respond_to?(:relationships_desc)
-              super_rels = super_klass.relationships_desc
-              super_rels.each_pair do |subject,rels|
-                @class_relationships_desc[subject] = {} unless @class_relationships_desc.has_key?(subject)
-                @class_relationships_desc[subject].merge!(rels)
-              end
-            end
-          end
-        end
-        @class_relationships_desc
+      # @param [String] uri a uri (as a string)
+      # @returns [String] the pid component of the URI
+      def pid_from_uri(uri)
+        uri.gsub("info:fedora/", "")
       end
-    
+
     end
   end
 end

data/lib/active_fedora/serialization.rb

@@ -0,0 +1,19 @@
+module ActiveFedora #:nodoc:
+  # = Active Fedora Serialization
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+
+    included do
+      self.include_root_in_json = false
+    end
+
+    def serializable_hash(options = nil)
+      options = options.try(:clone) || {}
+
+      options[:except] = Array(options[:except]).map { |n| n.to_s }
+
+      super(options)
+    end
+  end
+end

data/lib/active_fedora/sharding.rb

@@ -0,0 +1,58 @@
+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,11 +1,8 @@
 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]
@@ -17,7 +14,7 @@ module ActiveFedora
       @datastreams = {}
       
       dsids = profile_hash['datastreams'].keys
-      original_class = klass
+      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.
@@ -43,11 +40,24 @@ module ActiveFedora
       end
       self
     end
+
+    def fetch(field)
+      attribute = original_class.defined_attributes[field]
+      field_name = attribute.primary_solr_name
+      if field_name
+       val = solr_doc.fetch field_name
+       case attribute.type
+       when :date
+         val.is_a?(Array) ? val.map{|v| Date.parse v} : Date.parse(val)
+       else
+         val
+       end
+      end
+    end
     
     def new?
       false
     end
-    alias_method :new_record?, :new?
 
     def uri
       "solr:#{pid}"

data/lib/active_fedora/solr_instance_loader.rb

@@ -28,7 +28,7 @@ module ActiveFedora
     private
 
     def allocate_object
-      active_fedora_class.allocate.init_with_object(solr_digital_object)
+      active_fedora_class.allocate.init_with(solr_digital_object)
     end
 
     def solr_digital_object