gm-notepad 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 810f059bbc2e85fe481e437d815c66bcf6961d2a0db10961185760866d668bc3
-  data.tar.gz: ecbd3218e749bbfda79dd4844a74f77eb550f1b28d8a95bcc847138a99717f86
+  metadata.gz: cf576a76ad9f5f2c4676b9a14d9f3557eeddddf74e2050ebc17a97e3d9f65f65
+  data.tar.gz: 81b1342b09f2321b1efa7dbd3b53acedc21303d27ce8bdb2b3e56888805b896c
 SHA512:
-  metadata.gz: '038db1de31070662c1014545d0b812ddea79ce9e79cf2cce5d30483b6149ce9bdab3a4dcf8367bd22fbb719ac63d6b409ea7a88c41586c1caea2442a7784fbe5'
-  data.tar.gz: aed9015c6102810fbe795654ecf4e2ba5adcfb2f9b038471f32ec44f97452437a8549dfd3fcbecd10efb439f7206639e1f8bc1611eae4c60b0a05465a7498fd9
+  metadata.gz: 78d7865d2e222c20e8acb490637b0442426bad4fb9d739cfb32bbb1f4c283ac92ca5037e96ec80b58bb8bdab55ad48b7dd3d699ac5b28f1817bdc86e4b6cb696
+  data.tar.gz: 00262af2d6920303a49c22946cf7224f8e09e6b0bfe8da2275ae283ce097079256e61574e3bb00f19c17dd48fe0d13aa4a4fd06d85ad0028806cf3661924edd2

data/README.md

@@ -43,8 +43,6 @@ line and render it to one or more of the buffers.
 
 ## Examples
 
-### Simple Help
-
 First, take a look at the help: `$ gm-notepad -h`
 
 ```console
@@ -100,10 +98,10 @@ glob: `./**/*.txt`.
 
 Included in the gem's test suite are four files:
 
-* `./spec/fixtures/name.txt`
-* `./spec/fixtures/first-name.txt`
-* `./spec/fixtures/last-name.txt`
-* `./spec/fixtures/location.csv`
+* ./spec/fixtures/name.txt
+* ./spec/fixtures/first-name.txt
+* ./spec/fixtures/last-name.txt
+* ./spec/fixtures/location.csv
 
 When I run `gm-notepad -l`, `gm-notepad` does the following:
 
@@ -209,34 +207,39 @@ entry has a 1 in 3 chance of being randomly chosen.
 - [X] Colorize puts to `interactive` buffer
 - [X] Disable colors as a configuration option
 - [ ] Write expected interface document
-- [ ] Skip table lines that begin with `#`
+- [ ] Allow `{critical[2d6+1]}` to roll the dice then lookup the value in the critical table
+- [X] Skip table lines that begin with `#`
 - [X] Skip processing input lines that begin with `#`
-- [ ] Allow configuration to specify colors
 - [X] Allow configuration to specify table delimiter
-- [ ] Allow option to add a table to memory (instead of writing the table)
 - [ ] Add option to dump all tables to the given directory
 - [X] Allow configuration for where to dump data
 - [ ] Normalize `WriteToTableHandler` to use a renderer
 - [ ] Normalize `WriteToTableHandler` to deliver on `grep` and `index` behavior
 - [X] Gracefully handle requesting an entry from a table with an index that does not exist (e.g. with test data try `+name[23]`)
 - [X] Gracefully handle `+name[]`, where "name" is a registered table
-- [ ] Add time to live for line expansion (to prevent infinite loops)
+- [ ] Add time to live for line expansion (to prevent infinite loops); I suspect 100 to be reasonable
 - [X] Enable "up" and "down" to scroll through history
 - [ ] Add config that expands dice results while including the requested roll
-- [ ] Determine feasibility of adding dice to the `{}` expansion syntax (instead of the `[]` syntax)
 - [X] Add index name when rendering table entries
 - [ ] Gracefully handle loading a malformed data file (maybe?)
 - [ ] Add force write results to `output`
 - [X] Add concept of history
 - [ ] When expanding tables account for line expansion (via \n and \t)
 - [ ] Separate the InputHandler into pre-amble (e.g. allow overrides to where we are writing, determine what command we are writing)
