ffi-efl 0.0.1 → 0.0.2

data/Changelog

@@ -1,2 +1,8 @@
+2011-04-25 Jérémy Zurcher <jeremy@asynk.ch>
+	* release 0.2.0
+	* ecore getopt seems good
+	* basis of module function mapping and class method_missing usage setup
+	* small elementary elm_Win test app
+
 2011-04-08 Jérémy Zurcher <jeremy@asynk.ch>
 	* Project creation

data/README.rdoc

@@ -1,12 +1,14 @@
 ffi-efl
     by Jérémy Zurcher
-    http://cgit.asynk.ch
+    http://asynk.ch
 
 == DESCRIPTION:
 
 ffi-efl is a FFI[https://github.com/ffi/ffi/wiki] binding to Enlightenment Foundation Libraries (eina,eet,evas,ecore,edje...)
 base components of the Enlightenment project. (EFL API[http://www.enlightenment.org/p.php?p=docs&l=en])
 
+ffi-efl project is developed on asynk[http://cgit.asynk.ch/cgi-bin/cgit/ffi-efl], github[https://github.com/jeremyz] and gitorious[https://gitorious.org/~jeyzu]
+
 == FEATURES/PROBLEMS:
 
 * Project just started

data/Rakefile

@@ -1,5 +1,6 @@
 # -*- coding: UTF-8 -*-
 #
+require './lib/efl.rb'
 load './tasks/setup.rb'
 #
 # Project general information
@@ -7,7 +8,7 @@ PROJ.name = 'ffi-efl'
 PROJ.authors = 'Jérémy Zurcher'
 PROJ.email = 'jeremy@asynk.ch'
 PROJ.url = 'https://github.com/jeremyz/ffi-efl'
-PROJ.version = '0.0.1'
+PROJ.version = Efl::VERSION
 PROJ.rubyforge.name = 'ffi-efl'
 PROJ.readme_file = 'README.rdoc'
 #

data/lib/efl/ecore/ecore-ffi.rb

@@ -351,8 +351,8 @@ module Efl
         [ :ecore_timer_precision_set, [ :double ], :void ],
         # EAPI Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func, const void *data);
         [ :ecore_animator_add, [ :ecore_task_cb, :void_p ], :ecore_animator_p ],
-        # EAPI Ecore_Animator *ecore_animator_run_add(double runtime, Ecore_Timeline_Cb func, const void *data);
-        [ :ecore_animator_run_add, [ :double, :ecore_timeline_cb, :void_p ], :ecore_animator_p ],
+        # EAPI Ecore_Animator *ecore_animator_timeline_add(double runtime, Ecore_Timeline_Cb func, const void *data);
+        [ :ecore_animator_timeline_add, [ :double, :ecore_timeline_cb, :void_p ], :ecore_animator_p ],
         # EAPI void *ecore_animator_del(Ecore_Animator *animator);
         [ :ecore_animator_del, [ :ecore_animator_p ], :void_p ],
         # EAPI void ecore_animator_freeze(Ecore_Animator *animator);

data/lib/efl/ecore_getopt.rb

@@ -6,25 +6,65 @@ require 'efl/ecore/ecore_getopt-ffi'
 module Efl
     module API
         #
-        class Ecore_Getopt_Value < FFI::Union
-            layout  :val,   :pointer,
+        class EcoreGetoptValue < FFI::Union
+            layout  :strp,          :pointer,
+                    :boolp,         :eina_bool_p,
+                    :shortp,        :short_p,
+                    :intp,          :int_p,
+                    :longp,         :long_p,
+                    :ushortp,       :ushort_p,
+                    :uintp,         :uint_p,
+                    :ulongp,        :ulong_p,
+                    :doublep,       :double_p,
+                    :listp,         :eina_list_p,
+                    :ptrp,          :void_p,
         end
-        class Ecore_Action_Parma < FFI::Union
-            layout  :store,         :ecore_getopt_desc_store,
+        #
+        class EcoreGetoptDescStoreDef < FFI::Union
+            layout  :strv,          :pointer,
+                    :boolv,         :uchar,
+                    :shortv,        :short,
+                    :intv,          :int,
+                    :longv,         :long,
+                    :ushortv,       :ushort,
+                    :uintv,         :uint,
+                    :ulongv,        :ulong,
+                    :doublev,       :double,
+        end
+        #
+        class EcoreGetoptDescStore < FFI::Struct
+            layout  :type,          :ecore_getopt_type,                 # enum
+                    :arg_req,       :ecore_getopt_desc_arg_requirement, # enum
+                    :def,           EcoreGetoptDescStoreDef,
+        end
+        #
+        callback :ecore_getopt_desc_cb, [:ecore_getopt_p, :ecore_getopt_desc_p, :string, :pointer, :ecore_getopt_value_p ], :eina_bool
+        #
+        class EcoreGetoptDescCallback < FFI::Struct
+            layout  :func,          :ecore_getopt_desc_cb,
+                    :data,          :pointer,
+                    :arg_req,       :ecore_getopt_desc_arg_requirement, # enum
+                    :def,           :pointer,
+        end
+        #
+        class EcoreActionParam < FFI::Union
+            layout  :store,         EcoreGetoptDescStore,
                     :store_const,   :pointer,
                     :choices,       :pointer,
-                    :append_type,   :ecore_getopt_type,
-                    :callback,      :ecore_getopt_desc_callback,
+                    :append_type,   :ecore_getopt_type,                 # enum
+                    :callback,      EcoreGetoptDescCallback,
                     :dummy,         :pointer,
         end
-        class Ecore_Getopt_Desc < FFI::Struct
+        #
+        class EcoreGetoptDesc < FFI::Struct
             layout  :shortname,     :char,
                     :longname,      :pointer,
                     :help,          :pointer,
                     :metavar,       :pointer,
-                    :action,        :ecore_getopt_action,
-                    :action_param,  :pointer,
+                    :action,        :ecore_getopt_action,               # enum
+                    :action_param,  EcoreActionParam,
         end
+        #
         class EcoreGetopt < FFI::Struct
             layout  :prog,          :pointer,
                     :usage,         :pointer,
@@ -32,12 +72,205 @@ module Efl
                     :copyright,     :pointer,
                     :license,       :pointer,
                     :description,   :pointer,
-                    :strict,        :char,
-                    :descs,         :pointer
+                    :strict,        :char
+#                    :descs,         :pointer,   # NULL terminated  EcoreGetopt_Desc[]
+
+            def desc_ptr idx
+                EcoreGetoptDesc.new to_ptr+Efl::API::EcoreGetopt.size+(idx*Efl::API::EcoreGetoptDesc.size)
+            end
         end
         #
     end
     #
+    module EcoreGetopt
+        class Parser
+            def initialize desc
+                @desc = desc
+                @options = [
+                    [ 0, FFI::Pointer::NULL, FFI::Pointer::NULL, FFI::Pointer::NULL, 0, {:dummy=>FFI::Pointer::NULL} ]
+                ]
+                @values = [
+                    [ :ptrp, FFI::Pointer::NULL ]
+                ]
+                @refs = [] # to prevent FFI::MemoryPointer.from_string from beeing GC'ed
+            end
+            def p_from_string r
+                return r if r==FFI::Pointer::NULL
+                p = FFI::MemoryPointer.from_string r
+                @refs << p
+                p
+            end
+            def << o
+                @options.insert -2, o
+            end
+            def value type, ptr
+                @values.insert -2, [ type, ptr ]
+            end
+            def to_ptr
+                @parser_p.to_ptr
+            end
+            def create
+                @parser_p = Efl::API::EcoreGetopt.new FFI::MemoryPointer.new (Efl::API::EcoreGetopt.size+Efl::API::EcoreGetoptDesc.size*@options.length), 1
+                [:prog,:usage,:version,:copyright,:license,:description].each do |sym|
+                    @parser_p[sym] = ( @desc.has_key?(sym) ? FFI::MemoryPointer.from_string(@desc[sym]) : FFI::Pointer::NULL )
+                end
+                @parser_p[:strict] = @desc[:strict] if @desc.has_key? :strict
+                @options.each_with_index do |o,i|
+                    d = @parser_p.desc_ptr i
+                    d[:shortname] = o[0].ord
+                    d[:longname] = p_from_string o[1]
+                    d[:help] = p_from_string o[2]
+                    d[:metavar] = o[3]
+                    d[:action] = o[4]
+                    k, v = o[5]
+                    case k
+                    when :dummy
+                        d[:action_param][:dummy] = v
+                    when :callback
+                        cb = d[:action_param][:callback]
+                        cb[:func] = v[0]
+                        cb[:data] = v[1]
+                        cb[:arg_req] = v[2]
+                        cb[:def] = v[3]
+                    when :store
+                        st = d[:action_param][:store]
+                        st[:type] = v[0]
+                        st[:arg_req] = v[1]
+                        if not v[2].nil?
+                            if v[2][0]==:strv
+                                st[:def][:strv] = p_from_string v[2][1]
+                            else
+                                st[:def][v[2][0]] = v[2][1]
+                            end
+                        end
+                    when :store_const
+                        d[:action_param][:store_const] = v
+                    when :choices
+                        d[:action_param][:choices] = v
+                    when :append
+                        d[:action_param][:append_type] = v
+                    else
+                        d[:action_param][:dummy] = FFI::Pointer::NULL
+                    end
+                end
+                @values_p = FFI::MemoryPointer.new Efl::API::EcoreGetoptValue, @values.length, false
+                @values.each_with_index do |v,i|
+                    Efl::API::EcoreGetoptValue.new(@values_p+(i*Efl::API::EcoreGetoptValue.size))[v[0]] = v[1]
+                end
+            end
+            def parse argv
+                ptr = FFI::MemoryPointer.new(:pointer, argv.length+1)
+                argv.each_with_index do |s, i|
+                    ptr[i].put_pointer 0, p_from_string(s)
+                end
+                ptr[argv.length].put_pointer 0, FFI::Pointer::NULL
+                Efl::EcoreGetopt.parse @parser_p, @values_p, argv.length, ptr
+            end
+            def store_full short, long, help, meta, type, arg_req, def_val
+                self << [ short, long, help, meta, :ecore_getopt_action_store, [:store, [type,arg_req, def_val] ] ]
+            end
+            def store short, long, help, type
+                store_full short, long, help, FFI::Pointer::NULL, type, :ecore_getopt_desc_arg_requirement_yes, nil
+            end
+            def store_type type, short, long, help
+                store short, long, help, ('ecore_getopt_type_'+type.to_s).to_sym
+            end
+            def store_metavar short, long, help, meta, type
+                store_full short, long, help, meta, type, :ecore_getopt_desc_arg_requirement_yes, nil
+            end
+            def store_meta_type type, short, long, help, meta
+                store_metavar short, long, help, meta, ('ecore_getopt_type_'+type.to_s).to_sym
+            end
+            def store_def short, long, help, type, def_val
+                store_full short, long, help, FFI::Pointer::NULL, type, :ecore_getopt_desc_arg_requirement_optional, def_val
+            end
+            def store_def_type type, short, long, help, def_val
+                store_def short, long, help, ('ecore_getopt_type_'+type.to_s).to_sym, [ (type.to_s+'v').to_sym, def_val ]
+            end
+            def store_full_type type, short, long, help, meta, arg_req, def_val
+                store_full short, long, help, meta, ('ecore_getopt_type_'+type.to_s).to_sym, arg_req, [ (type.to_s+'v').to_sym, def_val ]
+            end
+            def store_const short, long, help, value
+                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_const, [:store_const, value] ]
+            end
+            def store_true short, long, help
+                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_true, [:dummy,FFI::MemoryPointer::NULL] ]
+            end
+            def store_false short, long, help
+                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_false, [:dummy,FFI::MemoryPointer::NULL] ]
+            end
+            def choice short, long, help, choices
+                ptr = FFI::MemoryPointer.new(:pointer, choices.length+1)
+                choices.each_with_index do |s, i|
+                    ptr[i].put_pointer 0, p_from_string(s)
+                end
+                ptr[choices.length].put_pointer 0, FFI::Pointer::NULL
+                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_choice, [:choices,ptr] ]
+            end
+            def choice_metavar short, long, help, meta, choices
+                ptr = FFI::MemoryPointer.new(:pointer, choices.length+1)
+                choices.each_with_index do |s, i|
+                    ptr[i].put_pointer 0, p_from_string(s)
+                end
+                ptr[choices.length].put_pointer 0, FFI::Pointer::NULL
+                self << [ short, long, help, meta, :ecore_getopt_action_choice, [:choices,ptr] ]
+            end
+            def append short, long, help, sub_type
+                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_append, [:append,sub_type] ]
+            end
+            def append_metavar short, long, help, meta, sub_type
+                self << [ short, long, help, meta, :ecore_getopt_action_append, [:append,sub_type] ]
+            end
+            def count short, long, help
+                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_count, [:dummy,FFI::Pointer::NULL] ]
+            end
+            def callback_full short, long, help, meta, cb, data, arg_req, def_val
+                self << [ short, long, help, meta, :ecore_getopt_action_callback, [:callback, [cb, data, arg_req,def_val] ] ]
+            end
+            def callback_noargs short, long, help, cb, data
+                callback_full short, long, help, FFI::Pointer::NULL, cb, data, :ecore_getopt_desc_arg_requirement_no, FFI::Pointer::NULL
+            end
+            def callback_args short, long, help, meta, cb, data
+                callback_full short, long, help, meta, cb, data, :ecore_getopt_desc_arg_requirement_yes, FFI::Pointer::NULL
+            end
+            def help short, long
+                self << [ short, long, 'show this message.', FFI::Pointer::NULL, :ecore_getopt_action_help, [:dummy,FFI::Pointer::NULL] ]
+            end
+            def version short, long
+                self << [ short, long, 'show program version.', FFI::Pointer::NULL, :ecore_getopt_action_version, [:dummy,FFI::Pointer::NULL] ]
+            end
+            def copyright short, long
+                self << [ short, long, 'show copyright.', FFI::Pointer::NULL, :ecore_getopt_action_copyright, [:dummy,FFI::Pointer::NULL] ]
+            end
+            def license short, long
+                self << [ short, long, 'show license.', FFI::Pointer::NULL, :ecore_getopt_action_license, [:dummy,FFI::Pointer::NULL] ]
+            end
+#            def sentinel
+#                self << [ 0, FFI::Pointer::NULL, FFI::Pointer::NULL, FFI::Pointer::NULL, 0, {:dummy=>FFI::Pointer::NULL} ]
+#            end
+            #
+            def debug
+                r = ''
+                r << "#{self.class} : #{@parser_p.to_ptr}\n"
+                [:prog,:usage,:version,:copyright,:license,:description].each do |sym|
+                    r<< "  #{sym.to_s} : #{@parser_p[sym]==FFI::Pointer::NULL ? 'NULL' : @parser_p[sym].read_string}\n"
+                end
+                r << "  strict : #{@parser_p[:strict]}\n"
+                i=0
+                while true
+                    d = @parser_p.desc_ptr i
+                    break if d[:shortname]==0 and d[:longname] == FFI::Pointer::NULL
+                    r << "    desc #{d.to_ptr}\n"
+                    r << "     short: #{d[:shortname].chr}\n" unless d[:shortname]==0
+                    r << "     long:  #{d[:longname].read_string}\n" unless d[:longname]==FFI::Pointer::NULL
+                    r << "     help:  #{d[:help].read_string}\n" unless d[:help]==FFI::Pointer::NULL
+                    i+=1
+                end
+                r
+            end
+        end
+    end
+    #
 end
 #
 # EOF

