tinyimg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a953ed5351abc1984d8739f8ec3d91a1bed9654a
+  data.tar.gz: c73c4110056238bc19a1c6e7ae6204b4c98a9968
+SHA512:
+  metadata.gz: 810f4ae575ca67c08c7a1551eb0abf4f16ca6fb12c77d4d9dd9227bd448856644d063424c0d34a6251aa2a52ef0be38ad9180e29f05d3e2a81ccb487d7c260b3
+  data.tar.gz: f7021348faf7e950ed87c51c12383684238bdfef806fb9f11d36bdb0c1e51c600576bb7fe7ac2ef48f31361d6769ffb50b988166ffabbb625cdf6983e7142560

data/.gitignore

@@ -0,0 +1,5 @@
+/*.gem
+ext/tinyimg/Makefile
+ext/tinyimg/mkmf.log
+ext/tinyimg/*.bundle
+ext/tinyimg/*.o

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    timyimg (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 3.0)
+  timyimg!

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright 2015 Roger Nesbitt
+
+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,74 @@
+# Tinyimg
+
+Load a JPEG or PNG, get its dimensions, resize it, and extract it again as either a JPEG or PNG.
+
+This gem can work from image data stored in memory, as well as from a file or IO stream.
+It's been coded to be as efficient as possible, so doesn't use temporary files.
+
+Tinyimg uses libgd for its image processing.  libgd is significantly less painful to install than
+ImageMagick and friends!  Other than that, all that is required is Ruby 2.0+.
+
+## Installation
+
+If you don't already have libgd installed on your system, install it.
+
+On OS X, install Homebrew and
+
+    brew install libgd
+
+On a Linux system, use your package manager.  For example, on Debian/Ubuntu:
+
+    sudo apt-get install libgd-dev
+
+Then add tinyimg to your project's Gemfile
+
+    gem 'tinyimg'
+
+## Usage
+
+Load the image with the method that fits your use case:
+
+    image = Tinyimg.from_string(an_image_that_is_already_loaded)
+    image = Tinyimg.from_file("some_image.png")
+    image = Tinyimg.from_io(params[:uploaded_file])
+
+Manipulate it by using one of the resize commands:
+
+    image.resize_to_fit!(100, 100)  # image will be 100x100 maximum
+    image.resize_to_fill!(100, 100) # image will be 100x100 minimum
+    image.resize!(100, 100)         # forces image to be exactly 100x100
+
+Then get an image back:
+
+    image.to_png                 # returns a string
+    image.to_jpeg                # returns a string
+    image.save("some_image.jpg") # file type auto-determined by extension
+
+You can ask for the image's dimensions:
+
+    image.width       # => 120
+    image.height      # => 80
+    image.dimensions  # => [120, 80]
+
+You can also use the non-! versions of the resize methods: `resize`, `resize_to_fit` and `resize_to_fill`.
+These create a new image in memory and return it, leaving the old image untouched.  This is useful if you want
+to resize an original image to multiple sizes.  Using these methods will take more memory.
+
+## Examples
+
+Take an uploaded file, save the original as a JPEG, then resize to create a thumbnail and save that too:
+
+    Tinyimg
+      .from_io(params[:uploaded_file])
+      .save("#{path}/full_size.jpg")
+      .resize_to_fit!(100, 100)
+      .save("#{path}/thumbnail.jpg")
+
+Load a file from disk, make a thumbnail, and return it as a JPEG so we can save it into our database:
+
+    data = Tinyimg.from_file(image_filename).resize_to_fit!(100, 100).to_jpeg
+    user.update!(thumbnail_image: data)
+
+## Author and licence
+
+Copyright 2015 Roger Nesbitt.  Licenced under the MIT licence.

data/ext/tinyimg/extconf.rb

@@ -0,0 +1,35 @@
+require 'mkmf'
+
+def filter_dirs(dirs)
+  dirs.select {|dir| Dir.exists?(dir)}
+end
+
+def cannot_find_gd
+  abort <<-TEXT
+*******************************************************************************
+  It looks like libgd is not installed on your system.
+
+  If you're on OS X, install homebrew and try
+    brew install libgd
+
+  If you're on Debian/Ubuntu linux, try
+    apt-get install libgd-dev
+*******************************************************************************
+  TEXT
+end
+
+header_dirs = %w(/opt/local/include /usr/local/include /usr/include)
+lib_dirs    = %w(/opt/local/lib /usr/local/lib /usr/lib)
+
+dir_config('gd', filter_dirs(header_dirs), filter_dirs(lib_dirs))
+
+have_library('gd', 'gdFree') or cannot_find_gd
+have_header('gd.h')          or cannot_find_gd
+have_func('gdImageJpegPtr')  or abort "Your libgd is too old!  You need at least version 1.8.0, and preferably 2.1.1+."
+have_func('gdImageFile')
+have_func('gdImageCreateFromFile')
+have_func('gdImageAlphaBlending')
+have_func('gdImageClone')
+have_func('gdImagePngPtrEx')
+
+create_makefile 'tinyimg/tinyimg'

data/ext/tinyimg/tinyimg.c

@@ -0,0 +1,255 @@
+#include <ruby.h>
+#include <gd.h>
+
+gdImagePtr get_image_data(VALUE self)
+{
+  gdImagePtr image;
+  VALUE wrapped_image = rb_iv_get(self, "@data");
+  Data_Get_Struct(wrapped_image, struct gdImageStruct, image);
+  return image;
+}
+
+void set_image_data(VALUE self, gdImagePtr image)
+{
+  VALUE klass, value;
+
+  klass = rb_const_get_at(rb_class_of(self), rb_intern("Image"));
+  value = Data_Wrap_Struct(klass, 0, gdImageDestroy, image);
+  rb_iv_set(self, "@data", value);
+}
+
+void set_alpha(gdImagePtr image)
+{
+#ifdef HAVE_GDIMAGEALPHABLENDING
+  gdImageAlphaBlending(image, 0);
+  gdImageSaveAlpha(image, 1);
+#endif
+}
+
+VALUE retrieve_image_dimensions(VALUE self)
+{
+  gdImagePtr image = get_image_data(self);
+
+  rb_iv_set(self, "@width", INT2FIX(gdImageSX(image)));
+  rb_iv_set(self, "@height", INT2FIX(gdImageSY(image)));
+
+  return Qnil;
+}
+
+VALUE load_from_string(VALUE self, VALUE input, VALUE type)
+{
+  gdImagePtr image;
+  ID type_id;
+
+  Check_Type(input, T_STRING);
+  Check_Type(type, T_SYMBOL);
+  type_id = SYM2ID(type);
+
+  if (type_id == rb_intern("png")) {
+    image = gdImageCreateFromPngPtr(RSTRING_LEN(input), RSTRING_PTR(input));
+  }
+  else if (type_id == rb_intern("jpeg")) {
+    image = gdImageCreateFromJpegPtr(RSTRING_LEN(input), RSTRING_PTR(input));
+  }
+  else {
+    rb_raise(rb_eArgError, "type must be a supported image type");
+  }
+
+  if (!image) {
+    rb_raise(rb_eRuntimeError, "Error loading image data");
+  }
+
+  set_image_data(self, image);
+  set_alpha(image);
+
+  retrieve_image_dimensions(self);
+
+  return self;
+}
+
+#ifdef HAVE_GDIMAGECREATEFROMFILE
+VALUE load_from_file(VALUE self, VALUE filename)
+{
+  gdImagePtr image;
+
+  Check_Type(filename, T_STRING);
+
+  image = gdImageCreateFromFile(StringValueCStr(filename));
+  if (!image) {
+    rb_raise(rb_eRuntimeError, "Error loading image data");
+  }
+
+  set_image_data(self, image);
+  set_alpha(image);
+
+  retrieve_image_dimensions(self);
+
+  return self;
+}
+#endif
+
+VALUE initialize_copy(int argc, VALUE *argv, VALUE self)
+{
+  gdImagePtr image, original;
+
+  rb_call_super(argc, argv);
+
+  original = get_image_data(self);
+
+#ifdef HAVE_GDIMAGECLONE
+  image = gdImageClone(original);
+#else
+  int width = gdImageSX(original), height = gdImageSY(original);
+
+  image = gdImageCreateTrueColor(width, height);
+  set_alpha(image);
+
+  gdImageCopy(image, original, 0, 0, 0, 0, width, height);
+#endif
+
+  set_image_data(self, image);
+
+  return Qnil;
+}
+
+#ifdef HAVE_GDIMAGEFILE
+VALUE save_to_file(VALUE self, VALUE filename)
+{
+  gdImagePtr image;
+  int result;
+
+  Check_Type(filename, T_STRING);
+
+  image = get_image_data(self);
+  result = gdImageFile(image, StringValueCStr(filename));
+
+  if (result == GD_FALSE) {
+    rb_raise(rb_eRuntimeError, "Unknown error occurred while trying to save the file; check it is using a known filename");
+  }
+
+  return self;
+}
+#endif
+
+VALUE to_jpeg(int argc, VALUE *argv, VALUE self)
+{
+  gdImagePtr image;
+  char *image_data;
+  int size, quality;
+  VALUE quality_value;
+
+  rb_scan_args(argc, argv, "01", &quality_value);
+
+  if (NIL_P(quality_value)) {
+    quality = -1;
+  }
+  else {
+    Check_Type(quality_value, T_FIXNUM);
+    quality = FIX2INT(quality_value);
+  }
+
+  if (quality < -1 || quality > 100) {
+    rb_raise(rb_eArgError, "Quality must be between 0 and 100, or -1 for default");
+  }
+
+  image = get_image_data(self);
+
+  image_data = (char *) gdImageJpegPtr(image, &size, quality);
+  if (!image_data) {
+    rb_raise(rb_eRuntimeError, "Unknown error occurred while trying to build a JPEG");
+  }
+
+  VALUE output = rb_str_new(image_data, size);
+  gdFree(image_data);
+  return output;
+}
+
+VALUE to_png(int argc, VALUE *argv, VALUE self)
+{
+  gdImagePtr image;
+  char *image_data;
+  int size;
+  VALUE compression_value;
+  int compression;
+
+  rb_scan_args(argc, argv, "01", &compression_value);
+
+  image = get_image_data(self);
+
+  if (NIL_P(compression_value)) {
+    image_data = (char *) gdImagePngPtr(image, &size);
+  }
+  else {
+    Check_Type(compression_value, T_FIXNUM);
+    compression = FIX2INT(compression_value);
+
+    if (compression < 0 || compression > 9) {
+      rb_raise(rb_eArgError, "Compression must be between 0 and 9");
+    }
+
+#ifdef HAVE_GDIMAGEPNGPTREX
+    image_data = (char *) gdImagePngPtrEx(image, &size, compression);
+#else
+    image_data = (char *) gdImagePngPtr(image, &size);
+#endif
+  }
+
+  if (!image_data) {
+    rb_raise(rb_eRuntimeError, "Unknown error occurred while trying to build a PNG");
+  }
+
+  VALUE output = rb_str_new(image_data, size);
+  gdFree(image_data);
+  return output;
+}
+
+VALUE resize_bang(VALUE self, VALUE width_value, VALUE height_value)
+{
+  gdImagePtr image_in, image_out;
+  int width, height;
+
+  Check_Type(width_value, T_FIXNUM);
+  Check_Type(height_value, T_FIXNUM);
+
+  width = FIX2INT(width_value);
+  height = FIX2INT(height_value);
+
+  if (width < 0 || height < 0) {
+    rb_raise(rb_eArgError, "width and height must both be positive integers");
+  }
+
+  image_in = get_image_data(self);
+  image_out = gdImageCreateTrueColor(width, height);
+  set_alpha(image_out);
+
+  gdImageCopyResampled(
+      image_out, image_in, 0, 0, 0, 0,
+      gdImageSX(image_out), gdImageSY(image_out),
+      gdImageSX(image_in), gdImageSY(image_in)
+  );
+
+  set_image_data(self, image_out);
+
+  retrieve_image_dimensions(self);
+
+  return self;
+}
+
+void Init_tinyimg()
+{
+  VALUE cTinyimg = rb_define_class("Tinyimg", rb_cObject);
+  rb_define_class_under(cTinyimg, "Image", rb_cObject);
+
+  rb_define_method(cTinyimg, "resize!", resize_bang, 2);
+  rb_define_method(cTinyimg, "to_jpeg", to_jpeg, -1);
+  rb_define_method(cTinyimg, "to_png", to_png, -1);
+  rb_define_private_method(cTinyimg, "initialize_copy", initialize_copy, -1);
+  rb_define_private_method(cTinyimg, "load_from_string", load_from_string, 2);
+  rb_define_private_method(cTinyimg, "retrieve_image_dimensions", retrieve_image_dimensions, 0);
+#ifdef HAVE_GDIMAGECREATEFROMFILE
+  rb_define_private_method(cTinyimg, "load_from_file", load_from_file, 1);
+#endif
+#ifdef HAVE_GDIMAGEFILE
+  rb_define_private_method(cTinyimg, "save_to_file", save_to_file, 1);
+#endif
+}

data/lib/tinyimg.rb

@@ -0,0 +1,138 @@
+require_relative '../ext/tinyimg/tinyimg'
+
+class Tinyimg
+  attr_reader :width, :height
+
+  private_class_method :new
+
+  def self.from_file(filename)
+    new(:filename, filename)
+  end
+
+  def self.from_io(io)
+    from_string(io.read)
+  end
+
+  def self.from_string(data)
+    new(:string, data)
+  end
+
+  def dimensions
+    [width, height]
+  end
+
+  def resize(width, height)
+    dup.resize!(width, height)
+  end
+
+  # Implemented in C
+  # def resize!(width, height)
+  # end
+
+  def resize_to_fit(new_width, new_height)
+    dup.resize_to_fit!(new_width, new_height)
+  end
+
+  def resize_to_fit!(new_width, new_height)
+    resize_to_fit_or_fill!(new_width, new_height) do |old_ratio, new_ratio|
+      old_ratio > new_ratio
+    end
+  end
+
+  def resize_to_fill(new_width, new_height)
+    dup.resize_to_fill!(new_width, new_height)
+  end
+
+  def resize_to_fill!(new_width, new_height)
+    resize_to_fit_or_fill!(new_width, new_height) do |old_ratio, new_ratio|
+      old_ratio < new_ratio
+    end
+  end
+
+  def save(filename)
+    if respond_to?(:save_to_file)
+      save_to_file(filename)
+    else
+      data = case determine_by_extension(filename)
+             when :jpeg then to_jpeg
+             when :png  then to_png
+             end
+
+      File.write(filename, data)
+    end
+  end
+
+  # Implemented in C
+  # def to_jpeg(quality = DEFAULT_JPEG_QUALITY)
+  # end
+
+  # Implemented in C
+  # def to_png(compression = nil)
+  # end
+
+  private
+
+  def initialize(mode, data, type = nil)
+    case mode
+    when :string
+      load_from_string(data, determine_type(data))
+    when :filename
+      if respond_to?(:load_from_file)
+        load_from_file(data)
+      else
+        content = File.read(data)
+        load_from_string(content, determine_type(content))
+      end
+    else
+      raise
+    end
+  end
+
+  def resize_to_fit_or_fill!(new_width, new_height)
+    old_ratio = width / height.to_f
+    new_ratio = new_width / new_height.to_f
+
+    if yield(old_ratio, new_ratio)
+      resize_width = new_width
+      resize_height = (height * (new_width / width.to_f)).to_i
+    else
+      resize_width = (width * (new_height / height.to_f)).to_i
+      resize_height = new_height
+    end
+
+    resize!(resize_width, resize_height)
+  end
+
+  def determine_type(data)
+    if data[0, 3].unpack("C*") == [255, 216, 255]
+      :jpeg
+    elsif data[0, 8].unpack("C*") == [137, 80, 78, 71, 13, 10, 26, 10]
+      :png
+    else
+      raise ArgumentError, "Only JPEG and PNG files are supported"
+    end
+  end
+
+  def determine_by_extension(filename)
+    case filename.split(".").last.to_s.downcase
+    when 'jpeg', 'jpg' then :jpeg
+    when 'png'         then :png
+    else
+      raise ArgumentError, "Cannot determine image type based on the filename"
+    end
+  end
+
+  # Implemented in C
+  # def load_from_string(data, type)
+  # end
+
+  # Implemented in C
+  # Only available with libgd 2.1.1+
+  # def load_from_file(filename)
+  # end
+
+  # Implemented in C
+  # Only available with libgd 2.1.1+
+  # def save_to_file(filename)
+  # end
+end

data/spec/tinyimg_spec.rb

@@ -0,0 +1,122 @@
+require 'tinyimg'
+
+RSpec.describe Tinyimg do
+  let(:samples_directory) { "#{File.dirname(__FILE__)}/samples" }
+  let(:sample_filename) { "#{samples_directory}/duck.png" }
+  let(:sample) { Tinyimg.from_file(sample_filename) }
+
+  let(:tmp_directory) { "#{File.dirname(__FILE__)}/tmp" }
+  let(:tmp_jpg_filename)  { "#{tmp_directory}/test.jpg" }
+  let(:tmp_png_filename)  { "#{tmp_directory}/test.png" }
+
+  describe "#from_file, #width, #height and #dimensions" do
+    it "loads from a file and returns the width and height of the image" do
+      expect(sample.width).to eq 200
+      expect(sample.height).to eq 153
+      expect(sample.dimensions).to eq [200, 153]
+    end
+  end
+
+  describe "#from_string" do
+    it "loads a PNG" do
+      image = Tinyimg.from_string(IO.read(sample_filename))
+      expect(image.dimensions).to eq [200, 153]
+    end
+  end
+
+  describe "#from_io" do
+    it "loads a PNG" do
+      File.open(sample_filename, "r") do |file|
+        image = Tinyimg.from_io(file)
+        expect(image.dimensions).to eq [200, 153]
+      end
+    end
+  end
+
+  describe "#resize" do
+    it "resizes the image as requested, creating a new image" do
+      result = sample.resize(100, 100)
+      expect(result).to_not eql sample
+      expect(sample.dimensions).to eq [200, 153]
+      expect(result.dimensions).to eq [100, 100]
+    end
+  end
+
+  describe "#resize!" do
+    it "resizes the image as requested" do
+      result = sample.resize!(100, 100)
+      expect(result).to eql sample
+      expect(sample.dimensions).to eq [100, 100]
+    end
+  end
+
+  describe "#resize_to_fit!" do
+    it "calculates the image dimensions so it fits the width and resizes" do
+      sample.resize_to_fit!(100, 100)
+      expect(sample.dimensions).to eq [100, 76]
+    end
+
+    it "calculates the image dimensions so it fits the height and resizes" do
+      sample.resize_to_fit!(1000, 100)
+      expect(sample.dimensions).to eq [130, 100]
+    end
+  end
+
+  describe "#resize_to_fill!" do
+    it "calculates the image dimensions so it fills the width and resizes" do
+      sample.resize_to_fill!(1000, 100)
+      expect(sample.dimensions).to eq [1000, 765]
+    end
+
+    it "calculates the image dimensions so it fills the height and resizes" do
+      sample.resize_to_fill!(100, 100)
+      expect(sample.dimensions).to eq [130, 100]
+    end
+  end
+
+  describe "#save" do
+    it "saves a JPEG" do
+      begin
+        sample.save(tmp_jpg_filename)
+        expect(File.read(tmp_jpg_filename, 3).unpack("C*")).to eq [255, 216, 255]
+
+        reloaded = Tinyimg.from_file(tmp_jpg_filename)
+        expect(reloaded.dimensions).to eq [200, 153]
+      ensure
+        File.unlink(tmp_jpg_filename)
+      end
+    end
+
+    it "saves a PNG" do
+      begin
+        sample.save(tmp_png_filename)
+        expect(File.read(tmp_png_filename, 3).unpack("C*")).to eq [137, 80, 78]
+
+        reloaded = Tinyimg.from_file(tmp_png_filename)
+        expect(reloaded.dimensions).to eq [200, 153]
+      ensure
+        File.unlink(tmp_png_filename)
+      end
+    end
+  end
+
+  describe "#to_jpeg" do
+    it "exports a JPEG" do
+      data = sample.to_jpeg
+      expect(data[0, 3].unpack("C*")).to eq [255, 216, 255]
+
+      reloaded = Tinyimg.from_string(data)
+      expect(reloaded.dimensions).to eq [200, 153]
+    end
+  end
+
+  describe "#to_png" do
+    it "exports a PNG" do
+      data = sample.to_png
+      expect(data[0, 3].unpack("C*")).to eq [137, 80, 78]
+
+      reloaded = Tinyimg.from_string(data)
+      expect(reloaded.dimensions).to eq [200, 153]
+    end
+  end
+end

data/tinyimg.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |gem|
+  gem.name = 'tinyimg'
+  gem.version = '0.1.0'
+  gem.summary = "Tiny and fast JPEG/PNG resizer and converter"
+  gem.description = "Convert between JPEG/PNG and resize images, either all in memory or via disk.  Only required libgd to function."
+  gem.has_rdoc = false
+  gem.author = "Roger Nesbitt"
+  gem.email = "roger@seriousorange.com"
+  gem.homepage = "http://github.com/mogest/tinyimg"
+  gem.license = 'MIT'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- spec/*`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.extensions    = %w(ext/tinyimg/extconf.rb)
+
+  gem.required_ruby_version = '>= 2.0.0'
+
+  gem.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: tinyimg
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Roger Nesbitt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Convert between JPEG/PNG and resize images, either all in memory or via
+  disk.  Only required libgd to function.
+email: roger@seriousorange.com
+executables: []
+extensions:
+- ext/tinyimg/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- ext/tinyimg/extconf.rb
+- ext/tinyimg/tinyimg.c
+- lib/tinyimg.rb
+- spec/samples/duck.png
+- spec/tinyimg_spec.rb
+- spec/tmp/.keep
+- tinyimg.gemspec
+homepage: http://github.com/mogest/tinyimg
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Tiny and fast JPEG/PNG resizer and converter
+test_files:
+- spec/samples/duck.png
+- spec/tinyimg_spec.rb
+- spec/tmp/.keep