rszr 0.4.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f6ab5d9447d5919f0bed35e0562f7645bb5a23db
-  data.tar.gz: 88988dc45c31575db6a1cf11618298be6641fca8
+SHA256:
+  metadata.gz: c4fc21afb848256445e310a0feebab86b2b10ee6baf464bd7e67a44b282b4d07
+  data.tar.gz: bfe92bbc780dbf03135b4b3d7296df141bee74279412b6bd3b6d2ba70362a140
 SHA512:
-  metadata.gz: 4a5d7d5ba83088cce7de9af7a0d68c92d2e2c0f58029617dfa1c270a83aa58af96168b11b2bebdd0c3ad1a930598726acd0809b5b3a7dea901567402bf23ed1b
-  data.tar.gz: 1a53df4fcbd02f524d42cfadcd9dbacdba3945423f5a244af8da190e4cc59de2b87b267de78b0481c4c8d106d27dc16a2ec30f4f728310eced9e9da8a0191f0f
+  metadata.gz: 26d46f7b4d594da5e871d75975d99cd54358bb6585d8b18fbddcba1b4383970099891f7af6d16b51b8dcf19f5ed179b275d001b15f546c3baa58a3b6573613f9
+  data.tar.gz: 0f5866b917277c7afb518fb15ba83451fc7b448681fec26dad4321d17cfa464854e9182cff88008f7ee25b1c6df135f6a14f3980b64a145db9ef93e035de1d9e

data/README.md

@@ -45,6 +45,9 @@ image.resize(400, 300)
 # save it
 image.save('resized.jpg')
 
+# save it as PNG
+image.save('resized.png')
+
 # auto height
 image.resize(400, :auto)
 
@@ -57,18 +60,28 @@ image.resize(0.5)
 # crop
 image.crop(200, 200, 100, 100)
 
+# rotate three times 90 deg clockwise
+image.turn!(3)
+
+# rotate one time 90 deg counterclockwise
+image.turn!(-1)
+
+# initialize copy
+image.dup
+
 # save memory, do not duplicate instance
 image.resize!(400, :auto)
 
-# image dimensions
+# image info
 image.width => 400
 image.height => 300
 image.dimensions => [400, 300]
