active-fedora 6.8.0 → 7.0.0.pre1

data/lib/active_fedora/associations/has_and_belongs_to_many_association.rb

@@ -1,11 +1,34 @@
 module ActiveFedora
   # = Active Fedora Has And Belongs To Many Association
   module Associations
-    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+    class HasAndBelongsToManyAssociation < CollectionAssociation #:nodoc:
       def initialize(owner, reflection)
         super
       end
 
+      def insert_record(record, force = true, validate = true)
+        if record.new_record?
+          if force
+            record.save!
+          else
+            return false unless record.save(:validate => validate)
+          end
+        end
+
+        ### TODO save relationship
+        @owner.add_relationship(@reflection.options[:property], record)
+
+        if @owner.new_record? and @reflection.options[:inverse_of]
+          logger.warn("has_and_belongs_to_many #{@reflection.inspect} is cowardly refusing to insert the inverse relationship into #{record}, because #{@owner} is not persisted yet.")
+        elsif @reflection.options[:inverse_of]
+          record.add_relationship(@reflection.options[:inverse_of], @owner)
+          record.save
+        end
+
+        return true
+      end
+
+
       def find_target
           page_size = @reflection.options[:solr_page_size]
           page_size ||= 200
@@ -19,35 +42,22 @@ module ActiveFedora
           return ActiveFedora::SolrService.reify_solr_results(solr_result)
       end
 
+      # In a HABTM, just look in the rels-ext, no need to run a count query from solr.
+      def count(options = {})
+        @owner.ids_for_outbound(@reflection.options[:property]).size
+      end
+
+      def first
+        load_target.first
+      end
+
       protected
 
         def count_records
           load_target.size
         end
 
-        def insert_record(record, force = true, validate = true)
-          if record.new_record?
-            if force
-              record.save!
-            else
-              return false unless record.save(:validate => validate)
-            end
-          end
-
-          ### TODO save relationship
-          @owner.add_relationship(@reflection.options[:property], record)
-
-          if @owner.new_record? and @reflection.options[:inverse_of]
-            logger.warn("has_and_belongs_to_many #{@reflection.inspect} is cowardly refusing to insert the inverse relationship into #{record}, because #{@owner} is not persisted yet.")
-          elsif @reflection.options[:inverse_of]
-            record.add_relationship(@reflection.options[:inverse_of], @owner)
-            record.save
-          end
-
-          return true
-        end
-
-        def delete_records(records)
+        def delete_records(records, method)
           records.each do |r| 
             @owner.remove_relationship(@reflection.options[:property], r)
             
@@ -57,7 +67,7 @@ module ActiveFedora
               # which is what we should have done. Now we need a way to look up the
               # reflection by predicate
               name = r.class.reflection_name_for_predicate(@reflection.options[:inverse_of])
-              r.send(name).reset
+              r.association(name).reset
               r.save
             end
           end

data/lib/active_fedora/associations/has_many_association.rb

@@ -1,6 +1,6 @@
 module ActiveFedora
   module Associations
-    class HasManyAssociation < AssociationCollection #:nodoc:
+    class HasManyAssociation < CollectionAssociation #:nodoc:
       def initialize(owner, reflection)
         super
       end
@@ -18,8 +18,6 @@ module ActiveFedora
           @target.size
         else
           @reflection.klass.count(:conditions => @counter_query)
-          # load_target
-          # @target.size
         end
 
         # If there's nothing in the database and @target has no new records
@@ -31,21 +29,48 @@ module ActiveFedora
       end
 
       def insert_record(record, force = false, validate = true)
-        if @owner.new_record?
-          logger.warn("has_many #{@reflection.inspect} is cowardly refusing to insert a relationship into #{record}, because #{@owner} is not persisted yet.")
-          return true 
-        end
         set_belongs_to_association_for(record)
-        #force ? record.save! : record.save(:validate => validate)
         record.save
       end
 
       protected
 
         # Deletes the records according to the <tt>:dependent</tt> option.
