vigilem-support 0.0.9

data/lib/vigilem/ffi/utils.rb

@@ -0,0 +1,240 @@
+module Vigilem
+module FFI
+  # utilities for FFI
+  module Utils
+  
+    # converts struct to a Hash
+    # @param  [#members, #values] struct
+    # @param  [Integer || NilClass] limit
+    # @return [Hash]
+    def struct_to_h(struct, limit=nil)
+      Utils._struct_to_h(struct, limit)
+    end
+    
+    # gets the FFI::Type::Builtin a type
+    # @param  [Symbol || ::FFI::Type::Builtin] type
+    # @return [Symbol] the builtin type name
+    def get_builtin_type_name(type)
+      builtin = ::FFI.find_type(type) || type
+      raise TypeError, "unable to resolve type '#{type}'" unless builtin.is_a? ::FFI::Type::Builtin
+      (nt = ::FFI::NativeType).constants.find {|const| nt.const_get(const) == builtin }.downcase
+    end
+    
+    alias_method :get_native_type_name, :get_builtin_type_name
+    
+    # @todo this is a problem, like XOpenDisplay, the ptr returned
+    # maybe huge, but that;s not the size of the object in the pointer
+    # @param  [Pointer] pointer
+    # @return [Integer]
+    def ptr_capacity(pointer)
+      pointer.size/pointer.type_size
+    end
+    
+    # 
+    # @param  [#type] obj
+    # @return [TrueClass || FalseClass]
+    def is_a_struct?(obj)
+      [::FFI::Struct, ::FFI::StructByValue, ::FFI::StructByReference].any? {|struct_klass| obj.is_a?(struct_klass) or obj.respond(:type).is_a? struct_klass }
+    end
+    
+    # 
+    # @param  [::FFI::Pointer] pointer
+    # @param  [Symbol || ::FFI::Type::Builtin] type
+    # @param  value
+    # @return [::FFI::Pointer] pointer
+    def write_typedef(pointer, type, value)
+      pointer.__send__(:"write_#{get_builtin_type_name(type) }", value)
+    end
+    
+    # 
+    # @param  [::FFI::Pointer] pointer
+    # @param  [Class] struct_class
+    # @param  [Integer] num
+    # @return [Array]
+    def read_array_of_structs(pointer, struct_class, num=nil)
+      1.upto(num||pointer.type_size/struct_class.size).map { struct_class.new(pointer) }
+    end
+    
+    # 
+    # possible refactor `pointer.write_array_of_type(type, :"write_array_of_#{get_builtin_type_name(type) }", [*value])`
+    # @param  [::FFI::Pointer] pointer
+    # @param  [Symbol || ::FFI::Type::Builtin] type
+    # @param  [Array] value
+    # @return [::FFI::Pointer] pointer
+    def write_array_typedef(pointer, type, value)
+      pointer.__send__(:"write_array_of_#{get_builtin_type_name(type) }", [*value])
+    end
+    
+    # 
+    # @param  [::FFI::Pointer] pointer
+    # @param  [Symbol || ::FFI::Type::Builtin] type
+    # @return value from pointer
+    def read_typedef(pointer, type)
+      pointer.__send__(:"read_#{get_builtin_type_name(type) }")
+    end
+    
+    # 
+    # @param  [::FFI::Pointer] pointer
+    # @param  [Symbol || ::FFI::Type::Builtin] type
+    # @param  [Integer] num
+    # @return [Array]
+    def read_array_typedef(pointer, type, num=1)
+      pointer.__send__(:"read_array_of_#{get_builtin_type_name(type) }", num)
+    end
+    
+    # 
+    # @param  [::FFI::Pointer] pointer
+    # @param  [String] type
+    # @param  value
+    # @param  [Integer] offset
+    # @return [::FFI::Pointer] pointer
+    def put_typedef(pointer, type, value, offset=0)
+      pointer.__send__(:"put_#{get_builtin_type_name(type) }", offset, value)
+    end
+    
+    # 
+    # @param  [::FFI::Pointer] pointer
+    # @param  [String] type
+    # @param  [Array] value
+    # @param  [Integer] offset
+    # @return pointer
+    def put_array_typedef(pointer, type, value, offset=0)
+      pointer.__send__(:"put_array_of_#{get_builtin_type_name(type) }", offset, [*value])
+    end
+    
+    # 
+    # @param  [::FFI::Pointer] pointer
+    # @param  [Symbol || ::FFI::Type::Builtin] type
+    # @param  value
+    # @return [::FFI::Pointer] pointer
+    def replace_typedef(pointer, type, value)
+      put_typedef(pointer, type, value)
+    end
+    
+    # 
+    # @param  [::FFI::Pointer] pointer
+    # @param  [Symbol || ::FFI::Type::Builtin] type
+    # @param  value
+    # @return pointer
+    def add_int_typedef(pointer, type, value)
+      replace_typedef(pointer, type, (value + self.read_typedef(pointer, type)))
+    end
+    
+    # @todo needed?
+    # @param  struct
+    # @param  [Proc] block
+    # @return the type of the fields or the result of the block
+    def types(struct, &block)
+      struct = Support::Utils.get_class(struct) unless struct.respond_to? :layout
+      struct.layout.fields.map do |field|
+        if block
+          yield field
+        else
+          field.type
+        end
+      end
+    end
+    
+    # @todo   refactor me
+    # assigns values to the struct
+    # @param  [::FFI::Struct] struct
+    # @param  [Array || Hash] vals
+    # @return struct
+    def struct_bulk_assign(struct, vals)
+      if vals.is_a? Hash
+        self.struct_bulk_assign_hash(struct, vals)
+      else
+        types(struct) do |fld|
+          _struct_bulk_assign(struct, fld, fld.name, vals)
+        end
+      end
+      struct
+    end
+    
+    alias_method :from_array, :struct_bulk_assign
+    
+    # 
+    # @param  [::FFI::Struct] struct
+    # @param  [Hash] hsh
+    # @return struct
+    def struct_bulk_assign_hash(struct, hsh)
+      hsh.each do |key, value|
+        the_field = struct.layout.fields.find {|fld| fld.name == key }
+        raise "on #{struct.class} attr #{key} not found in #{struct.layout.fields.map(&:name)}" unless the_field
+        _struct_bulk_assign(struct, the_field, key, [hsh[key]])
+      end
+      struct
+    end
+    
+    alias_method :from_hash, :struct_bulk_assign_hash
+    
+    # @todo   unions don't need know the member name, the space taken up is the same
+    # @todo   refactor me
+    # @param  [::FFI::Struct] struct
+    # @param  [::FFI::StructLayout::Field] field
+    # @param  [Symbol] attr_name
+    # @param  [Array || Hash] vals
+    # @return 
+    def _struct_bulk_assign(struct, field, attr_name, vals)
+      # struct.type.struct_class, why use field?
+      #if is_a_struct?(struct.type)
+      if is_a_struct?(field)
+        if is_a_struct?(frst = vals.first) or frst.is_a? ::FFI::Union
+          struct[attr_name] = vals.shift
+        else
+          ptr_offset = struct.offsets.assoc(attr_name).last
+          struct_obj = if (struct_klass = field.type.struct_class) <= VFFIStruct
+                        struct_klass.new(ptr_offset)
+                      else
+                        struct_klass.new
+                      end
+          struct[attr_name] = struct_bulk_assign(struct_obj, vals.shift)
+        end
+      else
+        raise ArgumentError, "Arity mismatch: complex type `#{struct.inspect}' does not match argument `#{vals.inspect}'" unless vals.respond_to? :shift
+        struct[attr_name] = vals.shift
+      end
+    end
+    
+    # 
+    # @param  [Class] struct_class
+    # @param  [String] str_bytes
+    # @return [Array<FFI::Struct>] 
+    def bytes_to_structs(struct_class, str_bytes)
+      ary_of_type(struct_class, struct_class.size, ::FFI::MemoryPointer.from_string(str_bytes))
+    end
+    
+    # converts a pointer to an ary of ary_type
+    # @param  type
+    # @param  [Fixnum] type_size, this is given because a ::from_string has type_size of 1
+    # @param  [FFI::Pointer] pointer
+    # @return [Array] of type
+    def ary_of_type(type, type_size, pointer, len=-1)
+      if type.is_a? Class and type <= ::FFI::Struct
+        # @todo slice is supposed to return new a pointer, when atype.type_size == pointer.type_size does this return the old pointer?
+        0.upto((pointer.size/type_size) - 1).map {|n| type.new(pointer.slice(n * type_size, type_size).dup) }
+      else
+        ::Vigilem::FFI::Utils.read_array_typedef(pointer, type, ptr_capacity(pointer))
+      end
+    end
+    
+    extend self
+    
+   module_function
+    # 
+    # @param  [#members, #values] struct
+    # @param  [Integer || NilClass] limit
+    # @return [Hash || Struct]
+    def _struct_to_h(struct, current=1, limit=nil)
+      if limit.nil? or limit <= current
+        Hash[struct.members.zip(struct.values.map {|val| is_a_struct?(val) ? _struct_to_h(val) : val } )]
+      else
+        struct
+      end
+    end
+    
+  end
+end
+end
+
+require 'vigilem/ffi/utils/struct'

