vigilem-support 0.0.9

data/lib/vigilem/support/key_map_info.rb

@@ -0,0 +1,85 @@
+module Vigilem
+module Support
+  # 
+  # 
+  class KeyMapInfo
+    
+    # 
+    # @param [Hash] opts
+    def initialize(attrs={})
+      attrs.each {|attr| send(:"#{attr}=", opts[attr]) }
+    end
+    
+    # 
+    # @return [Array<Symbol>]
+    def self.attrs
+      @attrs ||= [:keycode_range, :max_actions, 
+                  :number_of_functions_keys, :keymaps_in_use,
+                  :max_compose_defs, :compose_defs, 
+                  :compose_defs_in_use, :mod_weights, :keysyms]
+    end
+    
+    attr_accessor *attrs
+    
+    # 
+    # @param  [String] str
+    # @return [KeyMapInfo] 
+    def self.load_string(str)
+      (kmi = new).load_string(str)
+      kmi
+    end
+    
+    # 
+    # @param  [String] str
+    # @return 
+    def load_string(str)
+      str.lines do |substr|
+        case substr
+        when /^keycode range supported by kernel:/
+          keycode_range = substr.split(/:\s+/).last.rstrip
+        when /^max number of actions bindable to a key:/
+          max_actions = substr.split(/:\s+/).last.rstrip
+        when /^number of keymaps in actual use:/
+          keymaps_in_use = substr.split(/:\s+/).last.rstrip
+        when /^number of function keys supported by kernel:/
+          number_of_function_keys = substr.split(/:\s+/).last.rstrip
+        when /^max nr of compose definitions:/
+          max_compose_defs = substr.split(/:\s+/).last.rstrip
+        when /^nr of compose definitions in actual use:/
+          compose_defs_in_use = substr.split(/:\s+/).last.rstrip
+        when /^0x0[\dA-z]+/
+          hex_str, sym = substr.split(/\s+/)
+          keysyms[hex_str] = sym.rstrip
+        when /[a-z_]\s+for/i
+          # synonyms
+        when /^(shift|alt|control|ctrl|capsshift)(l|r|gr)?/
+          mod, col = substr.split(/\s+/)
+          mod_weights[mod] = col.rstrip.to_i
+        end
+      end
+    end
+    
+    # 
+    # @return [Hash]
+    def keysyms
+      @keysyms ||= {}
+    end
+    
+    
+    # 
+    # @return [Hash]
+    def char_refs
+      keysyms.invert
+    end
+    
+    # 
+    # @return [Hash]
+    def mod_weights
+      @mod_weights ||= {}
+    end
+    
+    alias_method :mod_columns, :mod_weights
+    
+  end
+end
+end

data/lib/vigilem/support/lazy_simple_delegator.rb

@@ -0,0 +1,81 @@
+require 'delegate'
+
+module Vigilem
+module Support
+  #
+  # a Delegator that allows it's delegate to be named later (after init)
+  class LazySimpleDelegator < Delegator
+    
+    methods_to_include = [:to_s, :inspect, :==, :===, :<=>, :eql?, :object_id]
+    
+    (kd = ::Kernel.dup).class_eval do                 
+      ((private_instance_methods | instance_methods) - methods_to_include).each do |m|
+        remove_method m
+      end
+    end
+    
+    include kd
+    
+    attr_writer :strict_eql
+    
+    # @param obj, the delegate
+    def initialize(obj=nil)
+      super(obj) if obj
+    end
+    
+    # 
+    # @return [self] 
+    def use_strict_eql
+      @strict_eql = true
+      self
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def strict_eql?
+      @strict_eql ||= false
+    end
+    
+    # 
+    # @see    Delegator
+    # @return obj the underlying object to delegate to
+    def __getobj__
+      @delegate_sd_obj
+    end
+    
+    # more visually apeeling..............#sorry
+    alias_method :peel, :__getobj__
+    
+    # change the object delegate to obj
+    # @see   Delegator
+    # @param obj the object to delegate to
+    def __setobj__(obj)
+      raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
+      @delegate_sd_obj = obj
+    end
+    
+    # compares #object_id's if #strict_eql?
+    # compares the other object against @delegate_sd_obj, what are the side effects?
+    # @return [TrueClass || FalseClass]
+    def eql?(other)
+      # @note Facets::Kerenl::respond munges the object_id
+      if other.respond_to?(:__getobj__)
+        if strict_eql?
+          self.__getobj__.object_id.eql? other.__getobj__.object_id
+        else
+          self.__getobj__.eql? other.__getobj__
+        end
+      else
+        if strict_eql?
+          self.__getobj__.object_id.eql? other.object_id
+        else
+          self.__getobj__.eql? other
+        end
+      end
+      
+    end #eql?
+    
+  end
+  
+end
+end