+- [X] Create a configuration object that captures the initial input (reduce passing around parameters and persisting copies of the config)
+- [ ] Add concept of "journal entry"; its not a table (perhaps) but something that you could capture notes.
+- [ ] Add column handling `{table[][]}`
+- [X] Support `\{\{table}-name}` You should be able to do `\{\{culture}-name}` and first evaluate to `{arabic-name}` and then get a value from the `arabic-name` table
+- [X] Ensure index names are lower-case
+- [ ] Hit 100% spec coverage
+
+### Stretch TODO
+
 - [ ] Handle a `.gm-notepadrc` to inject default configurations
+- [ ] Allow configuration to specify colors
+- [ ] Aspiration: Enable `\{\{monster}[ac]}` to pick a random monster and then fetch that monster's AC
+- [ ] Allow option to add a table to memory (instead of writing the table)
 - [ ] Add auto table expansion for "{}"
 - [ ] Add auto table expansion for "+"
 - [ ] Add auto index expansion for "["
-- [ ] Create a configuration object that captures the initial input (reduce passing around parameters and persisting copies of the config)
-- [ ] Aspiration: Enable `{{monster}[ac]}` to pick a random monster and then fetch that monster's AC
-- [ ] Add concept of "journal entry"; its not a table (perhaps) but something that you could capture notes.
-- [ ] Add column handling `{table[][]}`
-- [X] Support `{{table}-name}` You should be able to do `{{culture}-name}` and first evaluate to `{arabic-name}` and then get a value from the `arabic-name` table
-- [X] Ensure index names are lower-case
+- [ ] Determine feasibility of adding dice to the `{}` expansion syntax (instead of the `[]` syntax)

data/Rakefile

@@ -17,7 +17,7 @@ namespace :commitment do
     lastrun_filename = File.expand_path('../coverage/.last_run.json', __FILE__)
     if File.exist?(lastrun_filename)
       coverage_percentage = JSON.parse(File.read(lastrun_filename)).fetch('result').fetch('covered_percent').to_i
-      EXPECTED_COVERAGE_GOAL = 96
+      EXPECTED_COVERAGE_GOAL = 97
       if coverage_percentage < EXPECTED_COVERAGE_GOAL
         abort("ERROR: Code Coverage Goal Not Met:\n\t#{coverage_percentage}%\tExpected\n\t#{EXPECTED_COVERAGE_GOAL}%\tActual")
       else

data/exe/gm-notepad

@@ -2,22 +2,7 @@
 require 'gm/notepad'
 
 require 'optparse'
-config = {
-  report_config: false,
-  defer_output: false,
-  filesystem_directory: '.',
-  interactive_buffer: $stderr,
-  interactive_color: true,
-  output_color: false,
-  list_tables: false,
-  output_buffer: $stdout,
-  paths: ['.'],
-  column_delimiter: Gm::Notepad::DEFAULT_COLUMN_DELIMITER,
-  shell_prompt: Gm::Notepad::DEFAULT_SHELL_PROMPT,
-  skip_readlines: false,
-  table_extension: '.txt',
-  with_timestamp: false
-}
+config = Gm::Notepad::Configuration::CLI_CONFIG_DEFAULTS.clone
 
 command_name = File.basename(__FILE__)
 

data/lib/gm/notepad/configuration.rb

