valkyrie 1.2.0.rc1 → 1.2.0.rc2

data/lib/valkyrie/persistence/postgres/persister.rb

@@ -7,21 +7,29 @@ module Valkyrie::Persistence::Postgres
     attr_reader :adapter
     delegate :resource_factory, to: :adapter
 
-    # @note (see Valkyrie::Persistence::Memory::Persister#initialize)
+    # @param [MetadataAdapter] adapter
     def initialize(adapter:)
       @adapter = adapter
     end
 
-    # (see Valkyrie::Persistence::Memory::Persister#save)
+    # Persists a resource within the database
+    # @param [Valkyrie::Resource] resource
+    # @return [Valkyrie::Resource] the persisted/updated resource
+    # @raise [Valkyrie::Persistence::StaleObjectError] raised if the resource
+    #   was modified in the database between been read into memory and persisted
     def save(resource:)
       orm_object = resource_factory.from_resource(resource: resource)
       orm_object.save!
       resource_factory.to_resource(object: orm_object)
     rescue ActiveRecord::StaleObjectError
-      raise Valkyrie::Persistence::StaleObjectError, resource.id.to_s
+      raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process."
     end
 
-    # (see Valkyrie::Persistence::Memory::Persister#save_all)
+    # Persists a set of resources within the database
+    # @param [Array<Valkyrie::Resource>] resources
+    # @return [Array<Valkyrie::Resource>] the persisted/updated resources
+    # @raise [Valkyrie::Persistence::StaleObjectError] raised if the resource
+    #   was modified in the database between been read into memory and persisted
     def save_all(resources:)
       resource_factory.orm_class.transaction do
         resources.map do |resource|
@@ -29,17 +37,20 @@ module Valkyrie::Persistence::Postgres
         end
       end
     rescue Valkyrie::Persistence::StaleObjectError
-      raise Valkyrie::Persistence::StaleObjectError
+      raise Valkyrie::Persistence::StaleObjectError, "One or more resources have been updated by another process."
     end
 
-    # (see Valkyrie::Persistence::Memory::Persister#delete)
+    # Deletes a resource persisted within the database
+    # @param [Valkyrie::Resource] resource
+    # @return [Valkyrie::Resource] the deleted resource
     def delete(resource:)
       orm_object = resource_factory.from_resource(resource: resource)
       orm_object.delete
       resource
     end
 
-    # (see Valkyrie::Persistence::Memory::Persister#wipe!)
+    # Deletes all resources of a specific Valkyrie Resource type persisted in
+    #   the database
     def wipe!
       resource_factory.orm_class.delete_all
     end

data/lib/valkyrie/persistence/postgres/query_service.rb

@@ -10,26 +10,34 @@ module Valkyrie::Persistence::Postgres
     attr_reader :resource_factory
     delegate :orm_class, to: :resource_factory
 
-    # @note (see Valkyrie::Persistence::Memory::QueryService#initialize)
+    # @param [ResourceFactory] resource_factory
     def initialize(resource_factory:)
       @resource_factory = resource_factory
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_all)
+    # Retrieve all records for the resource and construct Valkyrie Resources
+    #   for each record
+    # @return [Array<Valkyrie::Resource>]
     def find_all
       orm_class.all.lazy.map do |orm_object|
         resource_factory.to_resource(object: orm_object)
       end
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_all_of_model)
+    # Retrieve all records for a specific resource type and construct Valkyrie
+    #   Resources for each record
+    # @param [Class] model
+    # @return [Array<Valkyrie::Resource>]
     def find_all_of_model(model:)
       orm_class.where(internal_resource: model.to_s).lazy.map do |orm_object|
         resource_factory.to_resource(object: orm_object)
       end
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_by)
+    # Find a record using a Valkyrie ID, and map it to a Valkyrie Resource
+    # @param [Valkyrie::ID, String] id
+    # @return [Valkyrie::Resource]
+    # @raise [Valkyrie::Persistence::ObjectNotFoundError]
     def find_by(id:)
       id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
       validate_id(id)
