libui 0.1.3.pre-x64-mingw32 → 0.2.0.pre-x64-mingw32

data/lib/libui/fiddle_patch.rb

@@ -1,87 +1,87 @@
-module LibUI
-  # This module overrides Fiddle's mtehods
-  # - Fiddle::Importer#extern
-  # - Fiddle::CParser#parse_signature
-  # Original methods are in
-  # - https://github.com/ruby/fiddle/blob/master/lib/fiddle/import.rb
-  # - https://github.com/ruby/fiddle/blob/master/lib/fiddle/cparser.rb
-  # These changes add the ability to parse the signatures of functions given as arguments.
-
-  module FiddlePatch
-    def parse_signature(signature, tymap = nil)
-      tymap ||= {}
-      ctype, func, args = case compact(signature)
-                          when /^(?:[\w\*\s]+)\(\*(\w+)\((.*?)\)\)(?:\[\w*\]|\(.*?\));?$/
-                            [TYPE_VOIDP, Regexp.last_match(1), Regexp.last_match(2)]
-                          when /^([\w\*\s]+[*\s])(\w+)\((.*?)\);?$/
-                            [parse_ctype(Regexp.last_match(1).strip, tymap), Regexp.last_match(2), Regexp.last_match(3)]
-                          else
-                            raise("can't parserake the function prototype: #{signature}")
-                          end
-      symname = func
-      callback_argument_types = {}                                              # Added
-      argtype = split_arguments(args).collect.with_index do |arg, idx|          # Added with_index
-        # Check if it is a function pointer or not
-        if arg =~ /\(\*.*\)\(.*\)/                                              # Added
-          # From the arguments, create a notation that looks like a function declaration
-          # int(*f)(int *, void *) -> int f(int *, void *)
-          func_arg = arg.sub('(*', ' ').sub(')', '')                            # Added
-          # Use Fiddle's parse_signature method again.
-          callback_argument_types[idx] = parse_signature(func_arg)              # Added
-        end
-        parse_ctype(arg, tymap)
-      end
-      # Added callback_argument_types. Original method return only 3 values.
-      [symname, ctype, argtype, callback_argument_types]
-    end
-
-    def extern(signature, *opts)
-      symname, ctype, argtype, callback_argument_types = parse_signature(signature, type_alias)
-      opt = parse_bind_options(opts)
-      func = import_function(symname, ctype, argtype, opt[:call_type])
-
-      # callback_argument_types
-      func.instance_variable_set(:@callback_argument_types, 
-                                   callback_argument_types) # Added
-      # attr_reader
-      def func.callback_argument_types
-        @callback_argument_types
-      end
-
-      # argument_types
-      # Ruby 2.7 Fiddle::Function dose not have @argument_types
-      # Ruby 3.0 Fiddle::Function has @argument_types
-      if func.instance_variable_defined?(:@argument_types)
-        # check if @argument_types are the same
-        if func.instance_variable_get(:@argument_types) != argtype
-          warn "#{symname} func.argument_types:#{func.argument_types} != argtype #{argtype}"
-        end
-      else
-        func.instance_variable_set(:@argument_types, argtype)
-      end
-      # attr_reader
-      def func.argument_types
-        @argument_types
-      end
-
-      name = symname.gsub(/@.+/, '')
-      @func_map[name] = func
-      # define_method(name){|*args,&block| f.call(*args,&block)}
-      begin
-        /^(.+?):(\d+)/ =~ caller.first
-        file = Regexp.last_match(1)
-        line = Regexp.last_match(2).to_i
-      rescue StandardError
-        file, line = __FILE__, __LINE__ + 3
-      end
-      module_eval(<<-EOS, file, line)
-        def #{name}(*args, &block)
-          @func_map['#{name}'].call(*args,&block)
-        end
-      EOS
-      module_function(name)
-      func
-    end
-  end
-  private_constant :FiddlePatch
-end
+module LibUI
+  # This module overrides Fiddle's mtehods
+  # - Fiddle::Importer#extern
+  # - Fiddle::CParser#parse_signature
+  # Original methods are in
+  # - https://github.com/ruby/fiddle/blob/master/lib/fiddle/import.rb
+  # - https://github.com/ruby/fiddle/blob/master/lib/fiddle/cparser.rb
+  # These changes add the ability to parse the signatures of functions given as arguments.
+
+  module FiddlePatch
+    def parse_signature(signature, tymap = nil)
+      tymap ||= {}
+      ctype, func, args = case compact(signature)
+                          when /^(?:[\w\*\s]+)\(\*(\w+)\((.*?)\)\)(?:\[\w*\]|\(.*?\));?$/
+                            [TYPE_VOIDP, Regexp.last_match(1), Regexp.last_match(2)]
+                          when /^([\w\*\s]+[*\s])(\w+)\((.*?)\);?$/
+                            [parse_ctype(Regexp.last_match(1).strip, tymap), Regexp.last_match(2), Regexp.last_match(3)]
+                          else
+                            raise("can't parserake the function prototype: #{signature}")
+                          end
+      symname = func
+      callback_argument_types = {}                                              # Added
+      argtype = split_arguments(args).collect.with_index do |arg, idx|          # Added with_index
+        # Check if it is a function pointer or not
+        if arg =~ /\(\*.*\)\(.*\)/                                              # Added
+          # From the arguments, create a notation that looks like a function declaration
+          # int(*f)(int *, void *) -> int f(int *, void *)
+          func_arg = arg.sub('(*', ' ').sub(')', '')                            # Added
+          # Use Fiddle's parse_signature method again.
+          callback_argument_types[idx] = parse_signature(func_arg)              # Added
+        end
+        parse_ctype(arg, tymap)
+      end
+      # Added callback_argument_types. Original method return only 3 values.
+      [symname, ctype, argtype, callback_argument_types]
+    end
+
+    def extern(signature, *opts)
+      symname, ctype, argtype, callback_argument_types = parse_signature(signature, type_alias)
+      opt = parse_bind_options(opts)
+      func = import_function(symname, ctype, argtype, opt[:call_type])
+
+      # callback_argument_types
+      func.instance_variable_set(:@callback_argument_types, 
+                                   callback_argument_types) # Added
+      # attr_reader
+      def func.callback_argument_types
+        @callback_argument_types
+      end
+
+      # argument_types
+      # Ruby 2.7 Fiddle::Function dose not have @argument_types
+      # Ruby 3.0 Fiddle::Function has @argument_types
+      if func.instance_variable_defined?(:@argument_types)
+        # check if @argument_types are the same
+        if func.instance_variable_get(:@argument_types) != argtype
+          warn "#{symname} func.argument_types:#{func.argument_types} != argtype #{argtype}"
+        end
+      else
+        func.instance_variable_set(:@argument_types, argtype)
+      end
+      # attr_reader
+      def func.argument_types
+        @argument_types
+      end
+
+      name = symname.gsub(/@.+/, '')
+      @func_map[name] = func
+      # define_method(name){|*args,&block| f.call(*args,&block)}
+      begin
+        /^(.+?):(\d+)/ =~ caller.first
+        file = Regexp.last_match(1)
+        line = Regexp.last_match(2).to_i
+      rescue StandardError
+        file, line = __FILE__, __LINE__ + 3
+      end
+      module_eval(<<-EOS, file, line)
+        def #{name}(*args, &block)
+          @func_map['#{name}'].call(*args,&block)
+        end
+      EOS
+      module_function(name)
+      func
+    end
+  end
+  private_constant :FiddlePatch
+end