data/lib/efl/elementary/elementary-ffi.rb

@@ -336,6 +336,26 @@ module Efl
         [ :elm_run, [  ], :void ],
         # EAPI void elm_exit(void);
         [ :elm_exit, [  ], :void ],
+        # EAPI void elm_app_info_set(void *mainfunc, const char *dom, const char *checkfile);
+        [ :elm_app_info_set, [ :void_p, :string, :string ], :void ],
+        # EAPI void elm_app_compile_bin_dir_set(const char *dir);
+        [ :elm_app_compile_bin_dir_set, [ :string ], :void ],
+        # EAPI void elm_app_compile_lib_dir_set(const char *dir);
+        [ :elm_app_compile_lib_dir_set, [ :string ], :void ],
+        # EAPI void elm_app_compile_data_dir_set(const char *dir);
+        [ :elm_app_compile_data_dir_set, [ :string ], :void ],
+        # EAPI void elm_app_compile_locale_set(const char *dir);
+        [ :elm_app_compile_locale_set, [ :string ], :void ],
+        # EAPI const char *elm_app_prefix_dir_get(void);
+        [ :elm_app_prefix_dir_get, [  ], :string ],
+        # EAPI const char *elm_app_bin_dir_get(void);
+        [ :elm_app_bin_dir_get, [  ], :string ],
+        # EAPI const char *elm_app_lib_dir_get(void);
+        [ :elm_app_lib_dir_get, [  ], :string ],
+        # EAPI const char *elm_app_data_dir_get(void);
+        [ :elm_app_data_dir_get, [  ], :string ],
+        # EAPI const char *elm_app_locale_dir_get(void);
+        [ :elm_app_locale_dir_get, [  ], :string ],
         # EAPI void elm_quicklaunch_mode_set(Eina_Bool ql_on);
         [ :elm_quicklaunch_mode_set, [ :eina_bool ], :void ],
         # EAPI Eina_Bool elm_quicklaunch_mode_get(void);
