vigilem-dom 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b56d55d2f86728b678f5e5fbe144190c18a9427f
+  data.tar.gz: cff68b533d8098ec170300c5110b6ef892b42165
+SHA512:
+  metadata.gz: 4fc80e126ffa25143ed2bf06453a1f67793b332f33a24dbf55c1880db722fe50b4ca90ab6c6862b98f135c6ef408805408777289d7cbbf7cb3adaf7d6e8c7dd1
+  data.tar.gz: 312cd3a18461414d87f97c9b2e78d17818cc5d2122deb4905951f89e632f8817fc9d50dd6e68d33e09e577e2507b9bc6660dc92756882bde86dc42ff962dc079

data/lib/vigilem/dom.rb

@@ -0,0 +1,27 @@
+require 'w3c/dom'
+
+module Vigilem
+module DOM
+  
+  class << self
+    attr_writer :strict
+    # controls checking of various values
+    # @return [TrueClass||FalseClass]
+    def strict
+      @strict ||= true
+    end
+  end
+  
+  KeyValues = ::W3C::DOM3::KeyValues
+  CodeValues = ::W3C::DOM3::CodeValues
+  
+  Event = ::W3C::DOM4::Event
+  
+  UIEvent = ::W3C::DOM3::UIEvent
+  
+  require 'vigilem/dom/keyboard_event'
+  
+end
+end
+
+require 'vigilem/dom/utils'

data/lib/vigilem/dom/keyboard_event.rb

