hemi 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b1a159b551a31d4a0ff8fda11c6c150a90bbef0d95ffedbd4dfd6e6142ccf8f
-  data.tar.gz: a1a2ee8d0853fc8bad1c63c85fb625c80291b8e4ab5f9a0deeb3c2f902a1dec5
+  metadata.gz: 8f36ce1ac46670d07a633de63c38a9f5b0f5faeb44e35c207647634cc9c34319
+  data.tar.gz: 71a1d9d0f6833d6ec66cd952a0ffc6d538508244d30165bdbb54c8dfd461eb54
 SHA512:
-  metadata.gz: 7f03cbe78fd24c28c0c047d0af79c30dfdf30cfc489fd68266857f13b2bfcfacb741483874010950ba32eccebe4fe48017de48c73a9888080189a35d95e5f305
-  data.tar.gz: 907cc97ad98a88349b1d7b0bb8dbd06c8f04340cf38ecfa5bf4257593b6e1a96515390d916af67a0f8ffd7d5502210a3f0dfe6bf98831288a5e9458bc25f3094
+  metadata.gz: 76cb55701b6c8c2a6464baebeadd91b0fe134bc42ec7d6beb543c4e50b7ee8db5c4951f518350a650c661e26bd3d97e453b5671cb4e37d8a3f92a1ff21dac8ae
+  data.tar.gz: c11c2a318a70225d2cf5773c10245e842f7fdc9fc7c509006d225e004d7be9a43b58b2a2faf2dd0ad1ee424e8aa4e22844266fff898e98726b27c1f5ed1d8009

data/.circleci/config.yml

@@ -0,0 +1,79 @@
+version: 2.1
+orbs:
+  ruby: circleci/ruby@0.1.2
+
+defaults: &defaults
+  working_directory: ~/hemi
+
+ruby_machine: &ruby_machine
+  <<: *defaults
+  docker:
+    - image: ellmo/ruby-hemi:0.0.3
+      environment:
+        RAILS_ENV: test
+        BUNDLE_PATH: vendor/bundle
+        BUNDLER_VERSION: 2.1.4
+  executor: ruby/default
+
+jobs:
+  build:
+    <<: *ruby_machine
+    steps:
+      - checkout
+      - attach_workspace:
+          at: ~/hemi
+      - run:
+          name: Bundle install
+          command: |
+            gem install bundler -v=${BUNDLER_VERSION}
+            bundle install --path=vendor/bundle
+      - run:
+          name: Download cc-test-reporter
+          command: |
+            mkdir -p tmp/
+            curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./tmp/cc-test-reporter
+            chmod +x ./tmp/cc-test-reporter
+      - persist_to_workspace:
+          root: ~/hemi
+          paths:
+            - vendor/bundle
+            - tmp/cc-test-reporter
+
+  test:
+    <<: *ruby_machine
+    steps:
+      - checkout
+      - attach_workspace:
+          at: ~/hemi
+      - run:
+          name: RSpec
+          command: |
+            gem install bundler -v=${BUNDLER_VERSION}
+            bundle exec rspec
+            ./tmp/cc-test-reporter format-coverage -t simplecov -o tmp/codeclimate.backend.json coverage/backend/.resultset.json
+      - persist_to_workspace:
+          root: ~/hemi
+          paths:
+            - tmp/codeclimate.backend.json
+  upload_coverage:
+    <<: *ruby_machine
+    steps:
+      - attach_workspace:
+          at: ~/hemi
+      - run:
+          name: Upload coverage results to Code Climate
+          command: |
+            ./tmp/cc-test-reporter sum-coverage tmp/codeclimate.*.json -p 1 -o tmp/codeclimate.total.json
+            ./tmp/cc-test-reporter upload-coverage -i tmp/codeclimate.total.json
+
+workflows:
+  version: 2
+  build_and_test:
+    jobs:
+      - build
+      - test:
+          requires:
+            - build
+      - upload_coverage:
+          requires:
+            - test

data/.gitignore

@@ -1,8 +1,10 @@
 *.gem
 .DS_store
 .bundle/