@@ -0,0 +1,130 @@
+require 'gm/notepad/defaults'
+module Gm
+  module Notepad
+    # Global configuration values
+    class Configuration
+      CLI_CONFIG_DEFAULTS = {
+        report_config: false,
+        defer_output: false,
+        filesystem_directory: '.',
+        interactive_buffer: $stderr,
+        interactive_color: true,
+        output_color: false,
+        list_tables: false,
+        output_buffer: $stdout,
+        paths: ['.'],
+        column_delimiter: Gm::Notepad::DEFAULT_COLUMN_DELIMITER,
+        shell_prompt: Gm::Notepad::DEFAULT_SHELL_PROMPT,
+        skip_readlines: false,
+        table_extension: '.txt',
+        with_timestamp: false
+      }.freeze
+
+      # NOTE: ORDER MATTERS! I have a temporal dependency in these
+      # defaults
+      INTERNAL_CONFIG_DEFAULTS_METHOD_NAMES = [
+        :table_registry,
+        :input_handler_registry,
+        :input_processor,
+        :renderer,
+      ]
+
+      def self.init!(target:, from_config: [], additional_params: [], &block)
+        # Need to rebind the parameter
+        _additional_params = additional_params
+        target.define_method(:initialize) do |config: nil, **params|
+          @config = config || CLI_CONFIG_DEFAULTS
+          from_config.each do |method_name|
+            send("#{method_name}=", @config[method_name])
+          end
+          _additional_params.each do |key|
+            send("#{key}=", params.fetch(key))
+          end
+          instance_exec(&block) if block
+        end
+        from_config.each do |method_name|
+          target.module_exec do
+            attr_accessor(method_name)
+            protected "#{method_name}="
+          end
+        end
+        _additional_params.each do |method_name|
+          target.module_exec do
+            attr_accessor(method_name)
+            protected "#{method_name}="
+          end
+        end
+        target.attr_reader :config
+      end
+
+      def initialize(input_handler_registry: nil, table_registry: nil, renderer: nil, input_processor: nil, **overrides)
+        CLI_CONFIG_DEFAULTS.each_pair do |key, default_value|
+          value = overrides.fetch(key, default_value)
+          if !value.is_a?(IO)
+            value = value.clone
+            value.freeze
+          end
+          self.send("#{key}=", value)
+        end
+        self.table_registry = (table_registry || default_table_registry)
+        self.input_handler_registry = (input_handler_registry || default_input_handler_registry)
+        self.renderer = (renderer || default_renderer)
+        self.input_processor = (input_processor || default_input_processor)
+      end
+      attr_reader(*CLI_CONFIG_DEFAULTS.keys)
+      attr_reader(*INTERNAL_CONFIG_DEFAULTS_METHOD_NAMES)
+
+      def to_hash
+        config = CLI_CONFIG_DEFAULTS.keys.each_with_object({}) do |key, mem|
+          mem[key] = send(key)
+        end
+        INTERNAL_CONFIG_DEFAULTS_METHOD_NAMES.each_with_object(config) do |key, mem|
+          mem[key] = send(key)
+        end
+      end
+
+      def [](value)
+        public_send(value)
+      end
+
+      private
+      attr_writer(*CLI_CONFIG_DEFAULTS.keys)
+      attr_writer(*INTERNAL_CONFIG_DEFAULTS_METHOD_NAMES)
+
+      def default_input_processor
+        require "gm/notepad/input_processor"
+        InputProcessor.new(config: self)
+      end
+
+      def default_table_registry
+        require "gm/notepad/table_registry"
+        TableRegistry.load_for(config: self)
+      end
+
+      def default_renderer
+        require 'gm/notepad/line_renderer'
+        LineRenderer.new(config: self)
+      end
+
+      def default_input_handler_registry
+        # Order matters. The first registered will be the first to
+        # answer "Can you handle the input?"
+        require "gm/notepad/input_handler_registry"
+        require "gm/notepad/input_handlers/help_handler"
+        require "gm/notepad/input_handlers/comment_handler"
+        require "gm/notepad/input_handlers/query_table_handler"
+        require "gm/notepad/input_handlers/query_table_names_handler"
+        require "gm/notepad/input_handlers/write_to_table_handler"
+        require "gm/notepad/input_handlers/write_line_handler"
+        InputHandlerRegistry.new do |registry|
+          registry.register(handler: InputHandlers::HelpHandler)
+          registry.register(handler: InputHandlers::CommentHandler)
+          registry.register(handler: InputHandlers::QueryTableHandler)
+          registry.register(handler: InputHandlers::QueryTableNamesHandler)
+          registry.register(handler: InputHandlers::WriteToTableHandler)
+          registry.register(handler: InputHandlers::WriteLineHandler)
+        end
+      end
+    end
+  end
+end

data/lib/gm/notepad/input_handlers/comment_handler.rb

@@ -3,10 +3,10 @@ module Gm
   module Notepad
     module InputHandlers
       class CommentHandler < DefaultHandler
-        COMMEND_PREFIX = '#'.freeze
+        COMMENT_PREFIX = '#'.freeze
 
         def self.handles?(input:)
