cocoa 0.1.3 → 0.1.4

data/lib/cocoa/objc.rb

@@ -1,22 +1,28 @@
+
+require 'cocoa/objc/method_def'
+
 module ObjC
   extend FFI::Library
  
   ffi_lib 'objc'
  
   attach_function :sel_registerName, [:string], :pointer
-  attach_function :objc_msgSend, [:pointer, :pointer, :varargs], :pointer
   attach_function :objc_getClass, [:string], :pointer
   attach_function :objc_allocateClassPair, [:pointer, :string, :int], :pointer
   attach_function :objc_registerClassPair, [:pointer], :void
 
-  def self.msgSend( id, selector, *args )
-    selector = sel_registerName(selector) if selector.is_a? String
-    objc_msgSend( id, selector, *args )
+  MethodDef::TYPES.values.uniq.each do |type|
+    name = "objc_msgSend_#{type}".to_sym
+    attach_function name, :objc_msgSend, [:pointer, :pointer, :varargs], type
+    define_singleton_method "msgSend_#{type}".to_sym do |id, selector, *args|
+      selector = sel_registerName(selector) if selector.is_a? String
+      send(name, id, selector, *args )
+    end
   end
 
   def self.msgSend_stret( return_type, id, selector, *args )
     selector = sel_registerName(selector) if selector.is_a? String
-    method = "objc_msgSend_stret_for_#{return_type.name.underscore}".to_sym
+    method = "objc_msgSend_stret_for_#{return_type.name.underscore.gsub('/','_')}".to_sym
     unless respond_to? method
       attach_function method, :objc_msgSend_stret, [:pointer, :pointer, :varargs], return_type.by_value
     end
@@ -25,11 +31,11 @@ module ObjC
 
   def self.String_to_NSString( string )
     nsstring_class = objc_getClass("NSString")
-    msgSend(nsstring_class, "stringWithUTF8String:", :string, string )
+    msgSend_pointer(nsstring_class, "stringWithUTF8String:", :string, string )
   end
  
   def self.NSString_to_String( nsstring_pointer )
-    c_string = msgSend( nsstring_pointer, "UTF8String")
+    c_string = msgSend_pointer( nsstring_pointer, "UTF8String")
     if c_string.null?
       return "(NULL)"
     else
@@ -37,172 +43,73 @@ module ObjC
     end
   end
 
+  def self.smart_constantize ret,klass_name
+    begin
+      Cocoa.const_get(klass_name)
+    rescue
+      _superclass = ObjC.msgSend_pointer(ret,'superclass')
+      superclass_name = ObjC::NSString_to_String(Cocoa::NSStringFromClass(_superclass))
+      superclass_name = if superclass_name =~ /^__NSCF/
+        "NS#{klass_name[6..-1]}" 
+      elsif superclass_name[0]=='_'
+        if superklass = Cocoa::const_get(NSString_to_String(Cocoa::NSStringFromClass(ObjC.msgSend_pointer(ret,"superclass"))))
+          superklass.name.split('::').last
+        else
+          "FIX_#{superclass_name}" 
+        end
+      else
+        superclass_name
+      end
+      superclass = Cocoa::const_get(superclass_name) rescue smart_constantize(_superclass,superclass_name)
+      proxy = Class.new(superclass)
+      Cocoa.const_set(klass_name, proxy)
+      klass = Cocoa.const_get(klass_name)
+      superclass.inherited(klass)
+      klass
+    end
+  end
+
   def self.object_to_instance ret
-    klass_name = NSString_to_String(Cocoa::NSStringFromClass(ObjC.msgSend(ret,"class")))
+    klass_name = NSString_to_String(Cocoa::NSStringFromClass(ObjC.msgSend_pointer(ret,"class")))
     return self if klass_name == '(NULL)'
     instance = begin
-      ("Cocoa::"+klass_name).constantize.new(true)
+      Cocoa::const_get(klass_name).new(true)
     rescue
       klass_name = if klass_name =~ /^__NSCF/
         "NS#{klass_name[6..-1]}" 
       elsif klass_name[0]=='_'
-        "FIX_#{klass_name}" 
+        if superklass = Cocoa::const_get(NSString_to_String(Cocoa::NSStringFromClass(ObjC.msgSend_pointer(ret,"superclass"))))
+          superklass.name.split('::').last
+        else
+          "FIX_#{klass_name}" 
+        end
       else
         klass_name
       end
