ruby-vips 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bfef1f0c49c2977f9561ace1a05cdd74c3e43bc
-  data.tar.gz: 135f092e8c9294be05a841b17f1ddb32070192ba
+  metadata.gz: f9821647ddcaaa31442cb2f6ce3b488004bfecd1
+  data.tar.gz: 77f02bd4c937b0b08d78419878728a2d62e47293
 SHA512:
-  metadata.gz: c105a43796733f2512eaa627e5d63aa71e1edffd616fed682782a388283033f7ed90be3747a970b872686f8a84a9718aedcaad75c3b23612571f9c1abd14fa4c
-  data.tar.gz: 282d2ad30057efd9a78f4e183a1d3833c4abd56fba1f111819f536b029c961d6ae302c4a0fa6f0715521a3929b1be1a3fd32de5f445455e74815e1941914eea5
+  metadata.gz: a7e07153fe581bb27cb56533e3274abdb3dca1bcc95e33e964606c35ed8aa3ad1007131fee4d2d5543bc704dc52ec52ff90f160ee71da996d2f59fc74b90a3e0
+  data.tar.gz: 865c2cc4d66b7ea6359225f36f9ae6c17274e1c4e0c34f54efc0a6cdce457cbe72fdb7388692b6c5836ef4c24ee243d26b9d1b9383078d0d2d38b2e65a441384

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # master 
 
-# Version 1.0.1
+# Version 1.0.3
+
+* doc improvements [John Cupitt]
+* add #size to get [width, height] [John Cupitt]
+* only ask for ruby 2.0 to help OS X [John Cupitt] 
+* break up Image.call to make it easier to understand [John Cupitt] 
+* detect operation build fail correctly [John Cupitt]
+* lock gobject-introspection at 3.0.8 to avoid breakage [John Cupitt]
+
+# Version 1.0.2
 
 * add .yardopts to fix ruby-gems docs [John Cupitt]
 

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.3

data/lib/vips/call.rb

@@ -1,225 +1,281 @@
 module Vips
 
-    # call a vips operation ... this will crash if there's a GC during the call,
-    # I've really no idea why :-(
+    # Call a vips operation.
     #
-    # Workaround: don't call this directly, use call_base (see below) instead.
-    # This will disable the GC, call this operation, then reenable it. 
+    # This will crash if there's a GC during the call, only use 
+    # this via {Vips.call}. 
+    private 
+    class Call
+        attr_writer :instance, :option_string
+
+        def initialize(name, supplied_values)
+            @name = name
+            @supplied_values = supplied_values
+            @instance = nil
+            @option_string = nil
+
+            if @supplied_values.last.is_a? Hash
+                @optional_values = @supplied_values.last
+                @supplied_values.delete_at -1
+            else
+                @optional_values = {}
+            end
 
-    private
-    def self.call_base_nogc(name, instance, option_string, supplied_values)
-        log "in Vips::call_base"
-        log "name = #{name}"
-        log "instance = #{instance}"
-        log "option_string = #{option_string}"
-        log "supplied_values are:"
-        supplied_values.each {|x| log "   #{x}"}
-
-        if supplied_values.last.is_a? Hash
-            optional_values = supplied_values.last
-            supplied_values.delete_at -1
-        else
-            optional_values = {}
-        end
+            begin
+                @op = Vips::Operation.new @name
+            rescue
+                raise Vips::Error, "no operator '#{@name}'"
+            end
 
-        begin
-            op = Vips::Operation.new name
-        rescue
-            raise Vips::Error, "no operator '#{name}'"
+            log "Vips::Call.init"
+            log "name = #{@name}"
+            log "supplied_values are:"
+            @supplied_values.each {|x| log "   #{x}"}
+            log "optional_values are:"
+            @optional_values.each {|x| log "   #{x}"}
         end
 