+image.format => "jpeg"
 ```
 
 ## Thread safety
 
-As of version 0.4.0, Rszr provides thread safety by synchronizing access to imlib2 function calls.
+As of version 0.4.0, Rszr is thread safe through the Ruby GIL.
 Use of any previous versions in a threaded environment is discouraged.
 
 ## Speed

data/Rakefile

@@ -9,3 +9,9 @@ begin
 rescue LoadError
   # no rspec available
 end
+
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('rszr') do |ext|
+  ext.lib_dir = 'lib/rszr'
+end

data/ext/rszr/errors.c

@@ -0,0 +1,63 @@
+#ifndef RUBY_RSZR_ERRORS
+#define RUBY_RSZR_ERRORS
+
+#include "rszr.h"
+#include "errors.h"
+
+VALUE eRszrError = Qnil;
+VALUE eRszrFileNotFound = Qnil;
+VALUE eRszrTransformationError = Qnil;
+VALUE eRszrErrorWithMessage = Qnil;
+VALUE eRszrLoadError = Qnil;
+VALUE eRszrSaveError = Qnil;
+
+static const char * const sRszrErrorMessages[] =
+{
+  "File does not exist",
+  "File is a directory",
+  "Read permission denied",
+  "Unsupported format",
+  "Path too long",
+  "Non-existant path component",
+  "Path component is not a directory",
+  "Path outside address space",
+  "Too many symbolic links",
+  "Out of memory",
+  "Out of file descriptors",
+  "Write permission denied",
+  "Out of disk space",
+  "Unknown error"
+};
+const int RSZR_MAX_ERROR_INDEX = 13;
+
+void Init_rszr_errors()
+{
+  eRszrError = rb_define_class_under(mRszr, "Error", rb_eStandardError);
+  eRszrFileNotFound = rb_define_class_under(mRszr, "FileNotFound", eRszrError);
+  eRszrTransformationError = rb_define_class_under(mRszr, "TransformationError", eRszrError);
+  eRszrErrorWithMessage = rb_define_class_under(mRszr, "ErrorWithMessage", eRszrError);
+  eRszrLoadError = rb_define_class_under(mRszr, "LoadError", eRszrErrorWithMessage);
+  eRszrSaveError = rb_define_class_under(mRszr, "SaveError", eRszrErrorWithMessage);
+}
+
+static void rszr_raise_error_with_message(VALUE rb_error_class, Imlib_Load_Error error)
+{
+  int error_index = (int) error - 1;
+  if (error_index < 1 || error_index > RSZR_MAX_ERROR_INDEX)
+    error_index = 13;
+  VALUE rb_error = rb_exc_new2(rb_error_class, sRszrErrorMessages[error_index]);
+  rb_exc_raise(rb_error);
+}
+
+void rszr_raise_load_error(Imlib_Load_Error error)
+{
+  rszr_raise_error_with_message(eRszrLoadError, error);
+}
+
+void rszr_raise_save_error(Imlib_Load_Error error)
+{
+  rszr_raise_error_with_message(eRszrSaveError, error);
+}
+
+
+#endif

data/ext/rszr/errors.h

@@ -0,0 +1,15 @@
+#ifndef RUBY_RSZR_ERRORS_H
+#define RUBY_RSZR_ERRORS_H
+
+void Init_rszr_errors();
+void rszr_raise_load_error(Imlib_Load_Error error);
+void rszr_raise_save_error(Imlib_Load_Error error);
+
+extern VALUE eRszrError;
+extern VALUE eRszrFileNotFound;
+extern VALUE eRszrTransformationError;
+extern VALUE eRszrErrorWithMessage;
+extern VALUE eRszrLoadError;
+extern VALUE eRszrSaveError;
+
+#endif

data/ext/rszr/extconf.rb

@@ -0,0 +1,18 @@
+require 'mkmf'
+require 'rbconfig'
+
+imlib2_config = with_config('imlib2-config', 'imlib2-config')
+
+$CFLAGS << ' -DX_DISPLAY_MISSING ' << `#{imlib2_config} --cflags`.chomp
+$LDFLAGS << ' ' << `#{imlib2_config} --libs`.chomp
+$LDFLAGS.gsub!(/\ -lX11\ -lXext/, '') if RUBY_PLATFORM =~ /darwin/
+
+unless find_header('Imlib2.h')
+  abort 'imlib2 development headers are missing'
+end
+
+unless find_library('Imlib2', 'imlib_set_cache_size')
+  abort 'Imlib2 is missing'
+end
+
+create_makefile 'rszr/rszr'

data/ext/rszr/image.c

