insano_image_resizer 0.4.6 → 0.5.7

data/README.md

@@ -1,16 +1,15 @@
 Insano Image Resizer
 ====================
 
-The Insano image resizer allows you to create resized versions of images, specifying a 
+The Insano image resizer allows you to create resized versions of images, specifying a
 desired width and height as well as a point of interest that the resizer will keep centered
-in the frame when possible. The resizer is built on top of the VIPS command-line tool, 
-and is designed to be as fast as possible. In our tests, VIPS is faster than ImageMagick for any 
-image larger than ~300x300px, and is exponentially faster for very large images. 
+in the frame when possible. The resizer is built on top of the VIPS command-line tool,
+and is designed to be as fast as possible. In our tests, VIPS is faster than ImageMagick for any
+image larger than ~300x300px, and is exponentially faster for very large images.
 
 ![A brief overview of the Insano processing function](insano_image_resizer/raw/master/samples/explanation.png)
 
-Output formats: The Insano image resizer will produce either a PNG or JPG image, depending
-on whether the source image includes transparency.
+Output formats: The Insano image resizer will keep PNGs as PNG, but any other format is converted to JPEG
 
 * Insano is the fastest waterslide in the world. This isn't a waterslide, but it's similarly fast.
 
@@ -27,18 +26,18 @@ Example:
     input_path = 'samples/test.jpg'
 
     # Create a new instance of the Image processor
-    processor = ImageResizer::Processor.new
-    
+    processor = ImageResizer::Processor.new(:vips_path => 'path_to_vips[defaults to vips]', :identify_path => 'path_to_ImageMagick_identify[defaults to identify]')
+
     # Process the image, creating a temporary file.
     output_path = processor.process(input_path, {w: 100, h: 200}, {x:986, y:820, region: 0.5})
-    
+
     # Move the image to an output path
     FileUtils.mv(output_path, 'samples/output/test.jpg')
 
 Input parameters:
 
 The `process` method is the main function of the Insano gem. Using different parameters,
-you can produce a wide range of resized images. Each of the parameters is explained below. 
+you can produce a wide range of resized images. Each of the parameters is explained below.
 
 The first argument is an input file path. Because the Insano image resizer uses the VIPS
 command line, it is not possible to transform an image that has been loaded into memory.
@@ -46,32 +45,31 @@ command line, it is not possible to transform an image that has been loaded into
 The second argument is a viewport hash containing width and height keys.
 You can specify both width and height to produce an output image of a specific size, or provide
 only width or height to have the resizer compute the other dimension based
-on the aspect ratio of the image. Finally, you can pass an empty hash to use 
+on the aspect ratio of the image. Finally, you can pass an empty hash to use
 the current width and height of the image. Note that the image resizer will
 never distort an image: the output image will always fill the viewport you provide,
 scaling up only if absolutely necessary.
 
 The third parameter is the point of interest that you'd like to keep centered if possible.
-Imagine that an 4:3 image contains a person's face on the left side. When you create a 
+Imagine that an 4:3 image contains a person's face on the left side. When you create a
 square thumbnail of the image, the persons face is half chopped off, because the processor
 trims off the left and right uniformly. Specifying a point of interest allows you to correct
-for this problem. 
+for this problem.
 
-By default, the POI is used only when cropping the image and deciding which sides 
-should be cropped off. However, specifying the optional :region parameter with a value 
-less than 1, you can make the image resizer zoom in around the POI, cropping the image 
-so that an area of size (region * image size) around the POI is visible. 
+By default, the POI is used only when cropping the image and deciding which sides
+should be cropped off. However, specifying the optional :region parameter with a value
+less than 1, you can make the image resizer zoom in around the POI, cropping the image
+so that an area of size (region * image size) around the POI is visible.
 
 Note that the output image may show more of the source image than you specify using the
 interest region. The region is only meant to indicate what region you'd like to ensure makes
-it into the output. For example, if you have a 200 x 200px image and request an output image of 
+it into the output. For example, if you have a 200 x 200px image and request an output image of
 100 x 100px, showing the 50px region around 150px x 150px, the output will contain more than
-just that region, since filling a 100px square with a 50px region would require enlarging the 
+just that region, since filling a 100px square with a 50px region would require enlarging the
 source image.
 
 Credits
 =======
 
-This project is loosely based off of the ImageResizer gem previously authored by Daniel Nelson of Populr.me.
-It draws heavily on the VIPS im_affinei command line function to resize images using an affine transform.
+This project draws heavily on the VIPS im_affinei command line function to resize images using an affine transform.
 