-.yardoc/
+.yardoc
 
 vendor/bundle/
 examples/
+coverage/
+doc/
 

data/.rubocop.yml

@@ -41,12 +41,23 @@ Style/ClassAndModuleChildren:
 Style/Documentation:
   Enabled: false
 
+# NAMING
+Naming/FileName:
+  Exclude:
+    - 'demo/**/*'
+
 # RSPEC
 RSpec/ContextWording:
   Enabled: false
+RSpec/MessageSpies:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Max: 5
 RSpec/NamedSubject:
   Enabled: false
 RSpec/NestedGroups:
   Max: 5
+RSpec/SubjectStub:
+  Enabled: false
 RSpec/VerifiedDoubles:
   Enabled: false

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown

data/DEV.md

@@ -0,0 +1,26 @@
+## Development
+(`sdl2` libs are - obviously - still required)
+
+#### 1. Install Ruby and gems
+
+Install specific ruby version using Rbenv (`rbenv install`) or RVM (yuck)
+
+Make sure you have Bundler gem installed for this revsion (`gem install bundler -v=1.17.3`)
+
+And `bundle install` away.
+
+#### 2. Update code (and bump the version)
+
+Dont forget to `git tag` and push with `--tags option`
+
+#### 3. Build and push to Rubygems
+
+`gem build hemi.gemspec`
+
+`gem push hemi-{VERSION}.gem`
+
+And if you need to test gem installation locally:
+
+`gem push hemi-{VERSION}.gem`
+
+

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hemi (0.0.2)
+    hemi (0.0.3)
       pry (~> 0.12)
       ruby-sdl2 (= 0.3.5)
 
@@ -11,6 +11,7 @@ GEM
     ast (2.4.0)
     coderay (1.1.3)
     diff-lcs (1.3)
+    docile (1.3.4)
     jaro_winkler (1.5.4)
     method_source (1.0.0)
     parallel (1.19.1)
@@ -46,7 +47,14 @@ GEM
       rubocop (>= 0.68.1)
     ruby-progressbar (1.10.1)
     ruby-sdl2 (0.3.5)
+    simplecov (0.20.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.2)
     unicode-display_width (1.6.0)
+    yard (0.9.26)
 
 PLATFORMS
   ruby
@@ -57,6 +65,8 @@ DEPENDENCIES
   rubocop (~> 0.77)
   rubocop-performance (~> 1.5)
   rubocop-rspec (~> 1.37)
+  simplecov (~> 0.20)
+  yard (~> 0.9)
 
 BUNDLED WITH
    2.1.4

data/README.md

@@ -7,37 +7,90 @@ Made for self-educational purposes.
 
 ## Usage
 