-        def delete_records(records)
-          records.each do |r| 
-            r.remove_relationship(find_predicate, @owner)
+        def delete_records(records, method)
+          if method == :destroy
+            records.each { |r| r.destroy }
+            #update_counter(-records.length) unless inverse_updates_counter_cache?
+          else
+            # Find all the records that point to this and nullify them
+            # keys  = records.map { |r| r[reflection.association_primary_key] }
+            # scope = scoped.where(reflection.association_primary_key => keys)
+
+            if method == :delete_all
+              raise "Not Implemented"
+              #update_counter(-scope.delete_all)
+            else
+
+                
+              if reflection.inverse_of # Can't get an inverse when class_name: 'ActiveFedora::Base' is supplied
+                inverse = reflection.inverse_of.name
+                records.each do |record|
+                  if record.persisted?
+                    record.reload
+                    assoc = record.association(inverse)
+                    if assoc.reflection.collection?
+                      # Remove from a has_and_belongs_to_many
+                      record.association(inverse).delete(@owner)
+                    else
+                      # Remove from a belongs_to
+                      record.association(inverse).id_writer(nil)
+                    end
+                    record.save!
+                  end
+                end
+              end
+
+              #update_counter(-scope.update_all(reflection.foreign_key => nil))
+            end
           end
         end
 

data/lib/active_fedora/associations/singular_association.rb

@@ -0,0 +1,62 @@
+module ActiveFedora
+  module Associations
+    class SingularAssociation < Association #:nodoc:
+
+      # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
+      def reader(force_reload = false)
+        if force_reload
+          klass.uncached { reload }
+        elsif !loaded? || stale_target?
+          reload
+        end
+        target
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(record)
+        replace(record)
+      end
+
+
+      def create(attributes = {})
+        new_record(:create, attributes)
+      end
+
+      def create!(attributes = {})
+        build(attributes).tap { |record| record.save! }
+      end
+
+      def build(attributes = {})
+        new_record(:build, attributes)
+      end
+
+      private
+
+        def find_target
+          scoped.first.tap { |record| set_inverse_instance(record) }
+        end
+
+        # Implemented by subclasses
+        def replace(record)
+          raise NotImplementedError
+        end
+
+        def set_new_record(record)
+          replace(record)
+        end
+
+        def check_record(record)
+          record = record.target if Association === record
+          raise_on_type_mismatch(record) if record
+          record
+        end
+
+        def new_record(method, attributes)
+          attributes = {} #scoped.scope_for_create.merge(attributes || {})
+          record = @reflection.send("#{method}_association", attributes)
+          set_new_record(record)
+          record
+        end
+    end
+  end
+end

data/lib/active_fedora/attributes.rb

@@ -2,9 +2,7 @@ module ActiveFedora
   module Attributes
     extend ActiveSupport::Concern
     extend ActiveSupport::Autoload
-    extend Deprecation
-    self.deprecation_horizon = 'active-fedora 7.0.0'
-    
+    include ActiveModel::Dirty
     
     autoload :Serializers
 
@@ -19,14 +17,19 @@ module ActiveFedora
 
     def attributes=(properties)
       properties.each do |k, v|
-        respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(UnknownAttributeError, "unknown attribute: #{k}")
+        respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(UnknownAttributeError, "#{self.class} does not have an attribute `#{k}'")
       end
     end
 
+    def attributes
+      self.class.defined_attributes.keys.each_with_object({"id" => id}) {|key, hash| hash[key] = self[key]}
+    end
+
     # Calling inspect may trigger a bunch of loads, but it's mainly for debugging, so no worries.
     def inspect
-      values = self.class.defined_attributes.keys.map {|r| "#{r}:#{send(r).inspect}"}
-      "#<#{self.class} pid:\"#{pretty_pid}\", #{values.join(', ')}>"
+      values = ["pid: #{pretty_pid.inspect}"]
+      values << self.class.defined_attributes.keys.map {|r| "#{r}: #{send(r).inspect}"}
+      "#<#{self.class} #{values.flatten.join(', ')}>"
     end
 
     def [](key)
@@ -37,37 +40,53 @@ module ActiveFedora
       array_setter(key, value)
     end
 
+    protected
+
+    # override activemodel so it doesn't trigger a load of all the attributes.
+    # the callback methods seem to trigger this, which means just initing an object (after_init)
+    # causes a load of all the datastreams.
+    def attribute_method?(attr_name) #:nodoc:
+      respond_to_without_attributes?(:attributes) && self.class.defined_attributes.include?(attr_name)
+    end
 
     private
     def array_reader(field, *args)
