active-fedora 9.4.3 → 9.5.0

data/lib/active_fedora/persistence.rb

@@ -145,15 +145,15 @@ module ActiveFedora
       assign_rdf_subject
       serialize_attached_files
       @ldp_source = @ldp_source.create
-      assign_uri_to_attached_files
-      save_attached_files
+      assign_uri_to_contained_resources
+      save_contained_resources
       refresh
     end
 
     def update_record(options = {})
       serialize_attached_files
       execute_sparql_update
-      save_attached_files
+      save_contained_resources
       refresh
     end
 
@@ -195,16 +195,25 @@ module ActiveFedora
       ActiveFedora.fedora.connection.put(path, "")
     end
 
-    def assign_uri_to_attached_files
-      attached_files.each do |name, ds|
-        ds.uri= "#{uri}/#{name}"
+    def assign_uri_to_contained_resources
+      contained_resources.each do |name, source|
+        source.uri= "#{uri}/#{name}"
       end
     end
 
-    def save_attached_files
-      attached_files.select { |_, file| file.changed? }.each do |_, file|
-        file.save # Don't call save! because if the content_changed? returns false, it'll raise an error.
+    def save_contained_resources
+      contained_resources.changed.each do |_, resource|
+        resource.save
       end
     end
+
+    def contained_resources
+      @contained_resources ||= attached_files.merge(contained_rdf_sources)
+    end
+
+    def contained_rdf_sources
+      @contained_rdf_sources ||=
+        AssociationHash.new(self, self.class.contained_rdf_source_reflections)
+    end
   end
 end

data/lib/active_fedora/reflection.rb

@@ -41,7 +41,11 @@ module ActiveFedora
       end
 
       def child_resource_reflections
-        reflections.select { |_, reflection| reflection.kind_of?(AssociationReflection) && reflection.macro == :contains }
+        reflections.select { |_, reflection| reflection.kind_of?(AssociationReflection) && reflection.macro == :contains && reflection.klass <= ActiveFedora::File}
+      end
+
+      def contained_rdf_source_reflections
+        reflections.select { |_, reflection| reflection.kind_of?(AssociationReflection) && reflection.macro == :contains && !(reflection.klass <= ActiveFedora::File)}
       end
 
       # Returns the AssociationReflection object for the +association+ (use the symbol).

data/lib/active_fedora/relation/calculations.rb

@@ -8,12 +8,12 @@ module ActiveFedora
       opts = {}
       opts[:rows] = limit_value if limit_value
       opts[:sort] = order_values if order_values
-      
+
       calculate :count, where_values, opts
     end
 
     def calculate(calculation, conditions, opts={})
-      SolrService.query(create_query(conditions), :raw=>true, :rows=>0)['response']['numFound']
+      SolrService.query(create_query(conditions), raw: true, rows: 0).fetch('response'.freeze)['numFound'.freeze]
     end
   end
 end

data/lib/active_fedora/relation/finder_methods.rb

@@ -111,7 +111,7 @@ module ActiveFedora
       unless opts.include?(:sort)
         opts[:sort]=@klass.default_sort_params
       end
-      SolrService.query(create_query(conditions), opts) 
+      SolrService.query(create_query(conditions), opts)
     end
 
     # Yields the found ActiveFedora::Base object to the passed block
@@ -199,7 +199,7 @@ module ActiveFedora
         # The true class may be a subclass of @klass, so always use from_class_uri
         resource_class = Model.from_class_uri(has_model_value(resource)) || ActiveFedora::Base
         unless equivalent_class?(resource_class)
-          raise ActiveFedora::ActiveFedoraError.new("Model mismatch. Expected #{@klass}. Got: #{resource_class}") 
+          raise ActiveFedora::ActiveFedoraError.new("Model mismatch. Expected #{@klass}. Got: #{resource_class}")
         end
         resource_class
       end
@@ -254,45 +254,42 @@ module ActiveFedora
     private
 
     # Returns a solr query for the supplied conditions
-    # @param[Hash] conditions solr conditions to match
+    # @param[Hash,String,Array] conditions solr conditions to match
     def create_query(conditions)
-        case conditions
-        when Hash
-          build_query([create_query_from_hash(conditions)])
-        when String
-          build_query(["(#{conditions})"])
-        else
-          build_query(conditions)
-        end
+      build_query(build_where(conditions))
     end
 
+    # @param [Array<String>] conditions
     def build_query(conditions)
