vips 8.8.0.3 → 8.10.5

data/lib/vips/align.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # Various types of alignment. See {Image#join}, for example.
   #
   # * `:low` Align on the low coordinate edge

data/lib/vips/angle.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # Various fixed 90 degree rotation angles. See {Image#rot}.
   #
   # * `:d0` no rotate

data/lib/vips/angle45.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # Various fixed 45 degree rotation angles. See {Image#rot45}.
   #
   # * `:d0` no rotate

data/lib/vips/bandformat.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # The format used for each band element. Each corresponds to a native C type
   # for the current machine.
   #
@@ -16,5 +15,4 @@ module Vips
   # * `:dpcomplex` double complex (two double) format
   class BandFormat < Symbol
   end
-
 end

data/lib/vips/blend_mode.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # Blend mode to use when compositing images. See {Image#composite}.
   #
   # `:clear` - where the second object is drawn, the first is removed
@@ -31,4 +30,3 @@ module Vips
   class BlendMode < Symbol
   end
 end
-

data/lib/vips/coding.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # How pixels are coded.
   #
   # Normally, pixels are uncoded and can be manipulated as you would expect.

data/lib/vips/compass_direction.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # A direction on a compass used for placing images. See {Image#gravity}.
   #
   # * `:centre`

data/lib/vips/connection.rb

@@ -0,0 +1,46 @@
+# This module provides an interface to the top level bits of libvips
+# via ruby-ffi.
+#
+# Author::    John Cupitt  (mailto:jcupitt@gmail.com)
+# License::   MIT
+
+require 'ffi'
+
+module Vips
+  if Vips::at_least_libvips?(8, 9)
+    attach_function :vips_connection_filename, [:pointer], :string
+    attach_function :vips_connection_nick, [:pointer], :string
+  end
+
+  # Abstract base class for connections.
+  class Connection < Vips::Object
+    # The layout of the VipsRegion struct.
+    module ConnectionLayout
+      def self.included(base)
+        base.class_eval do
+          layout :parent, Vips::Object::Struct
+          # rest opaque
+        end
+      end
+    end
+
+    class Struct < Vips::Object::Struct
+      include ConnectionLayout
+    end
+
+    class ManagedStruct < Vips::Object::ManagedStruct
+      include ConnectionLayout
+    end
+
+    # Get any filename associated with a connection, or nil.
+    def filename
+      Vips::vips_connection_filename self
+    end
+
+    # Get a nickname (short description) of a connection that could be shown to
+    # the user.
+    def nick
+      Vips::vips_connection_nick self
+    end
+  end
+end

data/lib/vips/direction.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # Operations like {Image#flip} need to be told whether to flip
   # left-right or top-bottom.
   #

data/lib/vips/extend.rb

@@ -1,5 +1,4 @@
 module Vips
-
   # When the edges of an image are extended, you can specify
   # how you want the extension done.
   # See {Image#embed}, {Image#conv}, {Image#affine} and

data/lib/vips/gobject.rb

@@ -8,7 +8,6 @@ require 'ffi'
 require 'forwardable'
 
 module GObject
-
   # we have a number of things we need to inherit in different ways:
   #
   # - we want to be able to subclass GObject in Ruby in a simple way
@@ -64,7 +63,6 @@ module GObject
     # the plain struct ... cast with this
     class Struct < FFI::Struct
       include GObjectLayout
-
     end
 
     # don't allow ptr == nil, we never want to allocate a GObject struct
@@ -75,6 +73,9 @@ module GObject
     def initialize ptr
       # GLib::logger.debug("GObject::GObject.initialize") {"ptr = #{ptr}"}
       @struct = ffi_managed_struct.new ptr
+
+      # sometimes we need to keep refs across C calls ... hide them here
+      @references = []
     end
 
     # access to the casting struct for this class
@@ -98,7 +99,6 @@ module GObject
         self.const_get :ManagedStruct
       end
     end
-
   end
 
   class GParamSpec < FFI::Struct
@@ -114,9 +114,13 @@ module GObject
     layout :value, GParamSpec.ptr
   end
 
-  attach_function :g_param_spec_get_blurb, [GParamSpec.ptr], :string
+  attach_function :g_param_spec_get_blurb, [:pointer], :string
 
   attach_function :g_object_ref, [:pointer], :void
   attach_function :g_object_unref, [:pointer], :void
 
