insano_image_resizer 0.3.0 → 0.3.1

data/README.md

@@ -19,7 +19,7 @@ Usage
 
 In your Gemfile:
 
-    gem 'insano_resizer'
+    gem 'insano_image_resizer'
 
 Example:
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ Bundler.setup(:default, :test)
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
-require 'image_resizer'
+require 'insano_image_resizer'
 require 'fileutils'
 require 'pry'
 require 'pry-nav'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: insano_image_resizer
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -111,18 +111,9 @@ files:
 - README.md
 - Rakefile
 - VERSION
-- lib/image_resizer.rb
-- lib/image_resizer/configurable.rb
-- lib/image_resizer/loggable.rb
-- lib/image_resizer/processor.rb
-- lib/image_resizer/shell.rb
 - samples/explanation.png
 - samples/test.jpg
 - samples/test.png
-- spec/image_resizer/configurable_spec.rb
-- spec/image_resizer/loggable_spec.rb
-- spec/image_resizer/processor_spec.rb
-- spec/image_resizer/shell_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/populr/insano_image_resizer
 licenses:

data/lib/image_resizer.rb

@@ -1,5 +0,0 @@
-
-require 'image_resizer/loggable'
-require 'image_resizer/configurable'
-require 'image_resizer/shell'
-require 'image_resizer/processor'

data/lib/image_resizer/configurable.rb

@@ -1,206 +0,0 @@
-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/loggable.rb

@@ -1,28 +0,0 @@
-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

data/lib/image_resizer/processor.rb

