image_resizer 0.1.4

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@image_resizer

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+
+group :development, :test do
+  gem 'rspec'
+  gem 'jeweler'
+  gem 'pry'
+  gem 'pry-nav'
+  gem 'pry-stack_explorer'
+end

data/Gemfile.lock

@@ -0,0 +1,45 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    binding_of_caller (0.6.7)
+    coderay (1.0.6)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.6.6)
+    method_source (0.7.1)
+    pry (0.9.8.4)
+      coderay (~> 1.0.5)
+      method_source (~> 0.7.1)
+      slop (>= 2.4.4, < 3)
+    pry-nav (0.2.0)
+      pry (~> 0.9.8.1)
+    pry-stack_explorer (0.4.1)
+      binding_of_caller (~> 0.6.2)
+      pry (~> 0.9.8.2)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    slop (2.4.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  pry
+  pry-nav
+  pry-stack_explorer
+  rspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+Copyright (c) 2012 Daniel W. Nelson
+Development sponsored by Centresource, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+ImageResizer
+============
+
+Provides an interface to ImageMagick for extracting image information and resizing / cropping.
+
+
+Usage
+=====
+
+In your Gemfile:
+
+    gem 'image_resizer'
+
+Example:
+
+    image = ImageResizer::TempObject.new(File.new(path_to_image_file))
+    processor = ImageResizer::Processor.new
+
+    # resize to fit the specified width, maintaining the original ratio
+    resized_file = processor.resize(temp_object, :width => 320)
+
+    # resize to fit the specified height, maintaining the original ratio
+    resized_file = processor.resize(temp_object, :height => 240)
+
+    # resize to the specified dimensions, cropping around the center to avoid stretching
+    resized_file = processor.resize(temp_object, :width => 320, :height => 240)
+
+    # crop the original image to a frame and resize the result
+    upper_left = [0.25, 0.15] # 25% from the left, 15% from the top 
+    lower_right = [0.75, 0.95] # 75% from the left, 95% from the top
+    width = 320
+    resized_file = processor.crop_to_frame_and_resize(temp_object,
+                                      :upper_left => upper_left,
+                                      :lower_right => lower_right,
+                                      :width => width
+                                      )
+
+    # crop the original image around a point and resize the result
+    point = [0.8, 0.3] # 80% from the left, 30% from the top
+    width = 320
+    height = 400
+    resized_file = processor.resize_and_crop_around_point(temp_object,
+                                      :point => point,
+                                      :width => width,
+                                      :height => height
+                                      )
+    File.open(output_file, 'wb') { |f| f.write(File.read(processed)) }
+
+
+Credits
+=======
+
+This project is heavily indebted to [Dragonfly](https://github.com/markevans/dragonfly). We needed the ability to crop and resize images, but there didn't appear to be any gems devoted to just that. Paperclip and Dragonfly both perform scaling and cropping using ImageMagick, but both do so as part of a larger project. So we pulled the ImageMagick specific parts out of Dragonfly, added new specs and cropping options, and are releasing the result as a dedicated image resizing gem.
+
+
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "image_resizer"
+  gem.homepage = "http://github.com/populr/image_resizer"
+  gem.license = "MIT"
+  gem.summary = %Q{Image resizing gem (requires ImageMagick)}
+  gem.description = %Q{Image resizing gem (requires ImageMagick)}
+  gem.email = "daniel@populr.me"
+  gem.authors = ["Daniel Nelson"]
+  # dependencies defined in Gemfile
+  gem.files.exclude 'spec'
+  gem.files.exclude 'samples'
+  gem.files.exclude 'tmp'
+  gem.files.exclude 'demo.rb'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "image_resizer #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.4

data/image_resizer.gemspec

@@ -0,0 +1,93 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "image_resizer"
+  s.version = "0.1.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Daniel Nelson"]
+  s.date = "2012-04-24"
+  s.description = "Image resizing gem (requires ImageMagick)"
+  s.email = "daniel@populr.me"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    ".rspec",
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "image_resizer.gemspec",
+    "lib/image_resizer.rb",
+    "lib/image_resizer/analyzer.rb",
+    "lib/image_resizer/configurable.rb",
+    "lib/image_resizer/encoder.rb",
+    "lib/image_resizer/has_filename.rb",
+    "lib/image_resizer/loggable.rb",
+    "lib/image_resizer/processor.rb",
+    "lib/image_resizer/shell.rb",
+    "lib/image_resizer/temp_object.rb",
+    "lib/image_resizer/utils.rb",
+    "samples/DSC02119.JPG",
+    "samples/a.jp2",
+    "samples/beach.jpg",
+    "samples/beach.png",
+    "samples/egg.png",
+    "samples/landscape.png",
+    "samples/round.gif",
+    "samples/sample.docx",
+    "samples/taj.jpg",
+    "samples/white pixel.png",
+    "spec/image_resizer/analyzer_spec.rb",
+    "spec/image_resizer/configurable_spec.rb",
+    "spec/image_resizer/encoder_spec.rb",
+    "spec/image_resizer/has_filename_spec.rb",
+    "spec/image_resizer/loggable_spec.rb",
+    "spec/image_resizer/processor_spec.rb",
+    "spec/image_resizer/shell_spec.rb",
+    "spec/image_resizer/temp_object_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/argument_matchers.rb",
+    "spec/support/image_matchers.rb",
+    "spec/support/simple_matchers.rb",
+    "tmp/test_file"
+  ]
+  s.homepage = "http://github.com/populr/image_resizer"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Image resizing gem (requires ImageMagick)"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
+      s.add_development_dependency(%q<pry-nav>, [">= 0"])
+      s.add_development_dependency(%q<pry-stack_explorer>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<pry-nav>, [">= 0"])
+      s.add_dependency(%q<pry-stack_explorer>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<pry-nav>, [">= 0"])
+    s.add_dependency(%q<pry-stack_explorer>, [">= 0"])
+  end
+end
+