data/lib/vigilem/ffi/utils/struct.rb

@@ -0,0 +1,93 @@
+module Vigilem
+module FFI
+module Utils
+  # Utils specfic to Vigilem::FFI::Struct
+  module Struct
+    
+    extend ActiveSupport::Concern
+    
+    # methods to be ::extend'd
+    module ClassMethods
+      
+      # converts the members of the struct to methods
+      # @return 
+      def members_to_methods
+        members.each do |member_name| 
+          define_method(member_name, &lambda { self[member_name] })
+          define_method(:"#{member_name}=", &lambda {|val| self[member_name] = val })
+        end
+      end
+      
+      # @see    FFI::Struct::layout
+      # @param  [Array] args
+      # @return 
+      def layout_with_methods(*args)
+        raise SizeError, "Odd number of aguments:`#{args}'" if args.size.odd?
+        aliases = []
+        layout *(args.map do |names_or_value| 
+          if names_or_value.is_a? Array
+            aliases << names_or_value
+            names_or_value.first
+          else
+            names_or_value
+          end
+        end)
+        ret = members_to_methods
+        aliases.each {|name_group| name_group.each {|alias_name| alias_method(alias_name, name_group[0]) } }
+        ret
+      end
+      
+      # @todo   update the layout without overwriting, when called after layout
+      # acts "like" the union keyword
+      # @return 
+      def union(name, *args, &block)
+                # can't be Ruby Struct, because of layout_with_methods
+        unyun = Class.new(::FFI::Union) do
+          include Vigilem::FFI::Utils::Struct
+          layout_with_methods *(args.empty? ? block.call : args)
+        end
+        const_set(:"#{name[0].upcase}#{name[1..-1]}", unyun)
+        [name.to_sym, unyun]
+      end
+      
+      # 
+      # @param  [String] str_bytes
+      # @return [Array<VFFIStruct>]
+      def from_string(str_bytes)
+        Utils.bytes_to_structs(self, str_bytes)
+      end
+    end
+      
+    # @see    FFI::Utils#bulk_assign
+    # @param  [Hash || Array] vals
+    # @return 
+    def bulk_assign(vals)
+      ::Vigilem::FFI::Utils.struct_bulk_assign(self, vals)
+    end
+    
+    # 
+    # @param  [Symbol] attr_name
+    # @return 
+    def type_of(attr_name)
+      field = self.class.layout.fields.find {|fld| fld.name == attr_name }
+      raise "no field by the name #{attr_name} for #{self}" unless field
+      field.type
+    end
+    
+    # 
+    # @param  [Proc] block
+    # @return 
+    def types(&block)
+      ::Vigilem::FFI::Utils.types(self, &block)
+    end
+    
+    # 
+    # @see    Vigilem::FFI::Utils.struct_to_h
+    # @return [Hash]
+    def to_h
+      ::Vigilem::FFI::Utils.struct_to_h(self)
+    end
+  end
+end
+end
+end