@@ -1,199 +0,0 @@
-require 'yaml'
-require 'shellwords'
-
-module ImageResizer
-  class Processor
-
-    include Configurable
-    include Shell
-    include Loggable
-    
-    def process(input_path, viewport_size = {}, interest_point = {})
-      input_properties = fetch_image_properties(input_path)
-      input_has_alpha = (input_properties["bands"] == 4)
-
-      output_tmp = Tempfile.new(["img", input_has_alpha ? ".png" : ".jpg"])
-
-      transform = calculate_transform(input_path, input_properties, viewport_size, interest_point)
-      run_transform(input_path, output_tmp.path, transform)
-
-      return output_tmp.path
-    end
-
-    def fetch_image_properties(input_path)
-      # read in the image headers to discover the width and height of the image.
-      # There's actually some extra metadata we ignore here, but this seems to be
-      # the only way to get width and height from VIPS.
-      result = run("vips im_printdesc '#{input_path}'")
-
-      # for some reason, the response isn't just YAML. It's one line of text in parenthesis 
-      # followed by YAML. Let's chop off the first line to get to the good stuff.
-      result = result[(result.index(')') + 2)..-1]
-      return YAML::load(result)
-    end
-
-    def calculate_transform(input_path, input_properties, viewport_size, interest_point)
-
-      # Pull out the properties we're interested in
-      image_size = {w: input_properties["width"].to_f, h: input_properties["height"].to_f}
-
-      # By default, the interest size is 30% of the total image size.
-      # In the future, this could be a parameter, and you'd pass the # of pixels around
-      # the POI you are interested in.
-      if (interest_point[:xf])
-        interest_point[:x] = image_size[:w] * interest_point[:xf]
-      end
-      
-      if (interest_point[:yf])
-        interest_point[:y] = image_size[:h] * interest_point[:yf]
-      end
-
-      if (interest_point[:region] == nil)
-        interest_point[:region] = 1
-      end
-
-      if (interest_point[:x] == nil)
-        interest_point[:x] = image_size[:w] * 0.5
-        interest_point[:region] = 1
-      end
-      if (interest_point[:y] == nil)
-        interest_point[:y] = image_size[:h] * 0.5
-        interest_point[:region] = 1
-      end
-
-      interest_size = {w: image_size[:w] * interest_point[:region], h: image_size[:h] * interest_point[:region]}
-
-      # Has the user specified both the width and the height of the viewport? If they haven't,
-      # let's go ahead and fill in the missing properties for them so that they get output at 
-      # the original aspect ratio of the image.
-      if ((viewport_size[:w] == nil) && (viewport_size[:h] == nil))
-        viewport_size = {w: input_properties["width"], h: input_properties["height"]}
-      
-      elsif (viewport_size[:w] == nil)
-        viewport_size[:w] = viewport_size[:h] * (input_properties["width"] / input_properties["height"])
-
-      elsif (viewport_size[:h] == nil)
-        viewport_size[:h] = viewport_size[:w] * (input_properties["height"] / input_properties["width"])
-      end
-
-      # how can we take our current image and fit it into the viewport? Time for
-      # some fun math! First, let's determine a scale such that the image fits
-      # within the viewport. There are a few rules we want to apply:
-      # 1) The image should _always_ fill the viewport.
-      # 2) The 1/3 of the image around the interest_point should always be visible.
-      #    This means that if we try to cram a massive image into a tiny viewport,
-      #    we won't get a simple scale-to-fill. We'll get a more zoomed-in version
-      #    showing just the 1/3 around the interest_point.
-
-      scale_to_fill = [viewport_size[:w] / image_size[:w], viewport_size[:h] / image_size[:h]].max
-      
-      scale_to_interest = [interest_size[:w] / image_size[:w], interest_size[:h] / image_size[:h]].max
-
-      log.debug("POI: ")
-      log.debug(interest_point)
-      log.debug("Image size: ")
-      log.debug(image_size)
-      log.debug("Requested viewport size: ")
-      log.debug(viewport_size)
-      log.debug("scale_to_fill: %f" % scale_to_fill)
-      log.debug("scale_to_interest: %f" % scale_to_interest)
-
-
-      scale_for_best_region = [scale_to_fill, scale_to_interest].max
-
-      # cool! Now, let's figure out what the content offset within the image should be.
-      # We want to keep the point of interest in view whenever possible. First, let's 
-      # compute an optimal frame around the POI:
-      best_region = {x: interest_point[:x].to_f - (image_size[:w] * scale_for_best_region) / 2, 
-                     y: interest_point[:y].to_f - (image_size[:h] * scale_for_best_region) / 2,
-                     w: image_size[:w] * scale_for_best_region,
-                     h: image_size[:h] * scale_for_best_region}
-      
-      # Up to this point, we've been using 'scale_for_best_region' to be the preferred scale of the image. 
-      # So, scale could be 1/3 if we want to show the area around the POI, or 1 if we're fitting a whole image
-      # in a viewport that is exactly the same aspect ratio.
-
-      # The next step is to compute a scale that should be applied to the image to make this desired section of 
-      # the image fit within the viewport. This is different from the previous scale—if we wanted to fit 1/3 of
-      # the image in a 100x100 pixel viewport, we computed best_region using that 1/3, and now we need to find
-      # the scale that will fit it into 100px.
-      scale = [scale_to_fill, viewport_size[:w] / best_region[:w], viewport_size[:h] / best_region[:h]].max
-
-      # Next, we scale the best_region so that it is in final coordinates. When we perform the affine transform, 
-      # it will SCALE the entire image and then CROP it to a region, so our transform rect needs to be in the 
-      # coordinate space of the SCALED image, not the initial image.
-      transform = {}
-      transform[:x] = best_region[:x] * scale
-      transform[:y] = best_region[:y] * scale
-      transform[:w] = best_region[:w] * scale
-      transform[:h] = best_region[:h] * scale
-      transform[:scale] = scale
-
-      # transform now represents the region we'd like to have in the final image. All of it, or part of it, may
-      # not actually be within the bounds of the image! We're about to apply some constraints, but first let's 
-      # trim the best_region so that it's the SHAPE of the viewport, not just the SCALE of the viewport. Remember,
-      # since the region is still centered around the POI, we can just trim equally on either the W or H as necessary.
-      transform[:x] -= (viewport_size[:w] - transform[:w]) / 2
-      transform[:y] -= (viewport_size[:h] - transform[:h]) / 2
-      transform[:w] = viewport_size[:w]
-      transform[:h] = viewport_size[:h]
-
-      # alright—now our transform most likely extends beyond the bounds of the image
-      # data. Let's add some constraints that push it within the bounds of the image.
-      if (transform[:x] + transform[:w] > image_size[:w] * scale)
-        transform[:x] = image_size[:w] * scale - transform[:w]
-      end
-
-      if (transform[:y] + transform[:h] > image_size[:h] * scale)
-        transform[:y] = image_size[:h] * scale - transform[:h]
-      end
-
-      if (transform[:x] < 0)
-        transform[:x] = 0.0
-      end
-
-      if (transform[:y] < 0)
-        transform[:y] = 0.0
-      end
-
-      log.debug("The transform properties:")
-      log.debug(transform)
-
-      return transform
-    end
-
-    def run_transform(input_path, output_path, transform)
-      # Call through to VIPS:
-      # int im_affinei(in, out, interpolate, a, b, c, d, dx, dy, x, y, w, h)
-      # The first six params are a transformation matrix. A and D are used for X and Y
-      # scale, the other two are b = Y skew and c = X skew.  TX and TY are translations
-      # but don't seem to be used.
-      # The last four params define a rect of the source image that is transformed.
-      log.debug(output_path[-3..-1])
-
-      if ((transform[:scale] < 0.5) && (output_path[-3..-1] == "jpg"))
-        scale = transform[:scale]
-        size = [transform[:w], transform[:h]].max
-
-        transform[:scale] = scale * 2
-        transform[:x] *= 2
-        transform[:y] *= 2
-        transform[:w] *= 2
-        transform[:h] *= 2
-
-
-        log.debug("Using two-pass transform")
-        run("vips im_affinei '#{input_path}' '#{output_path}' bilinear #{transform[:scale]} 0 0 #{transform[:scale]} 0 0 #{transform[:x]} #{transform[:y]} #{transform[:w]} #{transform[:h]}")
-        run("vipsthumbnail -s #{size} --nosharpen -o '%s_thumb.jpg:65' '#{output_path}'")
-        FileUtils.mv(output_path[0..-5]+"_thumb.jpg", output_path)
-
-      else 
-        run("vips im_affinei '#{input_path}' '#{output_path}' bilinear #{transform[:scale]} 0 0 #{transform[:scale]} 0 0 #{transform[:x]} #{transform[:y]} #{transform[:w]} #{transform[:h]}")
-
-      end
-
-      return output_path
-    end
-  end
-end
-