data/lib/image_resizer/analyzer.rb

@@ -0,0 +1,51 @@
+module ImageResizer
+  class Analyzer
+
+    include Configurable
+    include Utils
+
+    def width(temp_object)
+      identify(temp_object)[:width]
+    end
+
+    def height(temp_object)
+      identify(temp_object)[:height]
+    end
+
+    def aspect_ratio(temp_object)
+      attrs = identify(temp_object)
+      attrs[:width].to_f / attrs[:height]
+    end
+
+    def portrait?(temp_object)
+      attrs = identify(temp_object)
+      attrs[:width] <= attrs[:height]
+    end
+    alias portrait portrait?
+
+    def landscape?(temp_object)
+      attrs = identify(temp_object)
+      attrs[:width] >= attrs[:height]
+    end
+    alias landscape landscape?
+
+    def depth(temp_object)
+      identify(temp_object)[:depth]
+    end
+
+    def number_of_colours(temp_object)
+      details = raw_identify(temp_object, '-verbose -unique')
+      details[/Colors: (\d+)/, 1].to_i
+    end
+    alias number_of_colors number_of_colours
+
+    def format(temp_object)
+      identify(temp_object)[:format]
+    end
+
+    def image?(temp_object)
+      !!catch(:unable_to_handle){ identify(temp_object) }
+    end
+
+  end
+end

data/lib/image_resizer/configurable.rb

@@ -0,0 +1,206 @@
+module ImageResizer
+  module Configurable
+
+    # Exceptions
+    class NotConfigured < RuntimeError; end
+    class BadConfigAttribute < RuntimeError; end
+
+    def self.included(klass)
+      klass.class_eval do
+        include Configurable::InstanceMethods
+        extend Configurable::ClassMethods
+      end
+    end
+
+    class DeferredBlock # Inheriting from Proc causes errors in some versions of Ruby
+      def initialize(blk)
+        @blk = blk
+      end
+
+      def call
+        @blk.call
+      end
+    end
+
+    module InstanceMethods
+
+      def configure(&block)
+        yield ConfigurationProxy.new(self)
+        self
+      end
+
+      def configure_with(config, *args, &block)
+        config = saved_config_for(config) if config.is_a?(Symbol)
+        config.apply_configuration(self, *args)
+        configure(&block) if block
+        self
+      end
+
+      def has_config_method?(method_name)
+        config_methods.include?(method_name.to_sym)
+      end
+      
+      def configuration
+        @configuration ||= {}
+      end
+            
+      def config_methods
+        @config_methods ||= self.class.config_methods.dup
+      end
+      
+      def default_configuration
+        @default_configuration ||= self.class.default_configuration.dup
+      end
+
+      def set_config_value(key, value)
+        configuration[key] = value
+        child_configurables.each{|c| c.set_if_unset(key, value) }
+        value
+      end
+      
+      def use_as_fallback_config(other_configurable)
+        other_configurable.add_child_configurable(self)
+        self.fallback_configurable = other_configurable
+      end
+
+      protected
+
+      def add_child_configurable(obj)
+        child_configurables << obj
+        config_methods.push(*obj.config_methods)
+        fallback_configurable.config_methods.push(*obj.config_methods) if fallback_configurable
+      end
+
+      def set_if_unset(key, value)
+        set_config_value(key, value) unless set_locally?(key)
+      end
+
+      private
+      
+      attr_accessor :fallback_configurable
+      
+      def child_configurables
+        @child_configurables ||= []
+      end
+      
+      def set_locally?(key)
+        instance_variable_defined?("@#{key}")
+      end
+      
+      def default_value(key)
+        if default_configuration[key].is_a?(DeferredBlock)
+          default_configuration[key] = default_configuration[key].call
+        end
+        default_configuration[key]
+      end
+
+      def saved_configs
+        self.class.saved_configs
+      end
+
+      def saved_config_for(symbol)
+        config = saved_configs[symbol]
+        if config.nil?
+          raise ArgumentError, "#{symbol.inspect} is not a known configuration - try one of #{saved_configs.keys.join(', ')}"
+        end
+        config = config.call if config.respond_to?(:call)
+        config
+      end
+
+    end
+
+    module ClassMethods
+
+      def default_configuration
+        @default_configuration ||= configurable_ancestors.reverse.inject({}) do |default_config, klass|
+          default_config.merge!(klass.default_configuration)
+          default_config
+        end
+      end
+
+      def config_methods
+        @config_methods ||= configurable_ancestors.inject([]) do |conf_methods, klass|
+          conf_methods |= klass.config_methods
+          conf_methods
+        end
+      end
+
+      def nested_configurables
+        @nested_configurables ||= []
+      end
+
+      def register_configuration(name, config=nil, &config_in_block) 
+        saved_configs[name] = config_in_block || config
+      end
+
+      def saved_configs
+        @saved_configs ||= {}
+      end
+
+      def configurable_ancestors
+        @configurable_ancestors ||= ancestors.select{|a| a.included_modules.include?(Configurable) } - [self]
+      end
+
+      private
+
+      def configurable_attr attribute, default=nil, &blk
+        default_configuration[attribute] = blk ? DeferredBlock.new(blk) : default
+
+        # Define the reader
+        define_method(attribute) do
+          configuration.has_key?(attribute) ? configuration[attribute] : default_value(attribute)
+        end
+
+        # Define the writer
+        define_method("#{attribute}=") do |value|
+          instance_variable_set("@#{attribute}", value)
+          set_config_value(attribute, value)
+        end
+
+        configuration_method attribute
+        configuration_method "#{attribute}="
+      end
+
+      def configuration_method(*method_names)
+        config_methods.push(*method_names.map{|n| n.to_sym }).uniq!
+      end
+      
+      def nested_configurable(*method_names)
+        nested_configurables.push(*method_names)
+      end
+
+    end
+
+    class ConfigurationProxy
+
+      def initialize(owner)
+        @owner = owner
+      end
+
+      def method_missing(method_name, *args, &block)
+        if owner.has_config_method?(method_name)
+          attribute = method_name.to_s.tr('=','').to_sym
+          if method_name.to_s =~ /=$/ && owner.has_config_method?(attribute) # a bit hacky - if it has both getter and setter, assume it's a configurable_attr
+            owner.set_config_value(attribute, args.first)
+          else
+            owner.send(method_name, *args, &block)
+          end
+        elsif nested_configurable?(method_name)
+          owner.send(method_name)
+        else
+          raise BadConfigAttribute, "You tried to configure using '#{method_name.inspect}',  but the valid config attributes are #{owner.config_methods.map{|a| %('#{a.inspect}') }.sort.join(', ')}"
+        end
+      end
+
+      private
+
+      attr_reader :owner
+
+      def nested_configurable?(method)
+        owner.class.nested_configurables.include?(method.to_sym)
+      end
+
+    end
+
+  end
+end