@@ -2207,6 +2227,12 @@ module Efl
         [ :elm_genlist_item_cursor_engine_only_get, [ :elm_genlist_item_p ], :eina_bool ],
         # EAPI void elm_genlist_realized_items_update(Evas_Object *obj);
         [ :elm_genlist_realized_items_update, [ :evas_object_p ], :void ],
+        # EAPI void elm_genlist_item_mode_set(Elm_Genlist_Item *it, const char *mode_type, Eina_Bool mode_set);
+        [ :elm_genlist_item_mode_set, [ :elm_genlist_item_p, :string, :eina_bool ], :void ],
+        # EAPI const char *elm_genlist_mode_get(const Evas_Object *obj);
+        [ :elm_genlist_mode_get, [ :evas_object_p ], :string ],
+        # EAPI const Elm_Genlist_Item *elm_genlist_mode_item_get(const Evas_Object *obj);
+        [ :elm_genlist_mode_item_get, [ :evas_object_p ], :elm_genlist_item_p ],
         # EAPI Evas_Object *elm_check_add(Evas_Object *parent);
         [ :elm_check_add, [ :evas_object_p ], :evas_object_p ],
         # EAPI void elm_check_label_set(Evas_Object *obj, const char *label);;
@@ -2295,6 +2321,14 @@ module Efl
         [ :elm_slideshow_layout_set, [ :evas_object_p, :string ], :void ],
         # EAPI const Eina_List *elm_slideshow_layouts_get(const Evas_Object *obj);
         [ :elm_slideshow_layouts_get, [ :evas_object_p ], :eina_list_p ],