+  # we just use one gcallback type for every signal, hopefully this is OK
+  callback :gcallback, [:pointer], :void
+  attach_function :g_signal_connect_data,
+    [:pointer, :string, :gcallback, :pointer, :pointer, :int], :long
 end

data/lib/vips/gvalue.rb

@@ -6,7 +6,6 @@
 require 'ffi'
 
 module GObject
-
   # Represent a GValue. Example use:
   #
   # ```ruby
@@ -14,6 +13,8 @@ module GObject
   # gvalue.init GObject::GDOUBLE_TYPE
   # gvalue.set 3.1415
   # value = gvalue.get
+  # # optional -- drop any ref the gvalue had
+  # gvalue.unset
   # ```
   #
   # Lifetime is managed automatically. It doesn't know about all GType values,
@@ -28,7 +29,9 @@ module GObject
       value = value.to_s if value.is_a? Symbol
 
       if value.is_a? String
-        value = Vips::vips_enum_from_nick "ruby-vips", gtype, value
+        # libvips expects "-" as a separator in enum names, but "_" is more
+        # convenient for ruby, eg. :b_w
+        value = Vips::vips_enum_from_nick "ruby-vips", gtype, value.tr("_", "-")
         if value == -1
           raise Vips::Error
         end
@@ -134,7 +137,7 @@ module GObject
         ptr.write_array_of_pointer value
 
         # the gvalue needs a ref on each of the images
-        value.each {|image| ::GObject::g_object_ref image}
+        value.each { |image| ::GObject::g_object_ref image }
 
       when Vips::BLOB_TYPE
         len = value.bytesize
@@ -156,8 +159,7 @@ module GObject
 
         else
           raise Vips::Error, "unimplemented gtype for set: " +
-              "#{::GObject::g_type_name gtype} (#{gtype})"
-
+                             "#{::GObject::g_type_name gtype} (#{gtype})"
         end
       end
     end
@@ -233,8 +235,7 @@ module GObject
 
         else
           raise Vips::Error, "unimplemented gtype for get: " +
-              "#{::GObject::g_type_name gtype} (#{gtype})"
-
+                             "#{::GObject::g_type_name gtype} (#{gtype})"
         end
       end
 
@@ -243,9 +244,15 @@ module GObject
       # }
 
       return result
-
     end
 
+    # Clear the thing held by a GValue. 
+    #
+    # This happens automatically when a GValue is GCed, but this method can be 
+    # handy if you need to drop a reference explicitly for some reason.
+    def unset 
+      ::GObject::g_value_unset self
+    end
   end
 
   attach_function :g_value_init, [GValue.ptr, :GType], :void
@@ -277,5 +284,4 @@ module GObject
       [:pointer, :string, GValue.ptr], :void
   attach_function :g_object_get_property,
       [:pointer, :string, GValue.ptr], :void
-
 end

data/lib/vips/image.rb

@@ -14,6 +14,9 @@ module Vips
 
   attach_function :vips_image_copy_memory, [:pointer], :pointer
 
+  attach_function :vips_image_set_progress, [:pointer, :bool], :void
+  attach_function :vips_image_set_kill, [:pointer, :bool], :void
+
   attach_function :vips_filename_get_filename, [:string], :pointer
   attach_function :vips_filename_get_options, [:string], :pointer
 
@@ -22,6 +25,11 @@ module Vips
   attach_function :vips_foreign_find_load_buffer, [:pointer, :size_t], :string
   attach_function :vips_foreign_find_save_buffer, [:string], :string
 
+  if Vips::at_least_libvips?(8, 9)
+    attach_function :vips_foreign_find_load_source, [:pointer], :string
+    attach_function :vips_foreign_find_save_target, [:string], :string
+  end
+
   attach_function :vips_image_write_to_memory,
       [:pointer, SizeStruct.ptr], :pointer
 
@@ -29,20 +37,14 @@ module Vips
   attach_function :vips_image_get,
       [:pointer, :string, GObject::GValue.ptr], :int
 
-  # vips_image_get_fields was added in libvips 8.5
-  begin
+  if Vips::at_least_libvips?(8, 5)
     attach_function :vips_image_get_fields, [:pointer], :pointer
-  rescue FFI::NotFoundError
-    nil
+    attach_function :vips_image_hasalpha, [:pointer], :int
   end
 
-  # vips_addalpha was added in libvips 8.6
   if Vips::at_least_libvips?(8, 6)
     attach_function :vips_addalpha, [:pointer, :pointer, :varargs], :int
   end