data/lib/vigilem/support/max_size_error.rb

@@ -0,0 +1,17 @@
+require 'vigilem/support/size_error'
+
+# 
+# 
+module Vigilem::Support
+  class MaxSizeError < SizeError
+  
+    # 
+    # @param [Array || Hash] obj_and_max_size
+    # @option :obj
+    # @option :max_size
+    def initialize(obj_and_max_size)
+      obj_and_max_size = Hash[obj_and_max_size.zip([:obj, :max_size]).map(&:reverse)] if obj_and_max_size.is_a? Array
+      super("size cannot exceed #{obj_and_max_size[:max_size]} for #{obj_and_max_size[:obj]}")
+    end
+  end
+end

data/lib/vigilem/support/metadata.rb

@@ -0,0 +1,13 @@
+module Vigilem
+module Support
+  module Metadata
+    
+    # 
+    # @return [Hash]
+    def metadata
+      @metadata ||= {}
+    end
+    
+  end
+end
+end

data/lib/vigilem/support/obj_space.rb

@@ -0,0 +1,28 @@
+require 'vigilem/support/core_ext'
+
+module Vigilem
+module Support
+  # 
+  # ObjectSpace like methods
+  module ObjSpace
+    
+    # 
+    # @return [Array]
+    def all
+      @all ||= []
+    end
+    
+    # 
+    # @param  component
+    # @return [Array]
+    def obj_register(component)
+      self.all << component
+      if defined?(superclass) and superclass.respond_to? :obj_register
+        superclass.obj_register(component)
+      end
+      component
+    end
+  end
+  
+end
+end

data/lib/vigilem/support/patch/cucumber/c_lexer.rb

