vitals_image 0.1.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d8a81b62c6510bb742ceb8eecf2ab2fd37a5d07d53e2c9f9736bef089e6134d
-  data.tar.gz: e1590ed0d07ddcb7120950f3b2049cdcb6aa5a6774fee11e37e3be3e557dfc86
+  metadata.gz: 5399352c9f774e90f9a671459d582672c69c19b5640675e47a5c77536cb36826
+  data.tar.gz: a05b961a9730225fd60f81c8d5467ab44a542abd8fa96d659891f805ee5a21b7
 SHA512:
-  metadata.gz: ec023607a07b0910a34b0fc899d6e5dc8924382a2f1d96f6ceab26151360596e4fc4db7eff7c40c5201ab6f8ffc11c76abaef61e92ef305b4651476b8ef898ba
-  data.tar.gz: 1fa954c88cf57d363c2e2a3695751fffaa38cf099642dd1bf32a026706105a4aab7e7f3d081278860c55c65b340ac061905388106b4ebc25b36e32b6ed01e21d
+  metadata.gz: 41a2aca3f4efb2178525af7566d24fe9825f858860a0b482c48ada2f49bc62edadb085986f165dc7d1d2875c5faf2e60114040c6318c6f52e469db620b32fb4d
+  data.tar.gz: 1fe231165885de9b8c0876abfc466583f9fcb0da7c5ea2da73104e0d93348064c55e41fe9471decc0c077ac8392efcfe3f5c49b75db305c743752c7d78eeaa9a

data/CHANGELOG.md

@@ -0,0 +1,39 @@
+## [Unreleased]
+
+## [0.4.1] - 2021-07-22
+
+- Do not discard the specified `style` attribute
+
+## [0.4.0] - 2021-07-06
+
+- Fixed resize and pad in vips
+- Fixed image quality in vips
+- Reduced JPEG quality from 85 to 80
+- Removed optimal quality
+- Updated Vitals Image to 0.5
+
+## [0.3.0] - 2021-05-22
+
+- Redo the image helper
+- Redo the active storage optimizer 
+
+## [0.2.1] - 2021-05-22
+
+- Do not attempt to transform invariable images
+
+## [0.2.0] - 2021-05-18
+
+- Use the `optimal_quality` value of blob metadata instead of fixed `85` if its available;
+- Remove some unecessary configs;
+- Drop analyzers and use `active_analysis` gem instead;
+- Use "retry once" strategy instead of `create_or_find_by`; 
+- Fix 'can't be referred' error;
+- Do not cache development unless cache is enabled;
+
+## [0.1.1] - 2021-05-05
+
+- Relax dependencies
+
+## [0.1.0] - 2021-05-01
+
+- Initial release

data/README.md