+        # EAPI void elm_slideshow_cache_before_set(Evas_Object *obj, int count);
+        [ :elm_slideshow_cache_before_set, [ :evas_object_p, :int ], :void ],
+        # EAPI int elm_slideshow_cache_before_get(const Evas_Object *obj);
+        [ :elm_slideshow_cache_before_get, [ :evas_object_p ], :int ],
+        # EAPI void elm_slideshow_cache_after_set(Evas_Object *obj, int count);
+        [ :elm_slideshow_cache_after_set, [ :evas_object_p, :int ], :void ],
+        # EAPI int elm_slideshow_cache_after_get(const Evas_Object *obj);
+        [ :elm_slideshow_cache_after_get, [ :evas_object_p ], :int ],
         # EAPI Evas_Object *elm_fileselector_add(Evas_Object *parent);
         [ :elm_fileselector_add, [ :evas_object_p ], :evas_object_p ],
         # EAPI void elm_fileselector_is_save_set(Evas_Object *obj, Eina_Bool is_save);

data/lib/efl/ffi.rb

@@ -20,12 +20,19 @@ module Efl
         end
         module_function :attach_fcts
         #
+        typedef :pointer, :char_p
+        typedef :pointer, :short_p
         typedef :pointer, :int_p
-        typedef :pointer, :uint_p
-        typedef :pointer, :void_p
-        typedef :pointer, :uchar_p
+        typedef :pointer, :long_p
         typedef :pointer, :float_p
         typedef :pointer, :double_p