-      klass = begin
-        Cocoa.const_get(klass_name)
-      rescue => e
-        superclass_name = NSString_to_String(Cocoa::NSStringFromClass(ObjC.msgSend(ret,'superclass')))
-        superclass = "Cocoa::#{superclass_name}".constantize
-        proxy = Class.new(superclass)
-        Cocoa.const_set(klass_name, proxy)
-        klass = ("Cocoa::"+klass_name).constantize
-        superclass.inherited(klass)
-        klass
-      end
+      klass = smart_constantize(ret,klass_name)
       klass.new(true)
     end
     instance.object = ret
     instance
   end
 
-  def self.translate_retval method,ret,type
+  def self.ffi_to_ruby_value method,ffi_value,type
     case type
     when '@'
-      return nil if ret.address == 0
-      return ret if method == :NSStringFromClass
-      object_to_instance ret
+      return nil if ffi_value.address == 0
+      return ffi_value if method == :NSStringFromClass
+      ObjC.object_to_instance(ffi_value)
+    when '^v', 'Q', 'q', 'D', 'd', 'B', 'I', 'i'
+      ffi_value
+    when /^\^{([^=]*)=.*}$/
+      return nil if ffi_value.address == 0
+      ObjC.object_to_instance(ffi_value)
+    when '*'
+      ffi_value.read_string
     when '#'
-      ret
+      ffi_value
     when /^{([^=]*)=.*}$/
-      ret
-    when /^\^{[^=]*=.*}$/
-      return nil if ret.address == 0
-      object_to_instance ret
-    else
-      raise type
-    end
-  end
-
-  def self.fixed_args args,params={},types=[],options={}
-    if options[:variadic]
-      _types = (types.dup*args.size)
-      args
-    else
-      _types = types.dup
-      ([args.first]+params.values)
-    end.map do |arg|
-      type = _types.shift
-      case arg
-      when TrueClass, FalseClass
-        [:bool,arg]
-      when Fixnum, Bignum
-        case type
-        when 'q'
-          [:long_long,arg]
-        when 'Q'
-          [:ulong_long,arg]
-        when 'd'
-          [:double,arg]
-        else
-          raise type.inspect
-        end
-      when Float
-        [:double,arg]
-      when String
-        [:pointer,ObjC.String_to_NSString(arg)]
-      when NilClass
-        [:pointer,nil]
-      when Symbol
-        [:pointer,ObjC.sel_registerName("#{arg}:")]
-      when Cocoa::NSObject
-        [:pointer,arg.object]
-      when FFI::Struct
-        [arg.class.by_value,arg]
-      when FFI::Pointer
-        [:pointer,arg]
-      else
-        raise ArgumentError.new("#{arg.class.name}: #{arg.inspect}")
-      end
-    end.flatten
-  end
-
-  def self.apple_type_to_ffi type
-    # TODO: These are just stubbed on guess - check'em'all
-    case type
-    when 'C'
-      :uchar
-    when '@'
-      :pointer
-    when '#'
-      :pointer
-    when 'Q'
-      :int
-    when ':'
-      :pointer
-    when 'I'
-      :int
-    when 'L'
-      :int
-    when 'd'
-      :double
-    when 'f'
-      :float
-    when 'i'
-      :int
-    when 's'
-      :int
-    when 'q'
-      :long_long
-    when 'S'
-      :int
-    when /^\^/
-      :pointer
-    when 'B'
-      :bool
-    when 'v'
-      :void
-    when '[5*]'
-      :void
-    when /^{[^=]*=.*}$/
-      begin
-        /^{_*([^=]*)=.*}$/.match(type)[1].constantize.by_value
-      rescue => e
-        begin
-          "Cocoa::#{/^{_*([^=]*)=.*}$/.match(type)[1]}".constantize.by_value
-        rescue => e
-          match = /^{_*([^=]*)=(.*)}$/.match(type)
-          klass = begin
-            Cocoa.const_get(match[1])
-          rescue
-            # puts "defining struct Cocoa::#{match[1]} as #{match[2]}"
-            # this stuff doesnt work with jruby
-            klass = Class.new(FFI::Struct)
-            Cocoa.const_set(match[1], klass)
-            name = 'a'
-            layout = []
-            match[2].each_char do |c|
-              case c
-              when 'd'
-                layout << name.to_sym
-                name = name.next
-                layout << :double
-              end
-            end
-            klass = "Cocoa::#{match[1]}".constantize
-            klass.layout *layout
-            klass
-          end
-          klass.by_ref
-        end
-      end
-    when nil
-      :void
-    when '*' # character string
-      :pointer
-    when '@?'
-      :pointer
+      ffi_value
     else
       raise type.inspect
     end