-      clauses = search_model_clause ?  [search_model_clause] : []
-      clauses += conditions.reject{|c| c.blank?}
+      clauses = search_model_clause ? [search_model_clause] : []
+      clauses += conditions.reject { |c| c.blank? }
       return "*:*" if clauses.empty?
       clauses.compact.join(" AND ")
     end
 
+    # @param [Hash<Symbol,String>] conditions
+    # @returns [Array<String>]
     def create_query_from_hash(conditions)
-      conditions.map {|key,value| condition_to_clauses(key, value)}.compact.join(" AND ")
+      conditions.map { |key, value| condition_to_clauses(key, value) }.compact
     end
 
+    # @param [Symbol] key
+    # @param [String] value
     def condition_to_clauses(key, value)
-      unless value.nil?
-        # if the key is a property name, turn it into a solr field
-        if @klass.delegated_attributes.key?(key)
-          # TODO Check to see if `key' is a possible solr field for this class, if it isn't try :searchable instead
-          key = ActiveFedora::SolrQueryBuilder.solr_name(key, :stored_searchable, type: :string)
-        end
+      SolrQueryBuilder.construct_query([[field_name_for(key), value]])
+    end
 
-        if value.empty?
-          "-#{key}:['' TO *]"
-        elsif value.is_a? Array
-          value.map { |val| "#{key}:#{solr_escape(val)}" }
-        else
-          key = SOLR_DOCUMENT_ID if (key === :id || key === :id)
-          "#{key}:#{solr_escape(value)}"
-        end
+    # If the key is a property name, turn it into a solr field
+    # @param [Symbol] key
+    # @return [String]
+    def field_name_for(key)
+      if @klass.delegated_attributes.key?(key)
+        # TODO Check to see if `key' is a possible solr field for this class, if it isn't try :searchable instead
+        ActiveFedora::SolrQueryBuilder.solr_name(key, :stored_searchable, type: :string)
+      elsif key == :id
+        SOLR_DOCUMENT_ID
+      else
+        key.to_s
       end
     end
 
@@ -306,13 +303,5 @@ module ActiveFedora
         clauses.size == 1 ? clauses.first : "(#{clauses.join(" OR ")})"
       end
     end
-
-
-    private
-      # Adds esaping for spaces which are not handled by RSolr.solr_escape
-      # See rsolr/rsolr#101
-      def solr_escape terms
-        RSolr.solr_escape(terms).gsub(/\s+/,"\\ ")
-      end
   end
 end

data/lib/active_fedora/relation/query_methods.rb

@@ -17,7 +17,7 @@ module ActiveFedora
     def where_values=(values)
       raise ImmutableRelation if @loaded
       @values[:where] = values
-    end   
+    end
 
     def order_values
       @values[:order] || []
@@ -62,11 +62,13 @@ module ActiveFedora
       self
     end
 
+    # @param [Hash,String] values
+    # @return [Array<String>] list of solr hashes
     def build_where(values)
       return [] if values.blank?
       case values
       when Hash
-        [create_query_from_hash(values)]
+        create_query_from_hash(values)
       when String
         ["(#{values})"]
       else
@@ -76,7 +78,7 @@ module ActiveFedora
 
     # Order the returned records by the field and direction provided
     #
-    # @option [Array<String>] args a list of fields and directions to sort by 
+    # @option [Array<String>] args a list of fields and directions to sort by
     #
     # @example
     #  Person.where(occupation_s: 'Plumber').order('name_t desc', 'color_t asc')

data/lib/active_fedora/solr_query_builder.rb

@@ -1,5 +1,7 @@
 module ActiveFedora
   module SolrQueryBuilder
+    PARSED_SUFFIX = '_tesim'.freeze
+
     # Construct a solr query for a list of ids
     # This is used to get a solr response based on the list of ids in an object's RELS-EXT relationhsips
     # If the id_array is empty, defaults to a query of "id:NEVER_USE_THIS_ID", which will return an empty solr response
@@ -29,18 +31,72 @@ module ActiveFedora
     #   # => _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"
     #
     #   construct_query_for_rel [[Book.reflect_on_association(:library), "foo/bar/baz"]]
-    def self.construct_query_for_rel(field_pairs, join_with = 'AND')
+    def self.construct_query_for_rel(field_pairs, join_with = ' AND ')
       field_pairs = field_pairs.to_a if field_pairs.kind_of? Hash
+      construct_query(property_values_to_solr(field_pairs), join_with)
+    end
 