data/lib/image_resizer/shell.rb

@@ -1,48 +0,0 @@
-require 'shellwords'
-
-module ImageResizer
-  module Shell
-
-    include Configurable
-    configurable_attr :log_commands, true
-
-    # Exceptions
-    class CommandFailed < RuntimeError; end
-
-    def run(command, args="")
-      full_command = "#{command} #{escape_args(args)}"
-      log.debug("Running command: #{full_command}") if log_commands
-      begin
-        result = `#{full_command}`
-      rescue Errno::ENOENT
-        raise_shell_command_failed(full_command)
-      end
-      if $?.exitstatus == 1
-        throw :unable_to_handle
-      elsif !$?.success?
-        raise_shell_command_failed(full_command)
-      end
-      result
-    end
-
-    def raise_shell_command_failed(command)
-      raise CommandFailed, "Command failed (#{command}) with exit status #{$?.exitstatus}"
-    end
-
-    def escape_args(args)
-      args.shellsplit.map do |arg|
-        quote arg.gsub(/\\?'/, %q('\\\\''))
-      end.join(' ')
-    end
-
-    def quote(string)
-      q = running_on_windows? ? '"' : "'"
-      q + string + q
-    end
-
-    def running_on_windows?
-      ENV['OS'] && ENV['OS'].downcase == 'windows_nt'
-    end
-
-  end
-end

data/spec/image_resizer/configurable_spec.rb