-          return false unless input[0] == COMMEND_PREFIX
+          return false unless input[0] == COMMENT_PREFIX
           true
         end
 

data/lib/gm/notepad/input_processor.rb

@@ -1,12 +1,9 @@
-
+require 'gm/notepad/configuration'
 module Gm
   module Notepad
     # Responsible for processing the given input into a renderable state
     class InputProcessor
-      def initialize(table_registry:, **config)
-        self.table_registry = table_registry
-        self.input_handler_registry = config.fetch(:input_handler_registry) { default_input_handler_registry }
-      end
+      Configuration.init!(target: self, from_config: [:table_registry, :input_handler_registry])
 
       def process(input:)
         processor = build_for(input: input)
@@ -15,9 +12,6 @@ module Gm
         end
       end
 
-      attr_accessor :table_registry, :input_handler_registry
-      private :table_registry=, :input_handler_registry
-
       private
 
       def build_for(input:)
@@ -26,24 +20,6 @@ module Gm
         handler.table_registry = table_registry
         handler
       end
-
-      def default_input_handler_registry
-        require "gm/notepad/input_handler_registry"
-        require "gm/notepad/input_handlers/help_handler"
-        require "gm/notepad/input_handlers/comment_handler"
-        require "gm/notepad/input_handlers/query_table_handler"
-        require "gm/notepad/input_handlers/query_table_names_handler"
-        require "gm/notepad/input_handlers/write_to_table_handler"
-        require "gm/notepad/input_handlers/write_line_handler"
-        InputHandlerRegistry.new do |registry|
-          registry.register(handler: InputHandlers::HelpHandler)
-          registry.register(handler: InputHandlers::CommentHandler)
-          registry.register(handler: InputHandlers::QueryTableHandler)
-          registry.register(handler: InputHandlers::QueryTableNamesHandler)
-          registry.register(handler: InputHandlers::WriteToTableHandler)
-          registry.register(handler: InputHandlers::WriteLineHandler)
-        end
-      end
     end
   end
 end

data/lib/gm/notepad/line_evaluator.rb

@@ -7,9 +7,11 @@ module Gm
       DICE_REGEXP = %r{(?<dice_container>\[(?<dice>[^\]]+)\])}
       def call(line:, table_lookup_function:, expand_line: true)
         return line unless expand_line
-        while match = line.match(TABLE_NAME_REGEXP)
+        match = line.match(TABLE_NAME_REGEXP)
+        while match
           evaluated_table_name = table_lookup_function.call(table_name: match[:table_name].strip)
           line = line.sub(match[:table_name_container], evaluated_table_name)
+          match = line.match(TABLE_NAME_REGEXP)
         end
         while match = line.match(DICE_REGEXP)
           if parsed_dice = Dice.parse(match[:dice])

data/lib/gm/notepad/line_renderer.rb

@@ -1,21 +1,18 @@
+require 'gm/notepad/configuration'
 require 'time'
 require 'term/ansicolor'
 module Gm
   module Notepad
     # Responsible for rendering lines to the corresponding buffers
     class LineRenderer
-      def initialize(defer_output:, output_buffer: default_output_buffer, interactive_buffer: default_interactive_buffer, **config)
-        self.config = config
-        self.output_buffer = output_buffer
-        self.interactive_buffer = interactive_buffer
-        @defer_output = defer_output
+      Configuration.init!(target: self, from_config: [:with_timestamp, :defer_output, :output_buffer, :interactive_buffer]) do
         @lines = []
         yield(self) if block_given?
       end
 
       def call(lines, to_output: false, to_interactive: true, as_of: Time.now)
         render_interactive(lines) if to_interactive
-        render_output(lines, defer_output: defer_output, as_of: as_of) if to_output
+        render_output(lines, defer_output: config[:defer_output], as_of: as_of) if to_output
       end
 
       def close!
@@ -25,15 +22,6 @@ module Gm
 
       private
 
-      attr_accessor :config
-
-      # When true, we defer_output writing until we close the notepad
-      # When false, we write immediately to the output buffer
-      attr_reader :defer_output
-
-      # The receiver of interactive messages
-      attr_reader :interactive_buffer
-
       def interactive_buffer=(buffer)
         if config[:interactive_color]
           @interactive_buffer = BufferWrapper.new(buffer, color: :faint, as: :interactive)