-        # set string options first 
-        log "setting string options ..."
-        if option_string
-            if op.set_from_string(option_string) != 0
-                raise Error
+        # set any string options on the operation
+        def set_string_args
+            if @option_string
+                log "setting string options #{@option_string} ..."
+
+                if @op.set_from_string(@option_string) != 0
+                    raise Error
+                end
             end
         end
 
-        all_args = op.get_args
-
-        # the instance, if supplied, must be a vips image ... we use it for
-        # match_image, below
-        if instance and not instance.is_a? Vips::Image
-            raise Vips::Error, "@instance is not a Vips::Image."
-        end
+        # set @match_image to be the image we build constants to match
+        def find_match_image
+            # the instance, if supplied, must be a vips image ... we use it for
+            # match_image, below
+            if @instance and not @instance.is_a? Vips::Image
+                raise Vips::Error, "@instance is not a Vips::Image."
+            end
 
-        # if the op needs images but the user supplies constants, we expand
-        # them to match the first input image argument ... find the first
-        # image
-        log "searching for first image argument ..."
-        match_image = instance
-        if match_image == nil
-            match_image = supplied_values.find {|x| x.is_a? Vips::Image}
-        end
-        if match_image == nil
-            match = optional_values.find do |name, value|
-                value.is_a? Vips::Image
+            # if the op needs images but the user supplies constants, we expand
+            # them to match the first input image argument ... find the first
+            # image
+            log "searching for first image argument ..."
+            match_image = @instance
+            if match_image == nil
+                match_image = @supplied_values.find {|x| x.is_a? Vips::Image}
             end
-            # if we found a match, it'll be [name, value]
-            if match
-                match_image = match[1]
+            if match_image == nil
+                match = @optional_values.find do |name, value|
+                    value.is_a? Vips::Image
+                end
+                # if we found a match, it'll be [name, value]
+                if match
+                    match_image = match[1]
+                end
             end
-        end
 
-        # find unassigned required input args
-        log "finding unassigned required input arguments ..."
-        required_input = all_args.select do |arg|
-            not arg.isset and
-            (arg.flags & :input) != 0 and
-            (arg.flags & :required) != 0 
+            return match_image
         end
 
-        # do we have a non-nil instance? set the first image arg with this
-        if instance != nil
-            log "setting first image arg with instance ..."
-            x = required_input.find do |arg|
-                gtype = GLib::Type["VipsImage"]
-                vtype = arg.prop.value_type
+        # look through the operation args and find required and optional 
+        # input args
+        def find_input
+            all_args = @op.get_args
 
-                vtype.type_is_a? gtype
+            # find unassigned required input args
+            log "finding unassigned required input arguments ..."
+            required_input = all_args.select do |arg|
+                not arg.isset and
+                (arg.flags & :input) != 0 and
+                (arg.flags & :required) != 0 
             end
-            if x == nil
-                raise Vips::Error, 
-                    "No #{instance.class} argument to #{name}."
+
+            # find optional unassigned input args
+            log "finding optional unassigned input arguments ..."
+            optional_input = all_args.select do |arg|
+                not arg.isset and
+                (arg.flags & :input) != 0 and
+                (arg.flags & :required) == 0 
             end
-            x.set_value match_image, instance
-            required_input.delete x
-        end
 
-        if required_input.length != supplied_values.length
-            raise Vips::Error, 
-                "Wrong number of arguments. '#{name}' requires " +
-                "#{required_input.length} arguments, you supplied " +
-                "#{supplied_values.length}."
-        end
+            # make a hash from name to arg for the options
+            optional_input = Hash[
+                optional_input.map(&:name).zip(optional_input)]
 
-        log "setting required input arguments ..."
-        required_input.zip(supplied_values).each do |arg, value|
-            arg.set_value match_image, value
+            return required_input, optional_input
         end
 
-        # find optional unassigned input args
-        log "finding optional unassigned input arguments ..."
-        optional_input = all_args.select do |arg|
-            not arg.isset and
-            (arg.flags & :input) != 0 and
-            (arg.flags & :required) == 0 
-        end
+        def find_optional_output
+            all_args = @op.get_args
+
+            log "finding optional output arguments ..."
+            optional_output = all_args.select do |arg|
+                (arg.flags & :output) != 0 and
+                (arg.flags & :required) == 0 
+            end
+            optional_output = Hash[
+                optional_output.map(&:name).zip(optional_output)]
 
