active-fedora 2.3.8 → 3.0.0

data/.rvmrc

@@ -4,7 +4,7 @@
 # development environment upon cd'ing into the directory
 
 ruby_string="ree-1.8.7"
-gemset_name="active_fedora_2.x"
+gemset_name="active_fedora"
 
 # Install rubies when used instead of only displaying a warning and exiting
 rvm_install_on_use_flag=1

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    active-fedora (2.3.7)
-      activeresource (< 3.0.0)
+    active-fedora (3.0.0)
+      activeresource (~> 3.0.0)
+      activesupport (~> 3.0.0)
       equivalent-xml
       facets
       mediashelf-loggable
       mime-types (>= 1.16)
       multipart-post (= 1.1.2)
-      net-http-persistent
       nokogiri
       om (>= 1.0)
       solr-ruby (>= 0.0.6)
@@ -18,17 +18,23 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    RedCloth (4.2.8)
-    activeresource (2.3.14)
-      activesupport (= 2.3.14)
-    activesupport (2.3.14)
-    builder (3.0.0)
+    RedCloth (4.2.7)
+    activemodel (3.0.10)
+      activesupport (= 3.0.10)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activeresource (3.0.10)
+      activemodel (= 3.0.10)
+      activesupport (= 3.0.10)
+    activesupport (3.0.10)
+    builder (2.1.2)
     columnize (0.3.4)
     daemons (1.1.4)
     equivalent-xml (0.2.7)
       nokogiri (>= 1.4.3)
     facets (2.9.2)
     fastercsv (1.5.4)
+    i18n (0.5.0)
     jettywrapper (0.0.10)
       logger
       mediashelf-loggable
@@ -38,8 +44,8 @@ GEM
     mediashelf-loggable (0.4.7)
     mime-types (1.16)
     mocha (0.9.12)
+    multi_json (1.0.3)
     multipart-post (1.1.2)
-    net-http-persistent (2.1)
     nokogiri (1.5.0)
     om (1.4.0)
       mediashelf-loggable
@@ -63,7 +69,7 @@ GEM
       om (>= 1.0.0)
       stomp
       xml-simple
-    solrizer-fedora (1.1.0)
+    solrizer-fedora (1.1.1)
       active-fedora (>= 2.3.0)
       fastercsv
       rsolr

data/History.txt

@@ -1,9 +1,8 @@
-2.3.8
-
-HYDRA-670 -- Use persistent http connections
-Don't set log level to error by default
-Benchmark fedora and solr queries
+3.0.0
 
+added belongs_to and has_many model relationships
+added nested_attributes_for
+Added dependency on rails > 3.0.0
 
 2.3.7 
 

data/README.textile

@@ -1,6 +1,6 @@
 h2. Description
 