data/lib/libui/libui_base.rb

@@ -1,52 +1,52 @@
-module LibUI
-  module LibUIBase
-    FFI.func_map.each_key do |original_method_name|
-      name = Utils.convert_to_ruby_method(original_method_name)
-      func = FFI.func_map[original_method_name]
-
-      define_method(name) do |*args, &blk|
-        # Assume that block is the last argument.
-        args << blk if blk
-
-        # The proc object is converted to a Closure::BlockCaller object.
-        args.map!.with_index do |arg, idx|
-          next arg unless arg.is_a?(Proc)
-
-          # now arg must be Proc
-
-          # The types of the function arguments are stored in advance.
-          # See the monkey patch in ffi.rb.
-          _f, ret_type, arg_types = func.callback_argument_types[idx]
-          # TODO: raise some nice error if _f is nil.
-
-          callback = Fiddle::Closure::BlockCaller.new(
-            ret_type, arg_types, &arg
-          )
-          # Protect from GC
-          # by giving the owner object a reference to the callback.
-          # See https://github.com/kojix2/LibUI/issues/8
-          owner = if idx == 0 or   # UI.queue_main{}
-                     owner.frozen? # UI.timer(100) {}
-                    LibUIBase # or UI is better?
-                  else
-                    args[0] # receiver
-                  end
-          if owner.instance_variable_defined?(:@callbacks)
-            owner.instance_variable_get(:@callbacks) << callback
-          else
-            owner.instance_variable_set(:@callbacks, [callback])
-          end
-          callback
-        end
-
-        # Make it possible to omit the last nil. This may be an over-optimization.
-        siz = func.argument_types.size - 1
-        args[siz] = nil if args.size == siz
-
-        FFI.public_send(original_method_name, *args)
-      end
-    end
-  end
-
-  private_constant :LibUIBase
-end
+module LibUI
+  module LibUIBase
+    FFI.func_map.each_key do |original_method_name|
+      name = Utils.convert_to_ruby_method(original_method_name)
+      func = FFI.func_map[original_method_name]
+
+      define_method(name) do |*args, &blk|
+        # Assume that block is the last argument.
+        args << blk if blk
+
+        # The proc object is converted to a Closure::BlockCaller object.
+        args.map!.with_index do |arg, idx|
+          next arg unless arg.is_a?(Proc)
+
+          # now arg must be Proc
+
+          # The types of the function arguments are stored in advance.
+          # See the monkey patch in ffi.rb.
+          _f, ret_type, arg_types = func.callback_argument_types[idx]
+          # TODO: raise some nice error if _f is nil.
+
+          callback = Fiddle::Closure::BlockCaller.new(
+            ret_type, arg_types, &arg
+          )
+          # Protect from GC
+          # by giving the owner object a reference to the callback.
+          # See https://github.com/kojix2/LibUI/issues/8
+          owner = if idx == 0 or   # UI.queue_main{}
+                     owner.frozen? # UI.timer(100) {}
+                    LibUIBase # or UI is better?
+                  else
+                    args[0] # receiver
+                  end
+          if owner.instance_variable_defined?(:@callbacks)
+            owner.instance_variable_get(:@callbacks) << callback
+          else
+            owner.instance_variable_set(:@callbacks, [callback])
+          end
+          callback
+        end
+
+        # Make it possible to omit the last nil. This may be an over-optimization.
+        siz = func.argument_types.size - 1
+        args[siz] = nil if args.size == siz
+
+        FFI.public_send(original_method_name, *args)
+      end
+    end
+  end
+
+  private_constant :LibUIBase
+end

data/lib/libui/utils.rb

@@ -1,19 +1,19 @@
-module LibUI
-  module Utils
-    class << self
-      def convert_to_ruby_method(original_method_name)
-        underscore(original_method_name.delete_prefix('ui'))
-      end
-
-      # Converting camel case to underscore case in ruby
-      # https://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby#1509939
-      def underscore(str)
-        str.gsub(/::/, '/') # Maybe we don't need it.
-           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-           .tr('-', '_')
-           .downcase
-      end
-    end
-  end
-end
+module LibUI
+  module Utils
+    class << self
+      def convert_to_ruby_method(original_method_name)
+        underscore(original_method_name.delete_prefix('ui'))
+      end
+
+      # Converting camel case to underscore case in ruby
+      # https://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby#1509939
+      def underscore(str)
+        str.gsub(/::/, '/') # Maybe we don't need it.
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .tr('-', '_')
+           .downcase
+      end
+    end
+  end
+end

data/lib/libui/version.rb

@@ -1,3 +1,3 @@
-module LibUI
-  VERSION = '0.1.3.pre'
-end
+module LibUI
+  VERSION = '0.2.0.pre'
+end