-        # make a hash from name to arg
-        optional_input = Hash[
-            optional_input.map(&:name).zip(optional_input)]
+            return optional_output
 
-        # find optional unassigned output args
-        log "finding optional unassigned output arguments ..."
-        optional_output = all_args.select do |arg|
-            not arg.isset and
-            (arg.flags & :output) != 0 and
-            (arg.flags & :required) == 0 
         end
-        optional_output = Hash[
-            optional_output.map(&:name).zip(optional_output)]
-
-        # set all optional args
-        log "setting optional values ..."
-        optional_values.each do |name, value|
-            # we are passed symbols as keys
-            name = name.to_s
-            if optional_input.has_key? name
-                log "setting #{name} to #{value}"
-                optional_input[name].set_value match_image, value
-            elsif optional_output.has_key? name and value != true
+
+        def set_required_input(match_image, required_input)
+            # do we have a non-nil instance? set the first image arg with this
+            if @instance != nil
+                log "setting first image arg with instance ..."
+                x = required_input.find do |arg|
+                    gtype = GLib::Type["VipsImage"]
+                    vtype = arg.prop.value_type
+
+                    vtype.type_is_a? gtype
+                end
+                if x == nil
+                    raise Vips::Error, 
+                        "No #{@instance.class} argument to #{@name}."
+                end
+                x.set_value match_image, @instance
+                required_input.delete x
+            end
+
+            if required_input.length != @supplied_values.length
                 raise Vips::Error, 
-                    "Optional output argument #{name} must be true."
-            elsif not optional_output.has_key? name 
-                raise Vips::Error, "No such option '#{name}',"
+                    "Wrong number of arguments. '#{@name}' requires " +
+                    "#{required_input.length} arguments, you supplied " +
+                    "#{@supplied_values.length}."
+            end
+
+            log "setting required input arguments ..."
+            required_input.zip(@supplied_values).each do |arg, value|
+                arg.set_value match_image, value
+            end
+
+        end       
+
+        def set_optional_input(match_image, optional_input, optional_output)
+            log "setting optional input args ..."
+            @optional_values.each do |name, value|
+                # we are passed symbols as keys
+                name = name.to_s
+                if optional_input.has_key? name
+                    log "setting #{name} to #{value}"
+                    optional_input[name].set_value match_image, value
+                elsif optional_output.has_key? name and value != true
+                    raise Vips::Error, 
+                        "Optional output argument #{name} must be true."
+                elsif not optional_output.has_key? name 
+                    raise Vips::Error, "No such option '#{name}',"
+                end
             end
         end
 
-        log "building ..."
+        def build
+            log "building ..."
 
-        op2 = Vips::cache_operation_lookup op
-        if op2
-            log "cache hit"
-            op = op2
+            op2 = Vips::cache_operation_lookup @op
+            if op2
+                log "cache hit"
 
-            all_args = op.get_args
+                hit = true
+                @op = op2
+            else
+                log "cache miss ... building"
 
-            # find optional output args
-            optional_output = all_args.select do |arg|
-                (arg.flags & :output) != 0 and
-                (arg.flags & :required) == 0 
-            end
-            optional_output = Hash[
-                optional_output.map(&:name).zip(optional_output)]
-        else
-            log "cache miss ... building"
-            if not op.build
-                raise Vips::Error
+                hit = false
+                if @op.build() != 0
+                    raise Vips::Error
+                end
+                # showall
+
+                log "adding to cache ... "
+                Vips::cache_operation_add @op
             end
-            showall
 
-            log "adding to cache ... "
-            Vips::cache_operation_add op
+            return hit
         end
 