@@ -0,0 +1,30 @@
+require 'rbconfig'
+
+module Gherkin
+  module CLexer
+    def self.singleton_method_added(method_name)
+      if method_name == :[] and not @overriden
+        @overriden = true
+        define_singleton_method(:[]) do |i18n_underscored_iso_code|
+          begin
+            prefix = if RbConfig::CONFIG['arch'] =~ /mswin|mingw/ && RbConfig::CONFIG['target_vendor'] != 'w64'
+              "#{RbConfig::CONFIG['MAJOR']}.#{RbConfig::CONFIG['MINOR']}/"
+            else
+              ''
+            end
+            
+            lib = "#{prefix}gherkin_lexer_#{i18n_underscored_iso_code}"
+            require lib
+            const_get(i18n_underscored_iso_code.capitalize)
+          rescue LoadError => e
+            e.message << %{\nCouldn't load #{lib}\nThe $LOAD_PATH was:\n#{$LOAD_PATH.join("\n")}}
+            raise e
+          end
+        end
+      else
+        super(method_name)
+      end
+    end
+    
+  end
+end

data/lib/vigilem/support/patch/ffi/pointer.rb

@@ -0,0 +1,19 @@
+require 'ffi'
+require 'ffi/pointer'
+
+module FFI
+  class Pointer
+    def ==(other_obj)
+      return true if self.eql?(other_obj)
+      if other_obj.respond_to? :bytes
+        self.read_bytes(self.size) == other_obj.bytes
+      elsif other_obj.respond_to? :read_bytes and 
+                                      other_obj.respond_to? :size
+        self.read_bytes(self.size) == other_obj.read_bytes(other_obj.size)
+      else
+        false
+      end
+    end
+    
+  end
+end

data/lib/vigilem/support/size_error.rb

@@ -0,0 +1,6 @@
+module Vigilem::Support
+  # 
+  # 
+  class SizeError < ArgumentError 
+  end
+end

data/lib/vigilem/support/sys.rb

@@ -0,0 +1,5 @@
+require 'vigilem/support/system'
+
+module Vigilem::Support
+  Sys = System
+end

data/lib/vigilem/support/system.rb

@@ -0,0 +1,92 @@
+module Vigilem
+module Support
+  # 
+  # System detection utilities
+  module System
+    
+    SYSTEM_NAME_MASKS = { :mac => /darwin/, :windows => (win = Gem::WIN_PATTERNS.join('|')), 
+                          :win => win, :linux => /linux/, :bsd => /bsd/,
+                          :nix => /nix|solaris|darwin|bsd|aix|hpux/, :aix => /aix/ }
+                          #:java => /java/}
+    
+    # 
+    # @todo FFI::Platform || Fiddle::WINDOWS
+    # generates os_name? methods
+    # @return [Regexp]
+    SYSTEM_NAME_MASKS.each do |mask_name, mask|
+      define_method(:"#{mask_name}?") do
+        os =~ SYSTEM_NAME_MASKS[mask_name]
+      end
+    end
+    
+    # 
+    # @return [String] 
+    def os
+      RbConfig::CONFIG['host_os']
+    end
+    
+    # this will may mis-represent check out https://bugs.ruby-lang.org/issues/8568
+    # the size of a long
+    # @return [Integer]
+    def long_length
+      @long_len ||= [0].pack('L!').bytesize
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def x64bit?
+      @x64_bit ||= [nil].pack('p').bytesize == 8
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def x32bit?
+      not self.x64bit?
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def big_endian?
+      [1].pack('I') == [1].pack('N')
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def little_endian?
+      !big_endian?
+    end
+    
+    # 
+    # @param  [Numeric] number
+    # @return the same number converted to a native signed long
+    def native_signed_long(number)
+      [number].pack('l!').unpack('l!').first
+    end
+    
+    PACKVAR = 'ABCDEFGHILMNPQSUVWXZ'
+    
+    # replace/supplement with Fiddle::Importer#sizeof, ruby2c, MakeMakefile#check_sizeof
+    # @see    String#unpack
+    # @see    Array#pack
+    # @param  [String] format
+    # @return [Integer] the fize of the format
+    def sizeof(format)
+      # Only for numeric formats, String formats will raise a TypeError
+      elements = 0
+      format.scan(/[#{PACKVAR}]_?\d*/i) do |mtch|
+        if mtch =~ /\d+/
+          elements += mtch.gsub('_', '')[1..-1].to_i
+        elsif mtch !~ /!|_/
+          elements += 1
+        end
+      end
+      ([ 0 ] * elements).pack(format).length # bytesize?
+    end
+    
+    extend self
+      
+  end
+end
+end
+
+require 'vigilem/support/sys'

data/lib/vigilem/support/transmutable_hash.rb

@@ -0,0 +1,206 @@
+require 'forwardable'
+
+module Vigilem
+module Support
+  # A transmutable Hash, Splits arrays into multiple keys with the same value
+  # 
+  # 
+  #     {"a"=>:key1, "b"=>:key1, "c"=>:key1, "d"=>:key, "e"=>:key2, "f"=>:key2}
+  # becomes
+  # 
+  #     {:key1=>["a", "b", "c"], :key2=>["e", "f"], :key => "d"}
+  # 
+  # And
+  # 
+  #     {:key1=>["a", "b", "c"], :key2=>["d", "e", "f"]}
+  # becomes
+  # 
+  #     {"a"=>:key1, "b"=>:key1, "c"=>:key1, "d"=>:key, "e"=>:key2, "f"=>:key2}
+  # And
+  # 
+  #     {:key1=> ['a' , ['b', 'c']]}
+  # becomes
+  # 
+  #     {"a"=>:key1, ["b", 'c']=>:key1 }
+  # 
+  class TransmutableHash < Hash
+    
+    extend Forwardable
+    
+    # @param  [Hash] hsh_or_default_value
+    # @param  default_value
+    # @param  [Proc] default_proc
+    def initialize(hsh_or_default_value={}, default_value=nil, &default_proc)
+      hsh, dfault = if hsh_or_default_value.is_a?(Hash)
+                      [hsh_or_default_value, default_value]
+                    else
+                      [{}, hsh_or_default_value]
+                    end
+      super(*dfault, &default_proc).merge!(hsh)
+      self.invert_default = self.default
+      self.invert_default_proc = self.default_proc if default_proc
+    end
+    
+    # 
+    # it will have a different object_id, because technically its a different hash
+    # not sure if that's a bug
+    # @return [Hash]
+    def invert
+      # did self change?
+      if _hash_cache_ != (temp_cache = hash)
+        _hash_cache_ = temp_cache
+        _invert_cache_ = self.class.transmute(self)
+      end
+      # if it didn't change pass off the _invert_cache_
+      _invert_cache_
+    end
+    
+    # 
+    # 
+    def inverted?
+      @inverted ||= false
+    end
+    
+    # in-place version of #invert
+    # 
+    # @see    TransmutableHash#invert
+    # @return [Hash]
+    def invert!
+      @inverted = !@inverted
+      self.class[replace(invert)]
+    end
+    
+    class << self
+      # 
+      # 
+      # @param  [Hash] in_hash
+      # @param  [Hash] dest_hash
+      # @return [Hash] dest_hash
+      def transmute(in_hash, dest_hash={})
+        in_hash.each do |old_key, old_value|
+          if old_value.is_a? Array
+            old_value.uniq.each {|new_key| fuse_value(dest_hash, new_key, old_key) }
+          else
+            fuse_value(dest_hash, old_value, old_key) 
+          end
+        end
+        self[dest_hash]
+      end
+      
+      # creating somthing like ['keycode1', 'altgr', 'keycode1']
+      # @param  [Hash] hsh
+      # @param  key
+      # @param  value
+      # @return value
+      def fuse_value(hsh, key, value)
+        if hsh.has_key?(key)
+          if (current_val = hsh[key]).is_a? Array
+            current_val.concat([value])
+          else
+            hsh[key] = [current_val, value]
+          end
+        elsif value.is_a? Array
+          hsh[key] = [value]
+        else
+          hsh[key] = value
+        end
+        self[hsh]
+      end
+      
+    end
+    
+    # 
+    # @param  [Array<Hash>]
+    # @return 
+    def fuse!(*hashes)
+      hashes.each do |hsh|
+        hsh.each do |k, v|
+          self.class.fuse_value(self, k, v)
+        end
+      end
+      self
+    end
+    
+    # 
+    # @param  [Array<Hash>]
+    # @return 
+    def fuse(*hashes)
+      container = self.class.new
+      hashes.each do |hsh|
+        hsh.each do |k, v|
+          self.fuse_value(hsh, k, v)
+        end
+      end
+      container.defaults = self.defaults
+      container.default_procs = self.default_procs
+      container.fuze!(*hashes)
+    end
+    
+    # fetches from the Hash all the values that have keys that match
+    # the Regexp kind of like grep
+    # @param  [Regexp] regex 
+    # @param  [Integer] limit 
+    # @return [Array] 
+    def regex_fetch(regex, limit=nil)
+      limit ||= -1
+      key_list = self.keys.map {|key| [*key].grep(regex) }[0..limit].compact
+      key_list.map {|key| self[key] }
+    end
+    
+    def_delegator :_invert_cache_, :default=, :invert_default=
+    def_delegator :_invert_cache_, :default, :invert_default
+    def_delegator :_invert_cache_, :default_proc=, :invert_default_proc=
+    def_delegator :_invert_cache_, :default_proc, :invert_default_proc
+    
+    alias_method :uninvert_default=, :default=
+    alias_method :uninvert_default, :default
+    alias_method :uninvert_default_proc=, :default_proc=
+    alias_method :uninvert_default_proc, :default_proc
+    
+    # sets the default for both self and the inverted_cache
+    # @see Hash#default=
+    # @param  objs
+    # @return objs
+    def defaults=(objs)
+      send(:default=, [*objs].first)
+      _invert_cache_.default = [*objs].last
+      objs
+    end
+    
+    # gets the default for both self and the inverted_cache
+    # @return [Array]
+    def defaults
+      [default(), invert_default]
+    end
+    
+    # gets the default for both self and the inverted_cache
+    # @return [Array]
+    def default_procs
+      [default_proc(), invert_default_proc]
+    end
+    
+    # sets the default for both self and the inverted_cache
+    # @param  objs
+    # @return objs
+    def default_procs=(objs)
+      if fdprc = [*objs].first
+        send(:default_proc=, fdprc)
+      end
+      if ldprc = [*objs].last
+        _invert_cache_.default_proc = ldprc
+      end
+      objs
+    end
+   
+   private
+    attr_accessor :_hash_cache_
+    attr_writer :_invert_cache_
+     
+    # gets the cached version of the inverse
+    # @return [TransmutableHash]
+    def _invert_cache_
+      @_invert_cache_ ||= invert().tap {|obj| obj.instance_variable_set(:@inverted, true) }
+    end
+  end
+end
+end