From 19324a30a17c6ea0b3d77d34160841ef90ce3ed1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=A9my=20Zurcher?= Date: Thu, 28 Apr 2011 15:09:41 +0200 Subject: set hierarchy n lib and spec directories --- lib/efl/ecore/ecore_getopt.rb | 276 ++++++++++++++++++++++++++++++++++++++++ lib/efl/ecore_getopt.rb | 276 ---------------------------------------- lib/efl/eina/eina_list.rb | 78 ++++++++++++ lib/efl/eina_list.rb | 78 ------------ spec/ecore/ecore_getopt_spec.rb | 276 ++++++++++++++++++++++++++++++++++++++++ spec/ecore_getopt_spec.rb | 276 ---------------------------------------- spec/eina/eina_list_spec.rb | 100 +++++++++++++++ spec/eina_list_spec.rb | 100 --------------- spec/evas_spec.rb | 2 +- test/test_evas.rb | 8 +- 10 files changed, 736 insertions(+), 734 deletions(-) create mode 100644 lib/efl/ecore/ecore_getopt.rb delete mode 100644 lib/efl/ecore_getopt.rb create mode 100644 lib/efl/eina/eina_list.rb delete mode 100644 lib/efl/eina_list.rb create mode 100644 spec/ecore/ecore_getopt_spec.rb delete mode 100644 spec/ecore_getopt_spec.rb create mode 100644 spec/eina/eina_list_spec.rb delete mode 100644 spec/eina_list_spec.rb diff --git a/lib/efl/ecore/ecore_getopt.rb b/lib/efl/ecore/ecore_getopt.rb new file mode 100644 index 0000000..34c4539 --- /dev/null +++ b/lib/efl/ecore/ecore_getopt.rb @@ -0,0 +1,276 @@ +#! /usr/bin/env ruby +# -*- coding: UTF-8 -*- +# +require 'efl/ffi/ecore_getopt' +# +module Efl + module FFI + # + 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 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, # enum + :callback, EcoreGetoptDescCallback, + :dummy, :pointer, + end + # + class EcoreGetoptDesc < ::FFI::Struct + layout :shortname, :char, + :longname, :pointer, + :help, :pointer, + :metavar, :pointer, + :action, :ecore_getopt_action, # enum + :action_param, EcoreActionParam, + end + # + class EcoreGetopt < ::FFI::Struct + layout :prog, :pointer, + :usage, :pointer, + :version, :pointer, + :copyright, :pointer, + :license, :pointer, + :description, :pointer, + :strict, :char +# :descs, :pointer, # NULL terminated EcoreGetopt_Desc[] + + def desc_ptr idx + EcoreGetoptDesc.new to_ptr+Efl::FFI::EcoreGetopt.size+(idx*Efl::FFI::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::FFI::EcoreGetopt.new ::FFI::MemoryPointer.new (Efl::FFI::EcoreGetopt.size+Efl::FFI::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::FFI::EcoreGetoptValue, @values.length, false + @values.each_with_index do |v,i| + Efl::FFI::EcoreGetoptValue.new(@values_p+(i*Efl::FFI::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 diff --git a/lib/efl/ecore_getopt.rb b/lib/efl/ecore_getopt.rb deleted file mode 100644 index 34c4539..0000000 --- a/lib/efl/ecore_getopt.rb +++ /dev/null @@ -1,276 +0,0 @@ -#! /usr/bin/env ruby -# -*- coding: UTF-8 -*- -# -require 'efl/ffi/ecore_getopt' -# -module Efl - module FFI - # - 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 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, # enum - :callback, EcoreGetoptDescCallback, - :dummy, :pointer, - end - # - class EcoreGetoptDesc < ::FFI::Struct - layout :shortname, :char, - :longname, :pointer, - :help, :pointer, - :metavar, :pointer, - :action, :ecore_getopt_action, # enum - :action_param, EcoreActionParam, - end - # - class EcoreGetopt < ::FFI::Struct - layout :prog, :pointer, - :usage, :pointer, - :version, :pointer, - :copyright, :pointer, - :license, :pointer, - :description, :pointer, - :strict, :char -# :descs, :pointer, # NULL terminated EcoreGetopt_Desc[] - - def desc_ptr idx - EcoreGetoptDesc.new to_ptr+Efl::FFI::EcoreGetopt.size+(idx*Efl::FFI::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::FFI::EcoreGetopt.new ::FFI::MemoryPointer.new (Efl::FFI::EcoreGetopt.size+Efl::FFI::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::FFI::EcoreGetoptValue, @values.length, false - @values.each_with_index do |v,i| - Efl::FFI::EcoreGetoptValue.new(@values_p+(i*Efl::FFI::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 diff --git a/lib/efl/eina/eina_list.rb b/lib/efl/eina/eina_list.rb new file mode 100644 index 0000000..823fe72 --- /dev/null +++ b/lib/efl/eina/eina_list.rb @@ -0,0 +1,78 @@ +#! /usr/bin/env ruby +# -*- coding: UTF-8 -*- +# +require 'efl/eina' +require 'efl/ffi/eina_list' +# +class Array + def self.from_eina_list o + if o.is_a? Efl::Eina::EinaList + o.to_ary + elsif o.is_a? ::FFI::Pointer + Efl::Eina::EinaList.new(o).to_ary + else + raise ArgumentError.new " wrong argument #{o.class.name}" + end + end +end +module Efl + module FFI + class EinaList < ::FFI::Struct + layout :data, :pointer, + :next, :pointer, + :prev, :pointer, + :accounting, :pointer, + :magic, :uint, + end + end + module Eina + # + class EinaList + include Efl::Helper + include Enumerable + @func_prefixes = [ 'eina_list_' ].freeze + def initialize o=nil + @ptr = ( + case o + when ::FFI::Pointer + o + when NilClass + ::FFI::Pointer::NULL + when self.class + o.ptr + when Array + o.inject(::FFI::Pointer::NULL) { |p,e| Efl::FFI::eina_list_append p, e } + else + raise ArgumentError.new "#{ptr.class} valid argument" + end + ) + end + def free + return if @ptr==::FFI::Pointer::NULL + @ptr = Efl::FFI.eina_list_free @ptr + end + def each + p = @ptr + while p!=::FFI::Pointer::NULL + l = Efl::FFI::EinaList.new p + yield l[:data] + p = l[:next] + end + end + def to_ary + inject([]) { |s,e| s<"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 + # + @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 diff --git a/spec/ecore_getopt_spec.rb b/spec/ecore_getopt_spec.rb deleted file mode 100644 index 6f5c7f0..0000000 --- a/spec/ecore_getopt_spec.rb +++ /dev/null @@ -1,276 +0,0 @@ -#! /usr/bin/env ruby -# -*- coding: UTF-8 -*- -# -require 'efl/ecore' -require 'efl/ecore_getopt' -# -describe Efl::EcoreGetopt do - # - before(:all) do - Efl::Ecore.init - # - @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 - # - @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 diff --git a/spec/eina/eina_list_spec.rb b/spec/eina/eina_list_spec.rb new file mode 100644 index 0000000..2522256 --- /dev/null +++ b/spec/eina/eina_list_spec.rb @@ -0,0 +1,100 @@ +#! /usr/bin/env ruby +# -*- coding: UTF-8 -*- +# +require 'efl/eina/eina_list' +# +describe Efl::Eina::EinaList do + # + before(:all) { + EinaList = Efl::Eina::EinaList + Efl::Eina.init.should eql 1 + } + after(:all) { + Efl::Eina.shutdown.should eql 0 + } + # + it "should append prepend and fetch" do + l = EinaList.new + d1 = ::FFI::MemoryPointer.from_string "D0" + d2 = ::FFI::MemoryPointer.from_string "D1" + d3 = ::FFI::MemoryPointer.from_string "D2" + d4 = ::FFI::MemoryPointer.from_string "D3" + l.append d3 + l.prepend d2 + l << d4 + l.unshift d1 + 0.upto 3 do |i| + l.nth(i).read_string.should eql "D#{i}" + end + l.each { |p| p.read_string.empty?.should be_false } + l.free + end + # + it "should be able to convert into ruby Array from NULL pointer" do + ary = Array.from_eina_list ::FFI::Pointer::NULL + ary.empty?.should be_true + ary.is_a?(Array).should be_true + end + # + it "should be able to convert into ruby Array from empty EinaList" do + ary = Array.from_eina_list EinaList.new + ary.empty?.should be_true + ary.is_a?(Array).should be_true + end + # + it "should be able to convert into ruby Array from empty EinaList pointer" do + ary = Array.from_eina_list EinaList.new.ptr + ary.empty?.should be_true + ary.is_a?(Array).should be_true + end + # + it "should be able to convert into ruby Array from non empty EinaList" do + l = EinaList.new + d1 = ::FFI::MemoryPointer.from_string "D0" + d2 = ::FFI::MemoryPointer.from_string "D1" + d3 = ::FFI::MemoryPointer.from_string "D2" + d4 = ::FFI::MemoryPointer.from_string "D3" + l.append d3 + l.prepend d2 + l << d4 + l.unshift d1 + ary = Array.from_eina_list l + ary.length.should eql 4 + 0.upto 3 do |i| + ary[i].read_string.should eql "D#{i}" + end + l.free + end + # + it "should be able to convert into ruby Array from non empty EinaList pointer" do + l = EinaList.new + d1 = ::FFI::MemoryPointer.from_string "D0" + d2 = ::FFI::MemoryPointer.from_string "D1" + d3 = ::FFI::MemoryPointer.from_string "D2" + d4 = ::FFI::MemoryPointer.from_string "D3" + l.append d3 + l.prepend d2 + l << d4 + l.unshift d1 + ary = Array.from_eina_list l.ptr + ary.length.should eql 4 + 0.upto 3 do |i| + ary[i].read_string.should eql "D#{i}" + end + l.free + end + # + it "should be able to build from ruby Array" do + a = [] + a << ::FFI::MemoryPointer.from_string("D0") + a << ::FFI::MemoryPointer.from_string("D1") + a << ::FFI::MemoryPointer.from_string("D2") + a << ::FFI::MemoryPointer.from_string("D3") + l = EinaList.new a + 0.upto 3 do |i| + l.nth(i).read_string.should eql "D#{i}" + end + l.free + end + # +end diff --git a/spec/eina_list_spec.rb b/spec/eina_list_spec.rb deleted file mode 100644 index 5dba1de..0000000 --- a/spec/eina_list_spec.rb +++ /dev/null @@ -1,100 +0,0 @@ -#! /usr/bin/env ruby -# -*- coding: UTF-8 -*- -# -require 'efl/eina_list' -# -describe Efl::Eina::EinaList do - # - before(:all) { - EinaList = Efl::Eina::EinaList - Efl::Eina.init.should eql 1 - } - after(:all) { - Efl::Eina.shutdown.should eql 0 - } - # - it "should append prepend and fetch" do - l = EinaList.new - d1 = ::FFI::MemoryPointer.from_string "D0" - d2 = ::FFI::MemoryPointer.from_string "D1" - d3 = ::FFI::MemoryPointer.from_string "D2" - d4 = ::FFI::MemoryPointer.from_string "D3" - l.append d3 - l.prepend d2 - l << d4 - l.unshift d1 - 0.upto 3 do |i| - l.nth(i).read_string.should eql "D#{i}" - end - l.each { |p| p.read_string.empty?.should be_false } - l.free - end - # - it "should be able to convert into ruby Array from NULL pointer" do - ary = Array.from_eina_list ::FFI::Pointer::NULL - ary.empty?.should be_true - ary.is_a?(Array).should be_true - end - # - it "should be able to convert into ruby Array from empty EinaList" do - ary = Array.from_eina_list EinaList.new - ary.empty?.should be_true - ary.is_a?(Array).should be_true - end - # - it "should be able to convert into ruby Array from empty EinaList pointer" do - ary = Array.from_eina_list EinaList.new.ptr - ary.empty?.should be_true - ary.is_a?(Array).should be_true - end - # - it "should be able to convert into ruby Array from non empty EinaList" do - l = EinaList.new - d1 = ::FFI::MemoryPointer.from_string "D0" - d2 = ::FFI::MemoryPointer.from_string "D1" - d3 = ::FFI::MemoryPointer.from_string "D2" - d4 = ::FFI::MemoryPointer.from_string "D3" - l.append d3 - l.prepend d2 - l << d4 - l.unshift d1 - ary = Array.from_eina_list l - ary.length.should eql 4 - 0.upto 3 do |i| - ary[i].read_string.should eql "D#{i}" - end - l.free - end - # - it "should be able to convert into ruby Array from non empty EinaList pointer" do - l = EinaList.new - d1 = ::FFI::MemoryPointer.from_string "D0" - d2 = ::FFI::MemoryPointer.from_string "D1" - d3 = ::FFI::MemoryPointer.from_string "D2" - d4 = ::FFI::MemoryPointer.from_string "D3" - l.append d3 - l.prepend d2 - l << d4 - l.unshift d1 - ary = Array.from_eina_list l.ptr - ary.length.should eql 4 - 0.upto 3 do |i| - ary[i].read_string.should eql "D#{i}" - end - l.free - end - # - it "should be able to build from ruby Array" do - a = [] - a << ::FFI::MemoryPointer.from_string("D0") - a << ::FFI::MemoryPointer.from_string("D1") - a << ::FFI::MemoryPointer.from_string("D2") - a << ::FFI::MemoryPointer.from_string("D3") - l = EinaList.new a - 0.upto 3 do |i| - l.nth(i).read_string.should eql "D#{i}" - end - l.free - end - # -end diff --git a/spec/evas_spec.rb b/spec/evas_spec.rb index 6ef3cdb..03a9e61 100644 --- a/spec/evas_spec.rb +++ b/spec/evas_spec.rb @@ -256,7 +256,7 @@ describe Efl::Evas do a = ['/tmp1','/tmp2'] @e.evas_font_path_append a[1] @e.evas_font_path_prepend a[0] - require 'efl/eina_list' + require 'efl/eina/eina_list' Efl::Eina::EinaList.new(@e.evas_font_path_list).each_with_index do |p,i| p.read_string.should eql a[i] end diff --git a/test/test_evas.rb b/test/test_evas.rb index 516f35e..b393e82 100644 --- a/test/test_evas.rb +++ b/test/test_evas.rb @@ -2,7 +2,6 @@ # -*- coding: UTF-8 -*- # require 'efl/evas' -require 'efl/eina_list' # include Efl # @@ -32,13 +31,16 @@ def destroy_canvas c, pixels end # def draw_scene c - updates = Eina::EinaList.new c.render_updates + updates = c.render_updates + Evas::render_updates_free updates # FIXME needs EinaRectangle +# require 'efl/eina/eina_list' +# updates = Eina::EinaList.new c.render_updates # updates.each do |u| # r = Eina::EinaRectangle.new u # puts "UPDATED REGION: pos: #{r[:x]}, #{r[:y]} size: #{r[:w]}x#{r[:h]}" # end - Evas::render_updates_free updates.ptr +# Evas::render_updates_free updates.ptr end # def save_scene canvas, dest -- cgit v1.1-2-g2b99