-        log "fetching outputs ..."
-
-        # gather output args 
-        out = []
+        def fetch_output(optional_output)
+            log "fetching outputs ..."
+
+            # gather output args 
+            out = []
+
+            all_args = @op.get_args
+            all_args.each do |arg|
+                # required output
+                if (arg.flags & :output) != 0 and
+                    (arg.flags & :required) != 0 
+                    log "fetching required output #{arg.name}"
+                    out << arg.get_value
+                end
+
+                # modified input arg ... this will get the result of the 
+                # copy() we did in Argument.set_value 
+                if (arg.flags & :input) != 0 and
+                    (arg.flags & :modify) != 0 
+                    log "fetching modified input arg ..."
+                    out << arg.get_value
+                end
+            end
 
-        all_args.each do |arg|
-            # required output
-            if (arg.flags & :output) != 0 and
-                (arg.flags & :required) != 0 
-                log "fetching required output #{arg.name}"
-                out << arg.get_value
+            opts = {}
+            @optional_values.each do |name, value|
+                # we are passed symbols as keys
+                name = name.to_s
+                if optional_output.has_key? name
+                    log "fetching optional output arg ..."
+                    opts[name] = optional_output[name].get_value
+                end
             end
+            out << opts if opts != {}
 
-            # modified input arg ... this will get the result of the 
-            # copy() we did in Argument.set_value above
-            if (arg.flags & :input) != 0 and
-                (arg.flags & :modify) != 0 
-                log "fetching modified input arg ..."
-                out << arg.get_value
+            if out.length == 1
+                out = out[0]
+            elsif out.length == 0
+                out = nil
             end
+
+            return out
+
         end
 
-        opts = {}
-        optional_values.each do |name, value|
-            # we are passed symbols as keys
-            name = name.to_s
-            if optional_output.has_key? name
-                log "fetching optional output arg ..."
-                opts[name] = optional_output[name].get_value
+        def invoke
+            set_string_args()
+            match_image = find_match_image()
+            required_input, optional_input = find_input()
+            optional_output = find_optional_output()
+
+            set_required_input(match_image, required_input)
+            set_optional_input(match_image, optional_input, optional_output)
+
+            hit = build()
+
+            # if there was a cache hit, we need to refind this since all the arg
+            # pointers will have changed
+            if hit
+                optional_output = find_optional_output()
             end
-        end
-        out << opts if opts != {}
+            out = fetch_output(optional_output)
 
-        if out.length == 1
-            out = out[0]
-        elsif out.length == 0
-            out = nil
-        end
+            log "unreffing outputs ..."
+            @op.unref_outputs()
+            @op = nil
+            # showall
 
-        log "unreffing outputs ..."
-        op.unref_outputs
-        op = nil
-        # showall
+            log "success! #{@name}.out = #{out}"
 
-        log "success! #{name}.out = #{out}"
+            return out
+        end
 
-        return out
     end
 
-    # run call_base_nogc, with the GC disabled
+    # full-fat call, with the GC disabled
     private
     def self.call_base(name, instance, option_string, supplied_values)
         gc_was_enabled = GC.disable
         begin
-            result = call_base_nogc name, instance, 
-                option_string, supplied_values
+            call = Call.new(name, supplied_values)
+            call.instance = instance
+            call.option_string = option_string
+            result = call.invoke
         ensure
             GC.enable if gc_was_enabled
         end
@@ -283,7 +339,7 @@ module Vips
     # y = x % [1]
     # ```
     #
-    # Similarly, whereever an image is required, you can use a constant. The
+    # Similarly, wherever an image is required, you can use a constant. The
     # constant will be expanded to an image matching the first input image
     # argument. For example, you can write:
     #
@@ -296,7 +352,15 @@ module Vips
     # the constant value 255. 
 
     def self.call(name, *args)
-        Vips::call_base name, nil, "", args
+        gc_was_enabled = GC.disable
+        begin
+            call = Call.new(name, args)
+            result = call.invoke
+        ensure
+            GC.enable if gc_was_enabled
+        end
+
+        return result
     end
 
 end