+      if md = /^(.+)_id$/.match(field)
+        # a belongs_to association reader
+        association = association(md[1].to_sym)
+        return association.id_reader if association
+      end
       raise UnknownAttributeError, "#{self.class} does not have an attribute `#{field}'" unless self.class.defined_attributes.key?(field)
       if args.present?
-        instance_exec(*args, &self.class.defined_attributes[field][:reader])
+        instance_exec(*args, &self.class.defined_attributes[field].reader)
       else
-        instance_exec &self.class.defined_attributes[field][:reader]
+        instance_exec &self.class.defined_attributes[field].reader
       end
     end
 
     def array_setter(field, args)
+      if md = /^(.+)_id$/.match(field)
+        # a belongs_to association writer
+        association = association(md[1].to_sym)
+        return association.id_writer(args) if association
+      end
       raise UnknownAttributeError, "#{self.class} does not have an attribute `#{field}'" unless self.class.defined_attributes.key?(field)
-      instance_exec(args, &self.class.defined_attributes[field][:setter])
+      instance_exec(args, &self.class.defined_attributes[field].writer)
     end
 
     # @return [Boolean] true if there is an reader method and it returns a
     # value different from the new_value.
     def value_has_changed?(field, new_value)
-      begin
-        new_value != array_reader(field)
-      rescue NoMethodError
-        false
-      end
+      new_value != array_reader(field)
     end
 
     def mark_as_changed(field)
       self.send("#{field}_will_change!")
     end
 
-
+    def datastream_for_attribute(dsid)
+      datastreams[dsid] || raise(ArgumentError, "Undefined datastream id: `#{dsid}' in has_attributes")
+    end
 
     module ClassMethods
       def defined_attributes
@@ -83,7 +102,8 @@ module ActiveFedora
 
       def has_attributes(*fields)
         options = fields.pop
-        datastream = options.delete(:datastream)
+        datastream = options.delete(:datastream).to_s
+        raise ArgumentError, "You must provide a datastream to has_attributes" if datastream.blank?
         define_attribute_methods fields
         fields.each do |f|
           create_attribute_reader(f, datastream, options)
@@ -102,51 +122,17 @@ module ActiveFedora
       # @param [Symbol] field the field to query
       # @return [Boolean]
       def multiple?(field)
-        defined_attributes[field][:multiple]
+        defined_attributes[field].multiple
       end
 
-
+      def find_or_create_defined_attribute(field, dsid, args)  
+        self.defined_attributes[field] ||= DatastreamAttribute.new(field, dsid, datastream_class_for_name(dsid), args)
+      end
 
       private
-      def create_attribute_reader(field, dsid, args)
-        self.defined_attributes[field] ||= {}
-        self.defined_attributes[field][:reader] = lambda do |*opts|
-          ds = self.send(dsid)
-          if ds.kind_of?(ActiveFedora::RDFDatastream)
-            ds.send(field)
-          else
-            terminology = args[:at] || [field]
-            if terminology.length == 1 && opts.present?
-              ds.send(terminology.first, *opts)
-            else
-              ds.send(:term_values, *terminology)
-            end
-          end
-        end
 
-        if !args[:multiple].nil?
-          self.defined_attributes[field][:multiple] = args[:multiple]
-        elsif !args[:unique].nil?
-          i = 0 
-          begin 
-            match = /in `(delegate.*)'/.match(caller[i])
-            i+=1
-          end while match.nil?
-
-          prev_method = match.captures.first
-          Deprecation.warn Attributes, "The :unique option for `#{prev_method}' is deprecated. Use :multiple instead. :unique will be removed in ActiveFedora 7", caller(i+1)
-          self.defined_attributes[field][:multiple] = !args[:unique]
-        else 
-          i = 0 
-          begin 
-            match = /in `(delegate.*)'/.match(caller[i])
-            i+=1
-          end while match.nil?
-
-          prev_method = match.captures.first
-          Deprecation.warn Attributes, "You have not explicitly set the :multiple option on `#{prev_method}'. The default value will switch from true to false in ActiveFedora 7, so if you want to future-proof this application set `multiple: true'", caller(i+ 1)
-          self.defined_attributes[field][:multiple] = true # this should be false for ActiveFedora 7
-        end
+      def create_attribute_reader(field, dsid, args)
+        find_or_create_defined_attribute(field, dsid, args)
 
         define_method field do |*opts|
           val = array_reader(field, *opts)
