active-fedora 6.8.0 → 7.0.0.pre1

data/lib/active_fedora/rdf_datastream.rb

@@ -1,8 +1,6 @@
 module ActiveFedora
   class RDFDatastream < Datastream
 
-    include Solrizer::Common
-
     before_save do
       if content.blank?
         logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
@@ -10,6 +8,7 @@ module ActiveFedora
       end
     end
     include RdfNode
+    include Rdf::Indexing
     
     class << self 
       ##
@@ -30,12 +29,6 @@ module ActiveFedora
       true
     end
 
-    def prefix(name)
-      name = name.to_s unless name.is_a? String
-      pre = dsid.underscore
-      return "#{pre}__#{name}".to_sym
-    end
-
     # Overriding so that one can call ds.content on an unsaved datastream and they will see the serialized format
     def content
       serialize
@@ -52,32 +45,14 @@ module ActiveFedora
       @content = serialize
       super
     end
-
-    def to_solr(solr_doc = Hash.new) # :nodoc:
-      fields.each do |field_key, field_info|
-        values = get_values(rdf_subject, field_key)
-        if values
-          Array(values).each do |val|    
-            val = val.to_s if val.kind_of? RDF::URI
-            self.class.create_and_insert_terms(prefix(field_key), val, field_info[:behaviors], solr_doc)
-          end
-        end
-      end
-      solr_doc
-    end
-
-
     # Populate a RDFDatastream object based on the "datastream" content 
     # Assumes that the datastream contains RDF content
     # @param [String] data the "rdf" node 
     def deserialize(data = nil)
       repository = RDF::Repository.new
       return repository if new? and data.nil?
-      data ||= datastream_content
-
-      # Because datastream_content can return nil, we should check that here.
-      return repository if data.nil?
 
+      data ||= datastream_content
       data.force_encoding('utf-8')
       RDF::Reader.for(serialization_format).new(data) do |reader|
         reader.each_statement do |statement|
@@ -129,29 +104,6 @@ module ActiveFedora
       @graph = new_repository
     end
 
-    # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
-    def fields
-      field_map = {}.with_indifferent_access
-
-      rdf_subject = self.rdf_subject
-      query = RDF::Query.new do
-        pattern [rdf_subject, :predicate, :value]
-      end
-
-      query.execute(graph).each do |solution|
-        predicate = solution.predicate
-        value = solution.value
-        
-        name, config = self.class.config_for_predicate(predicate)
-        next unless config
-        type = config.type
-        behaviors = config.behaviors
-        next unless type and behaviors 
-        field_map[name] ||= {:values => [], :type => type, :behaviors => behaviors}
-        field_map[name][:values] << value.to_s
-      end
-      field_map
-    end
   end
 end
 

data/lib/active_fedora/rdf_node.rb

@@ -161,13 +161,9 @@ module ActiveFedora
     end
 
 
-    def config_for_term_or_uri(term)
-      case term
-      when RDF::URI
-        self.class.config.each { |k, v| return v if v.predicate == term}
-      else
-        self.class.config[term.to_sym]
-      end
+    # In Rails 4 you can do "delegate :config_for_term_or_uri, :class", but in rails 3 it breaks.
+    def config_for_term_or_uri(val)
+      self.class.config_for_term_or_uri(val)
     end
 
     # @param [Symbol, RDF::URI] term predicate  the predicate to insert into the graph
@@ -300,6 +296,15 @@ module ActiveFedora
         @rdf_type
       end
 
+      def config_for_term_or_uri(term)
+        case term
+        when RDF::URI
+          config.each { |k, v| return v if v.predicate == term}
+        else
+          config[term.to_sym]
+        end
+      end
+
       def config_for_predicate(predicate)
         config.each do |term, value|
           return term, value if value.predicate == predicate

data/lib/active_fedora/rdf_node/term_proxy.rb