@@ -0,0 +1,309 @@
+#ifndef RUBY_RSZR_IMAGE
+#define RUBY_RSZR_IMAGE
+
+#include "rszr.h"
+#include "image.h"
+#include "errors.h"
+
+VALUE cImage = Qnil;
+
+
+static void rszr_free_image(Imlib_Image image)
+{
+  imlib_context_set_image(image);
+  imlib_free_image();
+}
+
+
+static void rszr_image_deallocate(rszr_image_handle * handle)
+{
+  // fprintf(stderr, "rszr_image_deallocate");
+  if (handle->image) {
+    // fprintf(stderr, ": freeing");
+    rszr_free_image(handle->image);
+    handle->image = NULL;
+  }
+  free(handle);
+  // fprintf(stderr, "\n");
+}
+
+
+static VALUE rszr_image_s_allocate(VALUE klass)
+{
+  rszr_image_handle * handle = calloc(1, sizeof(rszr_image_handle));
+  return Data_Wrap_Struct(klass, NULL, rszr_image_deallocate, handle);
+}
+
+
+static VALUE rszr_image_initialize(VALUE self, VALUE rb_width, VALUE rb_height)
+{
+  rszr_image_handle * handle;
+  
+  Check_Type(rb_width,  T_FIXNUM);
+  Check_Type(rb_height, T_FIXNUM);
+
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  handle->image = imlib_create_image(FIX2INT(rb_width), FIX2INT(rb_height));
+
+  return self;
+}
+
+
+static VALUE rszr_image_s__load(VALUE klass, VALUE rb_path)
+{
+  rszr_image_handle * handle;
+  Imlib_Image image;
+  char * path;
+  Imlib_Load_Error error;
+  VALUE oImage;
+  
+  path = StringValueCStr(rb_path);
+
+  imlib_set_cache_size(0);
+  image = imlib_load_image_with_error_return(path, &error);
+  
+  if (!image) {
+    rszr_raise_load_error(error);
+    return Qnil;
+  }
+  
+  oImage = rszr_image_s_allocate(cImage);
+  Data_Get_Struct(oImage, rszr_image_handle, handle);
+  handle->image = image;
+  return oImage;
+}
+
+
+static VALUE rszr_image_format(VALUE self)
+{
+  rszr_image_handle * handle;
+  char * format;
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  format = imlib_image_format();
+  
+  if (format) {
+    return rb_str_new2(format);
+  } else {
+    return Qnil;
+  }
+}
+
+
+static VALUE rszr_image_width(VALUE self)
+{
+  rszr_image_handle * handle;
+  int width;
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  width = imlib_image_get_width();
+  
+  return INT2NUM(width);
+}
+
+
+static VALUE rszr_image_height(VALUE self)
+{
+  rszr_image_handle * handle;
+  int height;
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  height = imlib_image_get_height();
+  
+  return INT2NUM(height);
+}
+
+
+static VALUE rszr_image_dup(VALUE self)
+{
+  rszr_image_handle * handle;
+  rszr_image_handle * cloned_handle;
+  Imlib_Image cloned_image;
+  VALUE oClonedImage;
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  cloned_image = imlib_clone_image();
+  
+  if (!cloned_image) {
+    rb_raise(eRszrTransformationError, "error cloning image");
+    return Qnil;
+  }
+  
+  oClonedImage = rszr_image_s_allocate(cImage);
+  Data_Get_Struct(oClonedImage, rszr_image_handle, cloned_handle);
+  cloned_handle->image = cloned_image;
+
+  return oClonedImage;
+}
+
+
+static VALUE rszr_image__turn_bang(VALUE self, VALUE orientation)
+{
+  rszr_image_handle * handle;
+
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  imlib_image_orientate(NUM2INT(orientation));
+  
+  return self;
+}
+
+
+static Imlib_Image rszr_create_cropped_scaled_image(const Imlib_Image image, VALUE rb_src_x, VALUE rb_src_y, VALUE rb_src_w, VALUE rb_src_h, VALUE rb_dst_w, VALUE rb_dst_h)
+{
+  Imlib_Image resized_image;
+  
+  int src_x = NUM2INT(rb_src_x);
+  int src_y = NUM2INT(rb_src_y);
+  int src_w = NUM2INT(rb_src_w);
+  int src_h = NUM2INT(rb_src_h);
+  int dst_w = NUM2INT(rb_dst_w);
+  int dst_h = NUM2INT(rb_dst_h);
+
+  // TODO: raise if <= 0
+
+  imlib_context_set_image(image);
+  imlib_context_set_anti_alias(1);
+  resized_image = imlib_create_cropped_scaled_image(src_x, src_y, src_w, src_h, dst_w, dst_h);
+  
+  if (!resized_image) {
+    rb_raise(eRszrTransformationError, "error resizing image");
+    return NULL;
+  }
+  
+  return resized_image;
+}
+
+
+static VALUE rszr_image__resize(VALUE self, VALUE bang, VALUE rb_src_x, VALUE rb_src_y, VALUE rb_src_w, VALUE rb_src_h, VALUE rb_dst_w, VALUE rb_dst_h)
+{
+  rszr_image_handle * handle;
+  Imlib_Image resized_image;
+  rszr_image_handle * resized_handle;
+  VALUE oResizedImage;
+
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  resized_image = rszr_create_cropped_scaled_image(handle->image, rb_src_x, rb_src_y, rb_src_w, rb_src_h, rb_dst_w, rb_dst_h);
+  if (!resized_image) return Qfalse;
+  
+  if (RTEST(bang)) {
+    rszr_free_image(handle->image);
+    handle->image = resized_image;
+    
+    return self;
+  }
+  else {
+    oResizedImage = rszr_image_s_allocate(cImage);
+    Data_Get_Struct(oResizedImage, rszr_image_handle, resized_handle);
+    resized_handle->image = resized_image;
+  
+    return oResizedImage;
+  }
+}
+
+
+static Imlib_Image rszr_create_cropped_image(const Imlib_Image image, VALUE rb_x, VALUE rb_y, VALUE rb_w, VALUE rb_h)
+{
+  Imlib_Image cropped_image;
+  
+  int x = NUM2INT(rb_x);
+  int y = NUM2INT(rb_y);
+  int w = NUM2INT(rb_w);
+  int h = NUM2INT(rb_h);
+  
+  imlib_context_set_image(image);
+  cropped_image = imlib_create_cropped_image(x, y, w, h);
+  
+  if (!cropped_image) {
+    rb_raise(eRszrTransformationError, "error cropping image");
+    return NULL;
+  }
+  
+  return cropped_image;
+}
+
+
+static VALUE rszr_image__crop(VALUE self, VALUE bang, VALUE rb_x, VALUE rb_y, VALUE rb_w, VALUE rb_h)
+{
+  rszr_image_handle * handle;
+  Imlib_Image cropped_image;
+  rszr_image_handle * cropped_handle;
+  VALUE oCroppedImage;
+
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  cropped_image = rszr_create_cropped_image(handle->image, rb_x, rb_y, rb_w, rb_h);
+  if (!cropped_image) return Qfalse;
+  
+  if (RTEST(bang)) {
+    rszr_free_image(handle->image);
+    handle->image = cropped_image;
+    
+    return self;
+  }
+  else {
+    oCroppedImage = rszr_image_s_allocate(cImage);
+    Data_Get_Struct(oCroppedImage, rszr_image_handle, cropped_handle);
+    cropped_handle->image = cropped_image;
+  
+    return oCroppedImage;
+  }
+}
+
+
+static VALUE rszr_image__save(VALUE self, VALUE rb_path, VALUE rb_format)
+{
+  rszr_image_handle * handle;
+  char * path;
+  char * format;
+  Imlib_Load_Error save_error;
+  
+  path = StringValueCStr(rb_path);
+  format = StringValueCStr(rb_format);
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  imlib_image_set_format(format);
+  imlib_save_image_with_error_return(path, &save_error);
+  
+  if (save_error) {
+    rszr_raise_save_error(save_error);
+    return Qfalse;
+  }
+  
+  return Qtrue;
+}
+
+void Init_rszr_image()
+{
+  cImage = rb_define_class_under(mRszr, "Image", rb_cObject);
+  rb_define_alloc_func(cImage, rszr_image_s_allocate);
+
+  // Class methods
+  rb_define_private_method(rb_singleton_class(cImage), "_load", rszr_image_s__load, 1);
+
+  // Instance methods
+  rb_define_method(cImage, "initialize",  rszr_image_initialize, 2);
+  rb_define_method(cImage, "width",       rszr_image_width, 0);
+  rb_define_method(cImage, "height",      rszr_image_height, 0);
+  rb_define_method(cImage, "format",      rszr_image_format, 0);
+  rb_define_method(cImage, "dup",         rszr_image_dup, 0);
+  rb_define_private_method(cImage, "_resize",  rszr_image__resize, 7);
+  rb_define_private_method(cImage, "_crop",    rszr_image__crop, 5);
+  rb_define_private_method(cImage, "_turn!",   rszr_image__turn_bang, 1);
+  rb_define_private_method(cImage, "_save",    rszr_image__save, 2);
+}
+
+#endif