@@ -212,76 +119,15 @@ module ObjC
     case type
     when nil
       default
-    when '@'
-      type
-    when 'v'
+    when '@', 'v', 'q', 'Q', '^v'
       type
     when /^{([^=]*)=.*}$/
       type
+    when /^\^{([^=]*)=.*}$/
+      type
     else
       raise type.inspect
     end
   end
 
-  def self.call_arguments params,args
-    fixed_args = []
-    args.each_with_index do |arg,i|
-      case params[:types][i]
-      when '@'
-        fixed_args << arg
-      when 'd'
-        if arg.is_a?(Fixnum)
-          fixed_args << arg.to_f
-        else
-          raise ArgumentError.new("float expected, got #{arg.class.name}") unless arg.is_a?(Float)
-          fixed_args << arg
-        end
-      when 'I'
-        raise ArgumentError unless arg.is_a?(Fixnum)
-        fixed_args << arg
-      when 'Q'
-        raise ArgumentError.new(arg.inspect) unless arg.is_a?(Fixnum)
-        fixed_args << arg
-      when 'q'
-        raise ArgumentError unless arg.is_a?(Fixnum)
-        fixed_args << arg
-      when '#'
-        raise ArgumentError unless arg.is_a?(FFI::Pointer)
-        fixed_args << arg
-      when /^{[^=]*=.*}$/
-        raise ArgumentError.new(arg.inspect) unless arg.kind_of?(FFI::Struct)
-        fixed_args << arg
-      when /^\^{([^=]*)=.*}$/
-        case arg
-        when FFI::Pointer
-          fixed_args << arg
-        when Array
-          raise ArgumentError unless $1 == '__CFArray'
-          fixed_args << NSArray.arrayWithObjects(arg).object
-        else
-          match = $1
-          if arg.class.name =~ /^Cocoa::/ # "Cocoa::#{$1}".constantize
-            fixed_args << arg.object
-          elsif arg.is_a?(NilClass)
-            fixed_args << FFI::MemoryPointer::NULL
-          elsif arg.is_a?(String) && match == '__CFString'
-            fixed_args << Cocoa::String_to_NSString(arg)
-          else
-            raise ArgumentError.new("expected #{params[:types][i]} got #{arg.class.name} (#{match})")
-          end
-        end
-      when '^d'
-        raise ArgumentError unless arg.is_a?(Array)
-        arr = FFI::MemoryPointer.new(:double,arg.size)
-        arr.write_array_of_double(arg)
-        fixed_args << arr
-      when '^v'
-        raise ArgumentError unless arg.is_a?(NilClass)
-        fixed_args << FFI::MemoryPointer::NULL
-      else
-        raise params[:types][i]
-      end
-    end
-    fixed_args
-  end
 end

data/lib/cocoa/objc/method_def.rb