-  if Vips::at_least_libvips?(8, 5)
-    attach_function :vips_image_hasalpha, [:pointer], :int
-  end
 
   attach_function :vips_image_set,
       [:pointer, :string, GObject::GValue.ptr], :void
@@ -53,6 +55,8 @@ module Vips
 
   attach_function :nickname_find, :vips_nickname_find, [:GType], :string
 
+  attach_function :vips_image_invalidate_all, [:pointer], :void
+
   # turn a raw pointer that must be freed into a self-freeing Ruby string
   def self.p2str(pointer)
     pointer = FFI::AutoPointer.new(pointer, GLib::G_FREE)
@@ -67,6 +71,10 @@ module Vips
   class Image < Vips::Object
     alias_method :parent_get_typeof, :get_typeof
 
+    def close
+      Vips.vips_image_invalidate_all(self)
+    end
+
     private
 
     # the layout of the VipsImage struct
@@ -81,12 +89,10 @@ module Vips
 
     class Struct < Vips::Object::Struct
       include ImageLayout
-
     end
 
     class ManagedStruct < Vips::Object::ManagedStruct
       include ImageLayout
-
     end
 
     class GenericPtr < FFI::Struct
@@ -96,7 +102,7 @@ module Vips
     # handy for overloads ... want to be able to apply a function to an
     # array or to a scalar
     def self.smap x, &block
-      x.is_a?(Array) ? x.map {|y| smap(y, &block)} : block.(x)
+      x.is_a?(Array) ? x.map { |y| smap(y, &block) } : block.(x)
     end
 
     def self.complex? format
@@ -117,7 +123,7 @@ module Vips
 
       unless Image::complex? image.format
         if image.bands % 2 != 0
-          raise Error, "not an even number of bands"
+          raise Vips::Error, "not an even number of bands"
         end
 
         unless Image::float? image.format
@@ -147,46 +153,18 @@ module Vips
       end
     end
 
-    # Write can fail due to no file descriptors and memory can fill if
-    # large objects are not collected fairly soon. We can't try a
-    # write and GC and retry on fail, since the write may take a
-    # long time and may not be repeatable.
-    #
-    # GCing before every write would have a horrible effect on
-    # performance, so as a compromise we GC every @@gc_interval writes.
-    #
-    # ruby2.1 introduced a generational GC which is fast enough to be
-    # able to GC on every write.
-
-    @@generational_gc = RUBY_ENGINE == "ruby" && RUBY_VERSION.to_f >= 2.1
-
-    @@gc_interval = 100
-    @@gc_countdown = @@gc_interval
-
-    def write_gc
-      if @@generational_gc
-        GC.start full_mark: false
-      else
-        @@gc_countdown -= 1
-        if @@gc_countdown < 0
-          @@gc_countdown = @@gc_interval
-          GC.start
-        end
-      end
-    end
-
     public
 
     def inspect
-      "#<Image #{width}x#{height} #{format}, #{bands} bands, " +
-          "#{interpretation}>"
+      "#<Image #{width}x#{height} #{format}, #{bands} bands, #{interpretation}>"
     end
 
     def respond_to? name, include_all = false
       # To support keyword args, we need to tell Ruby that final image
       # arguments cannot be hashes of keywords.
       #
-      # https://makandracards.com/makandra/36013-heads-up-ruby-implicitly-converts-a-hash-to-keyword-arguments
+      # https://makandracards.com/makandra/
+      #   36013-heads-up-ruby-implicitly-converts-a-hash-to-keyword-arguments
       return false if name == :to_hash
 
       # respond to all vips operations by nickname
@@ -221,13 +199,13 @@ module Vips
     # load options, for example:
     #
     # ```
-    # image = Vips::new_from_file "fred.jpg[shrink=2]"
+    # image = Vips::Image.new_from_file "fred.jpg[shrink=2]"
     # ```
     #
     # You can also supply options as a hash, for example:
     #
     # ```
-    # image = Vips::new_from_file "fred.jpg", shrink: 2
+    # image = Vips::Image.new_from_file "fred.jpg", shrink: 2
     # ```
     #
     # The full set of options available depend upon the load operation that
@@ -298,11 +276,50 @@ module Vips
     # @return [Image] the loaded image
     def self.new_from_buffer data, option_string, **opts
       loader = Vips::vips_foreign_find_load_buffer data, data.bytesize