@@ -75,33 +75,42 @@ module ActiveFedora
 
       # Get the values off of the rdf nodes this proxy targets
       def load_values
-        values = []
+        values = parent.query(subject, options.predicate)
+        .map {|solution| coerce_to_primitive_type(solution.value)}
+        .select { |v| correct_rdf_type_for_term?(v)}
+        .map {|v| coerce_to_rdf_type(v) }
 
-        parent.query(subject, options.predicate).each do |solution|
-          v = solution.value
-          v = v.to_s if v.is_a? RDF::Literal
-          if options.type == :date
-            v = Date.parse(v)
-          end
-          # If the user provided options[:class_name], we should query to make sure this 
-          # potential solution is of the right RDF.type
-          if options.class_name
-            klass =  class_from_rdf_type(v)
-            values << v if klass == ActiveFedora.class_from_string(options.class_name, parent.class)
-          else
-            values << v
-          end
-        end
-
-        if options.class_name
-          values = values.map{ |found_subject| class_from_rdf_type(found_subject).new(parent.graph, found_subject)}
-        end
-        
         options.multivalue ? values : values.first
       end
       
       private 
 
+      def coerce_to_rdf_type(v)
+        if options.class_name
+          class_from_rdf_type(v).new(parent.graph, v)
+        else
+          v
+        end
+      end
+
+      # If the user provided options[:class_name], we should query to make sure this 
+      # potential solution is of the right RDF.type
+      def correct_rdf_type_for_term?(v)
+        !options.class_name || (options.class_name && class_from_rdf_type(v) == ActiveFedora.class_from_string(options.class_name, parent.class))
+      end
+
+      def coerce_to_primitive_type(v)
+        v = v.to_s if v.is_a? RDF::Literal
+        case options.type
+        when :date
+          Date.parse(v)
+        when :integer
+          v.to_i
+        else
+          v
+        end
+      end
+
       def target_class
         parent.target_class(options)
       end

data/lib/active_fedora/rdfxml_rdf_datastream.rb

@@ -7,7 +7,7 @@ module ActiveFedora
     end
 
     def self.default_attributes
-      super.merge(:mimeType => 'text/xml', :controlGroup => 'X')
+      super.merge(:mimeType => 'text/xml')
     end
   end
 end

data/lib/active_fedora/reflection.rb

@@ -41,10 +41,37 @@ module ActiveFedora
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
       def reflect_on_association(association)
-        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+        val = reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+        unless val
+          # When a has_many is paired with a has_and_belongs_to_many the assocation will have a plural name 
+          association = association.to_s.pluralize.to_sym
+          val = reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+        end
+        val 
+      end
+
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
       end
 
+
       class MacroReflection
+        # Returns the name of the macro.
+        #
+        # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+        attr_reader :name
+
+        # Returns the macro type.
+        #
+        # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+        attr_reader :macro
+
+        # Returns the hash of options used for the macro.
+        #
+        # <tt>has_many :clients</tt> returns +{}+
+        attr_reader :options
+
+        attr_reader :active_fedora
 
         # Returns the target association's class.
         #
@@ -64,6 +91,7 @@ module ActiveFedora
 
         def initialize(macro, name, options, active_fedora)
           @macro, @name, @options, @active_fedora = macro, name, options, active_fedora
+          @automatic_inverse_of = nil
         end
 
         # Returns a new, unsaved instance of the associated class. +options+ will
@@ -72,17 +100,6 @@ module ActiveFedora
           klass.new(*options)
         end
 
-        # Returns the name of the macro.
-        #
-        # <tt>has_many :clients</tt> returns <tt>:clients</tt>
-        attr_reader :name
-
-        # Returns the hash of options used for the macro.
-        #
-        # <tt>has_many :clients</tt> returns +{}+
-        attr_reader :options
-
-        attr_reader :macro
 
         # Returns the class name for the macro.
         #
@@ -98,6 +115,11 @@ module ActiveFedora
           @collection
         end
 