@@ -42,9 +30,6 @@ module Gm
         end
       end
 
-      # The receiver of output
-      attr_reader :output_buffer
-
       def output_buffer=(buffer)
         if config[:output_color]
           @output_buffer = BufferWrapper.new(buffer, color: :bold, as: :output)
@@ -53,15 +38,9 @@ module Gm
         end
       end
 
-
-      # When writing to output_buffer, should we prefix with a timestamp?
-      def with_timestamp?
-        config.fetch(:with_timestamp, false)
-      end
-
       def render_output(lines, defer_output:, as_of:)
         Array(lines).each do |line|
-          if with_timestamp?
+          if config[:with_timestamp]
             line = "#{as_of}\t#{line}"
           end
           if defer_output
@@ -77,14 +56,6 @@ module Gm
           interactive_buffer.puts("=>\t#{line}")
         end
       end
-
-      def default_output_buffer
-        $stdout
-      end
-
-      def default_interactive_buffer
-        $stderr
-      end
     end
 
     # To provide a means for colorizing the output

data/lib/gm/notepad/pad.rb

@@ -1,13 +1,9 @@
+require 'gm/notepad/configuration'
 module Gm
   module Notepad
     # Responsible for recording entries and then dumping them accordingly.
     class Pad
-      attr_reader :config
-      def initialize(**config)
-        self.config = config
-        self.table_registry = config.fetch(:table_registry) { default_table_registry }
-        self.renderer = config.fetch(:renderer) { default_renderer }
-        self.input_processor = config.fetch(:input_processor) { default_input_processor }
+      Notepad::Configuration.init!(target: self, from_config: [:table_registry, :renderer, :input_processor]) do
         open!
       end
 
@@ -18,57 +14,22 @@ module Gm
       end
 
       def close!
-        @renderer.close!
+        renderer.close!
       end
 
-      attr_reader :table_registry
-
       private
 
-      attr_reader :renderer
       def open!
-        return unless config[:report_config]
+        return unless config.report_config
         lines = ["# Configuration Parameters:"]
         config.each_pair do |key, value|
           lines << "#   config[#{key.inspect}] = #{value.inspect}"
         end
         # When running :list_tables by default I don't want to report
         # that to the output buffer.
-        to_output = !config[:list_tables]
+        to_output = !config.list_tables
         renderer.call(lines, to_interactive: true, to_output: to_output)
       end
-
-      attr_accessor :renderer, :input_processor
-      attr_writer :config, :table_registry
-
-      def default_input_processor
-        require "gm/notepad/input_processor"
-        InputProcessor.new(table_registry: table_registry)
-      end
-
-      def default_table_registry
-        require "gm/notepad/table_registry"
-        TableRegistry.load_for(**config)
-      end
-
-      def default_renderer
-        require 'gm/notepad/line_renderer'
-        LineRenderer.new(
-          with_timestamp: config.fetch(:with_timestamp, false),
-          defer_output: config.fetch(:defer_output, false),
-          output_buffer: config.fetch(:output_buffer, default_output_buffer),
-          interactive_buffer: config.fetch(:interactive_buffer, default_interactive_buffer),
-          **config
-        )
-      end
-
-      def default_output_buffer
-        $stdout
-      end
-
-      def default_interactive_buffer
-        $stderr
-      end
     end
   end
 end

data/lib/gm/notepad/readline.rb

@@ -23,6 +23,11 @@ module Gm
       # Hook-in the above completion function
       ::Readline.completion_proc = completion_function
 
+      # In the interactive shell, where are we sending the prompts?
+      # If this defaults to $stdout then if we are directing $stdout
+      # to a file, we end up typing blind into the terminal
+      ::Readline.output = $stderr
+
       def self.input_getter(**config)
         -> { ::Readline.readline("#{config.fetch(:shell_prompt, ">")}  ", true) }
       end

data/lib/gm/notepad/table.rb

@@ -4,10 +4,7 @@ require "gm/notepad/table_entry"
 module Gm
   module Notepad
     class Table
-      def initialize(table_name:, lines:, filename: nil, **config)
-        self.config = config
-        self.table_name = table_name
-        self.filename = filename
+      Configuration.init!(target: self, additional_params: [:table_name, :filename, :lines]) do
         process(lines: lines)
       end
 