@@ -38,7 +46,10 @@ module Valkyrie::Persistence::Postgres
       raise Valkyrie::Persistence::ObjectNotFoundError
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_by_alternate_identifier)
+    # Find and a record using a Valkyrie ID for an alternate ID, and construct
+    #   a Valkyrie Resource
+    # @param [Valkyrie::ID] alternate_identifier
+    # @return [Valkyrie::Resource]
     def find_by_alternate_identifier(alternate_identifier:)
       alternate_identifier = Valkyrie::ID.new(alternate_identifier.to_s) if alternate_identifier.is_a?(String)
       validate_id(alternate_identifier)
@@ -46,7 +57,10 @@ module Valkyrie::Persistence::Postgres
       run_query(find_inverse_references_query, internal_array).first || raise(Valkyrie::Persistence::ObjectNotFoundError)
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_many_by_ids)
+    # Find records using a set of Valkyrie IDs, and map each to Valkyrie
+    #   Resources
+    # @param [Array<Valkyrie::ID>] ids
+    # @return [Array<Valkyrie::Resource>]
     def find_many_by_ids(ids:)
       ids.map! do |id|
         id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
@@ -59,7 +73,10 @@ module Valkyrie::Persistence::Postgres
       end
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_members)
+    # Find all member resources for a given Valkyrie Resource
+    # @param [Valkyrie::Resource] resource
+    # @param [Class] model
+    # @return [Array<Valkyrie::Resource>]
     def find_members(resource:, model: nil)
       return [] if resource.id.blank?
       if model
@@ -69,30 +86,56 @@ module Valkyrie::Persistence::Postgres
       end
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_parents)
+    # Find all parent resources for a given Valkyrie Resource
+    # @param [Valkyrie::Resource] resource
+    # @return [Array<Valkyrie::Resource>]
     def find_parents(resource:)
       find_inverse_references_by(resource: resource, property: :member_ids)
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_references_by)
+    # Find all resources related to a given Valkyrie Resource by a property
+    # @param [Valkyrie::Resource] resource
+    # @param [String] property
+    # @return [Array<Valkyrie::Resource>]
     def find_references_by(resource:, property:)
       return [] if resource.id.blank? || resource[property].blank?
-      run_query(find_references_query, property, resource.id.to_s)
+      # only return ordered if needed to avoid performance penalties
+      if ordered_property?(resource: resource, property: property)
+        run_query(find_ordered_references_query, property, resource.id.to_s)
+      else
+        run_query(find_references_query, property, resource.id.to_s)
+      end
     end
 
-    # (see Valkyrie::Persistence::Memory::QueryService#find_inverse_references_by)
+    # Find all resources referencing a given Valkyrie Resource by a property
+    # @param [Valkyrie::Resource] resource
+    # @param [String] property
+    # @return [Array<Valkyrie::Resource>]
     def find_inverse_references_by(resource:, property:)
       ensure_persisted(resource)
       internal_array = "{\"#{property}\": [{\"id\": \"#{resource.id}\"}]}"
       run_query(find_inverse_references_query, internal_array)
     end
 
+    # Execute a query in SQL for resource records and map them to Valkyrie
+    #   Resources
+    # @param [String] query
+    # @return [Array<Valkyrie::Resource>]
     def run_query(query, *args)
       orm_class.find_by_sql(([query] + args)).lazy.map do |object|
         resource_factory.to_resource(object: object)
       end
     end
 
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   resource ID as an argument.
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # @note this uses a CROSS JOIN for all combinations of member IDs with the
+    #   IDs of their parents
+    # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+    # This also uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
     def find_members_query
       <<-SQL
         SELECT member.* FROM orm_resources a,
@@ -102,6 +145,15 @@ module Valkyrie::Persistence::Postgres
       SQL
     end
 
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   resource ID and resource type as arguments.
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # @note this uses a CROSS JOIN for all combinations of member IDs with the
+    #   IDs of their parents
+    # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+    # This also uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
     def find_members_with_type_query
       <<-SQL
         SELECT member.* FROM orm_resources a,
@@ -112,6 +164,12 @@ module Valkyrie::Persistence::Postgres
       SQL
     end
 
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   JSON object literal as an argument (e. g. { "alternate_ids": [{"id": "d6e88f80-41b3-4dbf-a2a0-cd79e20f6d10"}] }).
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # This uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
     def find_inverse_references_query
       <<-SQL
         SELECT * FROM orm_resources WHERE
