kithe 2.0.3 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fe55cd9eb6b6f323f8a64418420a91a3d3cc99baa677a006e72608d3e05ccaf
-  data.tar.gz: 167d25b42b8a490d4c8bd3e7fbdf8756560b9bcbdc9c684bc17db854dce3897a
+  metadata.gz: 6f3d3c39a3bdccd9fc97f8f5e16c94cf12d4926e7ca50cc5e3343406ad3044d3
+  data.tar.gz: 2bd6fc9c175d4ec213e58460fbb95b5c40b49ca1ae5808e77df26932cf60474a
 SHA512:
-  metadata.gz: f1cb5e7242f6fffcda9b0be4894f24251470b919204faf355f694f245863acd9a9c5e1ce9f67abd3c3cfb9b3ba01a8b7235d45ce8a9b22349ee8d03d1e7dbe67
-  data.tar.gz: fe8af824a5dc4f5af3719d12a109eff834cd260f647d668eba452c8aa88bbe61ac7b33c81206cbd1ec95169e260c312934843f820ee556a5c0452fc767bdb42a
+  metadata.gz: 55c9e6eb14e975a46927fa01b4c7a8a67ca1b804ae7662f2e34e7878ee0a3247b944395edf93e311f7c39b640392ddd5b74a3df77381ba5f761e78f883e48dfa
+  data.tar.gz: 730f6f1d20d45d7973d2c340e15889d6f2b56295f70eec8703a1e1b666ba078357b1d1ec2e34fa14ca5575ff17032f52340ffba3070e2b16e3da35012c5e8d9e

data/README.md