@@ -0,0 +1,314 @@
+module ObjC
+  class MethodDef
+    attr_accessor :name,:names,:types,:return_type
+
+    TYPES = {
+      'c' => :char,
+      'i' => :int,
+      's' => :short,
+      'l' => :long,
+      'q' => :long_long,
+      'C' => :uchar,
+      'I' => :uint,
+      'S' => :ushort,
+      'L' => :ulong,
+      'Q' => :ulong_long,
+      'f' => :float,
+      'd' => :double,
+      'B' => :bool,
+      'v' => :void,
+      '*' => :pointer, # :string?
+      '@' => :pointer,
+      '#' => :pointer,
+      ':' => :pointer,
+      # [array type]   - An array
+      # {name=type...} - A structure
+      # (name=type...) - A union
+      # bnum           - A bit field of num bits
+      # ^type          - A pointer to type
+      # ?              - An unknown type (among other things, this code is used for function pointers)
+    }
+
+    def initialize name,options
+      @name = name.to_sym
+      @names = options[:names].map(&:to_sym)
+      @types = options[:types]
+      @return_type = options[:retval]
+      @variadic = options[:variadic]
+    end
+
+    def variadic?
+      @variadic
+    end
+
+    def ffi_types
+      @ffi_types ||= types.map do |type|
+        TYPES[type] || case type
+        when '@?'
+          :pointer
+        when '^v', /^\^/, '^?', '^I'
+          :pointer
+        when /^{([^=]*)=(.*)}$/
+          begin
+            Cocoa::const_get($1).by_value
+          rescue
+            # this stuff doesnt work with jruby
+            attribs = $2
+            klass_name = /^{_*([^=]*)=.*}$/.match(type)[1]
+            klass = begin
+              Cocoa.const_get(klass_name)
+            rescue
+              klass = Class.new(FFI::Struct)
+              Cocoa.const_set($1, klass)
+              name = 'a'
+              layout = []
+              attribs.each_char do |c|
+                layout << name.to_sym
+                name = name.next
+                layout << case c
+                when '^', '?'
+                  :pointer
+                when 'v'
+                  :pointer
+                else
+                  TYPES[c]
+                end
+              end
+              klass = Cocoa::const_get($1)
+              klass.layout *layout
+              klass
+            end
+            klass.by_ref
+          end
+        when /^\^{([^=]*)=.*}$/
+          :pointer
+        else
+          raise type.inspect
+        end
+      end
+    end
+
+    def ffi_return_type
+      @ffi_return_type ||= TYPES[return_type] || case return_type
+      when nil
+        :void
+      when 'v'
+        :void
+      when /^\^/
+        :pointer
+      when '[5*]'
+        :void
+      when /^{[^=]*=.*}$/
+        begin
+          /^{_*([^=]*)=.*}$/.match(return_type)[1].constantize.by_value
+        rescue => e
+          begin
+            "Cocoa::#{/^{_*([^=]*)=.*}$/.match(return_type)[1]}".constantize.by_value
+          rescue => e
+            match = /^{_*([^=]*)=(.*)}$/.match(return_type)
+            klass = begin
+              Cocoa.const_get(match[1])
+            rescue
+              # puts "defining struct Cocoa::#{match[1]} as #{match[2]}"
+              # this stuff doesnt work with jruby
+              klass = Class.new(FFI::Struct)
+              Cocoa.const_set(match[1], klass)
+              name = 'a'
+              layout = []
+              match[2].each_char do |c|
+                case c
+                when 'd'
+                  layout << name.to_sym
+                  name = name.next
+                  layout << :double
+                end
+              end
+              klass = "Cocoa::#{match[1]}".constantize
+              klass.layout *layout
+              klass
+            end
+            klass.by_ref
+          end
+        end
+      when nil
+        :void
+      when '@?'
+        :pointer
+      else
+        raise self.inspect
+      end
+    end
+
+    def objc_types
+      ObjC.objc_type(@return_value,'v')+'@:'+@types.map{ |type| ObjC.objc_type(type) }.join
+    end
+
+    def ffi_casted values
+      i = -1
+      values.map do |value|
+        i += 1
+        case value
+        when TrueClass, FalseClass
+          [:bool,value]
+        when Fixnum, Bignum
+          [TYPES[types[i]],value]
+        when Float
+          [:double,value]
+        when String
+          [:pointer,ObjC.String_to_NSString(value)]
+        when NilClass
+          [:pointer,nil]
+        when Symbol
+          [:pointer,ObjC.sel_registerName("#{value}:")]
+        when Cocoa::NSObject
+          [:pointer,value.object]
+        when FFI::Struct
+          [value.class.by_value,value]
+        when FFI::Pointer
+          [:pointer,value]
+        else
+          raise ArgumentError.new(value.inspect)
+        end
+      end.flatten
+    end
+
+    def call_arguments args
+      fixed_args = []
+      args.each_with_index do |arg,i|
+        case types[i]
+        when '@'
+          fixed_args << arg
+        when 'd'
+          if arg.is_a?(Fixnum)
+            fixed_args << arg.to_f
+          else
+            raise ArgumentError.new("float expected, got #{arg.class.name}") unless arg.is_a?(Float)
+            fixed_args << arg
+          end
+        when 'I'
+          raise ArgumentError unless arg.is_a?(Fixnum)
+          fixed_args << arg
+        when 'Q', 'q'
+          raise ArgumentError.new(arg.inspect) unless arg.is_a?(Fixnum)
+          fixed_args << arg
+        when '#'
+          raise ArgumentError unless arg.is_a?(FFI::Pointer)
+          fixed_args << arg
+        when /^{[^=]*=.*}$/
+          raise ArgumentError.new(arg.inspect) unless arg.kind_of?(FFI::Struct)
+          fixed_args << arg
+        when /^\^{([^=]*)=.*}$/
+          case arg
+          when FFI::Pointer
+            fixed_args << arg
+          when Array
+            raise ArgumentError unless $1 == '__CFArray'
+            fixed_args << NSArray.arrayWithObjects(arg).object
+          else
+            match = $1
+            if arg.class.name =~ /^Cocoa::/ # "Cocoa::#{$1}".constantize
+              fixed_args << arg.object
+            elsif arg.is_a?(NilClass)
+              fixed_args << FFI::MemoryPointer::NULL
+            elsif arg.is_a?(String) && match == '__CFString'
+              fixed_args << Cocoa::String_to_NSString(arg)
+            else
+              raise ArgumentError.new("expected #{params[:types][i]} got #{arg.class.name} (#{match})")
+            end
+          end
+        when '^d'
+          raise ArgumentError unless arg.is_a?(Array)
+          arr = FFI::MemoryPointer.new(:double,arg.size)
+          arr.write_array_of_double(arg)
+          fixed_args << arr
+        when '^v'
+          raise ArgumentError unless arg.is_a?(NilClass)
+          fixed_args << FFI::MemoryPointer::NULL
+        else
+          raise types[i]
+        end
+      end
+      fixed_args
+    end
+
+    def selector
+      @selector ||= begin
+        if types.size > 0
+          "#{name}#{(['']+names).join(':')}:"
+        else
+          name.to_s
+        end
+      end
+    end
+
+    def ruby_return_value this,ffi_value
+      case return_type
+      when 'v'
+        this
+      else
+        ObjC.ffi_to_ruby_value name,ffi_value,return_type
+      end
+    end
+
+    def call this, object, *args
+      values = if @types.size == 0
+        []
+      elsif @types.size == 1
+        args
+      else
+        [args.first] + args.last.values
+      end
+
+      # TODO: BUG: cascadeTopLeftFromPoint struggles with msgSend_stret
+      if return_type =~ /^{([^=]*)=.*}$/ && name != :cascadeTopLeftFromPoint
+        struct = Cocoa.const_get($1.sub(/^_NS/,'NS'))
+        ObjC.msgSend_stret(struct,object,selector,*ffi_casted(values))
+      else
+        ret = if ffi_return_type.is_a?(FFI::StructByValue)
+          ObjC.send(:msgSend_pointer,object,selector,*ffi_casted(values))
+        else
+          ObjC.send("msgSend_#{ffi_return_type}".to_sym,object,selector,*ffi_casted(values))
+        end
+        return if name == :cascadeTopLeftFromPoint
+        return ret if name == :NSStringFromClass
+        ruby_return_value(this,ret)
+      end
+    end
+
+    def callback instance, params, args
+      keys = params.select{ |param| param.first == :key }.map{ |param| param.last }
+
+      ret = if params.size > 0 && params.last.first == :rest
+        args = args.map{ |arg| Cocoa::instance_for(arg) }
+        instance.send(name, args.first, Hash[*names.zip(args[1..-1]).flatten])
+      elsif keys.size > 0
+        args = args.map{ |arg| Cocoa::instance_for(arg) }
+        instance.send(name, args.first, Hash[*keys.zip(args[1..-1]).flatten])
+      else
+        instance.send(name, *args.map{ |arg| Cocoa::instance_for(arg) })
+      end
+      ffi_return_value(ret)
+    end
+
+    def ffi_return_value value
+      case return_type
+      when '@'
+        case value
+        when NilClass
+          nil
+        when String
+          Cocoa::NSString.stringWithString(value).object
+        else
+          raise value.inspect
+        end
+      when 'q', 'Q', 'd', 'B'
+        value
+      when 'v'
+        nil
+      else
+        raise inspect
+      end
+    end
+
+  end
+end