+        typedef :pointer, :uchar_p
+        typedef :pointer, :ushort_p
+        typedef :pointer, :uint_p
+        typedef :pointer, :ulong_p
+        typedef :pointer, :ufloat_p
+        typedef :pointer, :udouble_p
+        typedef :pointer, :void_p
         typedef :pointer, :string_array
         typedef :pointer, :string_array_p
         #

data/lib/efl.rb

@@ -3,12 +3,15 @@
 #
 #
 module Efl
-#    autoload :Eina,  './lib/efl/eina.rb'
-    autoload :Eet,   './lib/efl/eet.rb'
-    autoload :Evas,  './lib/efl/evas.rb'
-    autoload :Ecore, './lib/efl/ecore.rb'
-    autoload :Edje,  './lib/efl/edje.rb'
-    autoload :Elm,   './lib/efl/elementary.rb'
+    #
+    VERSION = '0.0.2'
+    #
+    autoload :Eet,          './lib/efl/eet.rb'
+    autoload :Evas,         './lib/efl/evas.rb'
+    autoload :Ecore,        './lib/efl/ecore.rb'
+    autoload :EcoreGetopt,  './lib/efl/ecore_getopt.rb'
+    autoload :Edje,         './lib/efl/edje.rb'
+    autoload :Elm,          './lib/efl/elementary.rb'
 end
 #
 # EOF

