photo-cook 1.1.2 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6005409b8dc3c640b98055fdf5632229ba5f4f1c
-  data.tar.gz: 39172ae4df3922a0e45a95971b2851a0ae58351a
+  metadata.gz: 54e3edc9dd1cca1b0bb175a4d1015b220f01d12e
+  data.tar.gz: 83bd26d3887b920c1a289d92cc4a274bada08c8b
 SHA512:
-  metadata.gz: 751fd68124f6dc8c7006587354a258f5a65c654c863a7eb6fabfaf1f321a63aaabf09ea72ad53a86de292bd11b3b1a058ee3c4765dde103961fe7db47c58a9aa
-  data.tar.gz: 8afd24b253d69b657f4308c85950f1d7f9ce6c4086cbdc0059fb2571a3c46a8f4b68a874c649ec780032c79a604f8a948507f69b9d5588f1a9a445801b449ef0
+  metadata.gz: fc6465991aac047ceb19817f305ade9d39949e6aa737b7fa82419b6bed5a3c5203907c29516a852472247155371112eefd823082a9d701315bf72158edd54059
+  data.tar.gz: a58e5f69881238958e46fd6b8379cbc49de2d67c94b417b3bccb45464558693660941d452ea2023515734acd373b5dd1146745d0f52d634685229dd9061b20e4

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+
+rvm:
+  - 2.3.1
+
+cache: bundler
+
+branches:
+  only:
+    - master
+
+env:
+  - RAILS_ENV=test RAKE_ENV=test
+
+script:
+  - bundle exec rake test

data/Gemfile

@@ -1,16 +1,6 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-# Declare your gem's dependencies in photo_cook.gemspec.
-# Bundler will treat runtime dependencies like base dependencies, and
-# development dependencies will be added by default to the :development group.
 gemspec
 
-# Declare any dependencies that are still in development here instead of in
-# your gemspec. These might include edge Rails or gems from your path or
-# Git. Remember to move these dependencies to your gemspec before releasing
-# your gem to rubygems.org.
-
-# To use debugger
-# gem 'debugger'
-
-gem 'mini_magick'
+gem 'test-unit',       '~> 3.1'
+gem 'shoulda-context', '~> 1.2'

data/README.md

@@ -10,6 +10,6 @@
 #       uploads
 #         photos
 #           1
-#             width=auto&height=640&pixel_ratio=1&crop=yes
+#             fit-640x640
 #               car.png
-```
+```

data/Rakefile

@@ -4,19 +4,6 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'PhotoCook'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-
-
-
 Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
@@ -24,9 +11,9 @@ require 'rake/testtask'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
   t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.pattern = 'test/**/test*.rb'
   t.verbose = false
 end
 
-
+desc 'Run test suite'
 task default: :test

data/app/assets/javascripts/photo-cook/photo-cook.coffee

@@ -0,0 +1,90 @@
+@PhotoCook =
+
+  initialize: -> try PhotoCook.persistDevicePixelRatio()
+
+  resizeCacheDir: do ->
+    if document? and (head = document.getElementsByTagName('head')[0])?
+      for el in head.getElementsByTagName('meta')
+        if el.getAttribute('name') is 'photo_cook:resize:cache_dir'
+          break if value = el.getAttribute('content')
+    value or 'resize-cache'
+
+  resizeCommandRegex: /^fit|fill\-\d+x\d+$/
+
+  # Returns device pixel ratio (float)
+  # If no ratio could be determined will return normal ratio (1.0)
+  devicePixelRatio: do ->
+    # https://gist.github.com/marcedwards/3446599
+    mediaQuery = [
+      '(-webkit-min-device-pixel-ratio: 1.3)'
+      '(-o-min-device-pixel-ratio: 13/10)'
+      'min-resolution: 120dpi'
+    ].join(', ')
+
+    ratio = window?.devicePixelRatio
+
+    # If no ratio found check if screen is retina
+    # and if so return 2x ratio
+    if not ratio and window?.matchMedia?(mediaQuery).matches
+      ratio = 2.0
+
+    parseFloat(ratio) or 1.0
+
+  resizeMultiplier: @devicePixelRatio
+
+  persistDevicePixelRatio: ->
+    date = new Date()
+
+    # Expires in 1 year
+    date.setTime(date.getTime() + 365 * 24 * 60 * 60 * 1000)
+    expires = 'expires=' + date.toUTCString()
+    document.cookie = 'DevicePixelRatio=' + PhotoCook.devicePixelRatio + '; ' + expires
+    return
+
+  resize: (path, width, height, mode, options) ->
+    multiplier = options?.multiplier or PhotoCook.resizeMultiplier
+    command    = "#{mode or 'fit'}-#{Math.floor(width  * multiplier)}x#{Math.floor(height * multiplier)}"
+    pathTokens = path.split('/');
+    pathTokens.splice(-1, 0, PhotoCook.resizeCacheDir, command)
+    pathTokens.join('/')
+
+  strip: (uri) ->
+    sections = uri.split('/')
+    length   = sections.length
+    return uri if length < 3
+
+    cacheDir = sections[length - 3];
+    command  = sections[length - 2];
+
+    return uri unless cacheDir is PhotoCook.resizeCacheDir
+    return uri unless PhotoCook.resizeCommandRegex.test(command)
+
+    sections.splice(length - 3, 2)
+    sections.join('/')
+
+  uriRegex: /^[-a-z]+:\/\/|^(?:cid|data):|^\/\//i
+
+    # Returns true if given URL can produce request to PhotoCook middleware on server
+    # This is important thing you probably should override when using CDN or different assets delivery method
+  isServableURL: (url) ->
+    # By default check that URL is relative
+    !PhotoCook.uriRegex.test(url)
+
+  sizeToFit: (maxw, maxh, reqw, reqh, round) ->
+    outw  = maxw
+    outh  = maxh
+
+    scale = if outw > reqw then reqw / outw else 1.0
+    outw *= scale
+    outh *= scale
+
+    scale = if outh > reqh then reqh / outh else 1.0
+    outw *= scale
+    outh *= scale
+
+    if !round? or round # (null or undefined) OR true-value
+      [Math.floor(outw), Math.floor(outh)]
+    else
+      [outw, outh]
+
+PhotoCook.initialize()