-      raise Vips::Error if loader == nil
+      raise Vips::Error if loader.nil?
 
       Vips::Operation.call loader, [data], opts, option_string
     end
 
+    # Create a new {Image} from a source. Load options may be passed as
+    # strings or appended as a hash. For example:
+    #
+    # ```
+    # source = Vips::Source.new_from_file("k2.jpg")
+    # image = Vips::Image.new_from_source source, "shrink=2"
+    # ```
+    #
+    # or alternatively:
+    #
+    # ```
+    # image = Vips::Image.new_from_source source, "", shrink: 2
+    # ```
+    #
+    # The options available depend on the file format. Try something like:
+    #
+    # ```
+    # $ vips jpegload_source
+    # ```
+    #
+    # at the command-line to see the available options. Not all loaders
+    # support load from source, but at least JPEG, PNG and
+    # TIFF images will work.
+    #
+    # Loading is fast: only enough data is read to be able to fill
+    # out the header. Pixels will only be read and decompressed when they are 
+    # needed.
+    #
+    # @param source [Vips::Source] the source to load from
+    # @param option_string [String] load options as a string
+    # @macro vips.loadopts
+    # @return [Image] the loaded image
+    def self.new_from_source source, option_string, **opts
+      loader = Vips::vips_foreign_find_load_source source
+      raise Vips::Error if loader.nil?
+
+      Vips::Operation.call loader, [source], opts, option_string
+    end
+
     def self.matrix_from_array width, height, array
       ptr = FFI::MemoryPointer.new :double, array.length
       ptr.write_array_of_double array
@@ -319,13 +336,13 @@ module Vips
     # For example:
     #
     # ```
-    # image = Vips::new_from_array [1, 2, 3]
+    # image = Vips::Image.new_from_array [1, 2, 3]
     # ```
     #
     # or
     #
     # ```
-    # image = Vips::new_from_array [
+    # image = Vips::Image.new_from_array [
     #     [-1, -1, -1],
     #     [-1, 16, -1],
     #     [-1, -1, -1]], 8
@@ -347,19 +364,20 @@ module Vips
       if array[0].is_a? Array
         height = array.length
         width = array[0].length
-        unless array.all? {|x| x.is_a? Array}
+        unless array.all? { |x| x.is_a? Array }
           raise Vips::Error, "Not a 2D array."
         end
-        unless array.all? {|x| x.length == width}
+        unless array.all? { |x| x.length == width }
           raise Vips::Error, "Array not rectangular."
         end
+
         array = array.flatten
       else
         height = 1
         width = array.length
       end
 
-      unless array.all? {|x| x.is_a? Numeric}
+      unless array.all? { |x| x.is_a? Numeric }
         raise Vips::Error, "Not all array elements are Numeric."
       end
 
@@ -385,8 +403,8 @@ module Vips
     def new_from_image value
       pixel = (Vips::Image.black(1, 1) + value).cast(format)
       image = pixel.embed 0, 0, width, height, extend: :copy
-      image.copy interpretation: interpretation,
-          xres: xres, yres: yres, xoffset: xoffset, yoffset: yoffset
+      image.copy interpretation: interpretation, xres: xres, yres: yres,
+        xoffset: xoffset, yoffset: yoffset
     end
 
     # Write this image to a file. Save options may be encoded in the
@@ -427,8 +445,6 @@ module Vips
       end
 
       Vips::Operation.call saver, [self, filename], opts, option_string
-
-      write_gc
     end
 
     # Write this image to a memory buffer. Save options may be encoded in
@@ -457,29 +473,63 @@ module Vips
     # @macro vips.saveopts
     # @return [String] the image saved in the specified format
     def write_to_buffer format_string, **opts
-      filename =
-          Vips::p2str(Vips::vips_filename_get_filename format_string)
-      option_string =
-          Vips::p2str(Vips::vips_filename_get_options format_string)
+      filename = Vips::p2str(Vips::vips_filename_get_filename format_string)
+      option_string = Vips::p2str(Vips::vips_filename_get_options format_string)
       saver = Vips::vips_foreign_find_save_buffer filename
       if saver == nil
-        raise Vips::Error, "No known saver for '#{filename}'."
+        raise Vips::Error, "No known buffer saver for '#{filename}'."
       end
 
       buffer = Vips::Operation.call saver, [self], opts, option_string
       raise Vips::Error if buffer == nil
 