+        # Returns +true+ if +self+ is a +belongs_to+ reflection.
+        def belongs_to?
+          macro == :belongs_to
+        end
+
         private
           def derive_class_name
             class_name = name.to_s.camelize
@@ -105,33 +127,154 @@ module ActiveFedora
             class_name
           end
 
+          def derive_foreign_key
+            if belongs_to?
+              "#{name}_id"
+            elsif options[:as]
+              "#{options[:as]}_id"
+            else
+              active_fedora.name.foreign_key
+            end
+          end
       end
 
       # Holds all the meta-data about an association as it was specified in the
       # Active Record class.
       class AssociationReflection < MacroReflection #:nodoc:
 
-        def initialize(macro, name, options, active_record)
+        def initialize(macro, name, options, active_fedora)
           super
           @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
         end
 
-        def primary_key_name
-          @primary_key_name ||= options[:foreign_key] || derive_primary_key_name
+
+        # Returns a new, unsaved instance of the associated class. +options+ will
+        # be passed to the class's constructor.
+        def build_association(*options)
+          klass.new(*options)
         end
-        
+
         # Creates a new instance of the associated class, and immediately saves it
-        # with ActiveRecord::Base#save. +options+ will be passed to the class's
+        # with ActiveFedora::Base#save. +options+ will be passed to the class's
         # creation method. Returns the newly created object.
         def create_association(*options)
           klass.create(*options)
         end
 
+        def foreign_key
+          @foreign_key ||= options[:foreign_key] || derive_foreign_key
+        end
+
+        # A chain of reflections from this one back to the owner. For more see the explanation in
+        # ThroughReflection.
+        def chain
+          [self]
+        end
+
+        alias :source_macro :macro
+
+        def inverse_of
+          return unless inverse_name
+
+          @inverse_of ||= klass.reflect_on_association inverse_name
+        end
+
+        
+        # Returns whether or not the association should be validated as part of
+        # the parent's validation.
+        #
+        # Unless you explicitly disable validation with
+        # <tt>:validate => false</tt>, validation will take place when:
+        #
+        # * you explicitly enable validation; <tt>:validate => true</tt>
+        # * you use autosave; <tt>:autosave => true</tt>
+        # * the association is a +has_many+ association
+        def validate?
+          !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+        end
+
+        def association_class
+          case macro
+          when :belongs_to
+            Associations::BelongsToAssociation
+          when :has_and_belongs_to_many
+            Associations::HasAndBelongsToManyAssociation
+          when :has_many
+            Associations::HasManyAssociation
+          end
+        end
+
+        VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_and_belongs_to_many, :belongs_to]
+        INVALID_AUTOMATIC_INVERSE_OPTIONS = [:conditions, :through, :polymorphic, :foreign_key]
+        
+
         private
 