@@ -154,94 +140,12 @@ module ActiveFedora
         end
       end
 
-
       def create_attribute_setter(field, dsid, args)
-        self.defined_attributes[field] ||= {}
-        self.defined_attributes[field][:setter] = lambda do |v|
-          ds = self.send(dsid)
-          mark_as_changed(field) if value_has_changed?(field, v)
-          if ds.kind_of?(ActiveFedora::RDFDatastream)
-            ds.send("#{field}=", v)
-          else
-            terminology = args[:at] || [field]
-            ds.send(:update_indexed_attributes, {terminology => v})
-          end
-        end
+        find_or_create_defined_attribute(field, dsid, args)
         define_method "#{field}=".to_sym do |v|
           self[field]=v
         end
       end
-
-    end
-    
-
-    public
-
-    # A convenience method  for updating indexed attributes.  The passed in hash
-    # must look like this : 
-    #   {{:name=>{"0"=>"a","1"=>"b"}}
-    #
-    # This will result in any datastream field of name :name having the value [a,b]
-    #
-    # An index of -1 will insert a new value. any existing value at the relevant index 
-    # will be overwritten.
-    #
-    # As in update_attributes, this overwrites _all_ available fields by default.
-    #
-    # If you want to specify which datastream(s) to update,
-    # use the :datastreams argument like so:
-    #  m.update_attributes({"fubar"=>{"-1"=>"mork", "0"=>"york", "1"=>"mangle"}}, :datastreams=>"my_ds")
-    # or
-    #  m.update_attributes({"fubar"=>{"-1"=>"mork", "0"=>"york", "1"=>"mangle"}}, :datastreams=>["my_ds", "my_other_ds"])
-    #
-    def update_indexed_attributes(params={}, opts={})
-      Deprecation.warn(Attributes, 'update_indexed_attributes is deprecated and will be removed in ActiveFedora 7.0.0. Consider using dsid.update_indexed_attributes() instead.', caller)
-      if ds = opts[:datastreams]
-        ds_array = []
-        ds = [ds] unless ds.respond_to? :each
-        ds.each do |dsname|
-          ds_array << datastreams[dsname]
-        end
-      else
-        ds_array = metadata_streams
-      end
-      result = {}
-      ds_array.each do |d|
-        result[d.dsid] = d.update_indexed_attributes(params,opts)
-      end
-      return result
-    end
-    
-    # Updates the attributes for each datastream named in the params Hash
-    # @param [Hash] params A Hash whose keys correspond to datastream ids and whose values are appropriate Hashes to submit to update_indexed_attributes on that datastream
-    # @param [Hash] opts (currently ignored.)
-    # @example Update the descMetadata and properties datastreams with new values
-    #   article = HydrangeaArticle.new
-    #   ds_values_hash = {
-    #     "descMetadata"=>{ [{:person=>0}, :role]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"} },
-    #     "properties"=>{ "notes"=>"foo" }
-    #   }
-    #   article.update_datastream_attributes( ds_values_hash )
-    def update_datastream_attributes(params={}, opts={})
-      Deprecation.warn(Attributes, 'update_datastream_attributes is deprecated and will be removed in ActiveFedora 7.0.0. Consider using delegate_to instead.', caller)
-      result = params.dup
-      params.each_pair do |dsid, ds_params| 
-        if datastreams.include?(dsid)
-          result[dsid] = datastreams[dsid].update_indexed_attributes(ds_params)
-        else
-          result.delete(dsid)
-        end
-      end
-      return result
-    end
-    
-    def get_values_from_datastream(dsid,field_key,default=[])
-      Deprecation.warn(Attributes, 'get_values_from_datastream is deprecated and will be removed in ActiveFedora 7.0.0. Consider using Datastream#get_values instead.', caller)
-      if datastreams.include?(dsid)
-        return datastreams[dsid].get_values(field_key,default)
-      else
-        return nil
-      end
     end
   end
 end