@@ -1,479 +0,0 @@
-require 'spec_helper'
-
-describe ImageResizer::Configurable do
-
-  before(:each) do
-    class Car
-      include ImageResizer::Configurable
-      configurable_attr :colour
-      configurable_attr :top_speed, 216
-      def self.other_thing=(thing); end
-    end
-    @car = Car.new
-  end
-
-  describe "setup" do
-    it "should provide attr_readers for configurable attributes" do
-      @car.should respond_to(:colour)
-    end
-
-    it "should provide attr_writers for configurable attributes" do
-      @car.colour = 'verde'
-      @car.colour.should == 'verde'
-    end
-
-    it "should set default values for configurable attributes" do
-      @car.top_speed.should == 216
-    end
-
-    it "should set the default as nil if not specified" do
-      @car.colour.should be_nil
-    end
-
-    it "should allow setting to nil" do
-      @car.top_speed = nil
-      @car.top_speed.should be_nil
-    end
-
-    it "should allow specifying configurable attrs as strings" do
-      class Bike
-        include ImageResizer::Configurable
-        configurable_attr 'colour', 'rude'
-      end
-      Bike.new.colour.should == 'rude'
-    end
-  end
-
-  describe "configuring" do
-    it "should allow you to change values" do
-      @car.configure do |c|
-        c.colour = 'red'
-      end
-      @car.colour.should == 'red'
-    end
-
-    it "should not allow you to call other methods on the object via the configuration" do
-      lambda{
-        @car.configure do |c|
-          c.other_thing = 5
-        end
-      }.should raise_error(ImageResizer::Configurable::BadConfigAttribute)
-    end
-
-    it "should return itself" do
-      @car.configure{|c|}.should == @car
-    end
-  end
-
-  describe "getting configuration" do
-    it "should return the configuration when nothing is set" do
-      @car.configuration.should == {}
-    end
-    it "should return the configuration when something is set" do
-      @car.top_speed = 10
-      @car.configuration.should == {:top_speed => 10}
-    end
-  end
-
-  describe "multiple objects" do
-    it "should return the default configuration" do
-      Car.default_configuration.should == {:colour => nil, :top_speed => 216}
-    end
-    it "should allow instances to be configured differently" do
-      car1 = Car.new
-      car1.configure{|c| c.colour = 'green'}
-      car2 = Car.new
-      car2.configure{|c| c.colour = 'yellow'}
-      car1.configuration.should == {:colour => 'green'}
-      car2.configuration.should == {:colour => 'yellow'}
-    end
-  end
-
-  describe "lazy attributes" do
-    before(:each) do
-      cow = @cow = mock('cow')
-      class Lazy; end
-      Lazy.class_eval do
-        include ImageResizer::Configurable
-        configurable_attr(:sound){ cow.moo }
-      end
-      @lazy = Lazy.new
-    end
-    it "should not call the block if the configurable attribute is set to something else" do
-      @cow.should_not_receive(:moo)
-      @lazy.configure{|c| c.sound = 'baa' }
-      @lazy.sound.should == 'baa'
-    end
-    it "should call the block if it's not been changed, once it's accessed" do
-      @cow.should_receive(:moo).and_return('mooo!')
-      @lazy.sound.should == 'mooo!'
-    end
-    it "should not call the block when accessed again" do
-      @cow.should_receive(:moo).exactly(:once).and_return('mooo!')
-      @lazy.sound.should == 'mooo!'
-      @lazy.sound.should == 'mooo!'
-    end
-    it "should not call an explicitly passed in proc" do
-      @lazy.configure{|c| c.sound = lambda{ @cow.fart }}
-      @lazy.sound.should be_a(Proc)
-    end
-  end
-
-  describe "configuration method" do
-
-    before(:each) do
-      class ClassWithMethod
-        include ImageResizer::Configurable
-        def add_thing(thing)
-          'poo'
-        end
-        def remove_thing(thing)
-          'bum'
-        end
-        configuration_method :add_thing, :remove_thing
-      end
-      @thing = ClassWithMethod.new
-    end
-
-    it "should allow calling the method through 'configure'" do
-      @thing.configure do |c|
-        c.add_thing('duck')
-        c.remove_thing('dog')
-      end
-    end
-
-  end
-
-  describe "nested configurable objects" do
-
-    before(:each) do
-      class NestedThing
-        include ImageResizer::Configurable
-        configurable_attr :age, 29
-        def some_method(val)
-          @some_thing = val
-        end
-        configuration_method :some_method
-        attr_reader :some_thing
-      end
-
-      class Car
-        def nested_thing
-          @nested_thing ||= NestedThing.new
-        end
-        nested_configurable :nested_thing
-      end
-
-      @car.configure do |c|
-        c.nested_thing.configure do |nt|
-          nt.age = 50
-          nt.some_method('yo')
-        end
-      end
-    end
-
-    it "should allow configuring nested configurable accessors" do
-      @car.nested_thing.age.should == 50
-    end
-
-    it "should allow configuring nested configurable normal methods" do
-      @car.nested_thing.some_thing.should == 'yo'
-    end
-
-    it "should not allow configuring directly on the config object" do
-      expect{
-        @car.configure do |c|
-          c.some_method('other')
-        end
-      }.to raise_error(ImageResizer::Configurable::BadConfigAttribute)
-    end
-  end
-
-  describe "configuring with a saved config" do
-    before(:each) do
-      @cool_configuration = Object.new
-      def @cool_configuration.apply_configuration(car, colour=nil)
-        car.configure do |c|
-          c.colour = (colour || 'vermelho')
-        end
-      end
-    end
-
-    it "should allow configuration by a saved config" do
-      @car.configure_with(@cool_configuration)
-      @car.colour.should == 'vermelho'
-      @car.top_speed.should == 216
-    end
-
-    it "should pass any args through to the saved config" do
-      @car.configure_with(@cool_configuration, 'preto')
-      @car.colour.should == 'preto'
-    end
-
-    it "should yield a block for any extra configuration" do
-      @car.configure_with(@cool_configuration) do |c|
-        c.colour = 'branco'
-      end
-      @car.colour.should == 'branco'
-    end
-
-    it "should return itself" do
-      @car.configure_with(@cool_configuration).should == @car
-    end
-
-    describe "using a symbol to specify the config" do
-
-      before(:all) do
-        @rally_config = Object.new
-        Car.register_configuration(:rally, @rally_config)
-        @long_journey_config = Object.new
-        Car.register_configuration(:long_journey){ @long_journey_config }
-        Car.register_configuration(:some_library){ SomeLibrary }
-      end
-
-      it "should map the symbol to the correct configuration" do
-        @rally_config.should_receive(:apply_configuration).with(@car)
-        @car.configure_with(:rally)
-      end
-
-      it "should map the symbol to the correct configuration lazily" do
-        @long_journey_config.should_receive(:apply_configuration).with(@car)
-        @car.configure_with(:long_journey)
-      end
-
-      it "should throw an error if an unknown symbol is passed in" do
-        lambda {
-          @car.configure_with(:eggs)
-        }.should raise_error(ArgumentError)
-      end
-
-      it "should only try to load the library when asked to" do
-        lambda{
-          @car.configure_with(:some_library)
-        }.should raise_error(NameError, /uninitialized constant.*SomeLibrary/)
-      end
-    end
-
-  end
-
-  describe "falling back to another config" do
-    before(:each) do
-      class Garage
-        include ImageResizer::Configurable
-        configurable_attr :top_speed, 100
-      end
-      @garage = Garage.new
-      @car.use_as_fallback_config(@garage)
-    end
-
-    describe "when nothing set" do
-      it "should use its default" do
-        @car.top_speed.should == 216
-      end
-      it "shouldn't affect the fallback config object" do
-        @garage.top_speed.should == 100
-      end
-    end
-
-    describe "if set" do
-      before(:each) do
-        @car.top_speed = 444
-      end
-      it "should work normally" do
-        @car.top_speed.should == 444
-      end
-      it "shouldn't affect the fallback config object" do
-        @garage.top_speed.should == 100
-      end
-    end
-
-    describe "both set" do
-      before(:each) do
-        @car.top_speed = 444
-        @garage.top_speed = 3000
-      end
-      it "should prefer its own setting" do
-        @car.top_speed.should == 444
-      end
-      it "shouldn't affect the fallback config object" do
-        @garage.top_speed.should == 3000
-      end
-    end
-
-    describe "the fallback config is set" do
-      before(:each) do
-        @garage.top_speed = 3000
-      end
-      it "should use the fallback config" do
-        @car.top_speed.should == 3000
-      end
-      it "shouldn't affect the fallback config object" do
-        @garage.top_speed.should == 3000
-      end
-    end
-
-    describe "falling back multiple levels" do
-      before(:each) do
-        @klass = Class.new
-        @klass.class_eval do
-          include ImageResizer::Configurable
-          configurable_attr :veg, 'carrot'
-        end
-        @a = @klass.new
-        @b = @klass.new
-        @b.use_as_fallback_config(@a)
-        @c = @klass.new
-        @c.use_as_fallback_config(@b)
-      end
-
-      it "should be the default if nothing set" do
-        @c.veg.should == 'carrot'
-      end
-
-      it "should fall all the way back to the top one if necessary" do
-        @a.veg = 'turnip'
-        @c.veg.should == 'turnip'
-      end
-
-      it "should prefer the closer one over the further away one" do
-        @b.veg = 'tatty'
-        @a.veg = 'turnip'
-        @c.veg.should == 'tatty'
-      end
-
-      it "should work properly with nils" do
-        @a.veg = nil
-        @c.veg = 'broc'
-        @a.veg.should be_nil
-        @b.veg.should be_nil
-        @c.veg.should == 'broc'
-      end
-    end
-
-    describe "objects with different methods" do
-      before(:each) do
-        class Dad
-          include ImageResizer::Configurable
-        end
-        @dad = Dad.new
-        class Kid
-          include ImageResizer::Configurable
-          configurable_attr :lug, 'default-lug'
-        end
-        @kid = Kid.new
-        @kid.use_as_fallback_config(@dad)
-      end
-
-      it "should not allow setting on the fallback obj directly" do
-        lambda{
-          @dad.lug = 'leg'
-        }.should raise_error(NoMethodError)
-      end
-
-      it "should not have the fallback obj respond to the method" do
-        @dad.should_not respond_to(:lug=)
-      end
-
-      it "should allow configuring through the fallback object even if it doesn't have that method" do
-        @dad.configure do |c|
-          c.lug = 'leg'
-        end
-        @kid.lug.should == 'leg'
-      end
-
-      it "should work when a grandchild config is added later" do
-        class Grandkid
-          include ImageResizer::Configurable
-          configurable_attr :oogie, 'boogie'
-        end
-        grandkid = Grandkid.new
-        grandkid.use_as_fallback_config(@kid)
-        @dad.configure{|c| c.oogie = 'duggen' }
-        grandkid.oogie.should == 'duggen'
-      end
-
-      it "should allow configuring twice through the fallback object" do
-        @dad.configure{|c| c.lug = 'leg' }
-        @dad.configure{|c| c.lug = 'blug' }
-        @kid.lug.should == 'blug'
-      end
-    end
-
-    describe "clashing with configurable modules" do
-      before(:each) do
-        @mod = mod = Module.new
-        @mod.module_eval do
-          include ImageResizer::Configurable
-          configurable_attr :team, 'spurs'
-        end
-        @class = Class.new
-        @class.class_eval do
-          include mod
-          include ImageResizer::Configurable
-          configurable_attr :tree, 'elm'
-        end
-      end
-
-      it "should not override the defaults from the module" do
-        obj = @class.new
-        obj.team.should == 'spurs'
-      end
-
-      it "should still use its own defaults" do
-        obj = @class.new
-        obj.tree.should == 'elm'
-      end
-
-      describe "when the configurable_attr is specified in a subclass that doesn't include Configurable" do
-        before(:each) do
-          @subclass = Class.new(@class)
-          @subclass.class_eval do
-            configurable_attr :car, 'mazda'
-            configurable_attr :tree, 'oak'
-          end
-          @obj = @subclass.new
-        end
-
-        it "should still work with default values" do
-          @obj.car.should == 'mazda'
-        end
-
-        it "should override the default from the parent" do
-          @obj.tree.should == 'oak'
-        end
-      end
-
-    end
-
-  end
-
-  describe "inheriting configurable_attrs from multiple places" do
-    before(:each) do
-      module A
-        include ImageResizer::Configurable
-        configurable_attr :a
-      end
-      module B
-        include ImageResizer::Configurable
-        configurable_attr :b
-      end
-      class K
-        include ImageResizer::Configurable
-        include A
-        include B
-        configurable_attr :c
-      end
-      class L < K
-      end
-    end
-
-    it "should include configuration from all of its mixins" do
-      l = L.new
-      l.configure do |c|
-        c.a = 'something'
-        c.b = 'something'
-        c.c = 'something'
-      end
-    end
-  end
-end