data/lib/vigilem/support.rb

@@ -0,0 +1,31 @@
+require 'vigilem/support/version'
+
+require 'active_support/concern'
+
+require 'vigilem/support/utils'
+
+require 'vigilem/support/core_ext'
+require 'vigilem/support/system'
+
+require 'vigilem/ffi'
+
+require 'vigilem/support/metadata'
+
+module Vigilem
+# 
+module Support
+  
+  # autoload is deprecated
+  # @param  [Symbol]
+  # @return 
+  def self.const_missing(const)
+    if [:System, :TransmutableHash, :LazySimpleDelegator, :MaxSizeError, :SizeError, :Sys, :KeyMap].include? const
+      require "vigilem/support/#{const.to_s.snakecase}"
+      const_get(const)
+    else
+      super(const)
+    end
+  end
+  
+end
+end

data/lib/vigilem/support/core_ext.rb

@@ -0,0 +1,13 @@
+require 'vigilem/support/core_ext/enumerable'
+
+require 'facets/kernel/respond'
+
+if defined?(Delegator) and not Delegator.method_defined?(:respond)
+  load Delegator.instance_method(:__getobj__).source_location.first
+end
+
+require 'facets/hash/autonew' # @todo in use?
+require 'facets/string/snakecase'
+require 'facets/string/titlecase'
+
+require 'facets/enumerable/every'