-RubyFedora and ActiveFedora provide a set of Ruby gems for creating and managing objects in the Fedora Repository Architecture ("http://fedora-commons.org":http://fedora-commons.org).  ActiveFedora is loosely based on "ActiveRecord" in Rails. This version of ActiveFedora depends on Rails 2.3.11 and has been superceeded by ActiveFedora 3.x which requires Rails 3.
+RubyFedora and ActiveFedora provide a set of Ruby gems for creating and managing objects in the Fedora Repository Architecture ("http://fedora-commons.org":http://fedora-commons.org).  ActiveFedora is loosely based on "ActiveRecord" in Rails.  The 3.x series of ActiveFedora depends on Rails 3, specifically activemodel and activesupport.
 
 h2. Getting Help
 

data/active-fedora.gemspec

@@ -22,11 +22,11 @@ Gem::Specification.new do |s|
   s.add_dependency('nokogiri')
   s.add_dependency('om', '>= 1.0')
   s.add_dependency('solrizer', '>1.0.0')
-  s.add_dependency("activeresource", "<3.0.0")
+  s.add_dependency("activeresource", '~> 3.0.0')
+  s.add_dependency("activesupport", '~> 3.0.0')
   s.add_dependency("mediashelf-loggable")
   s.add_dependency("equivalent-xml")
   s.add_dependency("facets")
-  s.add_dependency("net-http-persistent")
   s.add_development_dependency("yard")
   s.add_development_dependency("RedCloth") # for RDoc formatting
   s.add_development_dependency("rake")

data/lib/active_fedora.rb

@@ -1,36 +1,49 @@
 require 'rubygems'
-# require "bundler/setup"
-# Bundler.require(:default)
-
 gem 'solr-ruby'
 require "loggable"
 
 $: << 'lib'
+
+require 'active_support'
+require 'active_model'
+
 require 'active_fedora/solr_service.rb'
 require "solrizer"
 
 require 'ruby-fedora'
-require 'active_fedora/base.rb'
-require 'active_fedora/content_model.rb'
-require 'active_fedora/datastream.rb'
-require 'active_fedora/fedora_object.rb'
-require 'active_fedora/metadata_datastream_helper.rb'
-require 'active_fedora/metadata_datastream.rb'
-require 'active_fedora/nokogiri_datastream'
-require 'active_fedora/model.rb'
-require 'active_fedora/property.rb'
-require 'active_fedora/qualified_dublin_core_datastream.rb'
-require 'active_fedora/relationship.rb'
-require 'active_fedora/rels_ext_datastream.rb'
-require 'active_fedora/semantic_node.rb'
-require 'active_fedora/version.rb'
-
-require 'active_fedora/railtie' if defined?(Rails) && Rails.version >= "3.0"
+# require 'active_fedora/fedora_object.rb'
+# require 'active_fedora/version.rb'
+# 
+# require 'active_fedora/railtie' if defined?(Rails) && Rails.version >= "3.0"
 
 SOLR_DOCUMENT_ID = ActiveFedora::SolrService.id_field unless defined?(SOLR_DOCUMENT_ID)
 ENABLE_SOLR_UPDATES = true unless defined?(ENABLE_SOLR_UPDATES)
 
 module ActiveFedora #:nodoc:
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :Associations
+    autoload :AttributeMethods
+    autoload :Base
+    autoload :ContentModel
+    autoload :Reflection
+    autoload :Relationship
+    autoload :Datastream
+    autoload :Delegating
+    autoload :Model
+    autoload :MetadataDatastream
+    autoload :MetadataDatastreamHelper
+    autoload :NokogiriDatastream
+    autoload :Property
+    autoload :QualifiedDublinCoreDatastream
+    autoload :RelsExtDatastream
+    autoload :RelationshipsHelper
+    autoload :SemanticNode
+    autoload :NestedAttributes
+
+  end
+  
   
   include Loggable
   
@@ -68,6 +81,7 @@ module ActiveFedora #:nodoc:
   # 2. If it does not find a solr.yml and the fedora.yml contains a solr url, it will raise an configuration error 
   # 3. If it does not find a solr.yml and the fedora.yml does not contain a solr url, it will look in: +Rails.root+/config, +current working directory+/config, then the solr.yml shipped with gem
   def self.init( options={} )
+    logger.level = Logger::ERROR if logger.respond_to? :level ###MediaShelf StubLogger doesn't have a level= method
     # Make config_options into a Hash if nil is passed in as the value
     options = {} if options.nil?
 
@@ -276,5 +290,8 @@ module ActiveFedora
   class ServerError < Fedora::ServerError; end # :nodoc:
   class ObjectNotFoundError < RuntimeError; end # :nodoc:
   class PredicateMappingsNotFoundError < RuntimeError; end # :nodoc:
+  class UnknownAttributeError < NoMethodError; end; # :nodoc:
+  class ActiveFedoraConfigurationException < Exception; end # :nodoc:
+
 end
 

data/lib/active_fedora/associations.rb

@@ -0,0 +1,157 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
+
+module ActiveFedora
+  module Associations
+    extend ActiveSupport::Concern
+
+    autoload :HasManyAssociation, 'active_fedora/associations/has_many_association'
+    autoload :BelongsToAssociation, 'active_fedora/associations/belongs_to_association'
+
+    autoload :AssociationCollection, 'active_fedora/associations/association_collection'
+    autoload :AssociationProxy, 'active_fedora/associations/association_proxy'
+    private 
+
+      # Returns the specified association instance if it responds to :loaded?, nil otherwise.
+      def association_instance_get(name)
+        ivar = "@#{name}"
+        if instance_variable_defined?(ivar)
+          association = instance_variable_get(ivar)
+          association if association.respond_to?(:loaded?)
+        end
+      end
+
+      # Set the specified association instance.
+      def association_instance_set(name, association)
+        instance_variable_set("@#{name}", association)
+      end
+
+    
+
+    module ClassMethods
+
+      def has_many(association_id, options={})
+        raise "You must specify a property name for #{name}" if !options[:property]
+        has_relationship association_id.to_s, options[:property], :inbound => true
+        reflection = create_has_many_reflection(association_id, options)
+        collection_accessor_methods(reflection, HasManyAssociation)
+      end
+
+  
+      def belongs_to(association_id, options = {})
+        raise "You must specify a property name for #{name}" if !options[:property]
+        has_relationship association_id.to_s, options[:property]
+        reflection = create_belongs_to_reflection(association_id, options)
+
+        association_accessor_methods(reflection, BelongsToAssociation)
+          # association_constructor_method(:build,  reflection, BelongsToAssociation)
+          # association_constructor_method(:create, reflection, BelongsToAssociation)
+        #configure_dependency_for_belongs_to(reflection)
+      end
+
+
+      private 
+
+        def create_has_many_reflection(association_id, options)
+          create_reflection(:has_many, association_id, options, self)
+        end
+
+        def create_belongs_to_reflection(association_id, options)
+          create_reflection(:belongs_to, association_id, options, self)
+        end
+
+        def association_accessor_methods(reflection, association_proxy_class)
+          redefine_method(reflection.name) do |*params|
+            force_reload = params.first unless params.empty?
+            association = association_instance_get(reflection.name)
+
+            if association.nil? || force_reload
+              association = association_proxy_class.new(self, reflection)
+              retval = force_reload ? reflection.klass.uncached { association.reload } : association.reload
+              if retval.nil? and association_proxy_class == BelongsToAssociation
+                association_instance_set(reflection.name, nil)
+                return nil
+              end
+              association_instance_set(reflection.name, association)
+            end
+
+            association.target.nil? ? nil : association
+          end
+
+          redefine_method("loaded_#{reflection.name}?") do
+            association = association_instance_get(reflection.name)
+            association && association.loaded?
+          end
+
+          redefine_method("#{reflection.name}=") do |new_value|
+            association = association_instance_get(reflection.name)
+
+            if association.nil? || association.target != new_value
+              association = association_proxy_class.new(self, reflection)
+            end
+
+            association.replace(new_value)
+            association_instance_set(reflection.name, new_value.nil? ? nil : association)
+          end
+
+          redefine_method("set_#{reflection.name}_target") do |target|
+            return if target.nil? and association_proxy_class == BelongsToAssociation
+            association = association_proxy_class.new(self, reflection)
+            association.target = target
+            association_instance_set(reflection.name, association)
+          end
+
+          redefine_method("#{reflection.name}_id=") do |new_value|
+            send("#{reflection.name}=", reflection.klass.find(new_value))
+          end
+          redefine_method("#{reflection.name}_id") do 
+            obj = send("#{reflection.name}")
+            obj.pid if obj
+          end
+        end
+
+
+        def collection_reader_method(reflection, association_proxy_class)
+          redefine_method(reflection.name) do |*params|
+            
+            force_reload = params.first unless params.empty?
+            association = association_instance_get(reflection.name)
+            unless association
+              association = association_proxy_class.new(self, reflection)
+              association_instance_set(reflection.name, association)
+            end
+
+            association.reload if force_reload
+
+            association
+          end
+
+          redefine_method("#{reflection.name.to_s.singularize}_ids") do
+              send(reflection.name).map { |r| r.pid }
+          end
+
+        end
+
+
+        def collection_accessor_methods(reflection, association_proxy_class, writer = true)
+          collection_reader_method(reflection, association_proxy_class)
+
+          if writer
+            redefine_method("#{reflection.name}=") do |new_value|
+              # Loads proxy class instance (defined in collection_reader_method) if not already loaded
+              association = send(reflection.name)
+              association.replace(new_value)
+              association
+            end
+
+            redefine_method("#{reflection.name.to_s.singularize}_ids=") do |new_value|
+              ids = (new_value || []).reject { |nid| nid.blank? }
+              #TODO, like this when find() can return multiple records
+              #send("#{reflection.name}=", reflection.klass.find(ids))
+              send("#{reflection.name}=", ids.collect { |id| reflection.klass.find(id)})
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_fedora/associations/association_collection.rb

@@ -0,0 +1,180 @@
+module ActiveFedora
+  module Associations
+    class AssociationCollection < AssociationProxy #:nodoc:
+      def initialize(owner, reflection)
+        super
+      end
+
+      # Returns the size of the collection 
+      #
+      # If the collection has been already loaded +size+ and +length+ are
+      # equivalent. If not and you are going to need the records anyway
+      # +length+ will take one less query. Otherwise +size+ is more efficient.
+      #
+      # This method is abstract in the sense that it relies on
+      # +count_records+, which is a method descendants have to provide.
+      def size
+        if @owner.new_record? && @target
+          @target.size
+        elsif !loaded? && @target.is_a?(Array)
+          unsaved_records = @target.select { |r| r.new_record? }
+          unsaved_records.size + count_records
+        else
+          count_records
+        end
+      end
+
+      # Replace this collection with +other_array+
+      # This will perform a diff and delete/add only records that have changed.
+      def replace(other_array)
+        other_array.each { |val| raise_on_type_mismatch(val) }
+
+        load_target
+        other   = other_array.size < 100 ? other_array : other_array.to_set
+        current = @target.size < 100 ? @target : @target.to_set
+
+        delete(@target.select { |v| !other.include?(v) })
+        concat(other_array.select { |v| !current.include?(v) })
+      end
+      
+
+      def to_ary
+        load_target
+        if @target.is_a?(Array)
+          @target.to_ary
+        else
+          Array.wrap(@target)
+        end
+      end
+      alias_method :to_a, :to_ary
+
+      def reset
+        reset_target!
+        @loaded = false
+      end
+
+
+      def build(attributes = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr, &block) }
+        else
+          build_record(attributes) do |record|
+            block.call(record) if block_given?
+            set_belongs_to_association_for(record)
+          end
+        end
+      end
+
+      # Add +records+ to this association.  Returns +self+ so method calls may be chained.
+      # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
+      def <<(*records)
+        result = true
+        load_target if @owner.new_record?
+
+        flatten_deeper(records).each do |record|
+          raise_on_type_mismatch(record)
+          add_record_to_target_with_callbacks(record) do |r|
+            result &&= insert_record(record) unless @owner.new_record?
+          end
+        end
+
+        result && self
+      end
+
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      # Removes +records+ from this association calling +before_remove+ and
+      # +after_remove+ callbacks.
+      #
+      # This method is abstract in the sense that +delete_records+ has to be
+      # provided by descendants. Note this method does not imply the records
+      # are actually removed from the database, that depends precisely on
+      # +delete_records+. They are in any case removed from the collection.
+      def delete(*records)
+        remove_records(records) do |_records, old_records|
+          delete_records(old_records) if old_records.any?
+          _records.each { |record| @target.delete(record) }
+        end
+      end
+      
+
+      def load_target
+        if !@owner.new_record?
+          begin
+            if !loaded?
+              if @target.is_a?(Array) && @target.any?
+                @target = find_target.map do |f|
+                  i = @target.index(f)
+                  if i
+                    @target.delete_at(i).tap do |t|
+                      keys = ["id"] + t.changes.keys + (f.attribute_names - t.attribute_names)
+                      t.attributes = f.attributes.except(*keys)
+                    end
+                  else
+                    f
+                  end
+                end + @target
+              else
+                @target = find_target
+              end
+            end
+          rescue ObjectNotFoundError # TODO this isn't ever thrown. Maybe check for nil instead
+            reset
+          end
+        end
+
+        loaded if target
+        target
+      end
+
+      def find_target
+        @owner.load_inbound_relationship(@reflection.name.to_s, @reflection.options[:property])
+      end
+
+
+      def add_record_to_target_with_callbacks(record)
+      #  callback(:before_add, record)
+        yield(record) if block_given?
+        @target ||= [] unless loaded?
+        if index = @target.index(record)
+          @target[index] = record
+        else
+           @target << record
+        end
+      #  callback(:after_add, record)
+      #  set_inverse_instance(record, @owner)
+        record
+      end
+
+      protected
+        def reset_target!
+          @target = Array.new
+        end
+
+
+      private 
+
+        def build_record(attrs)
+          #attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
+          record = @reflection.build_association(attrs)
+          if block_given?
+            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
+          else
+            add_record_to_target_with_callbacks(record)
+          end
+        end
+
+        def remove_records(*records)
+          records = flatten_deeper(records)
+          records.each { |record| raise_on_type_mismatch(record) }
+
+          #records.each { |record| callback(:before_remove, record) }
+          old_records = records.reject { |r| r.new_record? }
+          yield(records, old_records)
+          #records.each { |record| callback(:after_remove, record) }
+        end
+      
+    end
+  end
+end