image_optim_tolerance 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cc3fcc0b514deaa80ade949a9ac3d9ba7425eefa
+  data.tar.gz: 20aa1f1e9cb06a616f489f56dcc465146a8056be
+SHA512:
+  metadata.gz: 7c7b0ae401482f733fd5cecc3abc023c37222106353e17702cfbd1e5423ffdfd0324138821fb6447ddfc819ef7a45c4d93ad43f724c4c18e8e13d2666c32c3d5
+  data.tar.gz: 468ec21bfd083103f71596e494ec44695c184a415213a67a8ad02c995fc63451632833c18093ad814059112c8328722034e47bc610f3a6e350c13c9511aadc44

data/LICENSE

@@ -0,0 +1,16 @@
+ImageOptimTolerance
+Copyright (c) 2014 LinkedIn Corp.  All rights reserved.
+Apache Software License 2.0
+
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,33 @@
+# image\_optim\_tolerance
+
+Tests that an image is compressed within a specified tolerance. [image_optim](https://github.com/toy/image_optim) does all the heavy lifting.
+
+## Installation
+
+### Install the gem
+
+```sh
+[sudo] gem install image\_optim\_tolerance
+```
+
+Instead of installing the gem directly via the command line, we recommend using [Bundler](http://gembundler.com/) to manage your gem dependencies.
+
+## Usage
+
+```
+Usage: image\_optim\_tolerance path [, path2 [, pathN]]
+
+Examples:
+ image\_optim\_tolerance /path/to/image.png /path/to/other/image.jpg
+ image\_optim\_tolerance -t 5 /path/to/image.png /path/to/other/image.jpg
+
+@options:
+    -t, --tolerance NUMBER           the maximum allowed compression tolerance (in percentage)
+    -a, --[no-]aggressive            if aggressive, also return the non-failing (acceptable) offenders if there are other offenders
+    -v, --[no-]verbose               run verbosely
+    -h, --help                       shows this help message
+```
+
+## Configuration
+
+See [image_optim](https://github.com/toy/image_optim) for configuration options. e.g. use a `.image_optim.yml` file.

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/bin/image_optim_tolerance

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "#{File.join(File.dirname(__FILE__), '..', 'lib/image_optim_tolerance/executor')}"

data/lib/image_optim_tolerance/executor.rb

@@ -0,0 +1,62 @@
+require 'optparse'
+
+require "#{File.join(File.dirname(__FILE__), 'image_optim_tolerance')}"
+
+# allow ImageOptim.app path to be discoverable if it exists
+image_optim_app_path = '/Applications/ImageOptim.app/Contents/MacOS'
+ENV['PATH'] = "#{image_optim_app_path}:#{ENV['PATH']}" if File.exist?(image_optim_app_path)
+
+# defaults
+options = {}
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Tests that an image is compressed within a specified tolerance\n\n"
+  opts.define_head "Usage: image_optim_tolerance path [, path2 [, pathN]]"
+  opts.separator ""
+  opts.separator "Examples:"
+  opts.separator " image_optim_tolerance /path/to/image.png /path/to/other/image.jpg"
+  opts.separator " image_optim_tolerance -t 5 /path/to/image.png /path/to/other/image.jpg"
+  opts.separator ""
+  opts.separator "@options:"
+
+  opts.on('-t', '--tolerance NUMBER', Float, 'the maximum allowed compression tolerance (in percentage)') do |v|
+    options[:tolerance] = v
+  end
+
+  opts.on("-a", "--[no-]aggressive", "if aggressive, also return the non-failing (acceptable) offenders if there are other offenders") do |v|
+    options[:aggressive] = v
+  end
+
+  opts.on("-v", "--[no-]verbose", "run verbosely") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on('-h', '--help', 'shows this help message') do
+    puts opts
+    exit
+  end
+end
+opts.parse!
+
+if not ARGV.empty?
+  image_optim_tolerance = ImageOptimTolerance.new(options)
+  offenders = image_optim_tolerance.offenders(ARGV)
+  if offenders && offenders.count > 0
+    $stderr << <<-TEXT.gsub(/^\s*\|/, '')
+    |the following images are not optimized:
+    |
+    |  #{offenders.join("\n  ")}
+    |
+    |FAILED
+    TEXT
+    exit 1
+  else
+    puts "PASSED"
+    exit 0
+  end
+else
+  puts opts
+  exit 1
+end
+
+exit

data/lib/image_optim_tolerance/image_optim_tolerance.rb

@@ -0,0 +1,90 @@
+require 'rubygems'
+require 'image_optim'
+
+class ImageOptimTolerance
+
+  attr_accessor :options
+
+  def initialize(options = {})
+    self.options = DEFAULTS.merge(options)
+  end
+
+  def is_valid_image(path)
+    return false if path.nil? or path.empty?
+    valid_pattern = /.*\.(gif|png|jpeg|jpg|svg)$/
+    return ((valid_pattern =~ path.to_s.strip) && File.exist?(path))
+  end
+
+  def log(msg, type = nil)
+    if self.options[:verbose]
+      puts (type && MARKS[type]) ? "  #{MARKS[type]} #{msg}" : msg
+    end
+  end
+
+  def offenders(paths)
+    offenders = {
+      :terrible   => [],
+      :acceptable => []
+    }
+    paths = [paths] if paths.is_a?(String)
+    paths.each do |path|
+      if self.is_valid_image(path)
+        self.log "checking optimization of #{path}..."
+        optimized = image_optim.optimize_image(path)
+        if optimized
+          size = {}
+          size[:original]   = File.size(path)
+          size[:optimized]  = File.size?(optimized) || size[:original]
+          size[:saved]      = size[:original] - size[:optimized]
+          size[:percentage] = size[:saved].to_f / size[:original].to_f * 100
+
+          if size[:saved] > 0
+            self.log "could have saved #{size[:saved]} bytes (#{size[:percentage].ceil}%)!", :sad
+            if size[:percentage] > self.options[:tolerance]
+              self.log "exceeds tolerance threshold by #{(size[:percentage] - self.options[:tolerance]).ceil}%", :bad
+              offenders[:terrible] << path
+            else
+              offenders[:acceptable] << path
+              self.log "within acceptable tolerance", :good
+            end
+            next
+          end
+        else
+          self.log "nothing to see here", :happy
+        end
+      end
+    end
+
+    # if there are terrible offenders that are above the threshold
+    if offenders[:terrible].count > 0
+      # return both the terrible and acceptable, if we're being aggressive
+      return offenders[:terrible] + offenders[:acceptable] if self.options[:aggressive]
+      return offenders[:terrible]
+    end
+
+    return nil
+  end
+
+  def verify(paths)
+    return self.offenders(paths).nil?
+  end
+
+private
+  MARKS = {
+    # Ruby < 1.9 has bad unicode support, so we're doing it this way
+    :good   => ['2714'.to_i(16)].pack('U*'),
+    :bad    => ['2717'.to_i(16)].pack('U*'),
+    :happy  => ['263A'.to_i(16)].pack('U*'),
+    :sad    => ['2639'.to_i(16)].pack('U*')
+  }
+
+  DEFAULTS = {
+    :tolerance  => 0,
+    :aggressive => true,
+    :verbose    => false
+  }
+
+  def image_optim
+    @image_optim ||= ImageOptim.new()
+  end
+end

data/lib/image_optim_tolerance/version.rb

@@ -0,0 +1,3 @@
+module ImageOptimTolerance
+  VERSION = File.read(File.join(File.dirname(__FILE__), "..", "..", "VERSION")).strip
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: image_optim_tolerance
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Eugene ONeill
+- LinkedIn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: image_optim
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+description: verifies that images are within an acceptable compression tolerance
+email: oneill.eugene@gmail.com
+executables:
+- image_optim_tolerance
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- VERSION
+- bin/image_optim_tolerance
+- lib/image_optim_tolerance/executor.rb
+- lib/image_optim_tolerance/image_optim_tolerance.rb
+- lib/image_optim_tolerance/version.rb
+homepage: 
+licenses:
+- Apache License (2.0)
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: verifies that images are within an acceptable compression tolerance
+test_files: []