-        def derive_primary_key_name
-          'pid'
-        end        
+        def inverse_name
+          options.fetch(:inverse_of) do
+            if @automatic_inverse_of == false
+              nil
+            else
+              @automatic_inverse_of ||= automatic_inverse_of
+            end
+          end
+        end
+
+        # Checks if the inverse reflection that is returned from the
+        # +automatic_inverse_of+ method is a valid reflection. We must
+        # make sure that the reflection's active_record name matches up
+        # with the current reflection's klass name.
+        #
+        # Note: klass will always be valid because when there's a NameError
+        # from calling +klass+, +reflection+ will already be set to false.
+        def valid_inverse_reflection?(reflection)
+          reflection &&
+            klass.name == reflection.active_fedora.name &&
+            can_find_inverse_of_automatically?(reflection)
+        end
+        
+
+        # returns either nil or the inverse association name that it finds.
+        def automatic_inverse_of
+          if can_find_inverse_of_automatically?(self)
+            inverse_name = ActiveSupport::Inflector.underscore(active_fedora.name).to_sym
+
+            begin
+              reflection = klass.reflect_on_association(inverse_name)
+            rescue NameError
+              # Give up: we couldn't compute the klass type so we won't be able
+              # to find any associations either.
+              reflection = false
+            end
+
+            if valid_inverse_reflection?(reflection)
+              return inverse_name
+            end
+          end
+
+          false
+        end
+
+        # Checks to see if the reflection doesn't have any options that prevent
+        # us from being able to guess the inverse automatically. First, the
+        # <tt>inverse_of</tt> option cannot be set to false. Second, we must
+        # have <tt>has_many</tt>, <tt>has_one</tt>, <tt>belongs_to</tt> associations.
+        # Third, we must not have options such as <tt>:polymorphic</tt> or
+        # <tt>:foreign_key</tt> which prevent us from correctly guessing the
+        # inverse association.
+        #
+        # Anything with a scope can additionally ruin our attempt at finding an
+        # inverse, so we exclude reflections with scopes.
+        def can_find_inverse_of_automatically?(reflection)
+          reflection.options[:inverse_of] != false &&
+            VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
+            !INVALID_AUTOMATIC_INVERSE_OPTIONS.any? { |opt| reflection.options[opt] } 
+            #&& !reflection.scope
+        end
+
+        # def derive_primary_key_name
+        #   'pid'
+        # end        
 
       end
     end

data/lib/active_fedora/relation.rb

@@ -1,18 +1,40 @@
 module ActiveFedora
   class Relation
-    extend Deprecation
-    delegate :map, :each, :collect, :all?, :include?, :to => :to_a
+
+    include FinderMethods, Calculations, SpawnMethods, QueryMethods, Delegation
+    
 
     attr_reader :loaded
+    attr_accessor :default_scoped
     alias :loaded? :loaded
-
-    attr_accessor :limit_value, :where_values, :order_values
     
-    def initialize(klass)
+    attr_accessor :values, :klass
+    
+    def initialize(klass, values = {})
       @klass = klass
       @loaded = false
-      self.where_values = []
-      self.order_values = []
+      @values = {}
+    end
+
+    # Tries to create a new record with the same scoped attributes
+    # defined in the relation. Returns the initialized object if validation fails.
+    #
+    # Expects arguments in the same format as +Base.create+.
+    #
+    # ==== Examples
+    #   users = User.where(name: 'Oscar')
+    #   users.create # #<User id: 3, name: "oscar", ...>
+    #
+    #   users.create(name: 'fxn')
+    #   users.create # #<User id: 4, name: "fxn", ...>
+    #
+    #   users.create { |user| user.name = 'tenderlove' }
+    #   # #<User id: 5, name: "tenderlove", ...>
+    #
+    #   users.create(name: nil) # validation on name
+    #   # #<User id: nil, name: nil, ...>
+    def create(*args, &block)
+      scoping { @klass.create(*args, &block) }
     end
 
     def reset
@@ -21,34 +43,6 @@ module ActiveFedora
       self
     end
 
-
-    # Returns the first records that was found.
-    #
-    # @example
-    #  Person.where(name_t: 'Jones').first
-    #    => #<Person @id="foo:123" @name='Jones' ... >
-    def first
-      if loaded?
-        @records.first
-      else
-        @first ||= limit(1).to_a[0]
-      end
-    end
-
-    # Returns the last record sorted by id.  ID was chosen because this mimics
-    # how ActiveRecord would achieve the same behavior.
-    #
-    # @example
-    #  Person.where(name_t: 'Jones').last
-    #    => #<Person @id="foo:123" @name='Jones' ... >
-    def last
-      if loaded?
-        @records.last
-      else
-        @last ||= order('id desc').limit(1).to_a[0]
-      end
-    end
-
     # Limits the number of returned records to the value specified
     #
     # @option [Integer] value the number of records to return
@@ -91,102 +85,17 @@ module ActiveFedora
       relation
     end
 