@@ -0,0 +1,215 @@
+# Vitals Image
+
+Vitals Image is a lib that makes it easier to create image tags that follow best practices for fast loading web pages in rails projects. It does that by adding a new view helper (`vitals_image_tag`) that can take a string or an active storage attachment and automatically set width, height and a few other recommended attributes.
+
+This gem was extracted from FestaLab's app and replaced the original code ([see it in action](https://festalab.com.br/modelo-de-convite?referer=github)).
+
+[![vitals-image-main](https://github.com/FestaLab/vitals_image/actions/workflows/main.yml/badge.svg)](https://github.com/FestaLab/vitals_image/actions/workflows/main.yml)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vitals_image'
+```
+
+And then execute:
+
+    $ bundle install
+
+Finally copy over the migration:
+
+    $ bin/rails vitals_image:install:migrations
+
+## Usage
+
+### Basics 
+The simplest usage for `vitals_image` is to replace a normal `image_tag` with it.
+
+Before:
+```rhtml
+<%= image_tag "icon.svg" %>
+<img src="icon.svg" />
+```
+
+After:
+```rhtml
+<%= vitals_image_tag "icon.svg" %>
+
+<!-- First time the image is seem -->
+<img src="icon.svg" loading="lazy" decoding="async" />
+
+<!-- Second time the image is seem -->
+<img src="icon.svg" width="20" height="40" loading="lazy" decoding="async" style="height: auto;" />
+```
+
+If the supplied source is an external url, or the url of an asset, `vitals_image` will, in a background job, download the image, analyze it and store its width and height, so that the next time it is seem, they can be applied, reducing the page's CLS. As for the extra tags:
+
+- `loading`: setting it to `lazy` allows Chrome to lazy load images that are not in the viewport without the need for a lazy load library.
+- `decoding`: another optimization similar to `loading`, which allows image to the decoded asynchronously.
+- `style`: setting `height: auto` allows your CSS to choose a different `width` for your image (`width: 100%;`) while keeping its aspect ratio intact and still benefitting from no impact on the CLS
+
+The same can be done with an active storage image:
+
+Before:
+```rhtml
+<%= image_tag user.avatar %>
+<img src="/rails/active_storage/blobs/redirect/(...).photo.jpeg" />
+```
+
+After:
+```rhtml
+<%= vitals_image_tag user.avatar %>
+
+<!-- Before active storage has analyzed the image -->
+<img src="/rails/active_storage/blobs/redirect/(...).photo.jpeg" loading="lazy" decoding="async" />
+
+<!-- After active storage has analyzed the image -->
+<img src="/rails/active_storage/blobs/redirect/(...).photo.jpeg" width="200" height="200" loading="lazy" decoding="async" style="height: auto;" />
+```
+
+### Setting width and height
+You might however decide to use a different width or height for your images. No problem, give one dimension, and `vitals_image` will figure out the other.
+```rhtml
+<%= vitals_image_tag "icon.svg", width: 10 %>
+<img src="icon.svg" width="10" height="20" loading="lazy" decoding="async" style="height: auto;" />
+```
+
+If you do the same in active storage, instead of the original image, you will get an optimized variant:
+```rhtml
+<%= vitals_image_tag user.avatar width: 100 %>
+<img src="/rails/active_storage/representations/redirect/(...).photo.jpeg" width="100" height="100" loading="lazy" decoding="async" style="height: auto;" />
+```
+
+To see which optimizations will be applied (and change them if you wish, check the "Configuration" section.)
+
+If you set both a width and a height and end up with a different aspect ratio than the image has, Vitals Image will make a "best guess" at what you want.
+
+For an image from an url, which it cannot apply transformations to, it will use `object-fit`
+```rhtml
+<%= vitals_image_tag "icon.svg", width: 100, height: 40 %>
+<img src="icon.svg" width="100" height="40" style="object-fit: contain" />
+```
+
+For an active storage image, it has two possible strategies for the resize:
+
+- `resize_to_limit`: This is the default. Downsizes the image to fit within the specified dimensions while retaining the original aspect ratio. Will only resize the image if it's larger than the specified dimensions.
+- `resize_and_pad`: This only be used if Vitals Image know that this image is an object in a white background. For that to work you must set `image_library = :vips` and `check_for_white_background = true` in your configuration. This will cause Vitals Image to replace the normal `analyze_job` that Active Storage uses, with a custom one that will add the attribute `white_background` to the blobs metadata,  
+
+### Advanced options
+You can disable lazy loading if you want:
+```rhtml
+<%= vitals_image_tag "icon.svg", lazy_load: false %>
+<img src="icon.svg" width="20" height="40" style="height: auto;" />
+```
+
+You can also choose a different route strategy for active storage, than the one it uses by default:
+```rhtml
+<%= vitals_image_tag user.avatar, active_storage_route: :proxy %>
+<img src="/rails/active_storage/representations/proxy/(...).photo.jpeg" width="100" height="100" loading="lazy" decoding="async" style="height: auto;" />
+```
+
+If you set the height, you will not get the `auto` added to it:
+```rhtml
+<%= vitals_image_tag "icon.svg", height: 20 %>
+<img src="icon.svg" width="10" height="20" />
+```
+
+
+
+## Configuration
+The following configuration options are available. The defaults were chosen for maximum compatibility and least surprises, while the values under "Recommended" are what the app from which this gem was extracted uses. 
+
+| Options                         | Default        | Recommended             | Description |
+| --------------------------------|----------------|-------------------------|-------------|
+| image_library                   | `:mini_magick` | `:vips`                 | The image library that will be used to analyze and optimize images. While `mini_magick` is available in most PaaS and CIs, `vips` is faster and uses less resources. |
+| resolution                      | `2`            | `2`                     | The resolution that downsized images will have. While some phones are capable of `3` or `4`, `2` should be [good enough for most people](https://blog.twitter.com/engineering/en_us/topics/infrastructure/2019/capping-image-fidelity-on-ultra-high-resolution-devices.html) |
+| lazy_loading                    | `:native`      | `:lozad` or `:lazyload` | If left at `:native`, the tags `loading` and `decoding` will be added. Otherwise, the value of this option will be added to the `class` attribute and `src` moved to `data-src`. I recommend either [lozad](https://apoorv.pro/lozad.js/) or [lazysizes](https://github.com/aFarkas/lazysizes)
+| lazy_loading_placeholder        | Blank GIF      | Blank GIF               | When using a lazy load library, this image will be used as the placeholder in the `src` attribute so that users don't see a broken image. See it [here](https://github.com/FestaLab/vitals_image/blob/main/lib/vitals_image/engine.rb#L36). |
+| require_alt_attribute           | `false`        | `true`                  | Will raise in exception if the `alt` attribute is not supplied to the helper. Useful to ensure no one ever forgets it again. |
+| check_for_white_background      | `false`        | `true`                  | Requires `image_library = :vips`. Same as above, but the analyzer will also try to deduce if the image is a photo, or a product on a white background. This will help define if `resize_to_limit` or `resize_and_pad` should be used when you supply both `width` and `height` to the helper. |
+| convert_to_jpeg                 | `false`        | `true`                  | If set to `true`, images will be converted to JPEG, unless the keyword `alpha: true` was used in the helper. |
+| jpeg_conversion                 | see below      | see below               | Hash of options to pass to active storage when converting other image formats to JPEG and optimizing. |
+| jpeg_optimization               | see below      | see below               | Hash of options to pass to active storage when optimizing a JPEG. |
+| png_optimization                | see below      | see below               | Hash of options to pass to active storage when optimizing a PNG. |
+| active_storage_route            | `:inherited`   | `:inherited`            | Defines how urls of active storage images will be generated. If `inherited` it will use the same as active storage. Other valid options are `redirect`, `proxy` and `public`. Whatever is set here can be overriden in the helper. |
+
+Minimagick
+```ruby
+# jpeg_conversion
+{ saver: { strip: true, quality: 85, interlace: "JPEG", sampling_factor: "4:2:0", colorspace: "sRGB", background: :white, flatten: true, alpha: :off }, format: "jpg" }
+
+# jpeg_optimization:
+{ saver: { strip: true, quality: 85, interlace: "JPEG", sampling_factor: "4:2:0", colorspace: "sRGB" } }
+
+# png_optimization:
+{ saver: { strip: true, quality: 00 } }
+```
+
+Vips
+```ruby
+# jpeg_conversion
+{ saver: { strip: true, quality: 85, interlace: true, optimize_coding: true, trellis_quant: true, quant_table: 3, background: 255 }, format: "jpg" }
+
+# jpeg_optimization:
+{ saver: { strip: true, quality: 85, interlace: true, optimize_coding: true, trellis_quant: true, quant_table: 3 } }
+
+# png_optimization:
+{ saver: { strip: true, compression: 9 } }
+```
+
+These can be configured in your environment files, just like any other rails settings:
+
+```
+Rails.application.configure do |config|
+  config.vitals_image.image_library = :vips
+  config.vitals_image.mobile_width = 410
+  config.vitals_image.desktop_width = 1264
+  config.vitals_image.lazy_loading = :lozad
+  config.vitals_image.require_alt_attribute = true
+  config.vitals_image.check_for_white_background = true
+  config.vitals_image.convert_to_jpeg = true
+end
+```
+
+Heads up! If you are already on Rails 7.0.0.alpha, make sure you are not using  `image_decoding` and `image_loading` config options below, as they will forcibly add native lazy loading and async decoding to the tags.
+
+### Customization
+If your use case requires it, you can easily add extra `optimizers` and `analyzers`, just like you would in Active Storage. Start by inheriting the abstract classes.
+
+```ruby
+class Base64ImageOptimizer < VitalsImage::Optimizer; end
+class Base64ImageAnalyzer < VitalsImage::Analyzer; end
+```
+
+And them during config add them ahead of others:
+```ruby
+Rails.application.configure do |config|
+  config.vitals_image.optimizers.prepend Base64ImageOptimizer
+  config.vitals_image.analyzers.prepend Base64ImageAnalyzer
+end
+```
+
+### TODO
+
+- Check ACCEPT headers and serve modern file formats if possible (webp and avif)
+- Add support for `srcset`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/FestaLab/vitals_image. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/FestaLab/vitals_image/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the VitalsImage project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/FestaLab/vitals_image/blob/main/CODE_OF_CONDUCT.md).

data/app/helpers/vitals_image/tag_helper.rb

@@ -6,32 +6,17 @@ module VitalsImage
       source = image_url(source) if source.is_a?(String)
       optimizer = VitalsImage::Base.optimizer(source, options)
 
-      if !optimizer.variable?
-        vitals_image_invariable_tag(optimizer)
-      elsif optimizer.native_lazy_load?
-        vitals_image_variable_tag(optimizer)
-      else
-        vitals_image_lazy_tag(optimizer)
-      end
-    end
-
-    private
-      def vitals_image_invariable_tag(optimizer)
-        image_tag optimizer.src, optimizer.html_options
-      end
-
-      def vitals_image_variable_tag(optimizer)
-        url = vitals_image_url(optimizer.src, optimizer.html_options)
-        image_tag url, optimizer.html_options
-      end
-
-      def vitals_image_lazy_tag(optimizer)
+      if optimizer.non_native_lazy_load?
         url = vitals_image_url(optimizer.html_options["data"]["src"], optimizer.html_options)
         optimizer.html_options["data"]["src"] = url
-
         image_tag optimizer.src, optimizer.html_options
+      else
+        url = vitals_image_url(optimizer.src, optimizer.html_options)
+        image_tag url, optimizer.html_options
       end
+    end
 
+    private
       def vitals_image_url(source, options)
         active_storage_route = options.delete("active_storage_route") || VitalsImage.active_storage_route
 

data/app/models/vitals_image/source.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module VitalsImage
-  class Source < ApplicationRecord
+  class Source < ActiveRecord::Base
     store :metadata, accessors: [ :analyzed, :width, :height ], coder: ActiveRecord::Coders::JSON, default: "{ analyzed: false }"
 
     after_create -> { AnalyzeJob.perform_later(self) }

data/lib/vitals_image.rb

@@ -21,7 +21,6 @@ module VitalsImage
   mattr_accessor :lazy_loading_placeholder
   mattr_accessor :require_alt_attribute
 
-  mattr_accessor :replace_active_storage_analyzer
   mattr_accessor :check_for_white_background
 
   mattr_accessor :convert_to_jpeg

data/lib/vitals_image/analyzer/{url.rb → url_analyzer.rb}

@@ -3,7 +3,7 @@
 require "open-uri"
 
 module VitalsImage
-  class Analyzer::Url < Analyzer
+  class Analyzer::UrlAnalyzer < Analyzer
     def self.accept?(source)
       source.is_a?(Source)
     end

data/lib/vitals_image/cache.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../app/models/vitals_image/source"
+
 module VitalsImage
   class Cache
     include Singleton
@@ -9,15 +11,24 @@ module VitalsImage
     end
 
     def locate(key)
-      source = @store.read(key)
+      with_retry do
+        source = @store.read(key)
 
-      if source.blank?
-        source = Source.create_or_find_by(key: key)
-        expires_in = source.analyzed ? nil : 1.minute
-        @store.write(key, source, expires_in: expires_in)
-      end
+        if source.blank?
+          source = Source.find_or_create_by(key: key)
+          expires_in = source.analyzed ? nil : 1.minute
+          @store.write(key, source, expires_in: expires_in)
+        end
 
-      source
+        source
+      end
     end
+
+    private
+      def with_retry
+        yield
+      rescue ActiveRecord::RecordNotUnique
+        yield
+      end
   end
 end

data/lib/vitals_image/engine.rb

@@ -9,65 +9,74 @@ require "active_support"
 require "marcel"
 require "ruby-vips"
 require "mini_magick"
+require "active_analysis"
 
 require "vitals_image/analyzer"
-require "vitals_image/analyzer/url"
+require "vitals_image/analyzer/url_analyzer"
 require "vitals_image/base"
 require "vitals_image/cache"
 require "vitals_image/errors"
 require "vitals_image/optimizer"
 require "vitals_image/optimizer/blank"
 require "vitals_image/optimizer/url"
-require "vitals_image/optimizer/active_storage"
+require "vitals_image/optimizer/variable"
+require "vitals_image/optimizer/invariable"
 
 module VitalsImage
   class Engine < ::Rails::Engine
     isolate_namespace VitalsImage
 
     config.vitals_image                                 = ActiveSupport::OrderedOptions.new
-    config.vitals_image.optimizers                      = [VitalsImage::Optimizer::Blank, VitalsImage::Optimizer::ActiveStorage, VitalsImage::Optimizer::Url]
-    config.vitals_image.analyzers                       = [VitalsImage::Analyzer::Url]
+    config.vitals_image.optimizers                      = [VitalsImage::Optimizer::Blank, VitalsImage::Optimizer::Variable, VitalsImage::Optimizer::Invariable, VitalsImage::Optimizer::Url]
+    config.vitals_image.analyzers                       = [VitalsImage::Analyzer::UrlAnalyzer]
 
     config.eager_load_namespaces << VitalsImage
 
     initializer "vitals_image.configs" do
       config.after_initialize do |app|
-        VitalsImage.logger                          = app.config.vitals_image.logger || Rails.logger
-        VitalsImage.optimizers                      = app.config.vitals_image.optimizers || []
-        VitalsImage.analyzers                       = app.config.vitals_image.analyzers || []
-        VitalsImage.image_library                   = app.config.vitals_image.image_library || :mini_magick
+        VitalsImage.image_library              = app.config.active_storage.variant_processor        || :mini_magick
 
-        VitalsImage.mobile_width                    = app.config.vitals_image.mobile_width || :original
-        VitalsImage.desktop_width                   = app.config.vitals_image.desktop_width || :original
-        VitalsImage.resolution                      = app.config.vitals_image.resolution || 2
-        VitalsImage.lazy_loading                    = app.config.vitals_image.lazy_loading || :native
-        VitalsImage.lazy_loading_placeholder        = app.config.vitals_image.lazy_loading_placeholder || VitalsImage::Base::TINY_GIF
-        VitalsImage.require_alt_attribute           = app.config.vitals_image.require_alt_attribute || false
+        VitalsImage.logger                     = app.config.vitals_image.logger                     || Rails.logger
+        VitalsImage.optimizers                 = app.config.vitals_image.optimizers                 || []
+        VitalsImage.analyzers                  = app.config.vitals_image.analyzers                  || []
 
-        VitalsImage.replace_active_storage_analyzer = app.config.vitals_image.replace_active_storage_analyzer || false
-        VitalsImage.check_for_white_background      = app.config.vitals_image.check_for_white_background || false
+        VitalsImage.mobile_width               = app.config.vitals_image.mobile_width               || :original
+        VitalsImage.desktop_width              = app.config.vitals_image.desktop_width              || :original
+        VitalsImage.resolution                 = app.config.vitals_image.resolution                 || 2
+        VitalsImage.lazy_loading               = app.config.vitals_image.lazy_loading               || :native
+        VitalsImage.lazy_loading_placeholder   = app.config.vitals_image.lazy_loading_placeholder   || VitalsImage::Base::TINY_GIF
+        VitalsImage.require_alt_attribute      = app.config.vitals_image.require_alt_attribute      || false
 
-        VitalsImage.convert_to_jpeg                 = app.config.vitals_image.convert_to_jpeg || false
-        VitalsImage.jpeg_conversion                 = app.config.vitals_image.jpeg_conversion || { sampling_factor: "4:2:0", strip: true, interlace: "JPEG", colorspace: "sRGB", quality: 80, format: "jpg", background: :white, flatten: true, alpha: :off }
-        VitalsImage.jpeg_optimization               = app.config.vitals_image.jpeg_optimization || { sampling_factor: "4:2:0", strip: true, interlace: "JPEG", colorspace: "sRGB", quality: 80 }
-        VitalsImage.png_optimization                = app.config.vitals_image.png_optimization || { strip: true, quality: 00 }
-        VitalsImage.active_storage_route            = app.config.vitals_image.png_optimization || :inherited
+        VitalsImage.check_for_white_background = app.config.vitals_image.check_for_white_background || true
 
-        VitalsImage.skip_ssl_verification           = app.config.vitals_image.skip_ssl_verification || false
+        VitalsImage.active_storage_route       = app.config.vitals_image.active_storage_route       || :inherited
+        VitalsImage.convert_to_jpeg            = app.config.vitals_image.convert_to_jpeg            || false
+        VitalsImage.jpeg_conversion            = app.config.vitals_image.jpeg_conversion
+        VitalsImage.jpeg_optimization          = app.config.vitals_image.jpeg_optimization
+        VitalsImage.png_optimization           = app.config.vitals_image.png_optimization
+
+        VitalsImage.skip_ssl_verification      = app.config.vitals_image.skip_ssl_verification      || false
       end
     end
 
-    initializer "vitals_image.core_extensions" do
-      require_relative "core_extensions/active_storage/image_analyzer"
-      require_relative "core_extensions/active_storage/isolated_image_analyzer"
-
+    initializer "vitals_image.analyzers" do
       config.after_initialize do |app|
         if VitalsImage.check_for_white_background
-          app.config.active_storage.analyzers.delete ActiveStorage::Analyzer::ImageAnalyzer
-          app.config.active_storage.analyzers.prepend CoreExtensions::ActiveStorage::IsolatedImageAnalyzer
-        elsif VitalsImage.replace_active_storage_analyzer
-          app.config.active_storage.analyzers.delete ActiveStorage::Analyzer::ImageAnalyzer
-          app.config.active_storage.analyzers.prepend CoreExtensions::ActiveStorage::ImageAnalyzer
+          app.config.active_analysis.addons << ActiveAnalysis::Addon::ImageAddon::WhiteBackground
+        end
+      end
+    end
+
+    initializer "vitals_image.optimizations" do
+      config.after_initialize do |app|
+        if VitalsImage.image_library == :vips
+          VitalsImage.jpeg_conversion   ||= { saver: { strip: true, quality: 80, interlace: true, optimize_coding: true, trellis_quant: true, quant_table: 3, background: 255 }, format: "jpg" }
+          VitalsImage.jpeg_optimization ||= { saver: { strip: true, quality: 80, interlace: true, optimize_coding: true, trellis_quant: true, quant_table: 3 } }
+          VitalsImage.png_optimization  ||= { saver: { strip: true, compression: 9 } }
+        else
+          VitalsImage.jpeg_conversion   ||= { saver: { strip: true, quality: 80, interlace: "JPEG", sampling_factor: "4:2:0", colorspace: "sRGB", background: :white, flatten: true, alpha: :off }, format: "jpg" }
+          VitalsImage.jpeg_optimization ||= { saver: { strip: true, quality: 80, interlace: "JPEG", sampling_factor: "4:2:0", colorspace: "sRGB" } }
+          VitalsImage.png_optimization  ||= { saver: { strip: true, quality: 75 } }
         end
       end
     end

data/lib/vitals_image/gem_version.rb

@@ -8,7 +8,7 @@ module VitalsImage
 
   module VERSION
     MAJOR = 0
-    MINOR = 1
+    MINOR = 4
     TINY  = 1
     PRE   = nil
 

data/lib/vitals_image/optimizer.rb

@@ -26,10 +26,10 @@ module VitalsImage
 
     def html_options
       @html_options ||= begin
-        html_options = @options.dup
+        html_options = @options.dup.except("lazy_load")
         html_options["width"]           = width
         html_options["height"]          = height
-        html_options["style"]           = style
+        html_options["style"]           = "#{style} #{html_options["style"]}".squish.presence
         html_options["class"]           = "vitals-image #{html_options["class"]}".squish
 
         if non_native_lazy_load?
@@ -57,11 +57,6 @@ module VitalsImage
       lazy_load? && VitalsImage.lazy_loading == :native
     end
 
-    # Override this method in a concrete subclass. Have it return true the source is an active storage blob
-    def variable?
-      false
-    end
-
     private
       def style
         if analyzed? && !requested_height

data/lib/vitals_image/optimizer/invariable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module VitalsImage
+  class Optimizer::Invariable < Optimizer
+    def self.accept?(source)
+      source.respond_to?(:variable?) && !source.variable?
+    end
+
+    private
+      def source_url
+        @source
+      end
+
+      def style
+        if !analyzed?
+          # Do nothing
+        elsif !requested_height
+          "height:auto;"
+        elsif fixed_dimensions?
+          "object-fit: contain;"
+        end
+      end
+
+      def original_width
+        metadata[:width]
+      end
+
+      def original_height
+        metadata[:height]
+      end
+
+      def metadata
+        @source.metadata
+      end
+
+      def analyzed?
+        metadata[:analyzed]
+      end
+  end
+end

data/lib/vitals_image/optimizer/{active_storage.rb → variable.rb}

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
 module VitalsImage
-  class Optimizer::ActiveStorage < Optimizer
+  class Optimizer::Variable < Optimizer
     def self.accept?(source)
-      source.is_a?(::ActiveStorage::Attached) || source.is_a?(::ActiveStorage::Attachment) || source.is_a?(::ActiveStorage::Blob)
-    end
-
-    def variable?
-      true
+      source.respond_to?(:variable?) && source.variable?
     end
 
     private
@@ -50,7 +46,7 @@ module VitalsImage
       end
 
       def resize_mode
-        @options[:resize_mode] || @source.metadata["isolated"] ? :resize_and_pad : :resize_to_fill
+        @options[:resize_mode] || @source.metadata["white_background"] ? :resize_and_pad : :resize_to_fill
       end
 
       def variant
@@ -65,23 +61,32 @@ module VitalsImage
       end
 
       def optimize_jpeg
-        @source.variant VitalsImage.jpeg_optimization.merge("#{resize_mode}": dimensions)
+        @source.variant resize_and_flatten(VitalsImage.jpeg_optimization)
       end
 
       def optimize_png
         if alpha? || !VitalsImage.convert_to_jpeg
-          @source.variant VitalsImage.png_optimization.merge("#{resize_mode}": dimensions)
+          @source.variant resize(VitalsImage.png_optimization)
         else
-          @source.variant VitalsImage.jpeg_conversion.merge("#{resize_mode}": dimensions)
+          @source.variant resize_and_flatten(VitalsImage.jpeg_conversion)
         end
       end
 
       def optimize_generic
         if alpha? || !VitalsImage.convert_to_jpeg
-          @source.variant("#{resize_mode}": dimensions)
+          @source.variant resize
         else
-          @source.variant VitalsImage.jpeg_conversion.merge("#{resize_mode}": dimensions)
+          @source.variant resize_and_flatten(VitalsImage.jpeg_conversion)
         end
       end
+
+      def resize_and_flatten(defaults = {})
+        resize  = resize_mode != :resize_and_pad ? dimensions : dimensions.push(background: [255])
+        defaults.merge "#{resize_mode}": resize
+      end
+
+      def resize(defaults = {})
+        defaults.merge "#{resize_mode}": dimensions
+      end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vitals_image
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Breno Gazzola
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-06 00:00:00.000000000 Z
+date: 2021-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: active_analysis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -213,7 +227,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - MIT-LICENSE
+- README.md
 - Rakefile
 - app/assets/config/vitals_image_manifest.js
 - app/assets/stylesheets/vitals_image/application.css
@@ -230,24 +246,24 @@ files:
 - lib/tasks/vitals_image_tasks.rake
 - lib/vitals_image.rb
 - lib/vitals_image/analyzer.rb
-- lib/vitals_image/analyzer/url.rb
+- lib/vitals_image/analyzer/url_analyzer.rb
 - lib/vitals_image/base.rb
 - lib/vitals_image/cache.rb
-- lib/vitals_image/core_extensions/active_storage/image_analyzer.rb
-- lib/vitals_image/core_extensions/active_storage/isolated_image_analyzer.rb
 - lib/vitals_image/engine.rb
 - lib/vitals_image/errors.rb
 - lib/vitals_image/gem_version.rb
 - lib/vitals_image/optimizer.rb
-- lib/vitals_image/optimizer/active_storage.rb
 - lib/vitals_image/optimizer/blank.rb
+- lib/vitals_image/optimizer/invariable.rb
 - lib/vitals_image/optimizer/url.rb
+- lib/vitals_image/optimizer/variable.rb
 - lib/vitals_image/test_case.rb
 - lib/vitals_image/version.rb
 homepage: https://github.com/FestaLab/vitals_image
 licenses:
 - MIT
 metadata:
+  allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/FestaLab/vitals_image
   source_code_uri: https://github.com/FestaLab/vitals_image
   changelog_uri: https://github.com/FestaLab/vitals_image/CHANGELOG.mg

data/lib/vitals_image/core_extensions/active_storage/image_analyzer.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module VitalsImage
-  module CoreExtensions
-    module ActiveStorage
-      class ImageAnalyzer < ::ActiveStorage::Analyzer
-        def self.accept?(blob)
-          blob.image?
-        end
-
-        def metadata
-          read_image do |image|
-            if rotated_image?(image)
-              { width: image.height, height: image.width }
-            else
-              { width: image.width, height: image.height }
-            end
-          end
-        end
-
-        private
-          def read_image
-            download_blob_to_tempfile do |file|
-              require "ruby-vips"
-              image = Vips::Image.new_from_file(file.path, access: :sequential)
-
-              if valid_image?(image)
-                yield image
-              else
-                logger.info "Skipping image analysis because Vips doesn't support the file"
-                {}
-              end
-            end
-          rescue LoadError
-            logger.info "Skipping image analysis because the ruby-vips gem isn't installed"
-            {}
-          rescue Vips::Error => error
-            logger.error "Skipping image analysis due to an Vips error: #{error.message}"
-            {}
-          end
-
-          ROTATIONS = /Right-top|Left-bottom|Top-right|Bottom-left/
-
-          def rotated_image?(image)
-            ROTATIONS === image.get("exif-ifd0-Orientation")
-          rescue ::Vips::Error
-            false
-          end
-
-          def valid_image?(image)
-            image.avg
-            true
-          rescue ::Vips::Error
-            false
-          end
-      end
-    end
-  end
-end

data/lib/vitals_image/core_extensions/active_storage/isolated_image_analyzer.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module VitalsImage
-  module CoreExtensions
-    module ActiveStorage
-      class IsolatedImageAnalyzer < ImageAnalyzer
-        def metadata
-          read_image do |image|
-            if rotated_image?(image)
-              { width: image.height, height: image.width, isolated: isolated?(image) }
-            else
-              { width: image.width, height: image.height, isolated: isolated?(image) }
-            end
-          end
-        end
-
-        private
-          def isolated?(image)
-            corners = extract_corner_areas(image)
-            colors  = corners.map { |corner| primary_color_for(corner) }
-            colors.all? { |color| color.all? { |value| value > 250 } }
-          rescue
-            false
-          end
-
-          def extract_corner_areas(image)
-            paths = []
-
-            basename = SecureRandom.urlsafe_base64
-            width    = image.width
-            height   = image.height
-            size     = 8
-
-            filename = Rails.root.join("tmp", "#{basename}.jpg")
-            `vips copy #{image.filename} #{filename}`
-
-            paths << Rails.root.join("tmp", "#{basename}_top_left.jpg")
-            `vips im_extract_area #{filename} #{paths.last} 0 0 #{size} #{size}`
-
-            paths << Rails.root.join("tmp", "#{basename}_top_right.jpg")
-            `vips im_extract_area #{filename} #{paths.last} #{width - size} 0 #{size} #{size}`
-
-            paths << Rails.root.join("tmp", "#{basename}_bottom_right.jpg")
-            `vips im_extract_area #{filename} #{paths.last} #{width - size} #{height - size} #{size} #{size}`
-
-            paths << Rails.root.join("tmp", "#{basename}_bottom_left.jpg")
-            `vips im_extract_area #{filename} #{paths.last} 0 #{height - size} #{size} #{size}`
-
-            paths
-          end
-
-          def primary_color_for(filepath)
-            histogram = generate_color_histogram(filepath)
-            sorted    = sort_by_frequency(histogram)
-            extract_dominant_rgb(sorted)
-          end
-
-          def generate_color_histogram(path)
-            `convert #{path} +dither -colors 5 -define histogram:unique-colors=true -format "%c" histogram:info:`
-          end
-
-          def sort_by_frequency(histogram)
-            histogram.each_line.map { |line| parts = line.split(":"); [parts[0].to_i, parts[1]] }.sort_by { |line| line[0] }.reverse
-          end
-
-          def extract_dominant_rgb(array)
-            array.map { |line| line[1].match(/\(([\d.,]+)/).captures.first.split(",").take(3).map(&:to_i) }.first
-          end
-      end
-    end
-  end
-end