-      write_gc
-
       return buffer
     end
 
+    # Write this image to a target. Save options may be encoded in
+    # the format_string or given as a hash. For example:
+    #
+    # ```ruby
+    # target = Vips::Target.new_to_file "k2.jpg"
+    # image.write_to_target target, ".jpg[Q=90]"
+    # ```
+    #
+    # or equivalently:
+    #
+    # ```ruby
+    # image.write_to_target target, ".jpg", Q: 90
+    # ```
+    #
+    # The full set of save options depend on the selected saver. Try
+    # something like:
+    #
+    # ```
+    # $ vips jpegsave_target
+    # ```
+    #
+    # to see all the available options for JPEG save.
+    #
+    # @param target [Vips::Target] the target to write to
+    # @param format_string [String] save format plus string options
+    # @macro vips.saveopts
+    def write_to_target target, format_string, **opts
+      filename = Vips::p2str(Vips::vips_filename_get_filename format_string)
+      option_string = Vips::p2str(Vips::vips_filename_get_options format_string)
+      saver = Vips::vips_foreign_find_save_target filename
+      if saver == nil
+        raise Vips::Error, "No known target saver for '#{filename}'."
+      end
+
+      Vips::Operation.call saver, [self, target], opts, option_string
+    end
+
     # Write this image to a large memory buffer.
     #
     # @return [String] the pixels as a huge binary string
     def write_to_memory
       len = Vips::SizeStruct.new
       ptr = Vips::vips_image_write_to_memory self, len
+      raise Vips::Error if ptr == nil
 
       # wrap up as an autopointer
       ptr = FFI::AutoPointer.new(ptr, GLib::G_FREE)
@@ -487,6 +537,28 @@ module Vips
       ptr.get_bytes 0, len[:value]
     end
 
+    # Turn progress signalling on and off. 
+    #
+    # If this is on, the most-downstream image from this image will issue
+    # progress signals. 
+    #
+    # @see Object#signal_connect
+    # @param state [Boolean] progress signalling state
+    def set_progress state
+      Vips::vips_image_set_progress self, state
+    end
+
+    # Kill computation of this time.
+    #
+    # Set true to stop computation of this image. You can call this from a
+    # progress handler, for example.
+    #
+    # @see Object#signal_connect
+    # @param kill [Boolean] stop computation
+    def set_kill kill
+      Vips::vips_image_set_kill self, kill
+    end
+
     # Get the `GType` of a metadata field. The result is 0 if no such field
     # exists.
     #
@@ -525,10 +597,11 @@ module Vips
       end
 
       gvalue = GObject::GValue.alloc
-      result = Vips::vips_image_get self, name, gvalue
-      raise Vips::Error if result != 0
+      raise Vips::Error if Vips::vips_image_get(self, name, gvalue) != 0
+      result = gvalue.get
+      gvalue.unset
 
-      gvalue.get
+      result
     end
 
     # Get the names of all fields on an image. Use this to loop over all
@@ -573,6 +646,7 @@ module Vips
       gvalue.init gtype
       gvalue.set value
       Vips::vips_image_set self, name, gvalue
+      gvalue.unset
     end
 
     # Set the value of a metadata item on an image. The metadata item must
@@ -772,7 +846,7 @@ module Vips
     # @return [Image] result of subtraction
     def - other
       other.is_a?(Vips::Image) ?
-          subtract(other) : linear(1, Image::smap(other) {|x| x * -1})
+          subtract(other) : linear(1, Image::smap(other) { |x| x * -1 })
     end
 
     # Multiply an image, constant or array.
@@ -790,7 +864,7 @@ module Vips
     # @return [Image] result of division
     def / other
       other.is_a?(Vips::Image) ?
-          divide(other) : linear(Image::smap(other) {|x| 1.0 / x}, 0)
+          divide(other) : linear(Image::smap(other) { |x| 1.0 / x }, 0)
     end
 
     # Remainder after integer division with an image, constant or array.
@@ -961,16 +1035,16 @@ module Vips
 
       # make the template for unpack
       template = {
-          :char => 'c',
-          :uchar => 'C',
-          :short => 's_',
-          :ushort => 'S_',
-          :int => 'i_',
-          :uint => 'I_',
-          :float => 'f',
-          :double => 'd',
-          :complex => 'f',
-          :dpcomplex => 'd'
+        char: 'c',
+        uchar: 'C',
+        short: 's_',
+        ushort: 'S_',
+        int: 'i_',
+        uint: 'I_',
+        float: 'f',
+        double: 'd',
+        complex: 'f',
+        dpcomplex: 'd'
       }[format] + '*'
 
       # and unpack into something like [1, 2, 3, 4 ..]
