local-fastimage_resize 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f327d6289f0a78931571438e476321352ad3e3ad
+  data.tar.gz: 25d60b345bf41043e6c444def8cf47f632070ae4
+SHA512:
+  metadata.gz: 9cae988edee0fb067cdc7fd9ed1fd1926d00d6eacfc0c23491f1f7e2b0547a65d0b82043972e8ae2514d9a457c330c74baa56edb9c367959f6a928abca2ea34b
+  data.tar.gz: 2b780ebdf8b756b9597d83729fec8e8a27e9164a7939676c1cc8215234bfcbe2552c9427faf0be16a787ace0a4a46dea0681459334131cb9b03c37186fe93b78

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 3.0.0 - 2016-06-02
+
+Removing remote image support

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    local-fastimage_resize (3.0.0)
+      RubyInline (>= 3.8.2)
+      local-fastimage (>= 3.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    RubyInline (3.12.4)
+      ZenTest (~> 4.3)
+    ZenTest (4.11.0)
+    local-fastimage (3.0.0)
+    minitest (5.9.0)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12)
+  local-fastimage_resize!
+  minitest (~> 5.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.12.5

data/MIT_LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2011 Stephen Sykes
+
+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

@@ -0,0 +1,27 @@
+FastImage Resize is an extremely light solution for resizing images in ruby by using libgd
+
+=== Examples
+
+  require 'fastimage_resize'
+
+  FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", "my.gif", 100, 20)
+  => 1
+
+=== Requirements
+
+RubyInline
+
+  gem install RubyInline
+
+FastImage
+
+  gem install fastimage
+
+Libgd
+
+See http://www.libgd.org/
+Libgd is commonly available on most unix platforms, including OSX.
+
+=== References
+
+* http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing

data/README.md

@@ -0,0 +1,44 @@
+# Local FastImage Resize
+
+This is a fork of the [FastImage
+Resize](https://github.com/sdsykes/fastimage_resize) gem.
+
+It features the following differences:
+
+* Removal of all remote image handling code
+* Minor changes to code organization
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'local-fastimage_resize', require: 'fastimage/resize'
+```
+
+And then execute:
+
+    $ bundle
+
+
+If you are using Bundler's autorequire, you're good to go. Otherwise make sure
+to `require "fastimage/resize"`.
+
+Or install it yourself as:
+
+    $ gem install local-fastimage_resize
+
+Again, make sure to `require "fastimage/resize"`.
+
+
+
+## Usage
+
+See [README.textile](README.textile) for more documentation. Everything should
+work as advertised, except for remote images of course.
+
+
+
+## License
+
+MIT, see file [MIT-LICENSE](MIT-LICENSE)

data/README.textile

@@ -0,0 +1,150 @@
+h1. FastImage Resize
+
+> This fork of the FastImage Resize Gem removes remote URL support to avoid a
+> whole class of security-related problems. See "README.md":README.md for
+> more details.
+
+h4. FastImage Resize is an extremely light solution for resizing images in ruby by using libgd
+
+FastImage Resize will resize gifs, jpegs, and png files.
+
+It uses resampling to get good looking results.
+
+And it doesn't rely on installing external heavy libraries such as RMagick (which relies on ImageMagick or GraphicsMagick) or ImageScience (which relies on FreeImage).
+
+FastImage Resize uses *Libgd*, which is commonly available on most unix platforms, including OSX.  It is very likely that you already have this software installed on your server.
+
+As its input, FastImage Resize can take a URI, a filename, or an IO object (or anything that responds to :read).
+If you do not supply an output filename in the :outfile option, FastImage Resize will return you a Tempfile object. This will be unlinked when it is finalized during garbage collection.
+
+FastImage Resize relies on "RubyInline":https://github.com/seattlerb/rubyinline for compiling and managing the C extension code.
+
+h4. Incompatible API change Version 2.0.0 and above
+
+Note that the parameters for version 2.0.0 have changed, the output filename is no longer the second parameter. See the examples.
+
+h2. Examples
+
+<pre>
+<code>
+  require 'fastimage_resize'
+
+  FastImage.resize("example.gif", 100, 20, :outfile=>"my.gif")
+  => nil
+
+  outfile = FastImage.resize("nonexistentfile.png", 50, 50)
+  =>FastImage::ImageFetchFailure: FastImage::ImageFetchFailure
+
+  outfile = FastImage.resize("afile.png", 50, 150)
+  => #<File:/var/folders/vm/vd65y2597xl_by6c73_m9j1h0000gn/T/FastImage20111003-7638-x3l8r7-0.png>
+  
+  File.open("afile.png", "r") {|f| FastImage.resize(f, 100, 100)}
+  => #<File:/var/folders/vm/vd65y2597xl_by6c73_m9j1h0000gn/T/FastImage20111003-7638-y1ofh-0.png>
+</code>
+</pre>
+
+Giving a zero value for width or height causes the image to scale proportionately.
+
+h2. Installation
+
+First check the requirements section below.
+
+h4. Gem
+
+<pre>
+<code>
+  gem install fastimage_resize
+</pre>
+</code>
+
+h4. Rails
+
+Install the gem as above, and for Rails 2 configure it in your environment.rb file as below:
+<pre>
+<code>
+...
+Rails::Initializer.run do |config|
+  ...
+  config.gem "fastimage_resize"
+  ...
+end
+...
+</code>
+</pre>
+
+For Rails 3, add this to your Gemfile:
+
+<pre>
+<code>
+gem 'fastimage_resize'
+</code>
+</pre>
+
+For any Rails version, you may also need this in your environment.rb so that the rails process puts the compiled C code in a place it can access:
+
+<pre>
+<code>
+ENV['INLINEDIR'] = RAILS_ROOT + "/tmp"  # for RubyInline
+</code>
+</pre>
+
+Then you're off - just use FastImage.resize() in your code as in the examples.
+
+h2. Requirements
+
+* RubyInline
+
+<pre>
+<code>
+  gem install RubyInline
+</pre>
+</code>
+
+* FastImage
+
+<pre>
+<code>
+  gem install fastimage
+</pre>
+</code>
+
+* Libgd
+
+See "http://www.libgd.org/":http://www.libgd.org/
+
+Libgd is commonly available on most unix platforms, including OSX.
+
+On OSX, if you have "macports":http://www.macports.org/ you can use.
+
+<pre>
+<code>
+  sudo port install gd2
+</code>
+</pre>
+
+It is also available in "homebrew":http://github.com/mxcl/homebrew (search for gd), and "fink":http://www.finkproject.org/ (try fink install gd2 gd2-bin).
+
+h2. Documentation
+
+"http://rdoc.info/projects/sdsykes/fastimage_resize":http://rdoc.info/projects/sdsykes/fastimage_resize
+
+h2. Caveats
+
+Because of the way that libgd works, gif files that have transparency may not always come through with the transparency perfectly retained.
+
+
+h2. Tests
+
+Run @ruby test/test.rb@ to execute the tests.
+
+h2. References
+
+* "http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing":http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing
+
+h2. Licence
+
+MIT, see file MIT_LICENCE
+
+h2. Author
+
+Stephen Sykes, @sdsykes

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:patch: 3
+:major: 2
+:build: 
+:minor: 0

data/lib/fastimage/resize.rb

@@ -0,0 +1,177 @@
+# FastImage Resize is an extremely light solution for resizing images in ruby by using libgd
+#
+# === Examples
+#
+#   require 'fastimage_resize'
+#
+#   FastImage.resize("image.gif", 100, 20, :outfile=>"thumbnail.gif")
+#   => 1
+#
+# === Requirements
+#
+# RubyInline and FastImage (installed via RubyGems) and libgd
+#
+# See http://www.libgd.org/
+#
+# Libgd is commonly available on most unix platforms, including OSX.
+#
+# === References
+#
+# * http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing
+
+require 'inline'
+require 'tempfile'
+require 'fastimage'
+
+module FastImage::Resize
+  SUPPORTED_FORMATS = [:jpeg, :png, :gif]
+  FILE_EXTENSIONS = [:jpg, :png, :gif]  # prefer jpg to jpeg as an extension
+
+  class FormatNotSupported < FastImage::FastImageException # :nodoc:
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    # Resizes an image, storing the result in a file given in file_out
+    #
+    # Input can be a filename, a uri, or an IO object.
+    #
+    # FastImage Resize can resize GIF, JPEG and PNG files.
+    #
+    # Giving a zero value for width or height causes the image to scale proportionately.
+    #
+    # === Example
+    #
+    #   require 'fastimage_resize'
+    #
+    #   FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", 100, 20, :outfile=>"my.gif")
+    #
+    # === Supported options
+    # [:jpeg_quality]
+    #   A figure passed to libgd to determine quality of output jpeg (only useful if input is jpeg)
+    # [:outfile]
+    #   Name of a file to store the output in, in this case a temp file is not used
+    #
+    def resize(source, width, height, options={})
+      new(source, :raise_on_failure => true).resize(width, height, options)
+    end
+  end
+
+  def resize(width, height, options = {})
+    jpeg_quality = options[:jpeg_quality] || -1
+    file_out = options[:outfile]
+
+    type_index = SUPPORTED_FORMATS.index(type)
+    raise FormatNotSupported unless type_index
+
+    if !file_out
+      temp_file = Tempfile.new(["fastimage-resize-", ".#{FILE_EXTENSIONS[type_index]}"])
+      temp_file.binmode
+      file_out = temp_file.path
+    else
+      temp_file = nil
+    end
+
+    resize_image(path, file_out.to_s, width.to_i, height.to_i, type_index, jpeg_quality.to_i)
+
+    temp_file
+  rescue RuntimeError => e
+    raise ImageFetchFailure, e.message
+  end
+
+  private
+
+  def resize_image(filename_in, filename_out, w, h, image_type, jpeg_quality); end
+
+  inline do |builder|
+    builder.include '"gd.h"'
+    builder.add_link_flags "-lgd"
+
+    builder.c <<-"END"
+      VALUE resize_image(char *filename_in, char *filename_out, int w, int h, int image_type, int jpeg_quality) {
+        gdImagePtr im_in, im_out;
+        FILE *in, *out;
+        int trans = 0, x = 0, y = 0, f = 0;
+
+        in = fopen(filename_in, "rb");
+        if (!in) return Qnil;
+
+        switch(image_type) {
+          case 0: im_in = gdImageCreateFromJpeg(in);
+                  break;
+          case 1: im_in = gdImageCreateFromPng(in);
+                  break;
+          case 2: im_in = gdImageCreateFromGif(in);
+                  trans = gdImageGetTransparent(im_in);
+                  /* find a transparent pixel, then turn off transparency
+                     so that it copies correctly */
+                  if (trans >= 0) {
+                    for (x=0; x<gdImageSX(im_in); x++) {
+                      for (y=0; y<gdImageSY(im_in); y++) {
+                        if (gdImageGetPixel(im_in, x, y) == trans) {
+                          f = 1;
+                          break;
+                        }
+                      }
+                      if (f) break;
+                    }
+                    gdImageColorTransparent(im_in, -1);
+                    if (!f) trans = -1;  /* no transparent pixel found */
+                  }
+                  break;
+          default: return Qnil;
+        }
+
+        if (w == 0 || h == 0) {
+          int originalWidth  = gdImageSX(im_in);
+          int originalHeight = gdImageSY(im_in);
+          if (w == 0) {
+            w = (int)(h * originalWidth / originalHeight);
+          } else {
+            h = (int)(w * originalHeight / originalWidth);
+          }
+        }
+
+        im_out = gdImageCreateTrueColor(w, h);  /* must be truecolor */
+
+        if (image_type == 1) {
+          gdImageAlphaBlending(im_out, 0);  /* handle transparency correctly */
+          gdImageSaveAlpha(im_out, 1);
+        }
+
+        fclose(in);
+
+        /* Now copy the original */
+        gdImageCopyResampled(im_out, im_in, 0, 0, 0, 0,
+          gdImageSX(im_out), gdImageSY(im_out),
+          gdImageSX(im_in), gdImageSY(im_in));
+
+        out = fopen(filename_out, "wb");
+        if (out) {
+          switch(image_type) {
+            case 0: gdImageJpeg(im_out, out, jpeg_quality);
+                    break;
+            case 1: gdImagePng(im_out, out);
+                    break;
+            case 2: gdImageTrueColorToPalette(im_out, 0, 256);
+                    if (trans >= 0) {
+                      trans = gdImageGetPixel(im_out, x, y);  /* get the color index of our transparent pixel */
+                      gdImageColorTransparent(im_out, trans); /* may not always work as hoped */
+                    }
+                    gdImageGif(im_out, out);
+                    break;
+          }
+          fclose(out);
+        }
+        gdImageDestroy(im_in);
+        gdImageDestroy(im_out);
+        return Qnil;
+      }
+    END
+  end
+end
+
+FastImage.send(:include, FastImage::Resize)

data/lib/fastimage/resize/version.rb

@@ -0,0 +1,5 @@
+class FastImage
+  module Resize
+    VERSION = "3.0.0"
+  end
+end

data/local-fastimage_resize.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fastimage/resize/version"
+
+Gem::Specification.new do |s|
+  s.name = "local-fastimage_resize"
+  s.version = FastImage::Resize::VERSION
+  s.authors = ["Stephen Sykes"]
+  s.email = ["sdsykes@gmail.com"]
+
+  s.summary = "FastImage Resize - Image resizing fast and simple"
+  s.description = "FastImage Resize is an extremely light solution for resizing images in ruby by using libgd."
+  s.homepage = "http://github.com/sdsykes/fastimage_resize"
+
+  s.requirements = ["libgd, see www.libgd.org"]
+
+  s.license = "MIT"
+
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "RubyInline", ">= 3.8.2"
+  s.add_dependency "local-fastimage", ">= 3.0.0"
+
+  s.add_development_dependency "bundler", "~> 1.12"
+  s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: local-fastimage_resize
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Stephen Sykes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: RubyInline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.2
+- !ruby/object:Gem::Dependency
+  name: local-fastimage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: FastImage Resize is an extremely light solution for resizing images in
+  ruby by using libgd.
+email:
+- sdsykes@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- MIT_LICENCE
+- README
+- README.md
+- README.textile
+- Rakefile
+- VERSION.yml
+- lib/fastimage/resize.rb
+- lib/fastimage/resize/version.rb
+- local-fastimage_resize.gemspec
+homepage: http://github.com/sdsykes/fastimage_resize
+licenses:
+- MIT
+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:
+- libgd, see www.libgd.org
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: FastImage Resize - Image resizing fast and simple
+test_files: []