data/spec/ecore_getopt_spec.rb

@@ -1,43 +1,276 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
+require 'efl/ecore'
 require 'efl/ecore_getopt'
 #
 describe Efl::EcoreGetopt do
     #
-    it "should run a single iteration of the mainloop" do
+    before(:all) do
         Efl::Ecore.init
-#        puts Efl::EcoreGetopt::EcoreGetopt.methods.sort
-#        eg = Efl::EcoreGetopt::EcoreGetopt.new
-#        val1 = Efl::API::Ecore_Getopt_Value.new
-#        val1[:val] = 
-#        val2 = Efl::API::Ecore_Getopt_Value.new
         #
-        verbosity = 0
-        egd = Efl::API::Ecore_Getopt_Desc.new
-        egd[:shortname] = "V".to_i
-        egd[:longname] = FFI::MemoryPointer.from_string "verbose"
-        egd[:help] = FFI::MemoryPointer.from_string "increase log verbosity"
-        egd[:metavar] = 0
-        egd[:action] = 1 #:ecore_getopt_type_bool
-        egd[:action_param] = 0
-
-        descs = FFI::MemoryPointer.new :pointer, 2, false
-        descs[0] = egd
-        descs[1] = FFI::Pointer::NULL
+        @p = Efl::EcoreGetopt::Parser.new :prog =>"Prog", :usage => "Usage", :version => "0.0.0", :copyright => "less", :license => "MIT", :description => "description", :strict => 1
+        @callback = Proc.new do |parser, desc, string, data, value|
+            parser.address.should eql @p.to_ptr.address
+            string.should eql "my_data"
+            data.read_string.should eql "cb_data"
+            value.read_pointer.read_int.should eql 99
+            true
+        end
         #