@@ -1031,7 +1105,7 @@ module Vips
     #
     # @return [Array<Image>] Array of n one-band images
     def bandsplit
-      (0...bands).map {|i| extract_band i}
+      (0...bands).map { |i| extract_band i }
     end
 
     # Join a set of images bandwise.
@@ -1044,7 +1118,7 @@ module Vips
       end
 
       # if other is just Numeric, we can use bandjoin_const
-      not_all_real = !other.all?{|x| x.is_a? Numeric}
+      not_all_real = !other.all? { |x| x.is_a? Numeric }
 
       if not_all_real
         Vips::Image.bandjoin([self] + other)
@@ -1061,7 +1135,7 @@ module Vips
     # @option opts [Vips::Interpretation] :compositing_space Composite images in this colour space
     # @option opts [Boolean] :premultiplied Images have premultiplied alpha
     # @return [Image] blended image
-    def composite overlay, mode, **opts
+    def composite overlay, mode, **options
       unless overlay.is_a? Array
         overlay = [overlay]
       end
@@ -1073,7 +1147,7 @@ module Vips
         GObject::GValue.from_nick Vips::BLEND_MODE_TYPE, x
       end
 
-      Vips::Image.composite([self] + overlay, mode, opts)
+      Vips::Image.composite([self] + overlay, mode, **options)
     end
 
     # Return the coordinates of the image maximum.
@@ -1130,7 +1204,7 @@ module Vips
     # @see xyz
     # @return [Image] image converted to polar coordinates
     def polar
-      Image::run_cmplx(self) {|x| x.complex :polar}
+      Image::run_cmplx(self) { |x| x.complex :polar }
     end
 
     # Return an image with polar pixels converted to rectangular.
@@ -1143,7 +1217,7 @@ module Vips
     # @see xyz
     # @return [Image] image converted to rectangular coordinates
     def rect
-      Image::run_cmplx(self) {|x| x.complex :rect}
+      Image::run_cmplx(self) { |x| x.complex :rect }
     end
 
     # Return the complex conjugate of an image.
@@ -1155,7 +1229,7 @@ module Vips
     #
     # @return [Image] complex conjugate
     def conj
-      Image::run_cmplx(self) {|x| x.complex :conj}
+      Image::run_cmplx(self) { |x| x.complex :conj }
     end
 
     # Calculate the cross phase of two images.
@@ -1305,7 +1379,7 @@ module Vips
     # @option opts [Boolean] :blend (false) Blend smoothly between th and el
     # @return [Image] merged image
     def ifthenelse(th, el, **opts)
-      match_image = [th, el, self].find {|x| x.is_a? Vips::Image}
+      match_image = [th, el, self].find { |x| x.is_a? Vips::Image }
 
       unless th.is_a? Vips::Image
         th = Operation.imageize match_image, th
@@ -1322,148 +1396,127 @@ module Vips
     #
     # @param opts [Hash] Set of options
     # @return [Vips::Image] Output image
-    def scaleimage **opts
-      Vips::Image.scale self, opts
+    def scaleimage **options
+      Vips::Image.scale self, **options
     end
-
   end
 end
 
 module Vips
-
-  # This method generates yard comments for all the dynamically bound
+  # This module generates yard comments for all the dynamically bound
   # vips operations.
   #
   # Regenerate with something like:
   #
   # ```
   # $ ruby > methods.rb
-  # require 'vips'; Vips::generate_yard
+  # require 'vips'; Vips::Yard.generate
   # ^D
   # ```
 
-  def self.generate_yard
-    # these have hand-written methods, see above
-    no_generate = ["scale", "bandjoin", "composite", "ifthenelse"]
-
+  module Yard
     # map gobject's type names to Ruby