@@ -119,6 +177,15 @@ module Valkyrie::Persistence::Postgres
       SQL
     end
 
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   JSON object literal and resource ID as arguments.
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # @note this uses a CROSS JOIN for all combinations of member IDs with the
+    #   IDs of their parents
+    # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+    # This also uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
     def find_references_query
       <<-SQL
         SELECT member.* FROM orm_resources a,
@@ -127,22 +194,47 @@ module Valkyrie::Persistence::Postgres
       SQL
     end
 
+    def find_ordered_references_query
+      <<-SQL
+        SELECT member.* FROM orm_resources a,
+        jsonb_array_elements(a.metadata->?) WITH ORDINALITY AS b(member, member_pos)
+        JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
+        ORDER BY b.member_pos
+      SQL
+    end
+
+    # Constructs a Valkyrie::Persistence::CustomQueryContainer using this query service
+    # @return [Valkyrie::Persistence::CustomQueryContainer]
     def custom_queries
       @custom_queries ||= ::Valkyrie::Persistence::CustomQueryContainer.new(query_service: self)
     end
 
     private
 
+      # Determines whether or not an Object is a Valkyrie ID
+      # @param [Object] id
+      # @raise [ArgumentError]
       def validate_id(id)
         raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
       end
 
+      # Determines whether or not a resource has been persisted
+      # @param [Object] resource
+      # @raise [ArgumentError]
       def ensure_persisted(resource)
         raise ArgumentError, 'resource is not saved' unless resource.persisted?
       end
 
+      # Accesses the data type in PostgreSQL used for the primary key
+      # (For example, a UUID)
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaCache.html#method-i-columns_hash
+      # @return [Symbol]
       def id_type
         @id_type ||= orm_class.columns_hash["id"].type
       end
+
+      def ordered_property?(resource:, property:)
+        resource.class.schema[property].meta.try(:[], :ordered)
+      end
   end
 end

data/lib/valkyrie/persistence/postgres/resource_converter.rb

@@ -5,11 +5,16 @@ module Valkyrie::Persistence::Postgres
   class ResourceConverter
     delegate :orm_class, to: :resource_factory
     attr_reader :resource, :resource_factory
+
+    # @param [Valkyrie::Resource] resource
+    # @param [ResourceFactory] resource_factory
     def initialize(resource, resource_factory:)
       @resource = resource
       @resource_factory = resource_factory
     end
 
+    # Converts the Valkyrie Resource into an ActiveRecord object
+    # @return [ORM::Resource]
     def convert!
       orm_class.find_or_initialize_by(id: resource.id && resource.id.to_s).tap do |orm_object|
         orm_object.internal_resource = resource.internal_resource
@@ -18,6 +23,10 @@ module Valkyrie::Persistence::Postgres
       end
     end
 
+    # Retrieves the optimistic lock token from the Valkyrie attribute value and
+    #   sets it to the lock_version on ORM resource
+    # @see https://api.rubyonrails.org/classes/ActiveRecord/Locking/Optimistic.html
+    # @param [ORM::Resource] orm_object
     def process_lock_token(orm_object)
       return unless resource.respond_to?(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK)
       postgres_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find do |token|
@@ -29,6 +38,7 @@ module Valkyrie::Persistence::Postgres
 
     # Convert attributes to all be arrays to better enable querying and
     # "changing of minds" later on.