-        pointer = FFI::MemoryPointer.new :char, Efl::API::EcoreGetopt.size, false
-        ego = Efl::API::EcoreGetopt.new pointer
-        ego[:prog] = FFI::MemoryPointer.from_string "Prog"
-        ego[:usage] = FFI::MemoryPointer.from_string "Usage"
-        ego[:version] = FFI::MemoryPointer.from_string "0.0.0"
-        ego[:copyright] = FFI::MemoryPointer.from_string "less"
-        ego[:license] = FFI::MemoryPointer.from_string "MIT"
-        ego[:description] = FFI::MemoryPointer.from_string "description"
-        ego[:strict] = 1
-        ego[:descs] = descs
-        args = Efl::EcoreGetopt.parse(ego.to_ptr, FFI::MemoryPointer::NULL, 1, "--help");
+        @values = {
+            :license => FFI::MemoryPointer.new(:uchar),
+            :copyright => FFI::MemoryPointer.new(:uchar),
+            :version => FFI::MemoryPointer.new(:uchar),
+            :help => FFI::MemoryPointer.new(:uchar),
+            :int => FFI::MemoryPointer.new(:int),
+            :double => FFI::MemoryPointer.new(:double),
+            :short => FFI::MemoryPointer.new(:short),
+            :long => FFI::MemoryPointer.new(:long),
+            :const => FFI::MemoryPointer.new(:int),
+            :true => FFI::MemoryPointer.new(:uchar),
+            :false => FFI::MemoryPointer.new(:uchar),
+            :choice => FFI::MemoryPointer.new(:pointer),
+            :count => FFI::MemoryPointer.new(:int),
+            :callback => FFI::MemoryPointer.new(:int),
+        }
+        @meta1 = FFI::MemoryPointer.from_string "My pretty"
+        @meta2 = FFI::MemoryPointer.from_string "My precious"
+        @cb_data = FFI::MemoryPointer.from_string "cb_data"
+        #
+        @p.license 'L', 'license'
+        @p.value :boolp, @values[:license]
+        @p.copyright 'C', 'copyright'
+        @p.value :boolp, @values[:copyright]
+        @p.version 'V', 'version'
+        @p.value :boolp, @values[:version]
+        @p.help 'H', 'help'
+        @p.value :boolp, @values[:help]
+        @p.store_type :int, 'i', 'int', 'store an integer'
+        @p.value :intp, @values[:int]
+        @p.store_meta_type :double, 'd', 'double', 'store an double+meta', @meta1
+        @p.value :doublep, @values[:double]
+        @p.store_def_type :short, 's', 'short', 'store an short+default', 6
+        @p.value :shortp, @values[:short]
+        @p.store_full_type :long, 'l', 'long', 'store a long+full', @meta2, :ecore_getopt_desc_arg_requirement_yes, 666
+        @p.value :longp, @values[:long]
+        @p.store_const 'c', 'const', 'store a constant', 123456
+        @p.value :intp, @values[:const]
+        @p.store_true 't', 'true', 'store true'
+        @p.value :boolp, @values[:false]
+        @p.store_false 'f', 'false', 'store false'
+        @p.value :boolp, @values[:true]
+        @p.choice 'm', 'many', 'store choice', ['ch1','ch2','ch3']
+        @p.value :strp, @values[:choice]
+#        # FIXME: uses listp with Eina_List
+#        @p.append 'a', 'append', 'store append', :ecore_getopt_type_int
+        @p.count 'k', 'count', 'store count'
+        @p.value :intp, @values[:count]
+        @p.callback_args 'b', 'callback', 'callback full', @meta, @callback, @cb_data
+        @p.value :intp, @values[:callback]
+        @p.create
+#        puts @p.debug
+        #
+    end
+    before(:each) do
+        [ :license, :copyright, :version, :help ].each do |sym|
+            @values[sym].write_char 0
+        end
+        @values[:int].write_int 0
+        @values[:double].write_double 3.1415926
+        @values[:short].write_short 9
+        @values[:long].write_long 666
+        @values[:const].write_int -666
+        @values[:true].write_uchar 1
+        @values[:false].write_uchar 0
+        @values[:choice].write_pointer FFI::Pointer::NULL
+        @values[:count].write_int 664
+        @values[:callback].write_int 99
+    end
+    after(:all) do
         Efl::Ecore.shutdown
     end
     #