data/ext/rszr/image.h

@@ -0,0 +1,12 @@
+#ifndef RUBY_RSZR_IMAGE_H
+#define RUBY_RSZR_IMAGE_H
+
+typedef struct {
+  Imlib_Image image;
+} rszr_image_handle;
+
+extern VALUE cImage;
+
+void Init_rszr_image();
+
+#endif

data/ext/rszr/rszr.c

@@ -0,0 +1,17 @@
+#ifndef RUBY_RSZR
+#define RUBY_RSZR
+
+#include "rszr.h"
+#include "image.h"
+#include "errors.h"
+
+VALUE mRszr = Qnil;
+
+void Init_rszr()
+{
+    mRszr = rb_define_module("Rszr");
+    Init_rszr_errors();
+    Init_rszr_image();
+}
+
+#endif

data/ext/rszr/rszr.h

@@ -0,0 +1,10 @@
+#ifndef RUBY_RSZR_H
+#define RUBY_RSZR_H
+
+#include "ruby.h"
+#include <Imlib2.h>
+
+extern VALUE mRszr;
+void Init_rszr();
+
+#endif

data/lib/rszr.rb

@@ -1,12 +1,6 @@
-require 'fiddle'
-require 'fiddle/import'
 require 'rbconfig'
 require 'pathname'
 