data/spec/image_resizer/loggable_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-class Testoast
-  include ImageResizer::Loggable
-end
-
-describe ImageResizer::Loggable do
-
-  before(:each) do
-    @object = Testoast.new
-  end
-
-  shared_examples_for "common" do
-    it "should return a log" do
-      @object.log.should be_a(Logger)
-    end
-    it "should cache the log" do
-      @object.log.should == @object.log
-    end
-  end
-
-  describe "without being set" do
-    it "should return the log object as nil" do
-      @object.log_object.should be_nil
-    end
-    it_should_behave_like 'common'
-  end
-
-  describe "when set" do
-    before(:each) do
-      @log = Logger.new($stdout)
-      @object.log = @log
-    end
-    it "should return the new log" do
-      @object.log.should == @log
-    end
-    it "should return the log object" do
-      @object.log_object.should == @log
-    end
-    it_should_behave_like 'common'
-  end
-
-  describe "when set as a proc" do
-    before(:each) do
-      @log = Logger.new($stdout)
-      @object.log = proc{ @log }
-    end
-    it "should return the new log" do
-      @object.log.should == @log
-    end
-    it "should return the log object" do
-      @object.log_object.should be_a(Proc)
-    end
-    it "should allow for changing logs" do
-      logs = [@log]
-      @object.log = proc{ logs[0] }
-      @object.log.should == @log
-
-      new_log = Logger.new($stdout)
-      logs[0] = new_log
-
-      @object.log.should == new_log
-    end
-    it_should_behave_like 'common'
-  end
-
-  describe "sharing logs" do
-    before(:each) do
-      @log = Logger.new($stdout)
-      @obj1 = Testoast.new
-      @obj2 = Testoast.new
-    end
-    it "should enable sharing logs" do
-      @obj1.log = proc{ @log }
-      @obj2.use_same_log_as(@obj1)
-      @obj2.log.should == @log
-    end
-  end
-
-end