data/lib/insano_image_resizer/configurable.rb

@@ -39,15 +39,15 @@ module InsanoImageResizer
       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
@@ -57,7 +57,7 @@ module InsanoImageResizer
         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
@@ -76,17 +76,17 @@ module InsanoImageResizer
       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
@@ -129,7 +129,7 @@ module InsanoImageResizer
         @nested_configurables ||= []
       end
 
-      def register_configuration(name, config=nil, &config_in_block) 
+      def register_configuration(name, config=nil, &config_in_block)
         saved_configs[name] = config_in_block || config
       end
 
@@ -164,7 +164,7 @@ module InsanoImageResizer
       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

data/lib/insano_image_resizer/processor.rb

@@ -1,66 +1,49 @@
 require 'yaml'
-require 'shellwords'
 require 'exifr'
+require 'cocaine'
 
 module InsanoImageResizer
   class Processor
 
     include Configurable
-    include Shell
     include Loggable
+    include Cocaine
 
-    def initialize(options = {vips_path: "vips"})
-      @vips_path = options[:vips_path]
+    def initialize(options = {})
+      @vips_path = options[:vips_path] || 'vips'
+      @identify_path = options[:identify_path] || 'identify'
     end
 
     def process(input_path, viewport_size = {}, interest_point = {}, quality = 60)
-      input_properties = fetch_image_properties(input_path)
-      input_has_alpha = (input_properties[:bands] == 4)
+      width, height, original_format, target_extension = fetch_image_properties(input_path)
 
-      output_tmp = Tempfile.new(["img", input_has_alpha ? ".png" : ".jpg"])
+      output_tmp = Tempfile.new(['img', ".#{target_extension}"])
 
-      transform = calculate_transform(input_path, input_properties, viewport_size, interest_point)
-      run_transform(input_path, output_tmp.path, transform, quality)
+      transform = calculate_transform(input_path, width, height, viewport_size, interest_point)
+      run_transform(input_path, output_tmp.path, transform, original_format, target_extension, quality)
 
-      return output_tmp.path
+      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 = {}
-      result[:w] = run("#{@vips_path} im_header_int Xsize '#{input_path}'").to_f
-      result[:h] = run("#{@vips_path} im_header_int Ysize '#{input_path}'").to_f
-      result[:bands] = run("#{@vips_path} im_header_int Bands '#{input_path}'").to_f
-
-      # find the EXIF values
-      orientation = 0
-      begin
-        orientation = EXIFR::JPEG.new(input_path).orientation.to_i 
-      rescue
-        orientation = 0
-      end
+    private
 
-      if orientation == 6 || orientation == 8
-        nh = result[:w]
-        result[:w] = result[:h]
-        result[:h] = nh
-      end
-      return result
+    def fetch_image_properties(input_path)
+      line = Cocaine::CommandLine.new(@identify_path, '-format "%w %h %m" :input')
+      parts = line.run(:input => input_path).split(' ')
+      [parts[0].to_i, parts[1].to_i, parts[2], parts[2] == 'PNG' ? 'png' : 'jpg']
     end
 
-    def calculate_transform(input_path, input_properties, viewport_size, interest_point)
+    def calculate_transform(input_path, width, height, viewport_size, interest_point)
 
       # 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] = input_properties[:w] * interest_point[:xf]
+        interest_point[:x] = width * interest_point[:xf]
       end
 
       if (interest_point[:yf])
-        interest_point[:y] = input_properties[:h] * interest_point[:yf]
+        interest_point[:y] = height * interest_point[:yf]
       end
 
       if (interest_point[:region] == nil)
@@ -68,27 +51,27 @@ module InsanoImageResizer
       end
 
       if (interest_point[:x] == nil)
-        interest_point[:x] = input_properties[:w] * 0.5
+        interest_point[:x] = width * 0.5
         interest_point[:region] = 1
       end
       if (interest_point[:y] == nil)
-        interest_point[:y] = input_properties[:h] * 0.5
+        interest_point[:y] = height * 0.5
         interest_point[:region] = 1
       end
 
-      interest_size = {w: input_properties[:w] * interest_point[:region], h: input_properties[:h] * interest_point[:region]}
+      interest_size = {w: width * interest_point[:region], h: height * 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[:w], h: input_properties[:h]}
+        viewport_size = {w: width, h: height}
 
       elsif (viewport_size[:w] == nil)
-        viewport_size[:w] = (viewport_size[:h] * (input_properties[:w].to_f / input_properties[:h].to_f))
+        viewport_size[:w] = (viewport_size[:h] * (width.to_f / height.to_f))
 
       elsif (viewport_size[:h] == nil)