+    # @return [Hash]
     def attributes
       Hash[
         resource.attributes.except(:id, :internal_resource, :created_at, :updated_at).compact.map do |k, v|

data/lib/valkyrie/persistence/postgres/resource_factory.rb

@@ -7,6 +7,8 @@ module Valkyrie::Persistence::Postgres
   class ResourceFactory
     attr_reader :adapter
     delegate :id, to: :adapter, prefix: true
+
+    # @param [MetadataAdapter] adapter
     def initialize(adapter:)
       @adapter = adapter
     end
@@ -27,6 +29,7 @@ module Valkyrie::Persistence::Postgres
 
     # Accessor for the ActiveRecord class which all Postgres resources are an
     # instance of.
+    # @return [Class]
     def orm_class
       ::Valkyrie::Persistence::Postgres::ORM::Resource
     end

data/lib/valkyrie/persistence/solr/composite_indexer.rb

@@ -6,21 +6,31 @@ module Valkyrie::Persistence::Solr
   # @see https://en.wikipedia.org/wiki/Composite_pattern
   class CompositeIndexer
     attr_reader :indexers
+
+    # @param [Array<Object>] indexers
     def initialize(*indexers)
       @indexers = indexers
     end
 
+    # Construct a new Instance object
+    # @param [Valkyrie::Resource] resource
     def new(resource:)
       Instance.new(indexers, resource: resource)
     end
 
+    # Class providing the common method interface for the Indexer
     class Instance
       attr_reader :indexers, :resource
+
+      # @param [Array<Object>] indexers
+      # @param [Valkyrie::Resource] resource
       def initialize(indexers, resource:)
         @resource = resource
         @indexers = indexers.map { |i| i.new(resource: resource) }
       end
 
+      # Generate the Solr Documents from the indexers
+      # @return [Array<Hash>]
       def to_solr
         indexers.map(&:to_solr).inject({}, &:merge)
       end

data/lib/valkyrie/persistence/solr/metadata_adapter.rb

@@ -50,6 +50,9 @@ module Valkyrie::Persistence::Solr
       )
     end
 
+    # Generate the Valkyrie ID for this unique metadata adapter
+    # This uses the URL of the Solr endpoint to ensure that this is unique
+    # @return [Valkyrie::ID]
     def id
       @id ||= Valkyrie::ID.new(Digest::MD5.hexdigest(connection.base_uri.to_s))
     end
@@ -60,9 +63,13 @@ module Valkyrie::Persistence::Solr
       Valkyrie::Persistence::Solr::ResourceFactory.new(resource_indexer: resource_indexer, adapter: self)
     end
 
+    # Class modeling the indexer for cases where indexing is *not* performed
     class NullIndexer
+      # @note this is a no-op
       def initialize(_); end
 
+      # Generate the Solr hash
+      # @return [Hash] this will be empty
       def to_solr
         {}
       end

data/lib/valkyrie/persistence/solr/model_converter.rb

@@ -5,20 +5,31 @@ module Valkyrie::Persistence::Solr
   class ModelConverter
     attr_reader :resource, :resource_factory
     delegate :resource_indexer, to: :resource_factory
+
+    # @param [Valkyrie::Resource] resource
+    # @param [ResourceFactory] resource_factory
     def initialize(resource, resource_factory:)
       @resource = resource
       @resource_factory = resource_factory
     end
 
+    # Converts the Valkyrie Resource to the Solr Document
+    # @note this modifies the Solr Document for the conversion
+    # @return [Hash] the Solr Document for the Valkyrie Resource
     def convert!
+      # Appends the resource type to the Solr Document
       to_h.merge(Valkyrie::Persistence::Solr::Queries::MODEL.to_sym => [resource.internal_resource])
           .merge(indexer_solr(resource))
     end
 
+    # Generate the Solr Document for a Valkyrie Resource using the indexer
+    # @param [Valkyrie::Resource] resource
+    # @return [Hash] the Solr Document as a Hash
     def indexer_solr(resource)
       resource_indexer.new(resource: resource).to_solr
     end
 
+    # Access the ID for the Valkyrie Resource being converted to a Solr Document
     # @return [String] The solr document ID
     def id
       resource.id.to_s
@@ -45,6 +56,10 @@ module Valkyrie::Persistence::Solr
 
     private
 
+      # Maps Solr Document fields to attributes with single values
+      # Filters for fields which store the Valkyrie resource type
+      # @param [Hash] attribute_hash
+      # @return [Hash]
       def add_single_values(attribute_hash)
         attribute_hash.select do |k, v|
           field = k.to_s.split("_").last
@@ -56,15 +71,25 @@ module Valkyrie::Persistence::Solr
         end
       end
 
+      # Determines whether or not a field is multivalued
+      # @note this is tied to conventions in the Solr Schema
+      # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
+      # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
+      # @param [String] field
+      # @return [Boolean]
       def multivalued?(field)
         field.end_with?('m', 'mv')
       end
 