-    map_go_to_ruby = {
-        "gboolean" => "Boolean",
-        "gint" => "Integer",
-        "gdouble" => "Float",
-        "gfloat" => "Float",
-        "gchararray" => "String",
-        "VipsImage" => "Vips::Image",
-        "VipsInterpolate" => "Vips::Interpolate",
-        "VipsArrayDouble" => "Array<Double>",
-        "VipsArrayInt" => "Array<Integer>",
-        "VipsArrayImage" => "Array<Image>",
-        "VipsArrayString" => "Array<String>",
+    MAP_GO_TO_RUBY = {
+      "gboolean" => "Boolean",
+      "gint" => "Integer",
+      "gdouble" => "Float",
+      "gfloat" => "Float",
+      "gchararray" => "String",
+      "VipsImage" => "Vips::Image",
+      "VipsInterpolate" => "Vips::Interpolate",
+      "VipsConnection" => "Vips::Connection",
+      "VipsSource" => "Vips::Source",
+      "VipsTarget" => "Vips::Target",
+      "VipsSourceCustom" => "Vips::SourceCustom",
+      "VipsTargetCustom" => "Vips::TargetCustom",
+      "VipsArrayDouble" => "Array<Double>",
+      "VipsArrayInt" => "Array<Integer>",
+      "VipsArrayImage" => "Array<Image>",
+      "VipsArrayString" => "Array<String>",
     }
 
-    generate_operation = lambda do |gtype, nickname, op|
-      op_flags = op.get_flags
-      return if (op_flags & OPERATION_DEPRECATED) != 0
-      return if no_generate.include? nickname
-      description = Vips::vips_object_get_description op
-
-      # find and classify all the arguments the operator can take
-      required_input = []
-      optional_input = []
-      required_output = []
-      optional_output = []
-      member_x = nil
-      op.argument_map do |pspec, argument_class, argument_instance|
-        arg_flags = argument_class[:flags]
-        next if (arg_flags & ARGUMENT_CONSTRUCT) == 0
-        next if (arg_flags & ARGUMENT_DEPRECATED) != 0
-
-        name = pspec[:name].tr("-", "_")
-        # 'in' as a param name confuses yard
-        name = "im" if name == "in"
-        gtype = pspec[:value_type]
-        fundamental = GObject::g_type_fundamental gtype
-        type_name = GObject::g_type_name gtype
-        if map_go_to_ruby.include? type_name
-          type_name = map_go_to_ruby[type_name]
-        end
-        if fundamental == GObject::GFLAGS_TYPE ||
-            fundamental == GObject::GENUM_TYPE
-          type_name = "Vips::" + type_name[/Vips(.*)/, 1]
-        end
-        blurb = GObject::g_param_spec_get_blurb pspec
-        value = {:name => name,
-                 :flags => arg_flags,
-                 :gtype => gtype,
-                 :type_name => type_name,
-                 :blurb => blurb}
-
-        if (arg_flags & ARGUMENT_INPUT) != 0
-          if (arg_flags & ARGUMENT_REQUIRED) != 0
-            # note the first required input image, if any ... we
-            # will be a method of this instance
-            if !member_x && gtype == Vips::IMAGE_TYPE
-              member_x = value
-            else
-              required_input << value
-            end
-          else
-            optional_input << value
-          end
-        end
+    # these have hand-written methods, see above
+    NO_GENERATE = ["scale", "bandjoin", "composite", "ifthenelse"]
 
-        # MODIFY INPUT args count as OUTPUT as well
-        if (arg_flags & ARGUMENT_OUTPUT) != 0 ||
-            ((arg_flags & ARGUMENT_INPUT) != 0 &&
-             (arg_flags & ARGUMENT_MODIFY) != 0)
-          if (arg_flags & ARGUMENT_REQUIRED) != 0
-            required_output << value
-          else
-            optional_output << value
-          end
-        end
+    # these are aliased (appear under several names)
+    ALIAS = ["crop"]
 
+    # turn a gtype into a ruby type name
+    def self.gtype_to_ruby gtype
+      fundamental = GObject::g_type_fundamental gtype
+      type_name = GObject::g_type_name gtype
+
+      if MAP_GO_TO_RUBY.include? type_name
+        type_name = MAP_GO_TO_RUBY[type_name]
+      end
+
+      if fundamental == GObject::GFLAGS_TYPE ||
+         fundamental == GObject::GENUM_TYPE
+        type_name = "Vips::" + type_name[/Vips(.*)/, 1]
       end
 
+      type_name
+    end
+
+    def self.generate_operation introspect
+      return if (introspect.flags & OPERATION_DEPRECATED) != 0
+      return if NO_GENERATE.include? introspect.name
+
+      method_args = introspect.method_args
+      required_output = introspect.required_output
+      optional_input = introspect.optional_input
+      optional_output = introspect.optional_output
+
       print "# @!method "
-      print "self." unless member_x
-      print "#{nickname}("
-      print required_input.map{|x| x[:name]}.join(", ")
-      print ", " if required_input.length > 0
+      print "self." unless introspect.member_x
+      print "#{introspect.name}("
+      print method_args.map{ |x| x[:yard_name] }.join(", ")
+      print ", " if method_args.length > 0
       puts "**opts)"
 
-      puts "#   #{description.capitalize}."
+      puts "#   #{introspect.description.capitalize}."
 
-      required_input.each do |arg|
-        puts "#   @param #{arg[:name]} [#{arg[:type_name]}] " +
-            "#{arg[:blurb]}"
+      method_args.each do |details|
+        yard_name = details[:yard_name]
+        gtype = details[:gtype]
+        blurb = details[:blurb]
+
+        puts "#   @param #{yard_name} [#{gtype_to_ruby(gtype)}] #{blurb}"
       end
 
       puts "#   @param opts [Hash] Set of options"
-      optional_input.each do |arg|
-        puts "#   @option opts [#{arg[:type_name]}] :#{arg[:name]} " +
-            "#{arg[:blurb]}"
+      optional_input.each do |arg_name, details|
+        yard_name = details[:yard_name]
+        gtype = details[:gtype]
+        blurb = details[:blurb]
+
+        puts "#   @option opts [#{gtype_to_ruby(gtype)}] :#{yard_name} " +
+             "#{blurb}"
       end
-      optional_output.each do |arg|
-        print "#   @option opts [#{arg[:type_name]}] :#{arg[:name]}"
-        puts " Output #{arg[:blurb]}"
+      optional_output.each do |arg_name, details|
+        yard_name = details[:yard_name]
+        gtype = details[:gtype]
+        blurb = details[:blurb]
+
+        print "#   @option opts [#{gtype_to_ruby(gtype)}] :#{yard_name}"
+        puts " Output #{blurb}"
       end
 
       print "#   @return ["
       if required_output.length == 0
         print "nil"
       elsif required_output.length == 1
-        print required_output.first[:type_name]
-      elsif
-          print "Array<"
-        print required_output.map{|x| x[:type_name]}.join(", ")
+        print gtype_to_ruby(required_output.first[:gtype])
+      else
+        print "Array<"
+        print required_output.map{ |x| gtype_to_ruby(x[:gtype]) }.join(", ")
         print ">"
       end
       if optional_output.length > 0
         print ", Hash<Symbol => Object>"
       end
       print "] "
-      print required_output.map{|x| x[:blurb]}.join(", ")
+      print required_output.map{ |x| x[:blurb] }.join(", ")
       if optional_output.length > 0
         print ", " if required_output.length > 0
         print "Hash of optional output items"
@@ -1473,30 +1526,42 @@ module Vips
       puts ""
     end
 
-    generate_class = lambda do |gtype, a|
-      nickname = Vips::nickname_find gtype
+    def self.generate
+      alias_gtypes = {}
+      ALIAS.each do |name| 
+        gtype = Vips::type_find "VipsOperation", name
+        alias_gtypes[gtype] = name 
+      end
 
-      if nickname
-        begin
-          # can fail for abstract types
-          op = Vips::Operation.new nickname
-        rescue
+      generate_class = lambda do |gtype, _|
+        if alias_gtypes.key? gtype
+          name = alias_gtypes[gtype]
+        else
+          name = Vips::nickname_find gtype
         end
 
-        generate_operation.(gtype, nickname, op) if op
-      end
+        if name
+          begin
+            # can fail for abstract types
+            introspect = Vips::Introspect.get_yard name
+          rescue Vips::Error
+            nil
+          end
 
-      Vips::vips_type_map gtype, generate_class, nil
-    end
+          generate_operation(introspect) if introspect
+        end
 
-    puts "module Vips"
-    puts "  class Image"
-    puts ""
+        Vips::vips_type_map gtype, generate_class, nil
+      end
 
-    generate_class.(GObject::g_type_from_name("VipsOperation"), nil)
+      puts "module Vips"
+      puts "  class Image"
+      puts ""
 
-    puts "  end"
-    puts "end"
-  end
+      generate_class.(GObject::g_type_from_name("VipsOperation"), nil)
 
+      puts "  end"
+      puts "end"
+    end
+  end
 end