+require 'rszr/rszr'
 require 'rszr/version'
-require 'rszr/errors'
-require 'rszr/lib'
-require 'rszr/lock'
-require 'rszr/handle'
-require 'rszr/base'
 require 'rszr/image'

data/lib/rszr/image.rb

@@ -1,97 +1,53 @@
 module Rszr
   class Image
-    include Base
 
     class << self
       
-      alias_method :instantiate, :new
-      protected :instantiate
-      
-      def new(width, height)
-        ptr = with_lock { imlib_create_image(width, height) }
-        raise Error, 'Could not instantiate image' if ptr.null?
-        instantiate(ptr)
-      end
-            
       def load(path, options = {})
         path = path.to_s
         raise FileNotFound unless File.exist?(path)
-        load_error = LoadError.new
-        ptr = with_lock do
-          imlib_set_cache_size(0)
-          imlib_load_image_with_error_return(path, load_error.ptr)
-        end
-        raise load_error, load_error.message if ptr.null?
-        return instantiate(ptr)
+        _load(path)
       end
       alias :open :load
       
-      protected
-      
-      def finalize(ptr)
-        with_lock do
-          imlib_context_set_image(ptr)
-          imlib_free_image
-        end
-      end
-      
-    end
-    
-    def initialize(ptr)
-      @handle = Handle.new(self, ptr)
     end
-    
-    def width
-      with_image { imlib_image_get_width }
-    end
-    
-    def height
-      with_image { imlib_image_get_height }
-    end
-    
+
     def dimensions
       [width, height]
     end
-    
-    def format
-      str_ptr = with_image { imlib_image_format }
-      return if str_ptr.null?
-      str_ptr.to_s
+
+    def inspect
+      fmt = format
+      fmt = " #{fmt.upcase}" if fmt
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} #{width}x#{height}#{fmt}>"
     end
-    
+
     def resize(*args)
-      instantiate(create_resized_image(*args))
+      _resize(false, *calculate_size(*args))
     end
-    
+
     def resize!(*args)
-      handle.replace!(create_resized_image(*args))
-      self
+      _resize(true, *calculate_size(*args))
     end
-    
-    def crop(*args)
-      instantiate(create_cropped_image(*args))
+
+    def crop(x, y, width, height)
+      _crop(false, x, y, width, height)
     end
-    
-    def crop!(*args)
-      handle.replace!(create_cropped_image(*args))
-      self
+
+    def crop!(x, y, width, height)
+      _crop(true, x, y, width, height)
     end
-    
-    def save(path, format = nil)
-      with_image do
-        format ||= format_from_filename(path) || 'jpg'
-        imlib_image_set_format(format)
-        save_error = SaveError.new
-        imlib_save_image_with_error_return(path, save_error.ptr)
-        raise save_error, save_error.message if save_error.error?
-        true
-      end
+
+    def turn!(orientation)
+      orientation = orientation.abs + 2 if orientation.negative?
+      _turn!(orientation % 4)
     end
-    
-    def inspect
-      "#<#{self.class.name}:0x#{object_id.to_s(16)} width=#{width} height=#{height} format=#{format.inspect}>"
+
+    def save(path, format = nil)
+      format ||= format_from_filename(path) || 'jpg'
+      _save(path.to_s, format.to_s)
     end
-    
+
     private
     
     # 0.5               0 < scale < 1
@@ -102,7 +58,7 @@ module Rszr
     # 400, 300, background: rgba
     # 400, 300, aspect: false
     