-        viewport_size[:h] = (viewport_size[:w] * (input_properties[:h].to_f / input_properties[:w].to_f))
+        viewport_size[:h] = (viewport_size[:w] * (height.to_f / width.to_f))
       end
 
       # how can we take our current image and fit it into the viewport? Time for
@@ -100,28 +83,18 @@ module InsanoImageResizer
       #    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] / input_properties[:w].to_f, viewport_size[:h] / input_properties[:h].to_f].max
-      scale_to_interest = [interest_size[:w] / input_properties[:w].to_f, interest_size[:h] / input_properties[:h].to_f].max
-
-      log.debug("POI: ")
-      log.debug(interest_point)
-      log.debug("Image properties: ")
-      log.debug(input_properties)
-      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_to_fill = [viewport_size[:w] / width.to_f, viewport_size[:h] / height.to_f].max
+      scale_to_interest = [interest_size[:w] / width.to_f, interest_size[:h] / height.to_f].max
 
       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 - (input_properties[:w].to_f * scale_for_best_region) / 2,
-                     y: interest_point[:y].to_f - (input_properties[:h].to_f * scale_for_best_region) / 2,
-                     w: input_properties[:w].to_f * scale_for_best_region,
-                     h: input_properties[:h].to_f * scale_for_best_region}
+      best_region = {x: interest_point[:x].to_f - (width.to_f * scale_for_best_region) / 2,
+                     y: interest_point[:y].to_f - (height.to_f * scale_for_best_region) / 2,
+                     w: width.to_f * scale_for_best_region,
+                     h: height.to_f * 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
@@ -157,12 +130,12 @@ module InsanoImageResizer
 
       # 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] > input_properties[:w].to_f * scale)
-        transform[:x] = input_properties[:w].to_f * scale - transform[:w]
+      if (transform[:x] + transform[:w] > width.to_f * scale)
+        transform[:x] = width.to_f * scale - transform[:w]
       end
 
-      if (transform[:y] + transform[:h] > input_properties[:h].to_f * scale)
-        transform[:y] = input_properties[:h].to_f * scale - transform[:h]
+      if (transform[:y] + transform[:h] > height.to_f * scale)
+        transform[:y] = height.to_f * scale - transform[:h]
       end
 
       if (transform[:x] < 0)
@@ -173,47 +146,19 @@ module InsanoImageResizer
         transform[:y] = 0.0
       end
 
-      log.debug("The transform properties:")
-      log.debug(transform)
-
-      return transform
+      transform
     end
 
-    def run_transform(input_path, output_path, transform, quality = 90)
+    def run_transform(input_path, output_path, transform, original_format, output_extension, quality)
       # 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.
-      output_extension = output_path[-3..-1]
-      quality_extension = ""
 
-      if (output_extension == "jpg")
-        quality_extension = ":#{quality}"
-      end
-
-      # find the EXIF values
-      orientation = 0
-      begin
-        orientation = EXIFR::JPEG.new(input_path).orientation.to_i 
-      rescue
-        orientation = 0
-      end
-
-      if orientation == 3 || orientation == 6 || orientation == 8
-        o_transform = []
-        if orientation == 3
-          run("#{@vips_path} im_rot180 '#{input_path}' '#{output_path}#{quality_extension}'")
-        elsif orientation == 6
-          run("#{@vips_path} im_rot90 '#{input_path}' '#{output_path}#{quality_extension}'")
-        elsif orientation == 8
-          run("#{@vips_path} im_rot270 '#{input_path}' '#{output_path}#{quality_extension}'")
-        end
-        FileUtils.rm(input_path)
-        run("mogrify -strip #{output_path}")
-        FileUtils.mv(output_path, input_path)
-      end
+      quality_extension = ''
+      quality_extension = ":#{quality}" if output_extension == 'jpg'
 
       if (transform[:scale] < 0.5)
         # If we're shrinking the image by more than a factor of two, let's do a two-pass operation. The reason we do this
@@ -236,16 +181,67 @@ module InsanoImageResizer
         end
         intermediate_path = input_path[0..-4]+"_shrunk." + output_extension
 
-        run("#{@vips_path} im_shrink '#{input_path}' '#{intermediate_path}#{quality_extension}' #{shrink_factor} #{shrink_factor}")
-        run("#{@vips_path} im_affine '#{intermediate_path}' '#{output_path}#{quality_extension}' #{transform[:scale]} 0 0 #{transform[:scale]} 0 0 #{transform[:x]} #{transform[:y]} #{transform[:w]} #{transform[:h]}")
+        line = Cocaine::CommandLine.new(@vips_path, "im_shrink :input :intermediate_path :shrink_factor :shrink_factor")
+        line.run(:input => input_path,
+                 :intermediate_path => "#{intermediate_path}#{quality_extension}",
+                 :shrink_factor => shrink_factor.to_s)
+
+
+        line = Cocaine::CommandLine.new(@vips_path, "im_affine :intermediate_path :output :scale 0 0 :scale 0 0 :x :y :w :h")
+        line.run(:output => "#{output_path}#{quality_extension}",
+                 :intermediate_path => intermediate_path,
+                 :scale => transform[:scale].to_s,
+                 :x => transform[:x].to_s,
+                 :y => transform[:y].to_s,
+                 :w => transform[:w].to_s,
+                 :h => transform[:h].to_s)
+
         FileUtils.rm(intermediate_path)
 
       else
-        run("#{@vips_path} im_affine '#{input_path}' '#{output_path}#{quality_extension}' #{transform[:scale]} 0 0 #{transform[:scale]} 0 0 #{transform[:x]} #{transform[:y]} #{transform[:w]} #{transform[:h]}")
+        line = Cocaine::CommandLine.new(@vips_path, "im_affine :input :output :scale 0 0 :scale 0 0 :x :y :w :h")
+        line.run(:output => "#{output_path}#{quality_extension}",
+                 :input => input_path,
+                 :scale => transform[:scale].to_s,
+                 :x => transform[:x].to_s,
+                 :y => transform[:y].to_s,
+                 :w => transform[:w].to_s,
+                 :h => transform[:h].to_s)
+      end
+
+      # find the EXIF values
+      orientation = 0
+      orientation = EXIFR::JPEG.new(input_path).orientation.to_i if original_format == 'JPEG'
+
+      if orientation == 3 || orientation == 6 || orientation == 8
+        FileUtils.mv(output_path, intermediate_path)
+        o_transform = []
+        if orientation == 3
+          command = 'im_rot180'
+        elsif orientation == 6
+          command = 'im_rot90'
+        elsif orientation == 8
+          command = 'im_rot270'
+        else
+          command = nil
+        end
+
+        if command
+          line = Cocaine::CommandLine.new(@vips_path, ":command :intermediate_path :output")
+          line.run(:output => "#{output_path}#{quality_extension}",
+                   :intermediate_path => intermediate_path,
+                   :command => command)
+        end
+
+        FileUtils.rm(intermediate_path)
+        line = Cocaine::CommandLine.new(mogrify, "-strip :output")
+        line.run(:output => output_path,
+                 :intermediate_path => intermediate_path)
       end
 
       FileUtils.rm(input_path)
-      return output_path
+
+      output_path
     end
   end
 end

data/lib/insano_image_resizer.rb

@@ -1,5 +1,4 @@
 
 require 'insano_image_resizer/loggable'
 require 'insano_image_resizer/configurable'
-require 'insano_image_resizer/shell'
 require 'insano_image_resizer/processor'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: insano_image_resizer
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,27 +9,33 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-27 00:00:00.000000000 Z
+date: 2013-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
+  name: cocaine
+  requirement: &2161837320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  version_requirements: *2161837320
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2161836240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161836240
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2161834680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -37,15 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2161834680
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2161833680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -53,15 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2161833680
 - !ruby/object:Gem::Dependency
   name: pry-nav
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2161832100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -69,15 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2161832100
 - !ruby/object:Gem::Dependency
   name: pry-stack_explorer
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2161830740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -85,12 +76,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  version_requirements: *2161830740
+- !ruby/object:Gem::Dependency
+  name: exifr
+  requirement: &2161845740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161845740
 description: ! "An image resizing gem that generates smaller versions of requested
   \n                    images. Calls through to VIPS on the command line to perform
   processing,\n                    and automatically handles cropping and scaling
@@ -107,7 +104,6 @@ files:
 - lib/insano_image_resizer/configurable.rb
 - lib/insano_image_resizer/loggable.rb
 - lib/insano_image_resizer/processor.rb
-- lib/insano_image_resizer/shell.rb
 - LICENSE
 - README.md
 homepage: http://github.com/populr/insano_image_resizer
@@ -123,6 +119,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2229782920587942478
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -131,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: An image resizing gem that calls through to VIPS on the command line.

data/lib/insano_image_resizer/shell.rb

@@ -1,48 +0,0 @@
-require 'shellwords'
-
-module InsanoImageResizer
-  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