data/app/helpers/photo_cook_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module PhotoCookHelper
+  def device_pixel_ratio
+    PhotoCook.device_pixel_ratio
+  end
+
+  def resize_multiplier
+    PhotoCook::Resize.multiplier
+  end
+
+  def photo_cook_cache_key
+    "resize_multiplier:#{resize_multiplier}"
+  end
+end

data/lib/photo-cook/device-pixel-ratio-spy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module PhotoCook
+  module DevicePixelRatioSpy
+    extend ActiveSupport::Concern
+
+    included { before_action :pass_device_pixel_ratio }
+
+    def pass_device_pixel_ratio
+      ratio = PhotoCook::DevicePixelRatio.parse(cookies[:DevicePixelRatio])
+      PhotoCook.device_pixel_ratio = if PhotoCook::DevicePixelRatio.valid?(ratio)
+        ratio
+      else
+        PhotoCook::DevicePixelRatio::DEFAULT
+      end
+    end
+  end
+end

data/lib/photo-cook/device-pixel-ratio.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module PhotoCook
+  module DevicePixelRatio
+    DEFAULT = 1.0.freeze
+    MAX     = 4.0.freeze
+
+    class << self
+      def parse(x)
+        typecast(x)
+      end
+
+      def parse!(x)
+        check!(x = parse(x))
+        x
+      end
+
+      def check!(x)
+        x = typecast(x)
+        raise Invalid,     x if !x.kind_of?(Integer) && (x.nan? || x.infinite?)
+        raise OutOfBounds, x if x < DEFAULT || x > MAX
+        true
+      end
+
+      # Do not produce various number of pixel ratios:
+      #   1.0 => 1
+      #   2.5 => 3
+      #   2.1 => 3
+      #   3.1 => 4
+      def unify(x)
+        typecast(x).ceil
+      end
+
+      def valid?(x)
+        check!(x)
+      rescue Invalid, OutOfBounds
+        false
+      end
+
+      def typecast(x)
+        x.kind_of?(Numeric) ? x : x.to_f
+      end
+    end
+
+    class Invalid < ArgumentError
+      def initialize(*)
+        super 'Device pixel ratio is invalid (NaN) or infinite number'
+      end
+    end
+
+    class OutOfBounds < ArgumentError
+      def initialize(*)
+        super 'Device pixel ratio must be positive number (integer or float) ' +
+              "which satisfies #{DEFAULT} <= x <= #{MAX}"
+      end
+    end
+  end
+
+  class << self
+    def device_pixel_ratio
+      @device_pixel_ratio || DevicePixelRatio::DEFAULT
+    end
+
+    def device_pixel_ratio=(x)
+      @device_pixel_ratio = DevicePixelRatio.parse!(x)
+    end
+  end
+end

data/lib/photo-cook/engine.rb

@@ -1,7 +1,20 @@
+# frozen_string_literal: true
 module PhotoCook
   class Engine < ::Rails::Engine