-    def create_resized_image(*args)
+    def calculate_size(*args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       assert_valid_keys options, :crop, :background, :skew  #:extend, :width, :height, :max_width, :max_height, :box
       original_width, original_height = width, height
@@ -142,38 +98,18 @@ module Rszr
       else
         raise ArgumentError, "wrong number of arguments (#{args.size} for 1..2)"
       end
-      resized_ptr = with_image do
-        imlib_context_set_anti_alias(1)
-        imlib_create_cropped_scaled_image(x, y, imlib_image_get_width, imlib_image_get_height, new_width.round, new_height.round)
-      end
-      raise TransformationError, "error resizing image" if resized_ptr.null?
-      resized_ptr
-    end
-    
-    def create_cropped_image(x, y, width, height)
-      cropped_ptr = with_image { imlib_create_cropped_image(x, y, width, height) }
-      raise TransformationError, 'error cropping image' if cropped_ptr.null?
-      cropped_ptr
+      [x, y, original_width, original_height, new_width.round, new_height.round]
     end
     
     def format_from_filename(path)
       File.extname(path)[1..-1]
     end
-    
-    def context_set_image
-      imlib_context_set_image(ptr)
-    end
-    
-    def with_image
-      with_lock do
-        context_set_image
-        yield
+
+    def assert_valid_keys(hsh, *valid_keys)
+      if unknown_key = (hsh.keys - valid_keys).first
+        raise ArgumentError.new("Unknown key: #{unknown_key.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
       end
     end
     
-    def instantiate(ptr)
-      self.class.send(:instantiate, ptr)
-    end
-    
   end
 end

data/lib/rszr/version.rb

@@ -1,3 +1,3 @@
 module Rszr
-  VERSION = "0.4.0"
+  VERSION = "0.5.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rszr
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Matthias Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-05 00:00:00.000000000 Z
+date: 2019-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -108,23 +122,40 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Fast image resizer - do one thing and do it fast.
 email:
 - mtgrosser@gmx.net
 executables: []
-extensions: []
+extensions:
+- ext/rszr/extconf.rb
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
 - Rakefile
+- ext/rszr/errors.c
+- ext/rszr/errors.h
+- ext/rszr/extconf.rb
+- ext/rszr/image.c
+- ext/rszr/image.h
+- ext/rszr/rszr.c
+- ext/rszr/rszr.h
 - lib/rszr.rb
-- lib/rszr/base.rb
-- lib/rszr/errors.rb
-- lib/rszr/handle.rb
 - lib/rszr/image.rb
-- lib/rszr/lib.rb
-- lib/rszr/lock.rb
 - lib/rszr/version.rb
 homepage: https://github.com/mtgrosser/rszr
 licenses:
@@ -134,6 +165,7 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -145,8 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Fast image resizer

data/lib/rszr/base.rb

@@ -1,29 +0,0 @@
-module Rszr
-  module Base
-    
-    def self.included(base)
-      Rszr::Lib.delegate(base)
-      Rszr::Lib.delegate(base.singleton_class)
-      base.include(Lock)
-      base.extend(Lock)
-    end
-    
-    protected
-    
-    def handle
-      @handle
-    end
-    
-    def ptr
-      @handle.ptr
-    end
-    
-    private
-    
-    def assert_valid_keys(hsh, *valid_keys)
-      if unknown_key = (hsh.keys - valid_keys).first
-        raise ArgumentError.new("Unknown key: #{unknown_key.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
-      end
-    end
-  end
-end

data/lib/rszr/errors.rb

@@ -1,42 +0,0 @@
-module Rszr
-  class Error < StandardError; end
-
-  class ErrorWithMessage < Error
-    MESSAGES = [nil,
-                'File does not exist',
-                'File is a directory',
-                'Read permission denied',
-                'Unsupported format',
-                'Path too long',
-                'Non-existant path component',
-                'Path component is not a directory',
-                'Path outside address space',
-                'Too many symbolic links',
-                'Out of memory',
-                'Out of file descriptors',
-                'Write permission denied',
-                'Out of disk space',
-                'Unknown error']
-    
-    attr_reader :ptr
-    
-    def initialize
-      @ptr = Fiddle::Pointer.malloc(Rszr::Lib.sizeof('Imlib_Load_Error'))
-    end
-    
-    def error?
-      return if ptr.null?
-      0 != ptr[0]
-    end
-    
-    def message
-      MESSAGES[ptr[0]] unless ptr.null?
-    end
-  end
-
-  
-  class FileNotFound < Error; end
-  class LoadError < ErrorWithMessage; end
-  class TransformationError < Error; end
-  class SaveError < ErrorWithMessage; end
-end

data/lib/rszr/handle.rb

@@ -1,37 +0,0 @@
-module Rszr
-  class Handle
-    attr_reader :ptr, :klass
-    
-    def initialize(obj, ptr)
-      @ptr = ptr
-      raise ArgumentError, "#{obj.class.inspect} does not define the finalize class method" unless obj.class.respond_to?(:finalize, true)
-      @klass = obj.class
-      ObjectSpace.define_finalizer(obj, self)
-    end
-    
-    def replace!(other_ptr)
-      raise ArgumentError, "Cannot replace pointer with itself" if ptr == other_ptr
-      finalize!
-      @ptr = other_ptr
-    end
-    
-    def finalize!(*args)
-      #puts "Finalizing #{args.inspect} #{ptr.inspect}"
-      if !ptr.null? && klass
-        #puts "  calling #{args.inspect}"
-        klass.send(:finalize, ptr)
-        @ptr = Fiddle::Pointer.new(0)
-      #else
-        #puts "  skipping #{args.inspect}"
-      end
-    end
-    
-    def release!
-      replace! Fiddle::Pointer.new(0)
-    end
-    
-    def call(object_id)
-      finalize!(object_id)
-    end
-  end
-end

data/lib/rszr/lib.rb

@@ -1,73 +0,0 @@
-module Rszr
-  
-  module Lib
-    extend Fiddle::Importer
-    
-    library, message = case RbConfig::CONFIG['arch']
-      when /darwin/ then ['libImlib2.dylib', 'brew install imlib2']
-      when /mswin/, /cygwin/ then ['imlib2.dll', nil]
-    else
-      ['libImlib2.so', "yum install imlib2 imlib2-devel\napt-get install libimlib2 libimlib2-dev"]
-    end
-
-    begin
-      dlload library
-    rescue Fiddle::DLError => e
-      print "\n    The Imlib2 library could not be loaded. "
-      puts "You can install it using\n\n    #{message}\n" if message
-      puts ''
-      raise e
-    end
-    
-    typealias 'Imlib_Image',      'void *'
-    typealias 'Imlib_Context',    'void *'
-    typealias 'enum',             'int'
-    typealias 'Imlib_Load_Error', 'enum'
-
-    #typedef void       *Imlib_Color_Modifier;
-    #typedef void       *Imlib_Updates;
-    #typedef void       *Imlib_Font;
-    #typedef void       *Imlib_Color_Range;
-    #typedef void       *Imlib_Filter;
-    #typedef struct _imlib_border Imlib_Border;
-    #typedef struct _imlib_color Imlib_Color;
-    #typedef void       *ImlibPolygon;
-    
-    extern 'int         imlib_get_cache_size()'
-    extern 'void        imlib_set_cache_size(int)'
-    
-    extern 'Imlib_Image imlib_load_image(const char *)'
-    extern 'Imlib_Image imlib_load_image_without_cache(const char *)'
-    extern 'Imlib_Image imlib_load_image_with_error_return(const char *, Imlib_Load_Error *)'
-    extern 'Imlib_Image imlib_create_image(int, int)'
-    extern 'void        imlib_context_set_image(Imlib_Image)'
-    extern 'int         imlib_image_get_width()'
-    extern 'int         imlib_image_get_height()'
-    extern 'void        imlib_context_set_anti_alias(char)'
-
-    # source_x, source_y, source_width, source_height, destination_width, destination_height
-    extern 'Imlib_Image imlib_create_cropped_scaled_image(int, int, int, int, int, int)'
-    # x, y, width, height
-    extern 'Imlib_Image imlib_create_cropped_image(int, int, int, int)'
-    
-    extern 'char *      imlib_image_format()'
-    extern 'void        imlib_image_set_format(const char *)'
-    extern 'void        imlib_save_image(const char *)'
-    extern 'void        imlib_save_image_with_error_return(const char *, Imlib_Load_Error *)'
-    
-    extern 'void        imlib_free_image()'
-    extern 'void        imlib_free_image_and_decache()'
-    
-    def self.delegate(base)
-      Lib.methods.grep(/\Aimlib_/).each do |method|
-        line_no = __LINE__; str = %Q{
-          def #{method}(*args, &block)
-            Lib.#{method}(*args, &block)
-          end
-        }
-        base.class_eval(str, __FILE__, line_no)
-      end
-    end
-    
-  end
-end

data/lib/rszr/lock.rb

@@ -1,23 +0,0 @@
-module Rszr
-  @mutex = Mutex.new
-  
-  class << self
-    
-    def with_lock(&block) # :nodoc:
-      mutex.synchronize(&block)
-    end
-    
-    private
-    
-    def mutex
-      @mutex
-    end
-  end
-  
-  module Lock # :nodoc:
-    def with_lock(&block)
-      Rszr.with_lock(&block)
-    end
-  end
-  
-end