data/lib/vigilem/support/core_ext/debug_puts.rb

@@ -0,0 +1,5 @@
+module Kernel
+  def debug_puts(*args)
+    puts "#{caller.first.rpartition(%r{/}).last}>#{args.first}", args[1..-1]
+  end
+end

data/lib/vigilem/support/core_ext/enumerable.rb

@@ -0,0 +1,25 @@
+require 'facets/enumerable/find_yield'
+
+# 
+# 
+module Enumerable
+  
+  # gets all execpt the parameters listed
+  # on a hash this is a key
+  # @see #reject
+  # @param  [Array] objs
+  # @return [Enumerable]
+  def except(*objs)
+    reject {|item| objs.include?(item) }
+  end
+  
+  # @todo move to Array?
+  # gets all except items listed at specific indexes
+  # @param  [Array<Integer>] indexes
+  # @return [Enumerable]
+  def except_at(*indexes)
+    reject.with_index {|item, idx| indexes.include?(idx) }
+  end
+  
+  alias_method :find_result, :find_yield
+end

data/lib/vigilem/support/key_map.rb

@@ -0,0 +1,323 @@
+require 'vigilem/support/transmutable_hash'
+
+require 'vigilem/support/utils'
+
+require 'vigilem/support/metadata'
+
+require 'vigilem/support/key_map_info'
+
+module Vigilem
+module Support
+  # 
+  # 
+  # a TransmutableHash representing a keyboard map
+  # keymap = system, KeyMap ruby object
+  # @see http://kbd-project.org/manpages/man5/keymaps.5.html
+  # @see man dumpkeys -f
+  # @todo to_file
+  # @todo win32
+  # @todo document the expected columns
+  # @todo default for each key default_proc point
+  # @todo move to a parser object
+  # @todo update to fit Win32#LoadKeyboardLayout
+  # @todo eject os specific, and make them loadable/injectable
+  # @todo some methods return Hash instead of KeyMap
+  class KeyMap < TransmutableHash
+    
+    # starts with keycode | spaces or '='
+    KEYCODE_SPLIT_REGEX = /(keycode\s+\d{1,3})|\s(=)?\s?/
+    
+    include Metadata
+    
+    attr_writer :mod_weights, :short_inspect, :info
+    attr_accessor :charset
+    
+    # 
+    # @param  [Hash] init_hash_or_default the initial hash or default value
+    # @param  default_value, the default value if not given in init_hash_or_default
+    def initialize(init_hash_or_default={}, default_value=nil)
+      if init_hash_or_default.is_a? Hash
+        super(init_hash_or_default, default_value)
+      else
+        super({}, init_hash_or_default)
+      end
+    end
+    
+    # 
+    # @return [KeyMap]
+    def each(&block)
+      self.class[super(&block)]
+    end
+    
+    # 
+    # @return [KeyMap]
+    def select(&block)
+      self.class[super(&block)]
+    end
+    
+    # @todo   overwrite from info or move to info
+    # @return [Hash]
+    def mod_weights
+      if self.class.mod_weights != @mod_weights
+        @mod_weights = self.class.mod_weights.merge(@mod_weights)
+      else
+        @mod_weights
+      end
+    end
+    
+    # I.E. keymaps 0-2,4-5,8,12 
+    # @return [Array<Range || Integer>] the parsed keymap spec
+    def spec
+      @spec ||= []
+    end
+    
+    # 
+    # @param  [String || NilClass] str, defaults to nil
+    # @return [NilClass || KeyMapInfo] 
+    def info(str=nil)
+      if str
+        @info = KeyMapInfo.load_string(str)
+      else
+        @info
+      end
+    end
+    
+    # gets the left_side from the right_side_values
+    # @param  right_side_values
+    # @return right_side_values or w/e the left_side it is mapped to
+    def left_side(right_side_values=nil)
+      if right_side_values
+        if inverted? 
+          self[right_side_values]
+        else
+          invert[right_side_values]
+        end
+      else
+        inverted? ? self.values : self.keys
+      end
+    end
+    
+    # 
+    # @param  [Array<Symbol>] method_names
+    # @return [Proc]
+    def left_side_aliases(*method_names)
+      method_names.each do |method_name|
+        define_singleton_method(method_name) {|right_side_value=nil| self.left_side(right_side_value) }
+      end
+    end
+    
+    alias_method :left_side_alias, :left_side_aliases
+    
+    # keycode keynumber = keysym keysym keysym...
+    # modsym modsym modsym keycode keynumber = keysym keysym keysym...
+    # get the right_side from the left_side_values
+    # @param  left_side_values
+    # @return 
+    def right_side(left_side_values=nil)
+      if left_side_values
+        if inverted? 
+          invert[left_side_values]
+        else
+          self[left_side_values]
+        end
+      else
+        inverted? ? self.keys : self.values
+      end
+    end
+    
+    # essentially an alias_method
+    # @param  [Symbol] method_names
+    # @return [Proc]
+    def right_side_aliases(*method_names)
+      method_names.each do |method_name|
+        define_singleton_method(method_name) {|left_side_values=nil| self.right_side(left_side_values) }
+      end
+    end
+    
+    alias_method :right_side_alias, :right_side_aliases
+    
+    # @see    TransmutableHash#invert
+    # @return [KeyMap]
+    def invert
+      self.class[super]
+    end
+    
+    #=== @todo move to parser
+    
+    # takes keycode expresssion blocks and adds them to this KeyMap
+    # @param  [Array<String>] expresssion_blocks array of ["keycode = vvv", "keycode = vvvv", "alt keycode = vvvv"]
+    # @return [nil] 
+    def parse_keymap_expressions(*expresssion_blocks)
+      expresssion_blocks.each {|expr_block| parse_expression_block(expr_block) }.compact
+      nil
+    end
+    
+    # @todo   cleanup
+    # takes a keycode expresssion block and adds them to this KeyMap
+    # dumpkeys -f || cached.kmap.gz
+    # @param  [String] expr_blk a String block from keycode to next keycode
+    # @return [NilCLass]
+    def parse_expression_block(expr_blk)
+      expr_blk.split("\n").map do |line|
+        # skip comments
+        unless line.split('#').first.to_s.empty?
+          if line =~ /^keymaps/
+            parse_keymap_spec(line)
+          else
+            line_ary = line.to_s.split(KEYCODE_SPLIT_REGEX).reject(&:empty?)
+            if eq_index = line_ary.index('=')
+              # ["keycode   2",  "=", "U+0031", "U+0021", "U+0031", "U+0031", "VoidSymbol",... ]
+              _parse_sides(*Utils.split_on(line_ary, eq_index))
+            end #if eq_index
+          end #if line
+        end #unless
+      end #expr
+      nil
+    end
+    
+    # 
+    # @param  [String] left_side
+    # @param  [String] right_side
+    # @return 
+    def _parse_sides(left_side, right_side)
+      #["alt", "keycode   2"]
+      keycode = left_side.pop.gsub(/\s+/, '')
+      if left_side.size > 0
+        self[Utils.unwrap_ary([*left_side, keycode].flatten)] = Utils.unwrap_ary(right_side)
+      else
+        build_hash_from_full_table_line(right_side, keycode)
+      end
+    end
+    
+    private :_parse_sides
+    
+    # takes a list of keysyms configures thier modifiers and adds them to this keymap
+    # @see    ::build_hash_from_full_table_line
+    # @param  [Array<String>] right_side an array of keysyms, in a full table this is the right side
+    # @param  [String] keycode the keycode in that is being mapped
+    # @return [TransmutableHash] the results of 
+    def build_hash_from_full_table_line(right_side, keycode)
+      raise 'keymap specification missing' if spec.empty?
+      merge!(self.class.build_hash_from_full_table_line(right_side, keycode, spec))
+    end
+    
+    # converts keymap spec to ranged array
+    # @param  [String] expr 'keymaps 0-127' or 'keymaps ?-?,?'
+    # @return [Array<Range|| Integer>] the parsed keymap spec that
+    def parse_keymap_spec(expr)
+      @spec = expr.split(/\s|,/)[1..-1].map {|str| str =~ /\-/ ? Range.new(*str.split('-').map(&:to_i)) : str.to_i }
+    end
+    
+    # tests whether or not num is in the spec
+    # @param  [Numeric] num is this number within 'keymaps 0-127' or 'keymaps ?-?,?'
+    # @return [TrueClass || FalseClass]
+    def in_spec?(num)
+      Utils.in_ranged_array?(spec, num)
+    end
+    
+    class << self
+      
+      # weights of the modifiers set by `keymaps`
+      def mod_weights 
+        @mod_weights ||= { 'shift' => 1, 
+          'altgr' => 2, 'control' => 4, 
+          'alt' => 8, 'shiftl' => 16, 
+          'shiftr' => 32, 'ctrll' => 64, 
+          'ctrlr' => 128, 'capsshift' => 256 }
+      end
+      
+      alias_method :columns, :mod_weights
+      
+      # converts a a keymap file to a ruby object
+      # @todo   change to stream reading
+      # @param  [String] path the path of the File
+      # @return [KeyMap] the String as a Ruby object
+      def load_file(path)
+        load_string(File.binread(path))
+      end
+      
+      # loads a keymap string and converts it to a Ruby object
+      # @param  [String] str string to convert to KeyMap
+      # @return [KeyMap] the String as a Ruby object
+      def load_string(str, str_info=nil)
+        exprs = str.split(/^keycode/)
+        inst = self.new()
+        inst.parse_keymap_expressions(exprs[0], *exprs[1..-1].map {|exp| "keycode#{exp}" })
+        inst.info(KeyMapInfo.load_string(str_info)) if str_info
+        inst
+      end
+      
+      # takes a list of keysyms and converts it to a TransmutableHash
+      # @todo   name change?
+      # @param  [Array<String>] right_side an array of keysyms, in a full table this is the right side
+      # @param  [String] keycode the keycode in that is being mapped
+      # @param  [Array<Numeric||Range>] columns
+      # @return [TransmutableHash] of the keycode combinations mapped to keysyms
+      def build_hash_from_full_table_line(right_side, keycode, columns=[0..127])
+        raise 'cannot build expresssions for full table with no columns' if columns.empty?
+        sze = right_side.size
+        right_side.each_with_object(TransmutableHash.new).with_index do |(keysyms, hsh), idx|
+          if Utils.in_ranged_array?(columns, idx) 
+            # not sure why a 'b' is in the mapping when that's not an available range
+            (flat = [keysyms].flatten).last.gsub!(/^\+?0x0b/, '0x00') 
+            hsh[Utils.unwrap_ary([mod_combin(idx), keycode].flatten)] = Utils.unwrap_ary(flat)
+          end
+        end
+      end
+      
+      # finds the Combination (without repeats) of modifiers that fit into n
+      # @param  [Integer] n the number to fit the modifiers into
+      # @return [Array<String>] 
+      def modifier_combination(n)
+        mod_weights.map {|name, weight| name if weight & n != 0 }.compact
+      end
+      
+      alias_method :mod_combin, :modifier_combination
+      
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def short_inspect?
+      !!@short_inspect
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def short_inspect!
+      self.short_inpsect = true
+    end
+    
+    # 
+    # @return [String]
+    def short_inspect
+      num = (not @short_inspect.is_a?(Integer)) ? 30 : @short_inspect
+      "#{Hash[self.to_a.sample(num)].inspect.chomp('}')}...snip...@metadata.keys=#{metadata.keys}}"
+    end
+    
+    # 
+    # @return [String]
+    def inspect
+      if short_inspect?
+        short_inspect
+      else
+        super
+      end
+    end
+    
+    # 
+    # @param  [Symbol] method_name
+    # @param  [Array] args
+    # @param  [Proc] block
+    # @return 
+    def method_missing(method_name, *args, &block)
+      if self.keys.include? method_name
+        self[method_name]
+      else
+        super(method_name, *args, &block)
+      end
+    end
+    
+  end
+end
+end