@@ -58,6 +55,7 @@ module Gm
       def process(lines:)
         @table = {}
         lines.each do |line|
+          next if line[0] == '#'
           entry = TableEntry.new(line: line, **config)
           entry.lookup_range.each do |i|
             key = i.to_s

data/lib/gm/notepad/table_entry.rb

@@ -3,8 +3,7 @@ module Gm
   module Notepad
     TABLE_ENTRY_RANGE_MARKER = "-".freeze
     class TableEntry
-      def initialize(line:, column_delimiter: DEFAULT_COLUMN_DELIMITER, **config)
-        self.column_delimiter = column_delimiter
+      Configuration.init!(target: self, from_config: [:column_delimiter], additional_params: [:line]) do
         self.lookup_column, self.entry_column = line.split(column_delimiter)
       end
 
@@ -31,8 +30,6 @@ module Gm
 
       private
 
-      attr_accessor :column_delimiter
-
       def lookup_column=(input)
         @lookup_column = input.strip.downcase.freeze
       end

data/lib/gm/notepad/table_registry.rb

@@ -1,23 +1,20 @@
 require "gm/notepad/table"
 require "gm/notepad/exceptions"
+require 'gm/notepad/line_evaluator'
 
 module Gm
   module Notepad
     # Responsible for loading and registering all of the named tables
     class TableRegistry
-      def self.load_for(**config)
-        table_registry = new(**config)
+      def self.load_for(config:)
+        table_registry = new(config: config)
         table_registry.load!
         table_registry
       end
 
-      def initialize(line_evaluator: default_line_evaluator, **config)
-        self.config = config
-        self.line_evaluator = line_evaluator
-        self.paths = config.fetch(:paths) { [] }
-        self.table_extension = config.fetch(:table_extension) { ".txt" }
-        self.filesystem_directory = config.fetch(:filesystem_directory) { "." }
+      Configuration.init!(target: self, from_config: [:paths, :table_extension, :filesystem_directory]) do
         @registry = {}
+        @line_evaluator = LineEvaluator.new
       end
 
       def load!
@@ -29,16 +26,14 @@ module Gm
         end
       end
 
-      private
-      attr_accessor :line_evaluator, :paths, :table_extension, :filesystem_directory, :config
-      public
+      attr_reader :line_evaluator, :registry
 
       def table_names
-        @registry.keys.sort
+        registry.keys.sort
       end
 
       def fetch_table(name:)
-        @registry.fetch(name.downcase)
+        registry.fetch(name.downcase)
       end
 
       def append(table_name:, line:, write:)
@@ -76,13 +71,8 @@ module Gm
 
       def register(table_name:, lines:, filename: nil)
         table_name = table_name.downcase
-        raise DuplicateKeyError.new(key: table_name, object: self) if @registry.key?(table_name.downcase)
-        @registry[table_name] = Table.new(table_name: table_name, lines: lines, filename: filename, **config)
-      end
-
-      def default_line_evaluator
-        require 'gm/notepad/line_evaluator'
-        LineEvaluator.new
+        raise DuplicateKeyError.new(key: table_name, object: self) if registry.key?(table_name.downcase)
+        registry[table_name] = Table.new(config: config, table_name: table_name, lines: lines, filename: filename)
       end
     end
   end

data/lib/gm/notepad/version.rb

@@ -1,5 +1,5 @@
 module Gm
   module Notepad
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/lib/gm/notepad.rb

@@ -1,10 +1,12 @@
 require "gm/notepad/version"
 require "gm/notepad/defaults"
 require "gm/notepad/pad"
+require "gm/notepad/configuration"
 module Gm
   module Notepad
     def self.new(*args)
-      Pad.new(*args)
+      config = Configuration.new(*args)
+      Pad.new(config: config)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gm-notepad
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Jeremy Friesen
@@ -144,6 +144,7 @@ files:
 - exe/gm-notepad
 - gm-notepad.gemspec
 - lib/gm/notepad.rb
+- lib/gm/notepad/configuration.rb
 - lib/gm/notepad/defaults.rb
 - lib/gm/notepad/exceptions.rb
 - lib/gm/notepad/input_handler_registry.rb