-    initializer :photo_cook_javascripts do |app|
+    initializer :photo_cook_root do |app|
+      PhotoCook.root_path = Rails.root.to_s
+    end
+
+    initializer :photo_cook_logger do |app|
+      PhotoCook.logger = Rails.logger
+    end
+
+    initializer :photo_cook_assets do |app|
       app.config.assets.paths << File.join(PhotoCook::Engine.root, 'app/assets/javascripts')
     end
+
+    config.before_initialize do |app|
+      app.config.middleware.insert_before(Rack::Sendfile, PhotoCook::Resize::Middleware)
+    end
   end
-end
+end

data/lib/photo-cook/events.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module PhotoCook
+  class << self
+    def notify(event, *params)
+      blocks = @events && @events[event.to_s]
+      blocks && blocks.each { |blk| Utils.call_block_with_floating_arguments(blk, params) }
+      nil
+    end
+
+    def subscribe(event, &block)
+      ((@events ||= {})[event.to_s] ||= []) << block
+      nil
+    end
+  end
+end

data/lib/photo-cook/logger.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module PhotoCook
+  class << self
+    attr_accessor :logger
+    attr_accessor :logger_evaluator
+
+    def log(&block)
+      logger_evaluator.instance_eval do
+        log "\n"
+        log '--- PhotoCook ---'
+        instance_eval(&block)
+        log '---'
+      end if @logging_enabled
+      nil
+    end
+
+    def enable_logging!
+      @logging_enabled = true
+      nil
+    end
+
+    def disable_logging!
+      @logging_enabled = false
+      nil
+    end
+  end
+
+  class LoggerEvaluator
+    def log(msg)
+      PhotoCook.logger.info(msg)
+    end
+  end
+
+  self.logger           = Logger.new(STDOUT)
+  self.logger_evaluator = LoggerEvaluator.new
+  enable_logging!
+end

data/lib/photo-cook/optimization/__api__.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Optimization
+    class << self
+      # TODO PhotoCook::Optimization.optimizer = :image_optim
+      attr_accessor :optimizer
+
+      def perform(path)
+        if File.readable?(path) && (optimizer = self.optimizer)
+          result, msec = PhotoCook::Utils.measure { optimizer.optimize(path) }
+          params       = [path]
+          params.push(result[:before], result[:after], msec) if result
+          PhotoCook.notify("optimization:#{result ? 'success' : 'failure'}", *params)
+          !!result
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/photo-cook/optimization/carrierwave.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Optimization
+    module CarrierWave
+      def optimize
+        PhotoCook::Optimization.perform(current_path)
+      end
+    end
+  end
+end

data/lib/photo-cook/optimization/image-optim.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Optimization
+    class ImageOptim
+      include Singleton
+
+      def optimize(path)
+        result = image_optim.optimize_image!(path)
+        if result.kind_of?(::ImageOptim::ImagePath::Optimized)
+          { before: result.original_size, after: result.size }
+        else
+          false
+        end
+      end
+
+    protected
+      # https://github.com/toy/image_optim
+      def image_optim
+        @image_optim ||= ::ImageOptim.new(
+
+          # Nice level (defaults to 10)
+          nice: 10,
+
+          # Number of threads or disable (defaults to number of processors)
+          threads: begin
+            match = if OS.osx?
+              `sysctl -a | grep machdep.cpu | grep thread_count`
+            else
+              `cat /proc/cpuinfo | grep "cpu cores"`
+            end
+            $~.to_s.to_i if match.to_s =~ /\d{1,2}/
+          end,
+
+          # Verbose output (defaults to false)
+          verbose: false,
+
+          # Require image_optim_pack or disable it, by default image_optim_pack will be used if available, will turn on :skip-missing-workers unless explicitly disabled (defaults to nil)
+          pack: nil,
+
+          # Skip workers with missing or problematic binaries (defaults to false)
+          skip_missing_workers: nil,
+
+          # Allow lossy workers and optimizations (defaults to false)
+          allow_lossy: false,
+
+          advpng: {
+            # Compression level: 0 - don't compress, 1 - fast, 2 - normal, 3 - extra, 4 - extreme (defaults to 4)
+            level: 1
+          },
+          gifsicle: {
+            # Interlace: true - interlace on, false - interlace off, nil - as is in original image (defaults to running two instances, one with interlace off and one with on)
+            interlace: nil,
+
+            # Compression level: 1 - light and fast, 2 - normal, 3 - heavy (slower) (defaults to 3)
+            level: 1,
+
+            # Avoid bugs with some software (defaults to false)
+            careful: false
+          },
+          jhead: {},
+          jpegoptim: {
+            # List of extra markers to strip: :comments, :exif, :iptc, :icc or :all (defaults to :all)
+            strip: :all,
+
+            # Maximum image quality factor 0..100, ignored in default/lossless mode (defaults to 100)
+            max_quality: 100
+          },
+          jpegrecompress: {
+            # JPEG quality preset: 0 - low, 1 - medium, 2 - high, 3 - veryhigh (defaults to 3)
+            quality: 3
+          },
+          jpegtran: {
+
+            # Copy all chunks
+            copy_chunks: false,
+
+            # Create progressive JPEG file
+            progressive: true,
+
+            # Use jpegtran through jpegrescan, ignore progressive option
+            jpegrescan: false
+          },
+          optipng: {
+            # Optimization level preset: 0 is least, 7 is best
+            level: 3,
+
+            # Interlace: true - interlace on, false - interlace off, nil - as is in original image
+            interlace: false,
+
+            # Remove all auxiliary chunks (defaults to true)
+            strip: true
+          },
+          pngcrush: {
+            # List of chunks to remove or :alla - all except tRNS/transparency or :allb - all except tRNS and gAMA/gamma (defaults to :alla)
+            chunks: :alla,
+
+            # Fix otherwise fatal conditions such as bad CRCs (defaults to false)
+            fix: false,
+
+            # Brute force try all methods, very time-consuming and generally not worthwhile (defaults to false)
+            brute: false,
+
+            # Blacken fully transparent pixels (defaults to true)
+            blacken: true
+          },
+          pngout: {
+            # Copy optional chunks (defaults to false)
+            copy_chunks: false,
+
+            # Strategy: 0 - xtreme, 1 - intense, 2 - longest Match, 3 - huffman Only, 4 - uncompressed (defaults to 0)
+            strategy: 2
+          },
+          pngquant: {
+            # min..max - don't save below min, use less colors below max (both in range 0..100; in yaml - !ruby/range 0..100), ignored in default/lossless mode (defaults to 100..100, 0..100 in lossy mode)
+            quality: 100..100,
+
+            # speed/quality trade-off: 1 - slow, 3 - default, 11 - fast & rough (defaults to 3)
+            speed: 11
+          },
+          svgo: {
+            # List of plugins to disable (defaults to [])
+            disable_plugins: [],
+
+            # List of plugins to enable (defaults to [])
+            enable_plugins: []
+          }
+        )
+      end
+    end
+  end
+end