-      clauses = pairs_to_clauses(field_pairs.reject { |_, target_uri| target_uri.blank? })
-      clauses.empty? ? "id:NEVER_USE_THIS_ID" : clauses.join(" #{join_with} ".freeze)
+    # Construct a solr query from a list of pairs (e.g. [field name, values])
+    # @param [Array<Array>] pairs a list of pairs of property name and values
+    # @param [String] join_with ('AND') the value we're joining the clauses with
+    # @returns [String] a solr query
+    # @example
+    #   construct_query([['library_id_ssim', '123'], ['owner_ssim', 'Fred']])
+    #   # => "_query_:\"{!raw f=library_id_ssim}123\" AND _query_:\"{!raw f=owner_ssim}Fred\""
+    def self.construct_query(field_pairs, join_with = ' AND ')
+      pairs_to_clauses(field_pairs).join(join_with)
     end
 
     private
-      # Given an list of 2 element lists, transform to a list of solr clauses
+      # @param [Array<Array>] pairs a list of (key, value) pairs. The value itself may
+      # @return [Array] a list of solr clauses
       def self.pairs_to_clauses(pairs)
-        pairs.map do |field, target_uri|
-          raw_query(solr_field(field), target_uri)
+        pairs.flat_map do |field, value|
+          condition_to_clauses(field, value)
+        end
+      end
+
+      # @param [String] field
+      # @param [String, Array<String>] values
+      # @return [Array<String>]
+      def self.condition_to_clauses(field, values)
+        values = Array(values)
+        values << nil if values.empty?
+        values.map do |value|
+          if value.present?
+            if parsed?(field)
+              # If you do a raw query on a parsed field you won't get the matches you expect.
+              "#{field}:#{solr_escape(value)}"
+            else
+              raw_query(field, value)
+            end
+          else
+            # Check that the field is not present. In SQL: "WHERE field IS NULL"
+            "-#{field}:[* TO *]"
+          end
+        end
+      end
+
+      def self.parsed?(field)
+        field.end_with?(PARSED_SUFFIX)
+      end
+
+      # Adds esaping for spaces which are not handled by RSolr.solr_escape
+      # See rsolr/rsolr#101
+      def self.solr_escape terms
+        RSolr.solr_escape(terms).gsub(/\s+/,"\\ ")
+      end
+
+      # Given a list of pairs (e.g. [field name, values]), convert the field names
+      # to solr names
+      # @param [Array<Array>] pairs a list of pairs of property name and values
+      # @returns [Hash] map of solr fields to values
+      # @example
+      #   property_values_to_solr([['library_id', '123'], ['owner', 'Fred']])
+      #   # => [['library_id_ssim', '123'], ['owner_ssim', 'Fred']]
+      def self.property_values_to_solr(pairs)
+        pairs.each_with_object([]) do |(property, value), list|
+          list << [solr_field(property), value]
         end
       end
 

data/lib/active_fedora/solr_service.rb

@@ -103,8 +103,8 @@ module ActiveFedora
 
       def query(query, args={})
         raw = args.delete(:raw)
-        args = args.merge(:q=>query, :qt=>'standard')
-        result = SolrService.instance.conn.get('select', :params=>args)
+        args = args.merge(q: query, qt: 'standard')
+        result = SolrService.instance.conn.get('select', params: args)
         return result if raw
         result['response']['docs']
       end

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "9.4.3"
+  VERSION = "9.5.0"
 end

data/spec/integration/contains_association_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+RSpec.describe ActiveFedora::Base do
+  before do
+    class Source < ActiveFedora::Base
+      contains :sub_resource, class_name: "Source"
+      property :title, predicate: ::RDF::DC.title, multiple: false
+    end
+  end
+  after do
+    Object.send(:remove_const, :Source)
+  end
+
+  describe "contains relationships" do
+    it "should be able to have RDF sources" do
+      s = Source.new
+      s.sub_resource.title = "Test"
+      expect(s.sub_resource).not_to be_persisted
+      expect{ s.save }.not_to raise_error
+      s.reload
+      expect(s.sub_resource.title).to eq "Test"
+      expect(s.sub_resource.uri).to eq s.uri.to_s + "/sub_resource"
+    end
+    it "should be able to add RDF sources" do
+      s = Source.create
+      s.sub_resource.title = "Test"
+      expect(s.sub_resource).not_to be_persisted
+      expect{ s.save }.not_to raise_error
+      s.reload
+      expect(s.sub_resource.title).to eq "Test"
+      expect(s.sub_resource.uri).to eq s.uri.to_s + "/sub_resource"
+    end
+  end
+end