+      # If optimistic locking is enabled for this Valkyrie Resource, generates a Hash containing the locking token
+      # @return [Hash]
       def lock_hash
         return {} unless resource.optimistic_locking_enabled? && lock_token.present?
         { _version_: lock_token }
       end
 
+      # Retrieves the lock token from the resource attributes
+      # @return [String]
       def lock_token
         @lock_token ||= begin
           found_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
@@ -74,6 +99,8 @@ module Valkyrie::Persistence::Solr
         end
       end
 
+      # Generates the Valkyrie Resource attribute Hash
+      # @return [Hash]
       def attribute_hash
         properties.each_with_object({}) do |property, hsh|
           next if property == Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK
@@ -87,10 +114,14 @@ module Valkyrie::Persistence::Solr
         end
       end
 
+      # Accesses the keys for the attributes on the Valkyrie Resource
+      # @return [Array<Symbol>]
       def properties
         resource_attributes.keys - [:id, :created_at, :updated_at, :new_record]
       end
 
+      # Access the attributes for the Valkyrie resources
+      # @return [Hash]
       def resource_attributes
         @resource_attributes ||= resource.attributes
       end
@@ -143,10 +174,14 @@ module Valkyrie::Persistence::Solr
       # just one.
       class CompositeSolrRow
         attr_reader :solr_rows
+
+        # @param [Array<Valkyrie::Persistence::Solr::Mapper::SolrRow>] solr_rows
         def initialize(solr_rows)
           @solr_rows = solr_rows
         end
 
+        # Merge a Hash of attribute values into a logical row of Solr fields
+        # @param [Hash] hsh
         # @see Valkyrie::Persistence::Solr::Mapper::SolrRow#apply_to
         def apply_to(hsh)
           solr_rows.each do |solr_row|
@@ -163,10 +198,17 @@ module Valkyrie::Persistence::Solr
       # Casts {Boolean} values into a recognizable string in Solr.
       class BooleanPropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value behaves like a boolean value
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && ([true, false].include? value.value)
         end
 
+        # Constructs a SolrRow object for a Property with a Boolean value
+        # @note this prepends the string "boolean-" to the value indexed in Solr
+        # @return [SolrRow]
         def result
           calling_mapper.for(Property.new(value.key, "boolean-#{value.value}")).result
         end
@@ -175,10 +217,20 @@ module Valkyrie::Persistence::Solr
       # Casts nested resources into a JSON string in solr.
       class NestedObjectValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is a Hash
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.value.is_a?(Hash)
         end
 
+        # Constructs a SolrRow object for a Property with a Hash value
+        # @note this prepends the string "serialized-" to the value indexed in Solr
+        # This is indexed as a stored multivalued text
+        # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
+        # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
+        # @return [SolrRow]
         def result
           SolrRow.new(key: value.key, fields: ["tsim"], values: "serialized-#{value.value.to_json}")
         end
@@ -187,10 +239,16 @@ module Valkyrie::Persistence::Solr
       # Casts enumerable values one by one.
       class EnumerableValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is an Array
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(Array)
         end
 