@@ -0,0 +1,187 @@
+require 'vigilem/support/core_ext'
+
+require 'vigilem/dom'
+
+module Vigilem
+module DOM
+  # 
+  # @see W3C::DOM3::KeyboardEvent
+  class KeyboardEvent < ::W3C::DOM3::KeyboardEvent
+    
+    attr_reader :os_specific, :modifier_state #@todo, :chr
+    
+    # 
+    # @see    #SharedKeyboardAndMouseEventInit
+    # @param  [String || Symbol] type
+    # @param  [Hash] options
+    # @option [String] :key
+    # @option [String] :code
+    # @option [Hash] :location 
+    # @option :location [Integer] 0x00 DOM_KEY_LOCATION_STANDARD
+    # @option :location [Integer] 0x01 DOM_KEY_LOCATION_LEFT
+    # @option :location [Integer] 0x02 DOM_KEY_LOCATION_RIGHT
+    # @option :location [Integer] 0x03 DOM_KEY_LOCATION_NUMPAD
+    # @option [TrueClass || FalseClass] repeat
+    # @option[Hash] :modifiers || :modifier_state
+    # @option modifiers [TrueClass || FalseClass || NilClass] :alt, :altKey
+    # @option modifiers [TrueClass || FalseClass || NilClass] :alt_graph, :AltGraph
+    # @option modifiers [TrueClass || FalseClass || NilClass] :caps_lock, :CapsLock
+    # @option modifiers [TrueClass || FalseClass || NilClass] :control, :ctrl, :ctrlKey
+    # @option modifiers [TrueClass || FalseClass || NilClass] :meta, :metaKey
+    # @option modifiers [TrueClass || FalseClass || NilClass] :num_lock, :NumLock
+    # @option modifiers [TrueClass || FalseClass || NilClass] :scroll, :scroll_lock
+    # @option modifiers [TrueClass || FalseClass || NilClass] :shift, :shiftKey
+    # @option modifiers [TrueClass || FalseClass || NilClass] :symbol, :symbol_lock
+    # @param  [Hash] os_specific
+    def initialize(type, options={})
+      raise TypeError, "invalid type `#{type}'" if strict = Vigilem::DOM.strict and not self.class.types.include?(type)
+      @type = type
+      @key = options[:key] ||= ''
+      if options[:location] and strict and (kl = KeyLocations).constants.none? {|const| kl.const_get(const) == options[:location] }
+        raise ArgumentError, "invalid location `#{options[:location]}'" 
+      end
+      @location = options[:location] ||= 0
+      @repeat = options[:repeat] ||= false
+      @os_specific = self.class.hash_frozen_clone(options[:os_specific] || {})
+      
+      @modifier_state = self.class.hash_frozen_clone(options[:modifiers] || options[:modifier_state] || {})
+      
+      mod_dict = self.class.shared_keyboard_and_mouse_event_init(@modifier_state)
+      
+      super(type, mod_dict.merge(options))
+    end
+    
+    #---
+    
+    @modifier_attrs = ::W3C::DOM3::KeyboardEvent.instance_variable_get(:@modifer_attrs)
+    
+    @modifier_attrs.each do |method_name|
+      
+      snake_case = method_name.to_s.snakecase.to_sym
+      
+      mod_state_name = "keyModifierState#{method_name}".to_sym
+      define_method(snake_case) do 
+        modifier_state[mod_state_name]
+      end
+    end
+    
+    #---
+    
+    @dom_3_attrs = ::W3C::DOM3::KeyboardEvent.instance_variable_get(:@dom_3_attrs) + ::W3C::DOM4::Event.instance_variable_get(:@attrs)
+    
+    @dom_3_attrs.each do |method_name|
+      
+      snake_case = method_name.to_s.snakecase.to_sym
+      
+      snake_case = "#{snake_case}?" if snake_case[0..1] == 'is'
+      
+      alias_method snake_case, method_name
+    end
+    
+    # 
+    # @param  [#to_s] key_type
+    # @return [KeyboardEvent]
+    def copy_to(key_type)
+      copy = Support::Utils.deep_dup(self)
+      copy.instance_variable_set(:@type, key_type.to_s)
+      copy
+    end
+    
+    # has @type @key @location, so the object can be distinguised from other KeyboardEvents
+    # @return [String]
+    def to_s
+      "#{super().chop} @type=#{@type.inspect} @key=#{@key.inspect} @location=#{location.inspect}>"
+    end
+    
+    # 
+    # @return [String]
+    def inspect
+      "<#{self.class}:0x#{self.object_id} #{instance_variables.map {|var| "#{var}=#{instance_variable_get(var).inspect}" }.sort_by {|name| name[1..2]}.join(' ')}>"
+    end
+    
+    class << self
+      
+      # 
+      # @return [Array<String>]
+      def types
+        @types ||= %w(keyup keypress keydown)
+      end
+      
+      # this is not a hash so that the values can be #joined as a regex
+      # the last value of each group is the DOM value without the prefix
+      # @return [Array<Array<Symbol>>]
+      def alternative_key_names
+        @alternative_key_names ||= [[:alt, :menu, :altKey], [:alt_graph, :AltGraph], [:caps_lock, :CapsLock], [:ctrl, :control, :ctrlKey], 
+                                    [:Fn], [:fn_lock, :FnLock], [:Hyper], [:meta, :metaKey], [:num_lock, :NumLock], [:OS], 
+                                    [:scroll_lock, :ScrollLock], [:shift, :shiftKey], [:Super], [:Symbol], [:symbol_lock, :SymbolLock]]
+      end
+      
+      # converts a common key to shared_keyboard_and_mouse_event_init_key
+      # dom_3 are not prefixed by keyModifierState
+      # @param  [#to_s] key_name
+      # @return [Symbol || NilClass]
+      def shared_keyboard_and_mouse_event_init_key(key_name)
+        key_group = alternative_key_names.find {|key_grp| /^(#{key_grp.join('|')})$/i =~ key_name.to_s }
+        if key_group
+          if @dom_3_attrs.include?(correct_key = key_group.last)
+            correct_key 
+          else
+            "keyModifierState#{correct_key}".to_sym
+          end
+        end
+      end
+      
+      # gets the keys for SharedKeyboardAndMouseEventInit 
+      # 
+      # @return [Array<Symbol>]
+      def shared_keyboard_and_mouse_event_init_keys
+        shared_keyboard_and_mouse_event_init_keys ||= alternative_key_names.map do |key_grp| 
+            if @dom_3_attrs.include?(correct_key = key_grp.last) 
+              correct_key
+            else
+              "keyModifierState#{correct_key}".to_sym
+            end
+          end
+      end
+      
+      # converts common names to SharedKeyboardAndMouseEventInit
+      # @param  [Hash || Array] hsh_or_ary
+      # @return [Hash]
+      def SharedKeyboardAndMouseEventInit(hsh_or_ary)
+        
+        hsh = if hsh_or_ary.is_a?(Hash)
+          hsh_or_ary
+        else
+          Hash[hsh_or_ary.zip([true] * hsh_or_ary.size)]
+        end
+        
+        alternative_key_names.each_with_object({}) do |key_grp, out_hash|
+          skamei_name = shared_keyboard_and_mouse_event_init_key(key_grp.last)
+          matched_usr_key = hsh.keys.find {|usr_key| usr_key =~ /^(#{key_grp.join('|')})$/i }
+          out_hash[skamei_name] = !!hsh[matched_usr_key]
+        end
+      end
+      
+      alias_method :shared_keyboard_and_mouse_event_init, :SharedKeyboardAndMouseEventInit
+    end
+    
+    # 
+    # 
+    # @return [Hash] 
+    def modifier_state
+      @modifier_state ||= Hash[DOM::KeyValues::ModifierKeys.zip([false])].tap {|hsh| hsh.default = false }.freeze
+    end
+    
+   private
+    
+    # 
+    # @param  [Hash] hsh_obj
+    # @return [Hash] cloned obj
+    def self.hash_frozen_clone(hsh_obj)
+      hsh_obj.map.with_object({}) do |(key, value), hsh| 
+        hsh[key] = value.clone rescue value
+      end.freeze
+    end
+  end
+end
+end

data/lib/vigilem/dom/utils.rb

@@ -0,0 +1,49 @@
+require 'vigilem/dom/keyboard_event'
+
+module Vigilem
+module DOM
+  # @author jtzero
+  # 
+  # useful dom mapping methods
+  module Utils
+    
+    # 
+    # @return [Hash<String, Integer>]
+    def name_codes
+      @name_codes ||= Hash.new(KeyboardEvent::DOM_KEY_LOCATION_STANDARD).merge({
+        'L' => KeyboardEvent::DOM_KEY_LOCATION_LEFT,
+        'R' => KeyboardEvent::DOM_KEY_LOCATION_RIGHT,
+        'NUMPAD' => KeyboardEvent::DOM_KEY_LOCATION_NUMPAD,
+        'KP' => KeyboardEvent::DOM_KEY_LOCATION_NUMPAD
+      })
+    end
+    
+    # 
+    # @return [Hash<Integer, Regexp>
+    def codes_regex
+      @codes_regex ||= { KeyboardEvent::DOM_KEY_LOCATION_LEFT => /left/i, 
+                         KeyboardEvent::DOM_KEY_LOCATION_RIGHT => /right/i,
+                         KeyboardEvent::DOM_KEY_LOCATION_NUMPAD => /numpad/i,
+                         }
+    end
+    
+    # @todo   rename dom_location_to_common_str
+    # @param  [Integer] dom_location_code
+    # @return [String]
+    def to_dom_location_common_str(dom_location_code)
+      (@code_names ||= name_codes.invert.tap {|obj| obj.default = '' })[dom_location_code]
+    end
+    
+    #
+    # @param  [String<'L', 'R', 'NUMPAD', 'KP', Object>] location
+    # @return [Integer]
+    def common_str_to_dom_location(location)
+      name_codes[location]
+    end
+    
+    extend self
+  end
+end
+end
+
+VDOM = ::Vigilem::DOM

data/lib/vigilem/dom/version.rb

@@ -0,0 +1,5 @@
+module Vigilem
+module DOM
+  VERSION = '0.1.0'
+end
+end

data/lib/w3c/dom.rb

@@ -0,0 +1,16 @@
+# http://www.w3.org/TR/DOM-Level-3-Events/
+module W3C
+module DOM3
+end
+module DOM4
+end
+end
+
+require 'w3c/dom4/event'
+
+require 'w3c/dom3/ui_event'
+
+require 'w3c/dom3/key_values'
+require 'w3c/dom3/code_values'
+
+require 'w3c/dom3/keyboard_event'

data/lib/w3c/dom3/code_values.rb

@@ -0,0 +1,33 @@
+module W3C
+module DOM3
+# http://www.w3.org/TR/2014/WD-DOM-Level-3-Events-code-20140612/
+module CodeValues
+  WritingSystemKeys = ['Backquote', 'Backslash', 'Backspace', 'BracketLeft', 'BracketRight', 'Comma', 'Digit0', 'Digit1', 'Digit2', 
+                      'Digit3', 'Digit4', 'Digit5', 'Digit6', 'Digit7', 'Digit8', 'Digit9', 'Equal', 'IntlBackslash', 'IntlHash', 'IntlRo', 
+                      'IntlYen', 'KeyA', 'KeyB', 'KeyC', 'KeyD', 'KeyE', 'KeyF', 'KeyG', 'KeyH', 'KeyI', 'KeyJ', 'KeyK', 'KeyL', 'KeyM', 'KeyN', 
+                      'KeyO', 'KeyP', 'KeyQ', 'KeyR', 'KeyS', 'KeyT', 'KeyU', 'KeyV', 'KeyW', 'KeyX', 'KeyY', 'KeyZ', 'Minus', 'Period', 'Quote', 
+                      'Semicolon', 'Slash']
+  
+  FunctionalKeys = ['AltLeft', 'AltRight', 'CapsLock', 'ContextMenu', 'ControlLeft', 'ControlRight', 'Enter', 'OSLeft', 'OSRight', 
+                    'ShiftLeft', 'ShiftRight', 'Space', 'Tab', 'Convert', 'KanaMode', 'Lang1', 'Lang2', 'Lang3', 'Lang4', 'Lang5', 'NonConvert']
+  
+  ControlPadSection = ['Delete', 'End', 'Help', 'Home', 'Insert', 'PageDown', 'PageUp']
+  
+  ArrowPadSection = ['ArrowDown', 'ArrowLeft', 'ArrowRight', 'ArrowUp']
+  
+  NumpadSection = ['NumLock', 'Numpad0', 'Numpad1', 'Numpad2', 'Numpad3', 'Numpad4', 'Numpad5', 'Numpad6', 'Numpad7', 'Numpad8', 'Numpad9', 
+                  'NumpadAdd', 'NumpadBackspace', 'NumpadClear', 'NumpadClearEntry', 'NumpadComma', 'NumpadDecimal', 'NumpadDivide', 'NumpadEnter', 
+                  'NumpadEqual', 'NumpadMemoryAdd', 'NumpadMemoryClear', 'NumpadMemoryRecall', 'NumpadMemoryStore', 'NumpadMemorySubtract', 'NumpadMultiply', 
+                                                                                                      'NumpadParenLeft', 'NumpadParenRight', 'NumpadSubtract']
+  
+  FunctionSection = ['Escape', 'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F11', 'F12', 'Fn', 'FLock', 'PrintScreen', 'ScrollLock', 'Pause']
+  
+  MediaKeys = ['BrowserBack', 'BrowserFavorites', 'BrowserForward', 'BrowserHome', 'BrowserRefresh', 'BrowserSearch', 'BrowserStop', 'Eject', 
+              'LaunchApp1', 'LaunchApp2', 'LaunchMail', 'MediaPlayPause', 'MediaSelect', 'MediaStop', 'MediaTrackNext', 'MediaTrackPrevious', 'Power', 
+                                                                                              'Sleep', 'VolumeDown', 'VolumeMute', 'VolumeUp', 'WakeUp']
+  
+  LegacyKeysandNon_StandardKeys = ['Hyper', 'Super', 'Turbo', 'Abort', 'Resume', 'Suspend', 'Again', 'Copy', 'Cut', 'Find', 'Open', 'Paste', 'Props', 'Select', 
+                                                                                                                                    'Undo', 'Hiragana', 'Katakana']
+end
+end
+end

data/lib/w3c/dom3/key_values.rb

@@ -0,0 +1,56 @@
+module W3C
+module DOM3
+# @author jtzero
+# http://www.w3.org/TR/2014/WD-DOM-Level-3-Events-key-20140612/
+module KeyValues
+  SpecialKeyValues = 'Unidentified'
+  
+  ModifierKeys = ['Accel', 'Alt', 'AltGraph', 'CapsLock', 'Control', 'Fn', 'FnLock', 'Hyper', 'Meta', 
+                                        'NumLock', 'OS', 'ScrollLock', 'Shift', 'Super', 'Symbol', 'SymbolLock']
+                                        
+  WhitespaceKeys = ['Enter', 'Separator', 'Tab']
+  
+  NavigationKeys = ['ArrowDown', 'ArrowLeft', 'ArrowRight', 'ArrowUp', 'End', 'Home', 'PageDown', 'PageUp']
+  
+  EditingKeys = ['Backspace', 'Clear', 'Copy', 'CrSel', 'Cut', 'Delete', 'EraseEof', 'ExSel', 'Insert', 'Paste', 'Redo', 'Undo' ]
+  
+  UIKeys = ['Accept', 'Again', 'Attn', 'Cancel', 'ContextMenu', 'Escape', 'Execute', 'Find', 'Help', 'Pause', 
+                                                                                  'Play', 'Props', 'Select', 'ZoomIn', 'ZoomOut']
+  
+  DeviceKeys = ['BrightnessDown', 'BrightnessUp', 'Camera', 'Eject', 'LogOff', 'Power', 'PowerOff', 'PrintScreen', 'Hibernate', 'Standby', 'WakeUp'] 
+  
+  IMEandCompositionKeys = ['AllCandidates', 'Alphanumeric', 'CodeInput', 'Compose', 'Convert', 'Dead', 'FinalMode', 'GroupFirst', 'GroupLast', 
+                          'GroupNext', 'GroupPrevious', 'ModeChange', 'NextCandidate', 'NonConvert', 'PreviousCandidate', 
+                                                                                 'Process', 'SingleCandidate', 'HangulMode', 'HanjaMode', 'JunjaMode']
+  
+  KeysspecifictoKoreankeyboards = ['Eisu', 'Hankaku', 'Hiragana', 'HiraganaKatakana', 'KanaMode', 'KanjiMode', 'Katakana', 'Romaji', 
+                                                                                                              'Zenkaku', 'ZenkakuHankaku']
+  KeysspecifictoJapanesekeyboards = ['Eisu', 'Hankaku', 'Hiragana', 'HiraganaKatakana', 'KanaMode', 'KanjiMode', 'Katakana', 'Romaji', 
+                                                                                                              'Zenkaku', 'ZenkakuHankaku']
+  
+  General_PurposeFunctionKeys = ['F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F11', 'F12', 'Soft1', 'Soft2', 'Soft3', 'Soft4']
+  
+  MultimediaKeys = ['Close', 'MailForward', 'MailReply', 'MailSend', 'MediaPlayPause', 'MediaSelect', 'MediaStop', 'MediaTrackNext', 
+                                'MediaTrackPrevious', 'New', 'Open', 'Print', 'Save', 'SpellCheck', 'VolumeDown', 'VolumeUp', 'VolumeMute']
+  
+  ApplicationKeys = ['Launch', 'LaunchCalculator', 'LaunchCalendar', 'LaunchMail', 'LaunchMediaPlayer', 'LaunchMusicPlayer', 
+                     'LaunchMyComputer', 'LaunchScreenSaver', 'LaunchSpreadsheet', 'LaunchWebBrowser', 'LaunchWebCam', 'LaunchWordProcessor']
+  
+  BrowserKeys = ['BrowserBack', 'BrowserFavorites', 'BrowserForward', 'BrowserHome', 'BrowserRefresh', 'BrowserSearch', 'BrowserStop']
+  
+  MediaControllerKeys = ['AudioBalanceLeft', 'AudioBalanceRight', 'AudioBassBoostDown', 'AudioBassBoostUp', 'AudioFaderFront', 'AudioFaderRear', 
+                         'AudioSurroundModeNext', 'AVRInput', 'AVRPower', 'ChannelDown', 'ChannelUp', 'ColorF0Red', 'ColorF1Green', 
+                         'ColorF2Yellow', 'ColorF3Blue', 'ColorF4Grey', 'ColorF5Brown', 'ClosedCaptionToggle', 'Dimmer', 'DisplaySwap', 'Exit', 
+                         'FavoriteClear0', 'FavoriteClear1', 'FavoriteClear2', 'FavoriteClear3', 'FavoriteRecall0', 'FavoriteRecall1', 
+                         'FavoriteRecall2', 'FavoriteRecall3', 'FavoriteStore0', 'FavoriteStore1', 'FavoriteStore2', 'FavoriteStore3', 'Guide', 
+                         'GuideNextDay', 'GuidePreviousDay', 'Info', 'InstantReplay', 'Link', 'ListProgram', 'LiveContent', 'Lock', 'MediaApps', 
+                         'ContextMenu', 'MediaFastForward', 'MediaLast', 'MediaPause', 'MediaPlay', 'MediaRecord', 'MediaRewind', 'MediaSkip', 
+                         'NextFavoriteChannel', 'NextUserProfile', 'OnDemand', 'PinPDown', 'PinPMove', 'PinPToggle', 'PinPUp', 'PlaySpeedDown', 
+                         'PlaySpeedReset', 'PlaySpeedUp', 'RandomToggle', 'RcLowBattery', 'RecordSpeedNext', 'RfBypass', 'ScanChannelsToggle', 
+                         'ScreenModeNext', 'Settings', 'SplitScreenToggle', 'STBInput', 'STBPower', 'Subtitle', 'Teletext', 'TV', 'TVInput', 
+                         'TVPower', 'VideoModeNext', 'Wink', 'ZoomToggle','BrowserBack', 'BrowserForward', 'ContextMenu', 'Eject', 'End', 'Enter', 
+                         'Home', 'MediaPlayPause', 'MediaStop', 'MediaNextTrack', 'MediaPreviousTrack', 'Power', 'Unidentified', 'VolumeDown', 
+                                                                                                                        'VolumeUp', 'VolumeMute']
+end
+end
+end

data/lib/w3c/dom3/keyboard_event.rb

@@ -0,0 +1,90 @@
+require 'vigilem/support/core_ext'
+
+module W3C
+module DOM3
+  # 
+  # http://www.w3.org/TR/2014/WD-DOM-Level-3-Events-code-20140612/
+  # http://www.w3.org/TR/2014/WD-DOM-Level-3-Events-key-20140612/
+  # 
+  # http://www.w3.org/TR/2014/WD-DOM-Level-3-Events-20140925/#idl-def-KeyboardEvent
+  # 
+  # https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent.code
+  class KeyboardEvent < UIEvent
+    
+    module KeyLocations
+      DOM_KEY_LOCATION_STANDARD = 0x00
+      DOM_KEY_LOCATION_LEFT     = 0x01
+      DOM_KEY_LOCATION_RIGHT    = 0x02
+      DOM_KEY_LOCATION_NUMPAD   = 0x03
+    end
+    
+    include KeyLocations
+    
+    # 
+    # @param [String] typeArg
+    # @param [Hash] keyboardEventInitDict
+    # @option  keyboardEventInitDict
+    def initialize(typeArg, keyboardEventInitDict={})
+      @key = keyboardEventInitDict[:key] || ''
+      
+      if (not @key.empty?) and keyboardEventInitDict[:code].to_s.empty?
+        raise ArgumentError, "keyboardEventInitDict[:key] has a value while keyboardEventInitDict[:code] is nil"
+      end
+      
+      @code = keyboardEventInitDict[:code] || ''
+      
+      @location = keyboardEventInitDict[:location] || 0
+      @repeat = keyboardEventInitDict[:repeat] || false
+      @isComposing = keyboardEventInitDict[:isComposing] || false
+      
+      @modifier_state = Hash[DOM3::KeyValues::ModifierKeys.zip([false, 
+                        !!keyboardEventInitDict[:altKey], 
+                        !!keyboardEventInitDict[:keyModifierStateAltGraph],
+                        !!keyboardEventInitDict[:keyModifierStateCapsLock],
+                        !!keyboardEventInitDict[:ctrlKey],
+                        !!keyboardEventInitDict[:keyModifierStateFn],
+                        !!keyboardEventInitDict[:keyModifierStateFnLock],
+                        !!keyboardEventInitDict[:keyModifierStateHyper],
+                        !!keyboardEventInitDict[:metaKey],
+                        !!keyboardEventInitDict[:keyModifierStateNumLock],
+                        !!keyboardEventInitDict[:keyModifierStateOS],
+                        !!keyboardEventInitDict[:keyModifierStateScrollLock],
+                        !!keyboardEventInitDict[:shiftKey],
+                        !!keyboardEventInitDict[:keyModifierStateSuper],
+                        !!keyboardEventInitDict[:keyModifierStateSymbol],
+                        !!keyboardEventInitDict[:keyModifierStateSymbolLock]])]
+      @modifier_state.default = false
+      super(typeArg, keyboardEventInitDict)
+    end
+    
+   private
+    
+    # attrs and modifier_state
+    @modifer_attrs = [:ctrlKey, :shiftKey, :altKey, :metaKey]
+    
+    @dom_3_attrs = [:key, :code, :location, :repeat, :isComposing] + @modifer_attrs
+    # Legacy, introduced in DOM Level 3:
+    @attrs = @dom_3_attrs + [:charCode, :keyCode, :which]
+    
+   public
+    attr_reader *@attrs
+    
+    # defines methods for the modifiers that are also
+    # attr's
+    @modifer_attrs.each do |attr|
+      define_method(attr) do
+        instance_variable_get(:@modifier_state)[attr.to_s.gsub(/key/i, '').titlecase]
+      end
+    end
+    
+    # Queries the state of a modifier using a key value.
+    # 
+    # @param  [String] keyArg A modifier key value
+    # @return [TrueClass || FalseClass] 
+    def getModifierState(keyArg)
+      !!@modifier_state[keyArg]
+    end
+    
+  end
+end
+end

data/lib/w3c/dom3/ui_event.rb

@@ -0,0 +1,31 @@
+require 'w3c/dom4/event'
+
+# 
+# http://www.w3.org/TR/DOM-Level-3-Events/#idl-def-UIEvent
+# 
+module W3C
+module DOM3
+  class UIEvent < DOM4::Event
+    
+    # 
+    # @param [String] type
+    # @param [Hash] eventInitDict
+    # @option :view unused
+    # @option :detail unused
+    # @return self
+    def initialize(type, eventInitDict={})
+      @view = eventInitDict[:view] || nil 
+      @detail = eventInitDict[:detail] || 0
+      super(type, eventInitDict)
+    end
+    
+   private
+    @attrs = [:view, :detail]
+    attr_writer *@attrs
+    
+   public
+    
+    attr_reader *@attrs
+  end
+end
+end

data/lib/w3c/dom4/event.rb

@@ -0,0 +1,35 @@
+module W3C
+module DOM4
+  #
+  # http://www.w3.org/TR/2014/WD-dom-20140710/#interface-event
+  class Event
+    NONE            = 0;
+    CAPTURING_PHASE = 1;
+    AT_TARGET       = 2;
+    BUBBLING_PHASE  = 3;
+    
+    # 
+    # @param  [String] type
+    # @param  [Hash] eventInitDict
+    def initialize(type, eventInitDict={})
+      @type = type
+      @bubbles = eventInitDict[:bubbles] || false
+      @cancelable = eventInitDict[:cancelable] || false
+      @timeStamp = Time.now.to_i
+      @isTrusted = true
+    end
+    
+   private
+                                                                                                   # Unforgeable
+    @attrs = [:type, :target, :currentTarget, :eventPhase, :bubbles, :cancelable, :defaultPrevented, :isTrusted, :timeStamp]
+    
+   public 
+    attr_reader *@attrs
+    
+    def stopPropagation() end
+    def stopImmediatePropagation() end
+    def preventDefault() end
+    
+  end
+end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'bundler'
+
+Bundler.setup
+
+require 'vigilem/core'

data/spec/vigilem/dom/keyboard_event_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+require 'vigilem/dom'
+
+describe Vigilem::DOM::KeyboardEvent do
+  
+  subject { described_class.new('keyup', key: 'a', code: 'KeyA', location: 0, repeat: false) }
+  
+  describe '::new/initialization' do
+    
+    it 'sets the default modifier_state' do
+      
+      expect(subject.send(:modifier_state)).to eql({ "Accel"=>false, 
+                      "Alt"=>false, "AltGraph"=>false, "CapsLock"=>false, 
+                      "Control"=>false, "Fn"=>false, "FnLock"=>false, 
+                      "Hyper"=>false, "Meta"=>false, "NumLock"=>false, 
+                      "OS"=>false, "ScrollLock"=>false, "Shift"=>false, 
+                      "Super"=>false, "Symbol"=>false, "SymbolLock"=>false})
+    end
+    
+    it 'sets up the key by the argument' do
+      expect(subject.key).to eql('a')
+    end
+    
+    it 'sets up the code' do
+      expect(subject.code).to eql('KeyA')
+    end
+    
+    it 'sets up location by the argument' do
+      expect(subject.location).to eql(0)
+    end
+    
+    it 'sets up ctrlKey by defaults' do
+      expect(subject.ctrlKey).to eql(false)
+    end
+    
+    it 'sets up shiftKey by defaults' do
+      expect(subject.shiftKey).to eql(false)
+    end
+    
+    it 'sets up altKey by defaults' do
+      expect(subject.altKey).to eql(false)
+    end
+    
+    it 'sets up metaKey by defaults' do
+      expect(subject.metaKey).to eql(false)
+    end
+    
+    it 'sets up repeat by args' do
+      expect(subject.repeat).to eql(false)
+    end
+    
+  end
+  
+  describe '#copy_to' do
+    it 'copies the existing keyboard event and converts it the type passed in' do
+      expect(subject.copy_to('keydown').key).to eql('a')
+    end
+  end
+  
+end

data/spec/vigilem/dom/utils_spec.rb

@@ -0,0 +1,37 @@
+require 'vigilem/dom/utils' 
+
+describe Vigilem::DOM::Utils do
+  describe '::name_codes' do
+    it 'is a map of common strings to DOM values' do
+      expect(described_class::name_codes.keys.map(&:class).uniq).to contain_exactly(String)
+      expect(described_class::name_codes.values.map(&:class).uniq).to contain_exactly(Fixnum)
+    end
+  end
+  
+  describe '::codes_regex' do
+    it 'it is a map of common patterns to DOM values' do
+      expect(described_class::codes_regex.keys.map(&:class).uniq).to contain_exactly(Fixnum)
+      expect(described_class::codes_regex.values.map(&:class).uniq).to contain_exactly(Regexp)
+    end
+  end
+  
+  describe '::common_str_to_dom_location' do
+    it 'converts some common strings to DOM Location Codes' do
+      expect(described_class::common_str_to_dom_location('L')).to eql(1)
+    end
+  end
+  
+  describe '::to_dom_location_common_str' do
+    it 'converts some common strings to DOM Location Codes' do
+      expect(described_class::to_dom_location_common_str(1)).to eql('L')
+    end
+    
+    it 'defaults to empty String' do
+      expect(described_class::to_dom_location_common_str(nil)).to eql('')
+    end
+  end
+  
+  it 'creates a shortcut constant' do
+    expect(Object.const_get(:VDOM)).to eql(Vigilem.const_get(:DOM))
+  end
+end

data/spec/w3c/dom3/keyboard_event_spec.rb

@@ -0,0 +1,54 @@
+require 'ostruct'
+
+require 'w3c/dom4/event'
+
+require 'w3c/dom3/ui_event'
+
+require 'w3c/dom3/keyboard_event'
+
+describe W3C::DOM3::KeyboardEvent do
+  
+  
+  describe described_class::KeyLocations do
+    it 'will match the w3c specs' do
+      expect(described_class::DOM_KEY_LOCATION_STANDARD).to eql(0x00)
+      expect(described_class::DOM_KEY_LOCATION_LEFT).to eql(0x01)
+      expect(described_class::DOM_KEY_LOCATION_RIGHT).to eql(0x02)
+      expect(described_class::DOM_KEY_LOCATION_NUMPAD).to eql(0x03)
+    end
+  end
+  
+  describe 'read only attributes' do
+    it %q(aren't allowed to be updated) do
+      event = described_class.new('str')
+      expect(
+        described_class.instance_variable_get(:@attrs).map do |attr|
+          begin
+            event.public_send(:"#{attr}=", 'anything')
+          rescue StandardError => e
+            e
+          end
+        end
+      ).to all(be_a NoMethodError)
+    end
+  
+  end
+  
+  describe '#getModifierState' do
+    event = described_class.new('str', keyModifierStateNumLock: true)
+    
+    it 'returns the status of passed in key name, at the time the event was fired' do
+      expect(event.getModifierState('NumLock')).to be_truthy
+    end
+    
+  end
+  
+  describe '::new/initialize' do
+    it 'errors if key have a value and code is empty' do
+      expect do
+        described_class.new('keyup', key: 'a', location: 0, repeat: false)
+      end.to raise_error(ArgumentError)
+    end
+  end
+  
+end

data/spec/w3c/dom3/ui_event_spec.rb

@@ -0,0 +1,21 @@
+require 'w3c/dom3/ui_event'
+
+describe W3C::DOM3::UIEvent do
+  
+  describe 'read only attributes' do
+    it %q(aren't allowed to be updated) do
+      host = described_class.new('str')
+      expect(
+        described_class.instance_variable_get(:@attrs).map do |attr|
+          begin
+            host.public_send(:"#{attr}=", 'anything')
+          rescue StandardError => e
+            e
+          end
+        end
+      ).to all(be_a NoMethodError)
+    end
+  
+  end
+  
+end

data/spec/w3c/dom4/event_spec.rb

@@ -0,0 +1,31 @@
+#http://www.w3.org/TR/DOM-Level-2-Events/idl/events.idl
+require 'w3c/dom4/event'
+
+describe W3C::DOM4::Event do
+  
+  describe 'constants' do 
+    it 'will equal the value given in the dom spec' do
+      expect(described_class::NONE).to eql(0)
+      expect(described_class::CAPTURING_PHASE).to eql(1)
+      expect(described_class::AT_TARGET).to eql(2)
+      expect(described_class::BUBBLING_PHASE).to eql(3)
+    end
+  end
+  
+  describe 'read only attributes' do
+    it %q(aren't allowed to be updated) do
+      host = described_class.new('str')
+      expect(
+        described_class.instance_variable_get(:@attrs).map do |attr|
+          begin
+            host.public_send(:"#{attr}=", 'anything')
+          rescue StandardError => e
+            e
+          end
+        end
+      ).to all(be_a NoMethodError)
+    end
+  
+  end
+  
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: vigilem-dom
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jtzero
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: vigilem-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turnip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: DOM Structures for Vigilem
+email: jtzero511@gmail
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vigilem/dom.rb
+- lib/vigilem/dom/keyboard_event.rb
+- lib/vigilem/dom/utils.rb
+- lib/vigilem/dom/version.rb
+- lib/w3c/dom.rb
+- lib/w3c/dom3/code_values.rb
+- lib/w3c/dom3/key_values.rb
+- lib/w3c/dom3/keyboard_event.rb
+- lib/w3c/dom3/ui_event.rb
+- lib/w3c/dom4/event.rb
+- spec/spec_helper.rb
+- spec/vigilem/dom/keyboard_event_spec.rb
+- spec/vigilem/dom/utils_spec.rb
+- spec/w3c/dom3/keyboard_event_spec.rb
+- spec/w3c/dom3/ui_event_spec.rb
+- spec/w3c/dom4/event_spec.rb
+homepage: http://rubygems.org/gems/vigilem-dom
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: DOM Structures for Vigilem
+test_files:
+- spec/spec_helper.rb
+- spec/vigilem/dom/keyboard_event_spec.rb
+- spec/vigilem/dom/utils_spec.rb
+- spec/w3c/dom3/keyboard_event_spec.rb
+- spec/w3c/dom3/ui_event_spec.rb
+- spec/w3c/dom4/event_spec.rb