data/lib/image_resizer/encoder.rb

@@ -0,0 +1,55 @@
+module ImageResizer
+  class Encoder
+
+    include Configurable
+    include Utils
+
+    configurable_attr :supported_formats, [
+      :ai,
+      :bmp,
+      :eps,
+      :gif,
+      :gif87,
+      :ico,
+      :j2c,
+      :jp2,
+      :jpeg,
+      :jpg,
+      :pbm,
+      :pcd,
+      :pct,
+      :pcx,
+      :pdf,
+      :pict,
+      :pjpeg,
+      :png,
+      :png24,
+      :png32,
+      :png8,
+      :pnm,
+      :ppm,
+      :ps,
+      :psd,
+      :ras,
+      :tga,
+      :tiff,
+      :wbmp,
+      :xbm,
+      :xpm,
+      :xwd
+    ]
+
+    def encode(temp_object, format, args='')
+      format = format.to_s.downcase
+      throw :unable_to_handle unless supported_formats.include?(format.to_sym)
+      details = identify(temp_object)
+
+      if details[:format] == format.to_sym && args.empty?
+        temp_object
+      else
+        convert(temp_object, args, format)
+      end
+    end
+
+  end
+end

data/lib/image_resizer/has_filename.rb

@@ -0,0 +1,24 @@
+module ImageResizer
+  # Convenience methods for setting basename and extension
+  # Including class needs to define a 'name' accessor
+  # which is assumed to hold a filename-style string
+  module HasFilename
+
+    def basename
+      File.basename(name, '.*') if name
+    end
+
+    def basename=(basename)
+      self.name = [basename, ext].compact.join('.')
+    end
+
+    def ext
+      File.extname(name)[/\.(.*)/, 1] if name
+    end
+
+    def ext=(ext)
+      self.name = [(basename || 'file'), ext].join('.')
+    end
+
+  end
+end

data/lib/image_resizer/loggable.rb

@@ -0,0 +1,28 @@
+require 'logger'
+
+module ImageResizer
+  module Loggable
+
+    def log
+      case @log_object
+      when nil
+        @log_object = Logger.new($stdout)
+      when Proc
+        @log_object[]
+      when Logger
+        @log_object
+      end
+    end
+
+    def log=(object)
+      @log_object = object
+    end
+
+    attr_reader :log_object
+
+    def use_same_log_as(object)
+      self.log = proc{ object.log }
+    end
+
+  end
+end