+        # Constructs a CompositeSolrRow object for a set of Property values
+        # @return [CompositeSolrRow]
         def result
           CompositeSolrRow.new(
             value.value.map do |val|
@@ -203,10 +261,16 @@ module Valkyrie::Persistence::Solr
       # Skips nil values.
       class NilPropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value responds as nil
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && value.value.nil?
         end
 
+        # Constructs a SolrRow object for a Property with a nil value
+        # @return [SolrRow]
         def result
           SolrRow.new(key: value.key, fields: [], values: nil)
         end
@@ -215,10 +279,17 @@ module Valkyrie::Persistence::Solr
       # Casts {Valkyrie::ID} values into a recognizable string in solr.
       class IDPropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is a Valkyrie ID
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(::Valkyrie::ID)
         end
 
+        # Constructs a SolrRow object for the Property Valkyrie ID value
+        # @note this prepends the string "id-" to the value indexed in Solr
+        # @return [SolrRow]
         def result
           calling_mapper.for(Property.new(value.key, "id-#{value.value.id}")).result
         end
@@ -227,10 +298,17 @@ module Valkyrie::Persistence::Solr
       # Casts {RDF::URI} values into a recognizable string in solr.
       class URIPropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is a URI
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(::RDF::URI)
         end
 
+        # Constructs a SolrRow object for the Property URI value
+        # @note this prepends the string "uri-" to the value indexed in Solr
+        # @return [SolrRow]
         def result
           calling_mapper.for(Property.new(value.key, "uri-#{value.value}")).result
         end
@@ -239,28 +317,57 @@ module Valkyrie::Persistence::Solr
       # Casts {Integer} values into a recognizable string in Solr.
       class IntegerPropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is an Integer
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(Integer)
         end
 
+        # Constructs a SolrRow object for the Property Integer value
+        # @note this prepends the string "integer-" to the value indexed in Solr
+        # @return [SolrRow]
         def result
           calling_mapper.for(Property.new(value.key, "integer-#{value.value}")).result
         end
       end
 
+      # Casts {Float} values into a recognizable string in Solr.
+      class FloatPropertyValue < ::Valkyrie::ValueMapper
+        SolrMapperValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(Float)
+        end
+
+        def result
+          calling_mapper.for(Property.new(value.key, "float-#{value.value}")).result
+        end
+      end
+
       # Casts {DateTime} values into a recognizable string in Solr.
       class DateTimePropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is a DateTime or Time
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && (value.value.is_a?(Time) || value.value.is_a?(DateTime))
         end
 
+        # Constructs a SolrRow object for a datestamp derived from the value
+        # @note this prepends the string "datetime-" to the value indexed in Solr
+        # @return [SolrRow]
         def result
           calling_mapper.for(Property.new(value.key, "datetime-#{JSON.parse(to_datetime(value.value).to_json)}")).result
         end
 
         private
 
+          # Converts a value to a UTC timestamp if it is a DateTime or behaves like a Time value
+          # @param [Object] value
+          # @return [Time]
           def to_datetime(value)
             return value.utc if value.is_a?(DateTime)
             return value.to_datetime.utc if value.respond_to?(:to_datetime)
@@ -272,10 +379,16 @@ module Valkyrie::Persistence::Solr
       # for non-language-tagged strings.
       class SharedStringPropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is a String whether or not the Property has an RDF literal specifying the language tag
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(String) && value.scope.find { |x| x.is_a?(::RDF::Literal) }.present?
         end
 
+        # Constructs a CompositeSolrRow object with the language-tagged literal value
+        # @return [CompositeSolrRow]
         def result
           CompositeSolrRow.new(
             [
@@ -290,14 +403,32 @@ module Valkyrie::Persistence::Solr
       # Handles casting strings.
       class StringPropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is a String
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(String)
         end
 
+        # Constructs a SolrRow object with the String values and Solr field settings
+        # @return [SolrRow]
         def result
           SolrRow.new(key: value.key, fields: fields, values: value.value)
         end
 
+        # Generates the Solr fields used during the indexing
+        # String are normally indexed using the following:
+        #   - stored text
+        #   - stored english text
+        #   - stored single string
+        #   - multivalued string
+        #   - stored multivalued text
+        #   - stored multivalued english text
+        # If the string is greater than 1000 characters in length, it is only indexed as a stored multivalued text
+        # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
+        # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
+        # @return [Array<Symbol>]
         def fields
           if value.value.length > 1000
             [:tsim]
@@ -310,10 +441,16 @@ module Valkyrie::Persistence::Solr
       # Handles casting language-typed {RDF::Literal}s
       class LiteralPropertyValue < ::Valkyrie::ValueMapper
         SolrMapperValue.register(self)
+
+        # Determines whether or not a Property value is an RDF literal
+        # @param [Object] value
+        # @return [Boolean]
         def self.handles?(value)
           value.is_a?(Property) && value.value.is_a?(::RDF::Literal)
         end
 
+        # Constructs a CompositeSolrRow object with the language-tagged literal value
+        # @return [CompositeSolrRow]
         def result
           key = value.key
           val = value.value