data/spec/integration/scoped_query_spec.rb

@@ -30,7 +30,6 @@ describe "scoped queries" do
     Object.send(:remove_const, :ModelIntegrationSpec)
   end
 
-
   describe "When there is one object in the store" do
     let!(:test_instance) { ModelIntegrationSpec::Basic.create!()}
 
@@ -67,7 +66,7 @@ describe "scoped queries" do
         test_instance3.delete
       end
 
-      it "should query" do
+      it "queries" do
         field = ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string)
         expect(ModelIntegrationSpec::Basic.where(field => 'Beta')).to eq [test_instance1]
         expect(ModelIntegrationSpec::Basic.where('foo' => 'Beta')).to eq [test_instance1]
@@ -90,8 +89,13 @@ describe "scoped queries" do
         expect(ModelIntegrationSpec::Basic.where("foo:bar OR bar:baz").where_values).to eq ["(foo:bar OR bar:baz)"]
       end
 
-      it "should chain where queries" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string) => 'Peanuts').where("#{ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string)}:bar").where_values).to eq ["#{ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string)}:Peanuts", "(#{ActiveFedora::SolrQueryBuilder.solr_name('foo', type: :string)}:bar)"]
+      it "chains where queries" do
+        first_condition = { ActiveFedora::SolrQueryBuilder.solr_name('bar', type: :string) => 'Peanuts' }
+        second_condition = "foo_tesim:bar"
+        where_values = ModelIntegrationSpec::Basic.where(first_condition)
+                                                    .where(second_condition).where_values
+        expect(where_values).to eq ["bar_tesim:Peanuts",
+                                    "(foo_tesim:bar)"]
       end
 
       it "should chain count" do

data/spec/unit/attached_files_spec.rb

@@ -4,19 +4,24 @@ describe ActiveFedora::AttachedFiles do
   subject { ActiveFedora::Base.new }
   describe "contains" do
     before do
+      class Z < ActiveFedora::File
+      end
       class FooHistory < ActiveFedora::Base
          contains 'dsid', class_name: 'ActiveFedora::SimpleDatastream'
          contains 'complex_ds', autocreate: true, class_name: 'Z'
          contains 'thumbnail'
+         contains 'child_resource', class_name: 'ActiveFedora::Base'
       end
     end
     after do
+      Object.send(:remove_const, :Z)
       Object.send(:remove_const, :FooHistory)
     end
 
     it "should have a child_resource_reflection" do
       expect(FooHistory.child_resource_reflections).to have_key(:dsid)
       expect(FooHistory.child_resource_reflections).to have_key(:thumbnail)
+      expect(FooHistory.child_resource_reflections).not_to have_key(:child_resource)
     end
 
     it "should let you override defaults" do
@@ -34,6 +39,8 @@ describe ActiveFedora::AttachedFiles do
     before do
       @original_behavior = Deprecation.default_deprecation_behavior
       Deprecation.default_deprecation_behavior = :silence
+      class Z < ActiveFedora::File
+      end
       class FooHistory < ActiveFedora::Base
          has_metadata :name => 'dsid', type: ActiveFedora::SimpleDatastream
          has_metadata 'complex_ds', autocreate: true, type: 'Z'
@@ -42,6 +49,7 @@ describe ActiveFedora::AttachedFiles do
     after do
       Deprecation.default_deprecation_behavior = @original_behavior
       Object.send(:remove_const, :FooHistory)
+      Object.send(:remove_const, :Z)
     end
 
     it "should have a child_resource_reflection" do

data/spec/unit/file_spec.rb

@@ -39,6 +39,20 @@ describe ActiveFedora::File do
       it "sets the uri using the parent as the base" do
         expect(subject).to eq "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/1234/FOO1"
       end
+
+      context "and it's initialized with the URI" do
+        let(:file) { described_class.new(parent.uri+"/FOO1") }
+        it "works" do
+          expect(subject.to_s).to eq "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/1234/FOO1"
+        end
+      end
+
+      context "and it's initialized with an ID" do
+        let(:file) { described_class.new(parent.id+"/FOO1") }
+        it "works" do
+          expect(subject.to_s).to eq "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/1234/FOO1"
+        end
+      end
     end
 
     context "when the file doesn't have a uri" do