-    extend Deprecation
-    self.deprecation_horizon = 'active-fedora 7.0.0'
-
-    # Returns an Array of objects of the Class that +find+ is being 
-    # called on
-    #
-    # @param[String,Symbol,Hash] args either a pid or :all or a hash of conditions
-    # @option args [Integer] :rows when :all is passed, the maximum number of rows to load from solr
-    # @option args [Boolean] :cast when true, examine the model and cast it to the first known cModel
-    def find(*args)
-      return to_a.find { |*block_args| yield(*block_args) } if block_given?
-      options = args.extract_options!
-      options = options.dup
-
-      cast = if @klass == ActiveFedora::Base && !options.has_key?(:cast)
-        Deprecation.warn(Relation, "find's cast option will default to true in ActiveFedora 7.0.0.  To preserve existing behavior send parameter: `:cast=> false`", caller)
-        false
-      else 
-        options.delete(:cast)
-      end
-      if options[:sort]
-        # Deprecate sort sometime?
-        sort = options.delete(:sort) 
-        options[:order] ||= sort if sort.present?
-      end
-
-      if options.present?
-        options = args.first unless args.empty?
-        options = {conditions: options}
-        apply_finder_options(options).all
-      else
-        case args.first
-        when :first, :last, :all
-          Deprecation.warn Relation, "ActiveFedora::Base.find(#{args.first.inspect}) is deprecated.  Use ActiveFedora::Base.#{args.first} instead. This option will be removed in ActiveFedora 7", caller
-          send(args.first)
-        else
-          find_with_ids(args, cast)
-        end
-      end
-    end
-
-    def find_with_ids(ids, cast)
-      expects_array = ids.first.kind_of?(Array)
-      return ids.first if expects_array && ids.first.empty?
-
-      ids = ids.flatten.compact.uniq
-
-      case ids.size
-      when 0
-        raise ArgumentError, "Couldn't find #{@klass.name} without an ID"
-      when 1
-        result = @klass.find_one(ids.first, cast)
-        expects_array ? [ result ] : result
-      else
-        find_some(ids, cast)
-      end
-    end
-
-    def find_some(ids, cast)
-      ids.map{|id| @klass.find_one(id, cast)}
-    end
-
-    # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
-    # same arguments to this method as you can to <tt>find(:all)</tt>.
-    def all(*args)
-      args.any? ? apply_finder_options(args.first).to_a : to_a
-    end
-
-
-
     def to_a
       return @records if loaded?
       args = @klass == ActiveFedora::Base ? {:cast=>true} : {}
-      args[:rows] = @limit_value if @limit_value
-      args[:sort] = @order_values if @order_values
+      args[:rows] = limit_value if limit_value
+      args[:sort] = order_values if order_values
       
-      query = @where_values.present? ? @where_values : {}
-      @records = @klass.to_enum(:find_each, query, args).to_a
+      @records = to_enum(:find_each, where_values, args).to_a
 
       @records
     end
 
-    # Get a count of the number of objects from solr
-    # Takes :conditions as an argument
-    def count(*args)
-      return apply_finder_options(args.first).count  if args.any?
-      opts = {}
-      opts[:rows] = @limit_value if @limit_value
-      opts[:sort] = @order_values if @order_values
-      
-      query = @where_values.present? ? @where_values : {}
-      @klass.calculate :count, query, opts
-
-    end
-
-
 
     def ==(other)
       case other
@@ -231,13 +140,7 @@ module ActiveFedora
       if conditions
         where(conditions).destroy_all
       else
-        to_a.each {|object| 
-          begin
-            object.destroy
-          rescue ActiveFedora::ObjectNotFoundError
-            logger.error "When trying to destroy #{object.pid}, encountered an ObjectNotFoundError. Solr may be out of sync with Fedora"
-          end
-        }.tap { reset }.size
+        to_a.each {|object| object.destroy }.tap { reset }.size
       end
     end