@@ -7,72 +7,69 @@ An experiment in shareable tools/components for building a digital collections a
 
 Kithe is a toolkit for building digital collections/repository applications in Rails. It comes out of experience in the [samvera](https://samvera.org/) community of open source library-archives-museums digital collections/preservation work (but is not a samvera project).
 
-Kithe does not use fedora or valkyrie, but stores all metadata using ActiveRecord.  Kithe requires you use postgres 9.5+ as your db. While kithe provides some additional architecture and support on top of "ordinary" ActiveRecord, it tries to mostly let you develop as you would any Rails app, inclduing all choices and you'd normally have, and taking advantage of standard ActiveRecord-based functionality.  Kithe bases it's file handling framework on [shrine](https://shrinerb.com), supporting cloud or local file storage.
+Kithe does not use fedora or valkyrie, but stores all metadata using ActiveRecord.  Kithe requires you use postgres 9.5+ as your db. It uses [shrine](https://shrinerb.com) for file-handling/asset-storing and tries to support developing your app as a normal Rails/ActiveRecord app. It will not give you a working turnkey application, but is a collection of tools for building an app with certain patterns.
 
-Kithe will not give you a working "turnkey" application. It is a collection of tools to help you write a Rails app. You may end up using some but not all of kithe's tools.  The range of tools provided and areas of an app given some support in kithe will probably grow over time, in hopefully a careful and cautious way.
+Kithe provides tools to supports these architectural patterns:
 
-In that it provides tools and not a turnkey app, develping an app based on kythe in some ways similar to developing an app based on [valkyrie](https://github.com/samvera-labs/valkyrie). They both provide basic architecture for modelling/persistence, although in quite different ways. Kithe also provides tools in addition to modelling/persistence, but does _not_ provide the data-mapper/repository pattern valkyrie does, or any built-in abstraction for persisting anywhere but a postgres DB.
+* [Modelling and Persistence](./guides/modelling.md):
+  * A Collection/Work/Asset model based on Samvera/PCDM, using rails Single-Table Inheritance to support hetereogenous associations with efficient rdbms lookup.
+  * Using Postgres JSONB for "schema-less" flexible storage, via [attr_json](https://github.com/jrochkind/attr_json), supporting complex structured nested repeatable data values.
+  * [Work representatives](./guides/work_representative.md) via ActiveRecord association, using postgres recursive CTE's to compute the "leaf" representative, designed to support efficient use of the DB including pre-loading leaf representatives.
+  * UUIDv4's as internal primary keys, but also provide a "friendlier_id" with a shorter unique alphanumeric identifier for URLs and other UI. By default they are supplied by a postgres stored procedure, but your code can set them to whatever you like.
 
-If you are comparing it to a "solution bundle" digital collections platform, kithe may seem like more work. But experience has shown me that in our domain, historically "solution bundles" can be less of a "turnkey" approach than they seem, and can have greater development cost over total app lifecycle than anticipated. If you have similar experience that leads you to consider a more 'bespoke' app approach -- you may want to consider kithe. We hope to provide architecturally simple support and standardization for your custom app, taking care of some of the common "hard parts" and leaving you with flexibility to build out the app that meets your needs.
+* [Form support](./guides/forms.md):  Easy Rails-like forms for that complex nested and repeatable form data, leaning on simple_form.
+  * An extension to Rails "strong parameters" that make some common patterns for
+    embedded JSON attributes more convenient, [Kithe::Parameters](./app/models/kithe/parameters.rb)
 
-Kithe has beeen developed in tandem with the Science History Institute's in-development [replacement digital collections](https://github.com/sciencehistory/scihist_digicoll) app, and you can look there for a model/canonical/demo kithe use.
+* [File handling](./guides/file_handling.md): A framework that let's you easily plug in your own custom characterization and derivatives handling, to be handled in an efficient and flexible way, ordinarily using background jobs. Implemented on top of [shrine](https://shrinerb.com).
+  * [Derivatives](./guides/derivatives.md) handling ensures data consistency without race conditions, and efficient querying patterns, letting you plugin custom derivatives creation, with some standard routines included.
 
-The Science History Institute app is live and working, so kithe is 1.0. We are serious about [semantic verisioning](https://semver.org/) and will endeavor to release backwards breaking changes only with a major release, and minimize major releases.
-
-While it is working well for us, since it hasn't had wide use, it could still be considered somewhat of an experiment. But you are invited to try it out and see how it works. You are welcome to use it, but also welcome to copy any code or just ideas from kithe.
-
-Any questions or feedback of any kind are very welcome and encouraged, in the github project issues, samvera slack, or wherever is convenient.
-
-
-# Kithe parts
-
-Some guide documentation is available to explain each of kithe's major functionality areas. Definitely start with the modelling guide.
+* [Solr Indexing](./guides/solr_indexing.md): Built-in Solr indexing using [traject](https://github.com/traject/traject) for defining mappings from your model objects to what you want in a Solr index. Uses ActiveRecord callbacks to automatically sync saves to solr, with many opportunities for customization.
+  * Not coupled to any other kithe components, could be used independently, hypothetically on any ActiveRecord model.
 
-* [Modelling and Persistence](./guides/modelling.md):  It can be somewhwat challenging to figure out a good way to model our data in an rdbms. We give you a hopefully flexible and understandable architecture that is designed to support efficient performance. It's influenced by PCDM and traditional samvera modelling. It's based on [attr_json](https://github.com/jrochkind/attr_json) to let you model arbitrary and complex object-oriented data that gets persisted as a serialized json hash. It uses rails Single Table Inheritance to support hetereogenous associations and collections. The modelling classes in some places use postgres-specific features for efficiency.
+* A [recommended approach for using Blacklight](./guides/blacklight_approach.md) with search result view templates based on actual ActiveRecord models. Blacklight use is optional with kithe, but kithe works well with blacklight.
 
-  * [Work representatives](./guides/work_representative.md). Built in associations to support "representative", using postgres recursive CTE's to compute the "leaf" representative, designed to support efficient use of the DB including pre-loading leaf representatives.
+* Assorted optional utilities
+  * [Kithe::ConfigBase](./app/models/kithe/config_base.rb) A totally optional solution for managing environmental config variables.
 
-  * Kithe objects use UUIDv4's as internal primary keys, but also provide a "friendlier_id" with a shorter unique alphanumeric identifier for URLs and other UI. By default they are supplied by a postgres stored procedure, but your code can set them to whatever you like.
+  * [ArrayInclusionValdaitor](./app/validators/array_inclusion_validator.rb) Useful for validating on attr_json arrays of primitives.
 
-* [Form support](./guides/forms.md): Dealing with complex and _repeatable_ data, as our modelling layer allows, can be tricky in an HTML form. We supply javascript-backed Rails form input help for repeatable and compound/nested data.
+## Setting up your app to use kithe
 
-* [File handling](./guides/file_handling.md): Handling files is at the core of digital repository use cases. We need a file handling framework that is flexible, predictable and reliable, and architected for performance. We try to give you one based on the [shrine](https://shrinerb.com) file attachment toolkit for ruby.
+So you want to start an app that uses kithe. We should later provide better 'getting started' guide. For now some sketchy notes:
 
-  * [Derivatives](./guides/derivatives.md) A flexible and reliable derivatives architecture, designed to ensure data consistency without race conditions, and support efficient DB usage patterns.
+* Again re-iterate that kithe requires your Rails app use postgres, 9.5+.
 
-* [Solr Indexing](./guides/solr_indexing.md): Uses [traject](https://github.com/traject/traject) for defining mappings from your model objects to what you want in a Solr index. Uses ActiveRecord callbacks to automatically sync saves to solr, with many opportunities for customization.
-  * Not coupled to any other kithe components, could be used independently, hypothetically on any ActiveRecord model.
-  * Written after review of "prior art"  in [sunspot](https://github.com/sunspot/sunspot) and [searchkick](https://github.com/ankane/searchkick) (which both used AR callback-based indexing), and others.
+* kithe works with Rails 5.2 through 6.1.
 
-* A [recommended approach for using Blacklight](./guides/blacklight_approach.md) with search result view templates based on actual ActiveRecord models. It is totally optional to use Blacklight at all with kithe, or to use this approach if you do.
+* To install migrations from kithe to setup your database for it's models: `rake kithe_engine:install:migrations`
 
-### Also
+* Kithe view support generally assumes your app uses bootstrap 4, and uses [simple form](https://github.com/plataformatec/simple_form) configured with bootstrap settings. See https://github.com/plataformatec/simple_form#bootstrap . So you should install simple_form and bootstrap 4.
 
-* [Kithe::Parameters](./app/models/kithe/parameters.rb) provides some shortcuts around Rails "strong params" for attr_json serialized attributes.
+* Specific additional pre-requisites/requirements can sometimes be found in individual feature docs. And include the Javascript from [cocoon](https://github.com/nathanvda/cocoon), for form support for repeatable-field editing forms. We haven't quite figured out our preferred sane approach for sharing Javascript via kithe.
 
-* [Kithe::ConfigBase](./app/models/kithe/config_base.rb) A totally optional solution for managing environmental config variables.
 
-* [ArrayInclusionValdaitor](./app/validators/array_inclusion_validator.rb) Useful for validating on attr_json arrays of primitives.
+## Why kithe?
 
-## Setting up your app to use kithe
+Kithe tries to let you develop your app like "an ordinary Rails app" (in all it's possible variations), while handling some of the rough spots common to the kinds of modelling and administration common to digital collections domains.  But developers should be able to use standard Rails patterns and skills to develop an app to your specific local needs, familiar, no more complicated than building any other Rails app. You add features to a kithe app just like building Rails, using whatever patterns you like. We support modern Rails versions, 5.2+.
 
-So you want to start an app that uses kithe. We should later provide better 'getting started' guide. For now some sketchy notes:
+In that kithe provides tools and not a turnkey app, develping an app based on kythe in some ways similar to developing an app based on [valkyrie](https://github.com/samvera-labs/valkyrie) (but not hyrax). They both provide basic architecture for modelling/persistence, although in quite different ways. Kithe also provides tools in addition to modelling/persistence, but does _not_ provide the data-mapper/repository pattern valkyrie does, or any built-in abstraction for persisting anywhere but a postgres DB.
 
-* Again re-iterate that kithe requires your Rails app use postgres, 9.5+.
+If you are comparing it to a "solution bundle" digital collections platform like hyrax, kithe may seem like more work. But experience has shown us that in our domain, "solution bundles" can turn out less of a "turnkey" approach than they seem, and can have greater development cost over total app lifecycle than anticipated. If you have similar experience that leads you to consider a more 'bespoke' app approach -- you may want to consider kithe. We hope to provide architecturally simple support and standardization for your custom app, taking care of some of the common "hard parts" and leaving you with flexibility to build out the app that meets your needs.
 
-* kithe works with Rails 5.2 through 6.1.
+Kithe has beeen developed in tandem with the Science History Institute's in-development [replacement digital collections](https://github.com/sciencehistory/scihist_digicoll) app, which has been in production for several years using kithe.
 
-* To install migrations from kithe to setup your database for it's models: `rake kithe_engine:install:migrations`
+[The University of Minnesota found kithe](https://docs.google.com/presentation/d/1Z4AoIDOaxbY4pt3mDhNt6MfUs6VIMjysKKmaYQpjuk8/edit?usp=sharing) to pair well with GeoBlacklight, an easy way to provide the persistence layer and metadata editing UI that blacklight on it's own lacks.
 
-* Kithe view support generally assumes your app uses bootstrap 4, and uses [simple form](https://github.com/plataformatec/simple_form) configured with bootstrap settings. See https://github.com/plataformatec/simple_form#bootstrap . So you should install simple_form and bootstrap 4.
+We are serious about [semantic verisioning](https://semver.org/) and will endeavor to release backwards breaking changes only with a major release, and minimize major releases.
 
-* Specific additional pre-requisites/requirements can sometimes be found in individual feature docs. And include the Javascript from [cocoon](https://github.com/nathanvda/cocoon), for form support for repeatable-field editing forms. We haven't quite figured out our preferred sane approach for sharing Javascript via kithe.
+Kithe is working well for us, but has had limited (but non-zero) adoption from other institutions. It's still somewhat of an experiment, but one we think is going well. If you would consider developing a digital collections/repository app in "just Rails", we think it's worth investigating if kithe can save you some trouble in some rough common use cases. You are invited to try it out and see how it works, using kithe directly, or copying any code or just ideas from kithe.
 
-Note that at present kithe will end up forcing your app to use `:sql` [style schema dumps](https://guides.rubyonrails.org/v3.2.8/migrations.html#types-of-schema-dumps). We may try to fix this.
+Any questions or feedback of any kind are very welcome and encouraged!  In the github project issues, samvera slack, or wherever is convenient.
 
 ## To be done
 
-Considering some blacklight integration support.
+Considering some additional blacklight integration support, is any needed?
 
 Other components/features may become more clear as we continue to develop. It's possible that kithe won't (at least for a long time) contain controllers themselves (it may contain some helper methods for controllers), or generalized permissions architecture. Both of these are some of the things most particular to specific apps, that are hard to generalize without creating monsters.
 
@@ -83,8 +80,6 @@ This is a Rails 'engine' whose template was created with: `rails plugin new kith
 
 * Note we have chosen not to make it 'mountable' or 'isolated', I think that would be inappropriate for this kind of gem. It _is_ an engine so it can hook into Rails load paths and config as needed.
 
-
-
 * Note we are currently using the standard rails-generated dummy app in spec/dummy for testing, rather than [engine_cart](https://github.com/cbeer/engine_cart) or [combustion](https://github.com/pat/combustion).
   * Before you run the tests for the first time, create the database by running: `rails db:setup`. This will create two databases, kithe_development and kithe_test.
   * Some of the rspec tests depend on [FFmpeg](https://ffmpeg.org/) for testing file derivative transformations. Mac users can install [ffmpeg via homebrew](https://formulae.brew.sh/formula/ffmpeg): `brew install ffmpeg`

data/app/characterization/kithe/ffprobe_characterization.rb

@@ -0,0 +1,179 @@
+require 'tty/command'
+require 'json'
+
+module Kithe
+  # Characterizes Audio or Video files using `ffprobe`, a tool that comes with `ffmpeg`.
+  #
+  # You can pass in a local File object (with a pathname), a local String pathname, or
+  # a remote URL. (Remote URLs will be passed directy to ffprobe, which can efficiently
+  # fetch just the bytes it needs)
+  #
+  # You can get back normalized A/V metadata:
+  #
+  #     metadata = FfprobeCharacterization.new(url).normalized_metadata
+  #
+  # Normalized metadata is a *flat* hash of typed JSON-able values. It uses
+  # keys based on what the ActiveEncode gem seems to use, but adds some extras
+  # and makes a few tweaks. See the #normalized_metadata method source for
+  # keys supplied.
+  #
+  # Or the complete FFprobe response as JSON. (We try to use ffprobe options that
+  # are exhausitive as to what is returned, including ffprobe version(s))
+  #
+  #     ffprobe_results = FfprobeCharacterization.new(url).ffprobe_hash
+  #
+  class FfprobeCharacterization
+    class_attribute :ffprobe_command, default: "ffprobe"
+    class_attribute :ffprobe_timeout, default: 10
+
+    attr_reader :input_arg
+
+    # @param input [String,File] local File OR local filepath as String, OR remote URL as string
+    #   If you have a remote url, just passing hte remote url is way more performant than
+    #   downloading it yourself locally -- ffprobe will just fetch the bytes it needs.
+    def initialize(input)
+      if input.respond_to?(:path)
+        input = input.path
+      end
+      @input_arg = input
+    end
+
+    # a helper for creating a block for shrine uploader, you can always use
+    # FFprobeCharecterization.new directly too!
+    #
+    # * Does not run on "cache" action, only on promotion (or manual execution).
+    #
+    # * Will run only on items with "audio/" or "video/" content-type.
+    #
+    # * By default only on main original, not derivatives, although
+    #   you can pass `run_on_derivatives: true` if desired.
+    #
+    # Will use ffprobe with direct URL if possible based on source_io (ffprobe
+    # can very efficiently access only bytes needed from URL), otherwise will
+    # download local temp copy if necessary.
+    #
+    #    class AssetUploader < Kithe::AssetUploader
+    #      add_metadata do |source_io, **context|
+    #        Kithe::FfprobeCharacterization.characterize_from_uploader(source_io, context)
+    #      end
+    #
+    #      #...
+    #    end
+    #
+    def self.characterize_from_uploader(source_io, add_metadata_context, run_on_derivatives: false)
+      # only for A/V please
+      return {} unless add_metadata_context.dig(:metadata, "mime_type")&.start_with?(%r{\A(audio|video)/})
+
+      # don't run on cache, only on promotion or manual trigger
+      return {} unless add_metadata_context[:action] != :cache
+
+      # don't run on derivatives unless option given
+      return {} unless add_metadata_context[:derivative].nil? || run_on_derivatives
+
+      # ffprobe can use a URL and very efficiently only retrieve what bytes it needs...
+      if source_io.respond_to?(:url) && source_io.url.start_with?(/\Ahttps?:/)
+        Kithe::FfprobeCharacterization.new(source_io.url).normalized_metadata
+      else
+        # if not already a file, will download, possibly slow, but gets us to go.
+        Shrine.with_file(source_io) do |file|
+          Kithe::FfprobeCharacterization.new(file.path).normalized_metadata
+        end
+      end
+    end
+
+    # ffprobe args come from this suggestion:
+    #
+    # https://gist.github.com/nrk/2286511?permalink_comment_id=2593200#gistcomment-2593200
+    #
+    # We also add in various current version tags! If we're going to record all ffprobe
+    # output, we'll want that too!
+    def ffprobe_options
+      [
+        "-hide_banner",
+        "-loglevel", "fatal",
+        "-show_error", "-show_format", "-show_streams", "-show_programs",
+        "-show_chapters", "-show_private_data", "-show_versions",
+        "-print_format", "json",
+      ]
+    end
+
+    # ffprobe output parsed as JSON...
+    def ffprobe_hash
+      @ffprobe_hash ||= JSON.parse(ffprobe_stdout).merge(
+        "ffprobe_options_used" => ffprobe_options.join(" ")
+      )
+    end
+
+    # Returns a FLAT JSON-able hash of normalized a/v metadata.
+    #
+    # Tries to standardize to what ActiveEncode uses, with some changes and additions.
+    # https://github.com/samvera-labs/active_encode/blob/42f5ed5427a39e56093a5e82123918c4b2619a47/lib/active_encode/technical_metadata.rb
+    #
+    # A video file or other container can have more than one audio or video stream in it, although
+    # this is somewhat unusual for our domain. For the stream-specific audio_ and video_ metadata
+    # returned, we just choose the *first* returned audio or video stream (which may be more or
+    # less arbitrary)
+    #
+    # See also #ffprobe_hash for complete ffprobe results
+    def normalized_metadata
+      # overall  audio_sample_rate are null, audio codec is wrong
+      @normalized_metadata ||= {
+        "width" => first_video_stream_json&.dig("width"),
+        "height" => first_video_stream_json&.dig("height"),
+        "frame_rate" => video_frame_rate_as_float, # frames per second
+        "duration_seconds" => ffprobe_hash&.dig("format", "duration")&.to_f&.round(3),
+        "audio_codec" => first_audio_stream_json&.dig("codec_name"),
+        "video_codec" => first_video_stream_json&.dig("codec_name"),
+        "audio_bitrate" => first_audio_stream_json&.dig("bit_rate")&.to_i, # in bps
+        "video_bitrate" => first_video_stream_json&.dig("bit_rate")&.to_i, # in bps
+        # extra ones not ActiveEncode
+        "bitrate" => ffprobe_hash.dig("format", "bit_rate")&.to_i, # overall bitrate of whole file in bps
+        "audio_sample_rate" => first_audio_stream_json&.dig("sample_rate")&.to_i, # in Hz
+        "audio_channels" => first_audio_stream_json&.dig("channels")&.to_i, # usually 1 or 2 (for stereo)
+        "audio_channel_layout" => first_audio_stream_json&.dig("channel_layout"), # stereo or mono or (dolby) 2.1, or something else.
+      }.compact
+    end
+
+    # just the ffprobe version please. This is also available
+    # in ffprobe_hash
+    def ffprobe_version
+      ffprobe_hash.dig("program_version", "version")
+    end
+
+    private
+
+    def ffprobe_stdout
+      @ffprobe_output ||= TTY::Command.new(printer: :null).run(
+                            ffprobe_command,
+                            *ffprobe_options,
+                            input_arg,
+                            timeout: ffprobe_timeout).out
+    end
+
+    def first_video_stream_json
+      @first_video_stream_json ||= ffprobe_hash["streams"].find { |stream| stream["codec_type"] == "video" }
+    end
+
+    def first_audio_stream_json
+      @first_audio_stream_json ||= ffprobe_hash["streams"].find { |stream| stream["codec_type"] == "audio" }
+    end
+
+    # There are a few different values we could choose here. We're going to choose
+    # `avg_frame_rate` == total duration / number of frames,
+    # vs (not chosen) `r_frame_rate ` "the lowest framerate with which all timestamps can be represented accurately (it is the least common multiple of all framerates in the stream)"
+    #
+    # (note this sometimes gets us not what we expected, like it gets us 29.78 fps instead of 29.97)
+    #
+    # Then we have to change it from numerator/denomominator to float truncated to two decimal places,
+    # which we let ruby rational do for us.
+    def video_frame_rate_as_float
+      avg_frame_rate = first_video_stream_json&.dig("avg_frame_rate")
+
+      return nil unless avg_frame_rate
+
+      return nil if avg_frame_rate.split("/")[1] == "0" # sometimes it returns '0/0', don't know why.
+
+      Rational(avg_frame_rate).to_f.round(2)
+    end
+  end
+end

data/app/indexing/kithe/indexable/thread_settings.rb

@@ -57,7 +57,7 @@ module Kithe
       def initialize(batching:, disable_callbacks:, original_settings:,
         writer:, on_finish:)
         @original_settings = original_settings
-        @batching = !!batching
+        @batching = batching
         @disable_callbacks = disable_callbacks
         @on_finish = on_finish
 
@@ -80,8 +80,9 @@ module Kithe
       def writer
         @writer ||= begin
           if @batching
+            batch_size = (@batching == true) ? Kithe.indexable_settings.batching_mode_batch_size : @batching
             @local_writer = true
-            Kithe.indexable_settings.writer_instance!("solr_writer.batch_size" => 100)
+            Kithe.indexable_settings.writer_instance!("solr_writer.batch_size" => batch_size)
           end
         end
       end
@@ -97,6 +98,8 @@ module Kithe
         # only call on-finish if we have a writer, batch writers are lazily
         # created and maybe we never created one
         if @writer
+          # if we created the writer ourselves locally and nobody
+          # specified an on_finish, close our locally-created writer.
           on_finish = if @local_writer && @on_finish.nil?
             proc {|writer| writer.close }
           else
@@ -105,7 +108,7 @@ module Kithe
           on_finish.call(@writer) if on_finish
         end
 
-        Thread.current[THREAD_CURRENT_KEY] = @original_thread_current_settings
+        Thread.current[THREAD_CURRENT_KEY] = @original_settings
       end
 
       private

data/app/indexing/kithe/indexable.rb

@@ -120,6 +120,9 @@ module Kithe
     #
     # By default will use a per-update writer, or thread/block-specific writer configured with `self.index_with`,
     # or you can pass one in.
+    #
+    # This method is part of Kithe API, including allowing local apps to override! Backwards
+    # compatibilty matters for semver with any change to method signature.
     def update_index(mapper: kithe_indexable_mapper, writer:nil)
       RecordIndexUpdater.new(self, mapper: mapper, writer: writer).update_index
     end

data/app/indexing/kithe/indexer/obj_extract.rb

@@ -48,7 +48,8 @@ module Kithe
         first, *rest = *path
 
         result = if obj.kind_of?(Array)
-          obj.flat_map { |item| obj_extractor(item, path) }
+          first_path_element = path.shift # remove it from path
+          obj.flat_map { |item| obj_extractor(item, [first_path_element]) }
         elsif obj.kind_of?(Hash)
           obj[first]
         else

data/app/models/kithe/asset.rb

@@ -27,7 +27,8 @@ class Kithe::Asset < Kithe::Model
     to: :file, allow_nil: true
   delegate :stored?, to: :file_attacher
   delegate :set_promotion_directives, :promotion_directives, to: :file_attacher
-
+  # delegate "metadata" as #file_metadata
+  delegate :metadata, to: :file, prefix: true, allow_nil: true
 
   # will be sent to file_attacher.set_promotion_directives, provided by our
   # kithe_promotion_hooks shrine plugin.
@@ -81,31 +82,11 @@ class Kithe::Asset < Kithe::Model
     source = file
     return false unless source
 
-    #local_files = file_attacher.process_derivatives(:kithe_derivatives, only: only, except: except, lazy: lazy)
-    local_files = _process_kithe_derivatives_without_download(source, only: only, except: except, lazy: lazy)
+    local_files = file_attacher.process_derivatives(:kithe_derivatives, only: only, except: except, lazy: lazy)
 
     file_attacher.add_persisted_derivatives(local_files)
   end
 
-  # Working around Shrine's insistence on pre-downloading original before calling derivative processor.
-  # We want to avoid that, so when our `lazy` argument is in use, original does not get eagerly downloaded,
-  # but only gets downloaded if needed to make derivatives.
-  #
-  # This is a somewhat hacky way to do that, loking at the internals of shrine `process_derivatives`,
-  # and pulling them out to skip the parts we don't want. We also lose shrine instrumentation
-  # around this action.
-  #
-  # See: https://github.com/shrinerb/shrine/issues/470
-  #
-  # If that were resolved, the 'ordinary' shrine thing would be to replace calls
-  # to this local private method with:
-  #
-  #     file_attacher.process_derivatives(:kithe_derivatives, only: only, except: except, lazy: lazy)
-  #
-  private def _process_kithe_derivatives_without_download(source, **options)
-    processor = file_attacher.class.derivatives_processor(:kithe_derivatives)
-    local_files = file_attacher.instance_exec(source, **options, &processor)
-  end
 
   # Just a convennience for file_attacher.add_persisted_derivatives (from :kithe_derivatives),
   # feel free to use that if you want to add more than one etc.  By default stores to
@@ -144,6 +125,14 @@ class Kithe::Asset < Kithe::Model
     result && result.values.first
   end
 
+  # Like #update_derivative, but can update multiple at once.
+  #
+  #     asset.update_derivatives({ "big_thumb" => big_thumb_io, "small_thumb" => small_thumb_io })
+  #
+  # Options from kithe `add_persisted_derivatives`/shrine `add_derivative` supported.
+  #
+  #     asset.update_derivatives({ "big_thumb" => big_thumb_io, "small_thumb" => small_thumb_io }, delete_false)
+  #
   def update_derivatives(deriv_hash, **options)
     file_attacher.add_persisted_derivatives(deriv_hash, **options)
   end

data/app/models/kithe/validators/model_parent.rb

@@ -1,13 +1,14 @@
 class Kithe::Validators::ModelParent < ActiveModel::Validator
   def validate(record)
+    # don't load the parent just to validate it if it hasn't even changed.
+    return unless record.parent_id_changed?
+
     if record.parent.present? && (record.parent.class <= Kithe::Asset)
-      record.errors[:parent] << 'can not be an Asset instance'
+      record.errors.add(:parent, 'can not be an Asset instance')
     end
 
     if record.parent.present? && record.class <= Kithe::Collection
-      record.errors[:parent] << 'is invalid for Collection instances'
+      record.errors.add(:parent, 'is invalid for Collection instances')
     end
-
-    # TODO avoid recursive parents, maybe using a postgres CTE for efficiency?
   end
 end

data/app/validators/array_inclusion_validator.rb

@@ -42,7 +42,7 @@ class ArrayInclusionValidator < ActiveModel::EachValidator
 
     unless not_allowed_values.blank?
       formatted_rejected = not_allowed_values.uniq.collect(&:inspect).join(",")
-      record.errors.add(attribute, :inclusion, options.except(:in).merge!(rejected_values: formatted_rejected, value: value))
+      record.errors.add(attribute, :inclusion, **options.except(:in).merge!(rejected_values: formatted_rejected, value: value))
     end
   end
 end

data/lib/kithe/engine.rb

@@ -9,7 +9,6 @@ require 'shrine'
 # https://github.com/teoljungberg/fx/issues/33
 # https://github.com/teoljungberg/fx/pull/53
 require 'fx'
-require 'kithe/patch_fx'
 
 # not auto-loaded, let's just load it for backwards compat though
 require "kithe/config_base"
@@ -22,5 +21,13 @@ module Kithe
       g.assets false
       g.helper false
     end
+
+    # the fx gem lets us include stored procedures in schema.rb. For it to work
+    # in kithe's case, the stored procedures have to be *first* in schema.rb,
+    # so they can then be referenced as default value for columns in tables
+    # subsequently created. We configure that here, forcing it for any app, yes, sorry.
+    Fx.configure do |config|
+      config.dump_functions_at_beginning_of_schema = true
+    end
   end
 end

data/lib/kithe/indexable_settings.rb

@@ -1,14 +1,17 @@
 module Kithe
   class IndexableSettings
     attr_accessor :solr_url, :writer_class_name, :writer_settings,
-                  :model_name_solr_field, :solr_id_value_attribute, :disable_callbacks
+                  :model_name_solr_field, :solr_id_value_attribute, :disable_callbacks,
+                  :batching_mode_batch_size
     def initialize(solr_url:, writer_class_name:, writer_settings:,
-                   model_name_solr_field:, solr_id_value_attribute:, disable_callbacks: false)
+                   model_name_solr_field:, solr_id_value_attribute:, disable_callbacks: false,
+                   batching_mode_batch_size: 100)
       @solr_url = solr_url
       @writer_class_name = writer_class_name
       @writer_settings = writer_settings
       @model_name_solr_field = model_name_solr_field
       @solr_id_value_attribute = solr_id_value_attribute || 'id'
+      @batching_mode_batch_size = batching_mode_batch_size
     end
 
     # Use configured solr_url, and merge together with configured

data/lib/kithe/version.rb

@@ -1,6 +1,3 @@
 module Kithe
-  # not sure why rubygems turned our alphas into 2.0.0.pre.alpha1, inserting
-  # "pre". We need to do same thing with betas to get version orderings
-  # appropriate.
-  VERSION = '2.0.3'
+  VERSION = '2.4.0'
 end

data/lib/shrine/plugins/kithe_derivative_definitions.rb

@@ -10,7 +10,11 @@ class Shrine
 
         # Register our derivative processor, that will create our registered derivatives,
         # with our custom options.
-        uploader::Attacher.derivatives(:kithe_derivatives) do |original, **options|
+        #
+        # We do download: false, so when our `lazy` argument is in use, original does not get eagerly downloaded,
+        # but only gets downloaded if needed to make derivatives. This is great for performance, especially
+        # when running batch job to add just missing derivatives.
+        uploader::Attacher.derivatives(:kithe_derivatives, download: false) do |original, **options|
           Kithe::Asset::DerivativeCreator.new(self.class.kithe_derivative_definitions,
             source_io: original,
             shrine_attacher: self,
@@ -44,10 +48,12 @@ class Shrine
         # Tempfile and Dir.mktmpdir may be useful.
         #
         # If in order to do your transformation you need additional information about the original,
-        # just add a `record:` keyword argument to your block, and the Asset object will be passed in:
+        # just add a `attacher:` keyword argument to your block, and a `Shrine::Attacher` subclass
+        # will be passed in. You can then get the model object from `attacher.record`, or the
+        # original file as a `Shrine::UploadedFile` object with `attacher.file`.
         #
-        #     define_derivative :thumbnail do |original_file, record:|
-        #        record.width, record.height, record.content_type # etc
+        #     define_derivative :thumbnail do |original_file, attacher:|
+        #        attacher.record.title, attacher.file.width, attacher.file.content_type # etc
         #     end
         #
         # Derivatives are normally uploaded to the Shrine storage labeled :kithe_derivatives,

data/lib/shrine/plugins/kithe_determine_mime_type.rb

@@ -19,6 +19,12 @@ class Shrine
     # Ensure that if mime-type can't be otherwise determined, it is assigned
     # "application/octet-stream", basically the type for generic binary.
     class KitheDetermineMimeType
+      # marcel version 1.0 says audio/x-flac, whereas previous versions
+      # said audio/flac, which we prefer. Let's fix it.
+      RPELACE_CONTENT_TYPES = {
+        "audio/x-flac" => "audio/flac"
+      }
+
       def self.load_dependencies(uploader, *)
         uploader.plugin :determine_mime_type, analyzer: -> (io, analyzers) do
           mime_type = analyzers[:marcel].call(io)
@@ -30,6 +36,9 @@ class Shrine
 
           mime_type = "application/octet-stream" if mime_type.blank?
 
+          # Are there any we prefer an alternate spelling of?
+          mime_type = RPELACE_CONTENT_TYPES.fetch(mime_type, mime_type)
+
           mime_type
         end
       end

data/lib/shrine/plugins/kithe_persisted_derivatives.rb

@@ -26,6 +26,11 @@ class Shrine
         # Like the shrine `add_derivatives` method, but also *persists* the
         # derivatives (saves to db), in a realiably concurrency-safe way.
         #
+        # For ruby 3 compatibility, make sure you supply local_files as a hash
+        # literal with curly braces:
+        #
+        #     attacher.add_persisted_derivatives({ derivative_name1: io_obj1, deriv2: io2 })
+        #
         # Generally can take any options that shrine `add_derivatives`
         # can take, including custom `storage` or `metadata` arguments.
         #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kithe
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.4.0
 platform: ruby
 authors:
 - Jonathan Rochkind
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-11 00:00:00.000000000 Z
+date: 2022-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -70,14 +70,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: shrine-url
   requirement: !ruby/object:Gem::Requirement
@@ -188,7 +188,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '1'
@@ -198,7 +198,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '1'
@@ -264,6 +264,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: db-query-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -331,6 +345,7 @@ files:
 - README.md
 - Rakefile
 - app/assets/config/kithe_manifest.js
+- app/characterization/kithe/ffprobe_characterization.rb
 - app/derivative_transformers/kithe/ffmpeg_transformer.rb
 - app/derivative_transformers/kithe/vips_cli_image_to_jpeg.rb
 - app/helpers/kithe/form_helper.rb
@@ -376,7 +391,6 @@ files:
 - lib/kithe/config_base.rb
 - lib/kithe/engine.rb
 - lib/kithe/indexable_settings.rb
-- lib/kithe/patch_fx.rb
 - lib/kithe/sti_preload.rb
 - lib/kithe/version.rb
 - lib/shrine/plugins/kithe_accept_remote_url.rb
@@ -411,7 +425,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: Shareable tools/components for building a digital collections app in Rails.

data/lib/kithe/patch_fx.rb

@@ -1,39 +0,0 @@
-# fx is a gem that lets Rails schema.rb capture postgres functions and triggers
-#
-# For it to work for our use case, we need it to define functions BEFORE tables when
-# doing a `rake db:schema:load`, so we can refer to functions as default values in our
-# tables.
-#
-# This is a known issue in fx, with a PR, but isn't yet merged/released, so we hack
-# in a patch to force it. Better than forking.
-#
-# Based on: https://github.com/teoljungberg/fx/pull/53/
-#
-# We try to write future-compat code assuming that will be merged eventually....
-
-require 'fx'
-
-if Fx.configuration.respond_to?(:dump_functions_at_beginning_of_schema)
-  # we have the feature!
-
-  Fx.configure do |config|
-    config.dump_functions_at_beginning_of_schema = true
-  end
-
-else
-  # Fx does not have the feature, we have to patch it in
-
-  require 'fx/schema_dumper/function'
-
-  module Fx
-    module SchemaDumper
-      module Function
-        def tables(stream)
-          functions(stream)
-          super
-        end
-      end
-    end
-  end
-
-end