-#### 1. Required libraries
-
-Install `sdl2`, `sdl2_image`, `sdl2_mixer` and `sdl2_ttf` libraries. For MacOS you can simply `brew install` all of them.
-
-#### 2. Using gem
-
-Refer to [demo](https://github.com/ellmo/hemi/blob/master/demo/loop_machine_demo.rb) for now.
-
-## Development
-(`sdl2` libs are - obviously - still required)
-
-#### 1. Install Ruby and gems
-
-Install specific ruby version using Rbenv (`rbenv install`) or RVM (yuck)
-
-Make sure you have Bundler gem installed for this revsion (`gem install bundler -v=1.17.3`)
-
-And `bundle install` away.
-
-#### 2. Update code (and bump the version)
-
-Dont forget to `git tag` and push with `--tags option`
-
-#### 3. Build and push to Rubygems
-
-`gem build hemi.gemspec`
-
-`gem push hemi-{VERSION}.gem`
-
-And if you need to test gem installation locally:
-
-`gem push hemi-{VERSION}.gem`
-
-
+### 0. Required libraries
+Install `sdl2`, `sdl2_image`, `sdl2_mixer` and `sdl2_ttf` libraries.
+For MacOS you can simply `brew install` all of them.
+
+### 1. Using the gem
+
+#### 1.0 installation
+Install the gem, either straight-up with `gem install hemi` or using Bundler:
+
+```ruby
+# Gemfile
+source "https://rubygems.org"
+
+gem "hemi"
+```
+
+#### 1.1 prepend your starting class
+```ruby
+require "hemi"
+
+class Game
+  prepend Hemi::Engine
+end
+
+```
+
+#### 1.2 prepare a logic proc
+This `proc` will contain logic to be performed during each rendered frame.
+```ruby
+Font   = Hemi::Render::Font
+Sprite = Hemi::Render::Sprite
+
+def text_logic
+  proc {
+    Font[:jost_32].render("quick brown fox jumped over the lazy dog", position: [20, 20])
+    Font[:jost_16].render("press [space] to change LoopState", position: [20, 400])
+    Font[:jost_16].render("press [q] or [esc] to quit", position: [20, 420])
+    Font[:jost_16].render("press [F12] to start debug", position: [20, 440])
+  }
+end
+
+def sprite_logic
+  proc {
+    Sprite[:gem].render(position: { y: 220, x: 20 })
+    Sprite[:gem].render(position: { y: 320, x: 220 }, size: { height: 64, width: 128 })
+    Font[:jost_16].render("press [space] to change LoopState", position: [20, 400])
+    Font[:jost_16].render("press [q] or [esc] to quit", position: [20, 420])
+    Font[:jost_16].render("press [F12] to start debug", position: [20, 440])
+  }
+end
+```
+
+#### 1.3 prepare an {event:action} hash
+```ruby
+LM = Hemi::Event::LoopMachine
+
+def text_events
+  {
+    space: -> { LM.switch(:image) },
+    escape: :stop!,
+    q:      :stop!,
+    f12:    :debug!
+  }
+end
+
+def sprite_events
+  {
+    space: -> { LM.switch(:text) },
+    escape: :stop!,
+    q:      :stop!,
+    f12:    :debug!
+  }
+end
+```
+
+#### 1.4 register Loop Machine states
+```ruby
+def run
+  LM.register(:text, text_logic, text_events)
+  LM.register(:image, sprite_logic, sprite_events)
+end
+```
+
+#### 1.5 and run it
+```ruby
+Game.instance.run
+```

data/hemi.gemspec

@@ -30,4 +30,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop", "~> 0.77"
   spec.add_development_dependency "rubocop-performance", "~> 1.5"
   spec.add_development_dependency "rubocop-rspec", "~> 1.37"
+  spec.add_development_dependency "simplecov", "~> 0.20"
+  spec.add_development_dependency "yard", "~> 0.9"
 end

data/lib/hemi/engine.rb

@@ -4,24 +4,54 @@ require "sdl2"
 require_relative "loader"
 
 module Hemi
+  # Entry-level module, meant to be _prepended_ in the main class of the game using the `hemi` gem.
+  #
+  # Prepending this module allows developers to write their custom +initialize+ and +run+ methods
+  # without overriding any of the mandatory logic. Becasue of the `prepend` behavior,
+  # `Hemi::Engine` will end up first in ancestors' list.
+  #
+  # So, technically, if `Game` implements its own `initialize` / `run` methods, those will be
+  # super-called from `Hemi::Engine`:
+  #
+  # ```ruby
+  # require "hemi"
+  #
+  # class Game
+  #   prepend Hemi::Engine
+  # end
+  #
+  # Game.ancestors
+  # => [Hemi::Engine, Game, Singleton, Object, PP::ObjectMixin, Kernel, BasicObject]
+  # ```
   module Engine
     @debug = false
     @stop  = false
 
+    # Initializes all required `SDL` modules and then proceeds to execute the constructor of the
+    # class it prepends.
     def initialize
       sdl_init
       super
     end
 
+    # @return [SDL2::Window]
+    # @api private
     attr_reader :window
 
-    def sdl_init
-      SDL2.init(SDL2::INIT_EVERYTHING)
-    end
-
     class << self
-      attr_reader :debug, :stop
+      # @return [Boolean] Returns `true` if the engine is set to debugging mode.
+      attr_reader :debug
+      # @return [Boolean] Returns `true` if the engine is set to gracefully exit upon finishing
+      #   this event loop.
+      attr_reader :stop
 
+      # Ran when a class calls to be prepended by this module.
+      #
+      # As mentioned - this module is meant to be _prepended_ in the main game class. When
+      # prepended, this method is automatically ran, making the class a Singleton and makes sure all
+      # `Hemi` modules are loaded in required order.
+      #
+      # @param [Class] klass
       def prepended(klass)
         klass.include Singleton
 
@@ -31,19 +61,47 @@ module Hemi
         Loader.load_tree "event"
       end
 
+      # Sets `@debug` instance variable to `true`. Doing this will trigger the current
+      # {Hemi::Event::LoopMachine#call LoopMachine's} {Hemi::Event::EventLoop EventLoop} to stop at
+      # the nearest `binding.pry` (thus, halting the game and allowing game's current state to be
+      # debugged).
+      #
+      # @note Ideally this method should NOT be called manually, {Hemi::Event::EventLoop EventLoop}
+      #   calls it when it receives an event resulting in a `:debug!` action.
+      #
+      # @api private
       def debug_on!
         @debug = true
       end
 
+      # Sets `@debug` instance variable to `false`. This makes sure that after opening a pry
+      # REPL session and ending it with calling `exit` from pry's REPL, the `@debug` flag is off
+      # and the program can continue operating normally.
+      #
+      # @note Ideally this method should NOT be called manually. It is called internally right after
+      #   {Hemi::Event::LoopMachine#call LoopMachine} handles `binding.pry` in `#debug?` method.
+      #
+      # @api private
       def debug_off!
         @debug = false
       end
 
+      # Sets `@stop` instance variable to `true`. This triggers a _graceful_ exit of the entire
+      # {Hemi::Event::LoopMachine#call LoopMachine's} {Hemi::Event::EventLoop EventLoop} - and,
+      # by extension, exits the program upon the next complete loop.
+      #
+      # @note Ideally this method should NOT be called manually, {Hemi::Event::EventLoop EventLoop}
+      #   calls it when it receives an event resulting in a `:stop!` action.
+      #
+      # @api private
       def stop!
         @stop = true
       end
     end
 
+    # Starts the game engine. Takes care of all custom logic in prepended class' `#run` method, then
+    # initializes a program window and calls {Hemi::Event::LoopMachine LoopMachine} to start running
+    # its event loops.
     def run
       super if defined?(super)
       init_window
@@ -52,6 +110,10 @@ module Hemi
 
   private
 
+    def sdl_init
+      SDL2.init(SDL2::INIT_EVERYTHING)
+    end
+
     def init_window
       @window = Hemi::Render::Window.instance
     end

data/lib/hemi/event/_manifest.rb

@@ -0,0 +1,4 @@
+require_relative "key_handler"
+require_relative "pattern/key"
+require_relative "event_loop"
+require_relative "loop_machine"

data/lib/hemi/event/event_loop.rb

@@ -1,11 +1,10 @@
 module Hemi::Event
   class EventLoop
+    include Hemi::Event::KeyHandler
 
     def initialize(logic, events)
       @logic  = logic
-      @events = events.each_with_object({}) do |(key, action), hsh|
-        hsh[SDL2::Key::Scan.const_get(key.upcase)] = action
-      end
+      register_events!(events)
     end
 
     attr_reader :logic, :events, :event
@@ -17,8 +16,6 @@ module Hemi::Event
       when SDL2::Event::KeyDown
         handle_key
       end
-
-      @event = nil
     end
 
     def process
@@ -27,25 +24,6 @@ module Hemi::Event
 
   private
 
-    def handle_key
-      case action = events[event.scancode]
-      when Symbol
-        instance_eval action.to_s
-      when Proc
-        action.call
-      end
-    end
-
-    def key_event?
-      event.is_a?
-    end
-
-    def key_down
-      return unless key_event?
-
-      SDL2::Key::Scan.const_get(event.scancode).downcase
-    end
-
     def debug!
       Hemi::Engine.debug_on!
     end

data/lib/hemi/event/key_handler.rb

@@ -0,0 +1,30 @@
+module Hemi::Event
+  module KeyHandler
+  private
+
+    def handle_key
+      case action = events[event.structize]
+      when Symbol
+        instance_eval action.to_s
+      when Proc
+        action.call
+      end
+    end
+
+    def register_events!(events)
+      @events = event_hash(events)
+    end
+
+    def event_hash(events)
+      events.each_with_object({}) do |(input, action), hsh|
+        key, mods = if input.is_a? Array
+                      [input.shift, input]
+                    else
+                      input
+                    end
+
+        hsh[Hemi::Event::Pattern::Key.new(key, mods: mods)] = action
+      end
+    end
+  end
+end

data/lib/hemi/event/loop_machine.rb

@@ -1,12 +1,27 @@
 module Hemi::Event
+  # The brain of the operation. A state machine which keeps performing assigned logic, while
+  # listening for assigned events.
   class LoopMachine
     include Singleton
 
     @loops   = {}
     @current = nil
 
+    # @return [SDL2::Event] the last/current SDL event being handled.
+    # @api private
     attr_reader :event
 
+    # Main operation method. Performs these steps in order:
+    #
+    # 1. Wipes the current window (by drawing a black rectangle over it).
+    # 2. Checks if SDL picked up any events and handles them.
+    # 3. Processes the "frame" logic: calculating, moving and drawing to framebuffer.
+    # 4. Copies the frame's content from framebuffer to display (inside the window).
+    # 5. Checks if `Hemi::Engine.debug` has been set to `true`; opens a `pry` session if so.
+    # 6. Checks if `Hemi::Engine.stop` has been set to `true`; breaks from the loop if so.
+    # 7. Sleeps for a hardcoded amount of time.
+    #
+    # @note This method is being automatically called by {Hemi::Engine#run Hemi::Engine's} `#run`.
     def call
       loop do
         Hemi::Render::Window.wipe_screen
@@ -24,9 +39,32 @@ module Hemi::Event
     end
 
     class << self
-      attr_reader :loops, :current
-
-      def register(name, logic = -> {}, events = {})
+      # @return [Hash] A simple collection of "loop-states", with as their keys,
+      #   and {EventLoop} instances as values.
+      attr_reader :loops
+      # @return [EventLoop] The currently active "loop-state", which logic and events are being
+      #   handled in the main `#call` loop.
+      attr_reader :current
+
+      # Registers an {EventLoop} in the `@loops` collection with the `name` as its identifier.
+      # If the collection was empty before registration, the first {EventLoop} is automatically
+      # set as _current_.
+      #
+      # @param [Symbol] name The {EventLoop}'s identifier, i.e. - a key in `@loops` collection.
+      # @param [Proc] logic Proc-wrapped logic to be ran at every iteration of the loop (frame).
+      # @param [Hash] events A simple collection of events and their corresponding actions.
+      #
+      # @example excerpt from demo/01-loop_machine_demo.rb
+      #   class LoopMachineDemo
+      #     prepend Hemi::Engine
+      #     LM = Hemi::Event::LoopMachine
+      #
+      #     def run
+      #      LM.register(:text, text_block, text_events)
+      #      LM.register(:image, sprite_block, sprite_events)
+      #     end
+      #   end
+      def register(name, logic = proc {}, events = {})
         event_loop   = EventLoop.new(logic, events)
         @current     = event_loop if loops.empty?
         @loops[name] = event_loop
@@ -34,14 +72,24 @@ module Hemi::Event
         event_loop
       end
 
+      # Fetch a registered {EventLoop} from `@loops` collection.
+      #
+      # @param [Symbol] name
+      # @return [EventLoop]
       def [](name)
         @loops[name]
       end
 
+      # Transitions to another state, setting its {EventLoop} as `@current`. Starts performing its
+      # logic and listening to its events.
       def switch(name)
         @current = LoopMachine[name]
       end
 
+      # Empties `@loops` collection and sets `@current` state to nil. Currently only used
+      # to ensure spec scenario isolation.
+      #
+      # @api private
       def purge!
         @loops   = {}
         @current = nil

data/lib/hemi/event/pattern/key.rb

@@ -0,0 +1,38 @@
+module Hemi::Event
+  module Pattern
+    class Key
+      MATCHED_EVENT = "SDL2::Event::KeyDown".freeze
+
+      ALLOWED_TYPES = %i[up down].freeze
+      MOD_KEYS = %i[lshift rshift lctrl rctrl lalt ralt lgui rgui].freeze
+
+      def initialize(key, type: :down, mods: nil)
+        @type = type.to_s
+        @key  = key.to_s
+        @mods = mods
+        key_to_scancode
+        mods_to_modcode
+      end
+
+      attr_reader :type, :key, :mods, :scancode, :modcode
+
+      def hash
+        KeyPattern.new(scancode, modcode).hash
+      end
+
+      def inspect
+        "#<#{self.class}:#{hash} key=#{key} mods=#{mods.join(', ')}>"
+      end
+
+      def key_to_scancode
+        @scancode = SDL2::Key::Scan.const_get(key.upcase)
+      end
+
+      def mods_to_modcode
+        @modcode = mods&.sum do |modkey|
+          SDL2::Key::Mod.const_get(modkey.upcase)
+        end || 0
+      end
+    end
+  end
+end

data/lib/hemi/helpers/injections.rb

@@ -0,0 +1,11 @@
+class SDL2::Event
+  def structize
+    KeyPattern.new(scancode, mod)
+  end
+end
+
+class Struct
+  def eql?(other)
+    hash == other.hash
+  end
+end

data/lib/hemi/helpers/simple.rb

@@ -1,2 +1,3 @@
-Size     = Struct.new(:width, :height, keyword_init: true)
-Position = Struct.new(:x, :y, keyword_init: true)
+Size          = Struct.new(:width, :height, keyword_init: true)
+Position      = Struct.new(:x, :y, keyword_init: true)
+KeyPattern    = Struct.new(:scancode, :mod)

data/lib/hemi/loader.rb

@@ -1,11 +1,11 @@
 module Hemi
   module Loader
-    def self.load_tree(tree_dir)
+    def self.load_tree(tree_dir, relative: false)
       if File.exist?(manifest_file = File.join(__dir__, tree_dir, "_manifest.rb"))
-        require manifest_file
+        relative ? require_relative(manifest_file) : require(manifest_file)
       else
         Dir[File.join(__dir__, tree_dir, "**", "*.rb")].sort.each do |file|
-          require file
+          relative ? require_relative(file) : require(file)
         end
       end
     end

data/lib/hemi/render/texture.rb

@@ -2,7 +2,7 @@ module Hemi::Render
   class Texture
     ERR__INVALID_POSITION = "Ivalid position.".freeze
 
-    def initialize(name)
+    def initialize
       raise NotImplementedError
     end
 
@@ -66,7 +66,7 @@ module Hemi::Render
         position_obj.x = position[:x]
         position_obj.y = position[:y]
       else
-        raise ArgumentError(ERR__INVALID_POSITION)
+        raise ArgumentError, ERR__INVALID_POSITION
       end
 
       position_obj

data/lib/hemi/version.rb

@@ -1,3 +1,3 @@
 module Hemi
-  VERSION = "0.0.3".freeze
+  VERSION = "0.0.4".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hemi
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Jakub Żuchowski
@@ -94,25 +94,59 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.37'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 description: 
 email: ellmo@ellmo.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
+- ".yardopts"
+- DEV.md
 - Gemfile
 - Gemfile.lock
 - README.md
 - hemi.gemspec
 - lib/hemi.rb
 - lib/hemi/engine.rb
+- lib/hemi/event/_manifest.rb
 - lib/hemi/event/event_loop.rb
+- lib/hemi/event/key_handler.rb
 - lib/hemi/event/loop_machine.rb
-- lib/hemi/helpers/self_manager.rb
+- lib/hemi/event/pattern/key.rb
+- lib/hemi/helpers/injections.rb
 - lib/hemi/helpers/simple.rb
 - lib/hemi/loader.rb
 - lib/hemi/render/_manifest.rb