data/spec/image_resizer/processor_spec.rb

@@ -1,144 +0,0 @@
-require 'spec_helper'
-
-describe ImageResizer::Processor do
-
-  # IMPORTANT: Enable the flag below to print out the transforms that are generated by calculate_transform
-  # as you run the tests. This is great for updating the  expected_results array below if you change the 
-  # function and desire different behavior for the inputs, or add other test viewports of POIs.
-  actual_printed = false
-  actual_results = []
-
-  interest_variants_fractional = [{xf: 0, yf: 0}, {xf: 0, yf: 1}, {xf: 1, yf: 1}, {xf: 1, yf: 0}, {xf: 0.5, yf: 0.5}]
-  interest_variants_absolute = [{x: 0, y: 0}, {x: 0, y: 2500}, {x: 3800, y: 2500}, {x: 3800, y: 0}, {x: 3800.0 * 0.5, y: 2500.0 * 0.5}]
-  viewport_variants = [{w: 3800, h: 3000}, 
-                       {w: 5000, h: 5000}, 
-                       {w: 100, h: 100}, 
-                       {w: 100, h: 300}, 
-                       {w: 300, h: 100}, 
-                       {w: 100}, 
-                       {h: 100}, 
-                       {w: 3000}, 
-                       {h: 3000}, 
-                       {}]
-  
-  expected_abs_index = 0
-  expected_fraction_index = 0
-
-  expected_results = [{:x=>0.0, :y=>0.0, :w=>3800, :h=>3000, :scale=>1.2},
-                      {:x=>0.0, :y=>0.0, :w=>5000, :h=>5000, :scale=>2.0},
-                      {:x=>0.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>0.0, :y=>0.0, :w=>100, :h=>300, :scale=>0.12},
-                      {:x=>0.0, :y=>0.0, :w=>300, :h=>100, :scale=>0.07894736842105263},
-                      {:x=>0.0, :y=>0.0, :w=>100, :h=>0, :scale=>0.02631578947368421},
-                      {:x=>0.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>0.0, :y=>0.0, :w=>3000, :h=>0, :scale=>0.7894736842105263},
-                      {:x=>0.0, :y=>0.0, :w=>3000, :h=>3000, :scale=>1.2},
-                      {:x=>0.0, :y=>0.0, :w=>3800, :h=>2500, :scale=>1.0},
-                      {:x=>0.0, :y=>0.0, :w=>3800, :h=>3000, :scale=>1.2},
-                      {:x=>0.0, :y=>0.0, :w=>5000, :h=>5000, :scale=>2.0},
-                      {:x=>0.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>0.0, :y=>0.0, :w=>100, :h=>300, :scale=>0.12},
-                      {:x=>0.0, :y=>97.36842105263156, :w=>300, :h=>100, :scale=>0.07894736842105263},
-                      {:x=>0.0, :y=>65.78947368421052, :w=>100, :h=>0, :scale=>0.02631578947368421},
-                      {:x=>0.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>0.0, :y=>1973.6842105263158, :w=>3000, :h=>0, :scale=>0.7894736842105263},
-                      {:x=>0.0, :y=>0.0, :w=>3000, :h=>3000, :scale=>1.2},
-                      {:x=>0.0, :y=>0.0, :w=>3800, :h=>2500, :scale=>1.0},
-                      {:x=>760.0, :y=>0.0, :w=>3800, :h=>3000, :scale=>1.2},
-                      {:x=>2600.0, :y=>0.0, :w=>5000, :h=>5000, :scale=>2.0},
-                      {:x=>52.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>356.0, :y=>0.0, :w=>100, :h=>300, :scale=>0.12},
-                      {:x=>0.0, :y=>97.36842105263156, :w=>300, :h=>100, :scale=>0.07894736842105263},
-                      {:x=>0.0, :y=>65.78947368421052, :w=>100, :h=>0, :scale=>0.02631578947368421},
-                      {:x=>52.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>0.0, :y=>1973.6842105263158, :w=>3000, :h=>0, :scale=>0.7894736842105263},
-                      {:x=>1560.0, :y=>0.0, :w=>3000, :h=>3000, :scale=>1.2},
-                      {:x=>0.0, :y=>0.0, :w=>3800, :h=>2500, :scale=>1.0},
-                      {:x=>760.0, :y=>0.0, :w=>3800, :h=>3000, :scale=>1.2},
-                      {:x=>2600.0, :y=>0.0, :w=>5000, :h=>5000, :scale=>2.0},
-                      {:x=>52.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>356.0, :y=>0.0, :w=>100, :h=>300, :scale=>0.12},
-                      {:x=>0.0, :y=>0.0, :w=>300, :h=>100, :scale=>0.07894736842105263},
-                      {:x=>0.0, :y=>0.0, :w=>100, :h=>0, :scale=>0.02631578947368421},
-                      {:x=>52.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>0.0, :y=>0.0, :w=>3000, :h=>0, :scale=>0.7894736842105263},
-                      {:x=>1560.0, :y=>0.0, :w=>3000, :h=>3000, :scale=>1.2},
-                      {:x=>0.0, :y=>0.0, :w=>3800, :h=>2500, :scale=>1.0},
-                      {:x=>380.0, :y=>0.0, :w=>3800, :h=>3000, :scale=>1.2},
-                      {:x=>1300.0, :y=>0.0, :w=>5000, :h=>5000, :scale=>2.0},
-                      {:x=>26.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>178.0, :y=>0.0, :w=>100, :h=>300, :scale=>0.12},
-                      {:x=>0.0, :y=>48.68421052631578, :w=>300, :h=>100, :scale=>0.07894736842105263},
-                      {:x=>0.0, :y=>32.89473684210526, :w=>100, :h=>0, :scale=>0.02631578947368421},
-                      {:x=>26.0, :y=>0.0, :w=>100, :h=>100, :scale=>0.04},
-                      {:x=>0.0, :y=>986.8421052631579, :w=>3000, :h=>0, :scale=>0.7894736842105263},
-                      {:x=>780.0, :y=>0.0, :w=>3000, :h=>3000, :scale=>1.2},
-                      {:x=>0.0, :y=>0.0, :w=>3800, :h=>2500, :scale=>1.0}]
-
-  before(:each) do
-    @source_jpg_path = SAMPLES_DIR.join('test.jpg') # 3872, 2592
-    @source_png_path = SAMPLES_DIR.join('test.png') # 177, 180
-    @source_jpg_props = {};
-    @source_jpg_props['width'] = 3800
-    @source_jpg_props['height'] = 2500
-    @source_jpg_props['bands'] = 3
-
-    
-    @processor = ImageResizer::Processor.new
-  end
-
-  describe "fetch_image_properties" do
-
-    it "should return a hash of properties containing width and height" do
-      properties = @processor.fetch_image_properties(@source_jpg_path)
-      properties['width'].should == @source_jpg_props['width']
-      properties['height'].should == @source_jpg_props['height']
-    end
-
-    it "should return a hash of properties containing depth (JPG=3)" do
-      properties = @processor.fetch_image_properties(@source_jpg_path)
-      properties['bands'].should == 3
-    end
-
-    it "should return a hash of properties containing depth (PNG=4)" do
-      properties = @processor.fetch_image_properties(@source_png_path)
-      properties['bands'].should == 4
-    end
-
-    describe "calculate_transform" do
-
-      interest_variants_absolute.each do |ip|
-        viewport_variants.each do |viewport|
-
-          it "should produce the correct transform viewport: #{viewport}, point: #{ip}" do
-            transform = @processor.calculate_transform(@source_jpg_path, @source_jpg_props, viewport, ip)
-            transform.should == expected_results[expected_abs_index]
-            expected_abs_index += 1
-          end
-        
-        end
-      end
-
-      interest_variants_fractional.each do |ip|
-        viewport_variants.each do |viewport|
-
-          it "should produce the correct transform viewport: #{viewport}, point: #{ip}" do
-            transform = @processor.calculate_transform(@source_jpg_path, @source_jpg_props, viewport, ip)
-
-            if (actual_printed == true)
-              actual_results.push(transform)
-              if (actual_results.size() == interest_variants_fractional.size() * viewport_variants.size() - 1)
-                print actual_results
-              end
-            end
-
-            transform.should == expected_results[expected_fraction_index]
-            expected_fraction_index += 1
-          end
-
-        end
-      end
-
-    end
-  end
-end

data/spec/image_resizer/shell_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe ImageResizer::Shell do
-
-  include ImageResizer::Shell
-
-  it "should raise an error if the identify command isn't found" do
-    suppressing_stderr do
-      lambda{
-        run "non-existent-command"
-      }.should raise_error(ImageResizer::Shell::CommandFailed)
-    end
-  end
-
-  describe "escaping args" do
-    {
-      %q(hello) => %q('hello'),
-      %q("hello") => %q('hello'),
-      %q('hello') => %q('hello'),
-      %q(he\'llo) => %q('he'\''llo'),
-      %q('he'\''llo') => %q('he'\''llo'),
-      %q("he'llo") => %q('he'\''llo'),
-      %q(hel$(lo)) => %q('hel$(lo)'),
-      %q(hel\$(lo)) => %q('hel$(lo)'),
-      %q('hel\$(lo)') => %q('hel\$(lo)')
-    }.each do |args, escaped_args|
-      it "should escape #{args.inspect} -> #{escaped_args.inspect}" do
-        pending "not applicable to windows" if running_on_windows?
-        escape_args(args).should == escaped_args
-      end
-    end
-  end
-
-end