+    describe "license copyright version help" do
+        it "should handle -L" do
+            [ :license, :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+            args = @p.parse ["My lovely prog name","-L"]
+            @values[:license].read_char.should eql 1
+            [ :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+        end
+        it "should handle --license" do
+            [ :license, :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+            args = @p.parse ["My lovely prog name","--license"]
+            @values[:license].read_char.should eql 1
+            [ :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+        end
+        it "should handle -C" do
+            [ :license, :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+            args = @p.parse ["progname","-C"]
+            @values[:copyright].read_char.should eql 1
+            [ :license, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+        end
+        it "should handle --copyright" do
+            [ :license, :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+            args = @p.parse ["My lovely prog name","--copyright"]
+            @values[:copyright].read_char.should eql 1
+            [ :license, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+        end
+        it "should handle -V" do
+            [ :license, :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+            args = @p.parse ["My lovely prog name","-V"]
+            @values[:version].read_char.should eql 1
+            [ :license, :copyright, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+        end
+        it "should handle --version" do
+            [ :license, :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+            args = @p.parse ["progname","--version"]
+            @values[:version].read_char.should eql 1
+            [ :license, :copyright, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+        end
+        it "should handle -H" do
+            [ :license, :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+            args = @p.parse ["My lovely prog name","-H"]
+            @values[:help].read_char.should eql 1
+            [ :license, :copyright, :version ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+        end
+        it "should handle --help" do
+            [ :license, :copyright, :version, :help ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+            args = @p.parse ["progname","--help"]
+            @values[:help].read_char.should eql 1
+            [ :license, :copyright, :version ].each do |sym|
+                @values[sym].read_char.should eql 0
+            end
+        end
+    end
+    describe "simple short options" do
+        it "should handle -i" do
+            @values[:int].read_int.should eql 0
+            args = @p.parse ["progname","-i 666"]
+            @values[:int].read_int.should eql 666
+        end
+        it "should handle -d" do
+            @values[:double].read_double.should eql 3.1415926
+            args = @p.parse ["progname","-d 6.66"]
+            @values[:double].read_double.should eql 6.66
+        end
+        it "should handle -s" do
+            @values[:short].read_short.should eql 9
+            args = @p.parse ["progname","-s 125"]
+            @values[:short].read_short.should eql 125
+        end
+        it "should handle -l" do
+            @values[:long].read_long.should eql 666
+            args = @p.parse ["progname","-l 69"]
+            @values[:long].read_long.should eql 69
+        end
+        it "should handle -c" do
+            @values[:const].read_int.should eql -666
+            args = @p.parse ["progname","-c"]
+            @values[:const].read_int.should eql 123456
+        end
+        it "should handle -t" do
+            @values[:false].read_uchar.should eql 0
+            args = @p.parse ["progname","-t"]
+            @values[:false].read_uchar.should eql 1
+        end
+        it "should handle -f" do
+            @values[:true].read_uchar.should eql 1
+            args = @p.parse ["progname","-f"]
+            @values[:true].read_uchar.should eql 0
+        end
+        it "should handle -m" do
+            @values[:choice].read_pointer.should eql FFI::Pointer::NULL
+            args = @p.parse ["progname","-mch2"]
+            @values[:choice].read_pointer.read_string.should eql "ch2"
+        end
+        it "should handle -k" do
+            @values[:count].read_int.should eql 664
+            args = @p.parse ["progname","-kk"]
+            @values[:count].read_int.should eql 666
+        end
+        it "should handle -b" do
+            args = @p.parse ["progname","-bmy_data"]
+        end
+    end
+    describe "simple long options" do
+        it "should handle --int" do
+            @values[:int].read_int.should eql 0
+            args = @p.parse ["progname","--int=666"]
+            @values[:int].read_int.should eql 666
+        end
+        it "should handle --double" do
+            @values[:double].read_double.should eql 3.1415926
+            args = @p.parse ["progname","--double=6.66"]
+            @values[:double].read_double.should eql 6.66
+        end
+        it "should handle --short" do
+            @values[:short].read_short.should eql 9
+            args = @p.parse ["progname","--short=125"]
+            @values[:short].read_short.should eql 125
+        end
+        it "should handle --long" do
+            @values[:long].read_long.should eql 666
+            args = @p.parse ["progname","--long=69"]
+            @values[:long].read_long.should eql 69
+        end
+        it "should handle --const" do
+            @values[:const].read_int.should eql -666
+            args = @p.parse ["progname","--const"]
+            @values[:const].read_int.should eql 123456
+        end
+        it "should handle --true" do
+            @values[:false].read_uchar.should eql 0
+            args = @p.parse ["progname","--true"]
+            @values[:false].read_uchar.should eql 1
+        end
+        it "should handle --false" do
+            @values[:true].read_uchar.should eql 1
+            args = @p.parse ["progname","--false"]
+            @values[:true].read_uchar.should eql 0
+        end
+        it "should handle --many" do
+            @values[:choice].read_pointer.should eql FFI::Pointer::NULL
+            args = @p.parse ["progname","--many=ch3"]
+            @values[:choice].read_pointer.read_string.should eql "ch3"
+        end
+        it "should handle --count" do
+            @values[:count].read_int.should eql 664
+            args = @p.parse ["progname","--count","--count"]
+            @values[:count].read_int.should eql 666
+        end
+        it "should handle --callback" do
+            args = @p.parse ["progname","--callback=my_data"]
+        end
+    end
 end

metadata

@@ -2,7 +2,7 @@
 name: ffi-efl
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - "J\xC3\xA9r\xC3\xA9my Zurcher"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-21 00:00:00 +02:00
+date: 2011-04-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,6 +38,8 @@ dependencies:
 description: |-
   ffi-efl is a FFI[https://github.com/ffi/ffi/wiki] binding to Enlightenment Foundation Libraries (eina,eet,evas,ecore,edje...)
   base components of the Enlightenment project. (EFL API[http://www.enlightenment.org/p.php?p=docs&l=en])
+  
+  ffi-efl project is developed on asynk[http://cgit.asynk.ch/cgi-bin/cgit/ffi-efl], github[https://github.com/jeremyz] and gitorious[https://gitorious.org/~jeyzu]
 email: jeremy@asynk.ch
 executables: []