data/lib/photo-cook/optimization/job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Optimization
+    class Job < ActiveJob::Base
+      queue_as :photo_cook
+
+      def perform(path)
+        PhotoCook::Optimization.perform(path)
+      end
+    end
+  end
+end

data/lib/photo-cook/optimization/logging.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+PhotoCook.subscribe 'optimization:success' do |path, original_size, new_size, msec|
+  PhotoCook.log do
+    diff = original_size - new_size
+    log "Optimization successfully performed"
+    log "File path:     #{path}"
+    log "Original size: #{PhotoCook::Utils.format_size(original_size)}"
+    log "New size:      #{PhotoCook::Utils.format_size(new_size)}"
+    log "Saved:         #{PhotoCook::Utils.format_size(diff)} / #{diff} bytes / #{(diff / original_size.to_f * 100.0).round(2)}%"
+    log "Completed in:  #{msec.round(1)}ms"
+  end
+end
+
+PhotoCook.subscribe 'optimization:failure' do |path|
+  PhotoCook.log do
+    log "Optimization failed because one of the following:"
+    log "1) photo is already optimized;"
+    log "2) some problem occurred with optimization utility."
+    log "Related to: #{path}"
+  end
+end

data/lib/photo-cook/pixels.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Pixels
+    MAX = 4256.freeze
+
+    class << self
+      def parse(x)
+        round(typecast(x))
+      end
+
+      def parse!(x)
+        check!(x = parse(x))
+        x
+      end
+
+      def check!(x)
+        x = typecast(x)
+        raise Invalid,     x if !x.kind_of?(Integer) && (x.nan? || x.infinite?)
+        raise OutOfBounds, x unless in_bounds?(x)
+        true
+      end
+
+      def in_bounds?(x)
+        x = typecast(x)
+        0 < x && x <= MAX
+      end
+
+      # Standardize how dimensions are rounded in PhotoCook
+      def round(x)
+        x.floor
+      end
+
+      # Returns Imagemagick dimension-string
+      def to_magick_dimensions(width, height)
+        "#{width}x#{height}"
+      end
+
+      def typecast(x)
+        x.kind_of?(Numeric) ? x : x.to_f
+      end
+    end
+
+    class OutOfBounds < ArgumentError
+      def initialize(*)
+        super 'Size must be positive number (integer or float) ' +
+              "which satisfies 0 < x <= #{MAX}"
+      end
+    end
+
+    class Invalid < ArgumentError
+      def initialize(*)
+        super 'Size is invalid (NaN) or infinite number'
+      end
+    end
+  end
+end