gm-notepad 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce5817b9b619d272b6b534d4da74e9474fb15a5cbfc1dd21ac1094ec2aed844d
-  data.tar.gz: a82515600b627a7b0227305cb7430a548d53d0bdf006b633390da5da80c9af8a
+  metadata.gz: fea81d64cf4d80ba35966cfb2cf36ed00edf206307f46bad9c7d07dc524da732
+  data.tar.gz: b3d9513020a6db543dd6551214aca212c0bc94124fc2a0debbe4e379357606e0
 SHA512:
-  metadata.gz: 5c0eb020328774f1e4395f4609fef3da8bd15957f1a97acba14d2d492eee854322d7288ad55ee486ee39774464134f34a3ce9e4150900aa966913a78a4665d00
-  data.tar.gz: 54da4151c52a779dd42324efe1520e066db65c696e108ccf2780c5f756f9b97f84bb66a3538d43b229d2f8973c818c45e1e390defe69600c45d867470e8db293
+  metadata.gz: 2583aa8b65971bd9c8bf7a34246ae710e5ab315ccc937e7721862bb67b331a2b911b2bce9edc15e020034b5f1e3c4725ace64a8daf15bb0b7472ec51cf835e0a
+  data.tar.gz: e7008f2fcb80279c398c22fafda4a182346df1d8383c95de181d6489a401d06c587e5f9f5271b39d08e3ce4615c9082cc1ddc9092e91ee00fa0748c3e9d02100

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --color
+--order rand

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2019 Jeremy Friesen
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -6,6 +6,29 @@ A command-line tool to help with your GM-ing.
 
 `$ gem install gm-notepad`
 
+## Background
+
+On a commute home from work, while listening to [Judd Karlman's "Daydreaming about Dragons" podcast](https://anchor.fm/daydreaming-about-dragons/)
+he wondered about ways to organize notes for NPCs. And I started thinking. How
+might I organize my content for access while gaming? And what kind of
+content? More importantly, what kind of tasks do I need to complete as a GM.
+
+* Remember a character name
+* Lookup their passive perception
+* Lookup a random table
+* Roll on a random table
+* Create a random character name. Maybe based on a culture.
+* Record quick notes about an NPC
+
+I thought about `swnt`, and command line tool for Stars without Numbers.
+See the [github project](https://github.com/nboughton/swnt) for more information.
+
+And I thought about [Alex Schroeder's tools](https://alexschroeder.ch/wiki/RPG).
+
+I have kicked this around for awhile. I made an attempt in [Rollio](https://github.com/jeremyf/rollio).
+But I built that to roll on tables. I needed something more general.
+_I will, however, begin converting the data._
+
 ## Introduction
 
 By default `gm-notepad` interacts with `$stdout` and `$stderr`. There are
@@ -30,34 +53,44 @@ Note taking tool with random table expansion.
 
 Examples:
 	$ gm-notepad
-	$ gm-notepad rolls.txt
+	$ gm-notepad filename
 	$ echo '{name}' | gm-notepad
 
-Specific options:
-        --timestamp                  Append a timestamp to the note (Default: false)
-    -c, --config_reporting           Dump the configuration data (Default: false)
+Options:
+    -l, --list_tables                List tables loaded and exit (Default: false)
+    -r, --report_config              Dump the configuration data (Default: false)
+    -p, --path=PATH                  Path(s) for {table_name}.<config.table_extension> files (Default: ["."])
+    -f, --filesystem_directory=DIR   Path to dump tables (Default: ".")
+    -x, --table_extension=EXT        Extension to use for selecting tables (Default: ".txt")
+    -t, --timestamp                  Append a timestamp to the note (Default: false)
     -d, --defer_output               Defer output until system close (Default: false)
-    -p, --path=PATH                  Path for {table_name}.<config.table_extension> files (Default: ["."])
-    -t, --table_extension=EXT        Path for {table_name}.<config.table_extension> files (Default: ".txt")
-    -l, --list_tables                List tables loaded (Default: nil)
+
+Color options:
+    -i, --skip-interactive-color     Disable color rendering for interactive buffer (Default: false)
+    -o, --with-output-color          Enable color rendering for output buffer (Default: false)
+
     -h, --help                       You're looking at it!
 ```
 
 At it's core, `gm-shell` interacts with named tables. A named table is a file
 found amongst the specified `paths` and has the specified `table_extension`.
-Let's take a look at the defaults. In a new shell, type: `$ gm-notepad -c`
+Let's take a look at the defaults. In a new shell, type: `$ gm-notepad -r`
 
 Which writes the following to the `interactive` buffer (eg. `$stderr`)::
 
 ```console
-=>	# Configuration Parameters:
-=>	#   config[:config_reporting] = false
-=>	#   config[:defer_output] = false
-=>	#   config[:interactive_buffer] = #<IO:<STDERR>>
-=>	#   config[:output_buffer] = #<IO:<STDOUT>>
-=>	#   config[:paths] = ["."]
-=>	#   config[:table_extension] = ".txt"
-=>	#   config[:with_timestamp] = false
+# Configuration Parameters:
+#   config[:report_config] = true
+#   config[:defer_output] = false
+#   config[:filesystem_directory] = "."
+#   config[:interactive_buffer] = #<IO:<STDERR>>
+#   config[:interactive_color] = true
+#   config[:output_color] = false
+#   config[:list_tables] = false
+#   config[:output_buffer] = #<IO:<STDOUT>>
+#   config[:paths] = ["."]
+#   config[:table_extension] = ".txt"
+#   config[:with_timestamp] = false
 ```
 
 You'll need to exit out (CTRL+D).
@@ -65,11 +98,12 @@ You'll need to exit out (CTRL+D).
 By default `gm-notepad` will load as tables all files matching the following
 glob: `./**/*.txt`.
 
-Included in the gem's test suite are three files:
+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`
 
 When I run `gm-notepad -l`, `gm-notepad` does the following:
 
@@ -78,10 +112,11 @@ When I run `gm-notepad -l`, `gm-notepad` does the following:
 * puts the table_names to the `interactive` buffer
 * exits
 
-Below are the table names when you run the `gm-notepad` against the
-repository:
+Below are the table names when you run the `gm-notepad -l` against the
+repository (note when you run this command you'll get a preamble of the config):
 
 ```console
+=>	character
 =>	first-name
 =>	last-name
 =>	name
@@ -99,7 +134,7 @@ You now have an interactive shell for `gm-notepad`. Type `?` and hit
 =>	Prefixes:
 =>		? - Help (this command)
 =>		+ - Query table names and contents
-=>		<table_name> - Write the results to the given table
+=>		<table_name: - Write the results to the given table
 =>
 =>	Tokens:
 =>		! - Skip expansion
@@ -114,20 +149,26 @@ the following: `+first-name`
 `gm-notepad` will write the following to `interactive` buffer (eg. `$stderr`):
 
 ```console
-=>	Frodo
-=>	Merry
-=>	Pippin
-=>	Sam
-=>	{first-name}Wise
+=>	[1]	Frodo
+=>	[2]	Merry
+=>	[3]	Pippin
+=>	[4]	Sam
+=>	[5-6]	{first-name}Wise
 ```
 
-These are the five table entries in the `first-name` table. Notice the fifth
-entry: `{first-name}Wise`. The `{first-name}` references a table named
-"first-name" (the same on you are looking at). Now type the following in your `gm-notepad`
-session: `Hello {first-name}`
+These are the five table entries in the `first-name` table.
+"Frodo" is at index `1`. "Merry", "Pippin", and "Sam" are at indices 2,3,4
+respectively. For the fifth line there are two things happening. First the
+index spans a range. Second, notice the entry: `{first-name}Wise`. The
+`{first-name}` references a table named "first-name" (the same on you are
+looking at). Now type the following in your `gm-notepad` session: `Hello {first-name}`
 
 `gm-notepad` will read the line and recursively expand the `{first-name}` and
-write the result to the `interactive` buffer and `output` buffer.
+write the result to the `interactive` buffer and `output` buffer. The expander
+randomly picks a name from all entries, with ranges increasing the chance of
+being picked. In the above table "Frodo", "Merry", "Pippin", and "Sam" each
+have a 1 in 6 chance of being picked. And "{first-name}Wise" has a 2 in 6
+chance.
 
 In the session you might have something like the below:
 
@@ -145,19 +186,54 @@ session type the following: `{first-name} owes [2d6]gp to {first-name}`:
 Frodo owes 3gp to SamWise
 ```
 
-And there you go.
+Let's take a look at the `+character` table. Your table indices need not be
+numbers. And you can mix numbers and text. _If you expand the table via
+`{table}` each text index counts as 1 entry. For the below table, each
+entry has a 1 in 3 chance of being randomly chosen.
+
+```console
+=>	[name]	Grell
+=>	[ac]	15
+=>	[hd]	12D12
+```
+
+## Testing Locally
+
+* Clone the repository
+* Bundle the dependencies (`$ bundle install`)
+* Run the specs (`$ bundle exec rspec`)
+* Run the command from the repository (`$ bundle exec exe/gm-notepad`)
 
 ## Todo
 
-- [ ] Colorize puts to `interactive` buffer
+- [X] Colorize puts to `interactive` buffer
+- [X] Disable colors as a configuration option
+- [ ] Write expected interface document
+- [ ] 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
-- [ ] Gracefully handle requesting an entry from a table with an index that does not exist (e.g. with test data try `+name[23]`)
-- [ ] Gracefully handle `+name[]`, where "name" is a registered table
+- [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)
-- [ ] Enable "up" and "down" to scroll through history
+- [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)
-- [ ] Add index name when rendering table entries
+- [X] Add index name when rendering table entries
+- [ ] Gracefully handle loading a malformed data file (maybe?)
 - [ ] Add force write results to `output`
-- [ ] Add concept of history
+- [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)
+- [ ] Handle a `.gm-notepadrc` to inject default configurations
+- [ ] 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.

data/Rakefile

@@ -1,6 +1,33 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  ENV['COVERAGE'] = 'true'
+end
 
-task :default => :spec
+namespace :commitment do
+  task :configure_test_for_code_coverage do
+    ENV['COVERAGE'] = 'true'
+  end
+  task :code_coverage do
+    require 'json'
+    $stdout.puts "Checking code_coverage"
+    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
+      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
+        $stdout.puts "Code Coverage Goal Met (at least #{EXPECTED_COVERAGE_GOAL}% coverage)"
+      end
+    else
+      abort "Expected #{lastrun_filename} to exist for code coverage"
+    end
+  end
+end
+
+task(default: ['commitment:configure_test_for_code_coverage', :spec, 'commitment:code_coverage'])
+task(release: :default)

data/examples/basic_example_file

@@ -0,0 +1,14 @@
+# Write entry `1|entry one` to in memory table `basic_example`
+<#basic_example:1|entry one
+# Should render to interactive the internal help
+?
+# Should render to interactive the given tables
++
+# Should render to interactive the table `basic_example`
++basic_example
+# Should render `entry one`
+{basic_example}
+# Should append entry `2|entry two` into memory table `basic_example`
+<basic_example:2|entry two
+# Should dump basic_example onto the file system
++basic_example>

data/exe/gm-notepad

@@ -3,11 +3,18 @@ require 'gm/notepad'
 
 require 'optparse'
 config = {
-  config_reporting: false,
+  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
 }
@@ -20,37 +27,59 @@ OptionParser.new do |options|
     "Note taking tool with random table expansion.\n\n" \
     "Examples:\n" \
     "\t$ #{command_name}\n" \
-    "\t$ #{command_name} rolls.txt\n" \
-    "\t$ echo '{name}' | #{command_name}"
+    "\t$ #{command_name} filename \n" \
+    "\t$ echo '{name}' | #{command_name}\n\n" \
+    "Options:\n"
 
-  # Separator just adds a new line with the specified text.
-  options.separator ""
-  options.separator "Specific options:"
-
-  options.on("-t", "--timestamp", "Append a timestamp to the note (Default: #{config[:with_timestamp].inspect})") do |timestamp|
-    config[:with_timestamp] = timestamp
+  options.on_head("-l", "--list_tables", "List tables loaded and exit (Default: #{config[:list_tables].inspect})") do |list_tables|
+    config[:list_tables] = list_tables
   end
 
-  options.on("-c", "--config_reporting", "Dump the configuration data (Default: #{config[:config_reporting].inspect})") do |config_reporting|
-    config[:config_reporting] = config_reporting
+  options.on("-r", "--report_config", "Dump the configuration data (Default: #{config[:report_config].inspect})") do |report_config|
+    config[:report_config] = report_config
   end
 
-  options.on("-d", "--defer_output", "Defer output until system close (Default: #{config[:defer_output].inspect})") do |defer_output|
-    config[:defer_output] = defer_output
+  options.on("-pPATH", "--path=PATH", String, "Path(s) for {table_name}.<config.table_extension> files (Default: #{config[:paths].inspect})") do |path|
+    config[:paths] << path
   end
 
-  options.on("-pPATH", "--path=PATH", String, "Path for {table_name}.<config.table_extension> files (Default: #{config[:paths].inspect})") do |path|
-    config[:paths] << path
+  options.on("-fDIR", "--filesystem_directory=DIR", String, "Path to dump tables (Default: #{config[:filesystem_directory].inspect})") do |filesystem_directory|
+    # Should we guard that this exists?
+    config[:filesystem_directory] = filesystem_directory
   end
 
-  options.on("-tEXT", "--table_extension=EXT", String, "Path for {table_name}.<config.table_extension> files (Default: #{config[:table_extension].inspect})") do |table_extension|
+  options.on("-xEXT", "--table_extension=EXT", String, "Extension to use for selecting tables (Default: #{config[:table_extension].inspect})") do |table_extension|
     config[:table_extension] = table_extension
   end
 
-  options.on("-l", "--list_tables", "List tables loaded (Default: #{config[:list_tables].inspect})") do |list_tables|
-    config[:list_tables] = list_tables
+  options.on("-dDELIM", "--delimiter=DELIM", String, "Default column delimiter for tables (Default: #{config[:column_delimiter].inspect})") do |column_delimiter|
+    map = { "t" => "\t" }
+    config[:column_delimiter] = map.fetch(column_delimiter) { column_delimiter }
+  end
+
+  options.separator("")
+  options.separator("Output options:")
+  options.on("-t", "--timestamp", "Append a timestamp to the note (Default: #{config[:with_timestamp].inspect})") do |timestamp|
+    config[:with_timestamp] = timestamp
   end
 
+  options.on("--defer_output", "Defer output until system close (Default: #{config[:defer_output].inspect})") do |defer_output|
+    config[:defer_output] = defer_output
+  end
+
+  options.separator("")
+  options.separator("Color options:")
+
+  options.on("-i", "--skip-interactive-color", "Disable color rendering for interactive buffer (Default: #{!config[:interactive_color].inspect})") do |interactive_color|
+    config[:interactive_color] = !interactive_color
+  end
+
+  options.on("-o", "--with-output-color", "Enable color rendering for output buffer (Default: #{!config[:output_color].inspect})") do |output_color|
+    config[:output_color] = output_color
+  end
+
+  options.separator("")
+
   options.on_tail("-h", "--help", "You're looking at it!") do
     $stderr.puts options
     exit 1
@@ -58,26 +87,35 @@ OptionParser.new do |options|
 end.parse!
 
 if config[:list_tables]
-  notepad = Gm::Notepad.new(config.merge(config_reporting: true))
+  notepad = Gm::Notepad.new(config.merge(report_config: true))
   notepad.process(input: "+")
   exit(1)
 end
 
 begin
   @notepad = Gm::Notepad.new(**config)
-  # Keep reading lines of input as long as they're coming.
-  while input = ARGF.gets
+  if config.fetch(:skip_readlines)
+    input_getter = -> { print "#{config.fetch(:shell_prompt)}  "; ARGF.gets }
+  else
+    require 'gm/notepad/readline'
+    input_getter = Gm::Notepad::Readline.input_getter(**config)
+  end
+  while input = input_getter.call
+  # # Keep reading lines of input as long as they're coming.
     input.each_line do |input|
       begin
         @notepad.process(input: input)
       rescue Errno::EPIPE
+        @notepad.close!
+
         # sysexits(3) specifies that exit code 74 represent an IO error,
         # which is the likely situation
-        @notepad.close!
         exit(74)
       end
     end
   end
+rescue => e
+  $stderr.puts e
 ensure
   @notepad.close!
 end

data/gm-notepad.gemspec

@@ -12,6 +12,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{A command line tool for GM-ing}
   spec.description   = %q{A command line tool for GM-ing}
   spec.homepage      = "https://github.com/jeremyf/gm-notepad"
+  spec.license       = "APACHE2"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
@@ -21,9 +22,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "dice_parser"
+  spec.add_dependency "term-ansicolor"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "simplecov"
 end

data/lib/gm/notepad/defaults.rb

@@ -0,0 +1,6 @@
+module Gm
+  module Notepad
+    DEFAULT_SHELL_PROMPT = "🗒".freeze
+    DEFAULT_COLUMN_DELIMITER = "|".freeze
+  end
+end

data/lib/gm/notepad/input_handler_registry.rb

@@ -1,4 +1,4 @@
-require_relative 'input_handlers/default_handler'
+require "gm/notepad/input_handlers/default_handler"
 module Gm
   module Notepad
     # Responsible for registering the various input handlers

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

@@ -0,0 +1,25 @@
+require "gm/notepad/input_handlers/default_handler"
+module Gm
+  module Notepad
+    module InputHandlers
+      class CommentHandler < DefaultHandler
+        COMMEND_PREFIX = '#'.freeze
+
+        def self.handles?(input:)
+          return false unless input[0] == COMMEND_PREFIX
+          true
+        end
+
+        def after_initialize!
+          self.to_interactive = true
+          self.to_output = false
+          self.expand_line = false
+        end
+
+        def lines
+          [input]
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require_relative "default_handler"
+require "gm/notepad/input_handlers/default_handler"
 module Gm
   module Notepad
     module InputHandlers
@@ -21,7 +21,7 @@ module Gm
             "Prefixes:",
             "\t? - Help (this command)",
             "\t+ - Query table names and contents",
-            "\t<table_name> - Write the results to the given table",
+            "\t<table_name: - Write the results to the given table",
             "",
             "Tokens:",
             "\t! - Skip expansion",

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

@@ -1,4 +1,4 @@
-require_relative "default_handler"
+require "gm/notepad/input_handlers/default_handler"
 module Gm
   module Notepad
     module InputHandlers
@@ -16,6 +16,8 @@ module Gm
 
         WITH_GREP_REGEXP = %r{(?<declaration>\/(?<grep>[^\/]+)/)}
         WITH_INDEX_REGEXP = %r{(?<declaration>\[(?<index>[^\]]+)\])}
+        WITH_EMPTY_INDEX_REGEX = %r{(?<declaration>\[\])}
+        WITH_EMPTY_GREP_REGEX = %r{(?<declaration>\/\/)}
         NON_EXPANDING_CHARATER = '!'.freeze
         def after_initialize!
           self.expand_line = false
@@ -24,10 +26,13 @@ module Gm
 
           line = input[1..-1].to_s
           self.expand_line = false
-          if match = WITH_INDEX_REGEXP.match(line)
+          if match = WITH_EMPTY_INDEX_REGEX.match(line)
+            line = line.sub(match[:declaration], '')
+          elsif match = WITH_INDEX_REGEXP.match(line)
+            line = line.sub(match[:declaration], '')
+            self.index = match[:index]
+          elsif match = WITH_EMPTY_GREP_REGEX.match(line)
             line = line.sub(match[:declaration], '')
-            index = match[:index]
-            self.index = index
           elsif match = WITH_GREP_REGEXP.match(line)
             line = line.sub(match[:declaration], '')
             grep = match[:grep]
@@ -50,7 +55,11 @@ module Gm
             return [message]
           end
           if index
-            [table.lookup(index: index)]
+            begin
+              [table.lookup(index: index)]
+            rescue KeyError
+              [%(Entry with index "#{index}" not found in "#{table_name}" table)]
+            end
           elsif grep
             regexp = %r{#{grep}}i
             table.grep(regexp)

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

@@ -1,4 +1,4 @@
-require_relative "default_handler"
+require "gm/notepad/input_handlers/default_handler"
 
 module Gm
   module Notepad

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

@@ -1,4 +1,4 @@
-require_relative "default_handler"
+require "gm/notepad/input_handlers/default_handler"
 
 module Gm
   module Notepad

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

@@ -1,18 +1,19 @@
-require_relative "default_handler"
+require "gm/notepad/input_handlers/default_handler"
 
 module Gm
   module Notepad
     module InputHandlers
       class WriteToTableHandler < DefaultHandler
+        HANDLED_PREFIX = "<".freeze
         def self.handles?(input:)
-          return true if input[0] == "<"
+          return true if input[0] == HANDLED_PREFIX
         end
 
         attr_accessor :index, :grep, :table_name, :line
         NON_EXPANDING_CHARATER = '!'.freeze
         WITH_INDEX_REGEXP = %r{(?<declaration>\[(?<index>[^\]]+)\])}
         WITH_GREP_REGEXP = %r{(?<declaration>\/(?<grep>[^\/]+)/)}
-        WITH_WRITE_TARGET_REGEXP = %r{\A<(?<table_name>[^>]+)>(?<line>.*)}
+        WITH_WRITE_TARGET_REGEXP = %r{\A#{HANDLED_PREFIX}(?<table_name>[^:]+):(?<line>.*)}
         def after_initialize!
           self.to_filesystem = true
           self.to_interactive = true

data/lib/gm/notepad/input_processor.rb

@@ -1,3 +1,4 @@
+
 module Gm
   module Notepad
     # Responsible for processing the given input into a renderable state
@@ -27,14 +28,16 @@ module Gm
       end
 
       def default_input_handler_registry
-        require_relative "input_handler_registry"
-        require_relative "input_handlers/help_handler"
-        require_relative "input_handlers/query_table_handler"
-        require_relative "input_handlers/query_table_names_handler"
-        require_relative "input_handlers/write_to_table_handler"
-        require_relative "input_handlers/write_line_handler"
+        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)

data/lib/gm/notepad/line_renderer.rb

@@ -1,32 +1,32 @@
 require 'time'
+require 'term/ansicolor'
 module Gm
   module Notepad
     # Responsible for rendering lines to the corresponding buffers
     class LineRenderer
-      def initialize(with_timestamp: false, defer_output:, output_buffer: default_output_buffer, interactive_buffer: default_interactive_buffer)
-        @output_buffer = output_buffer
-        @interactive_buffer = interactive_buffer
-        @with_timestamp = with_timestamp
+      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
         @lines = []
         yield(self) if block_given?
       end
 
-      def call(line, to_output: false, to_interactive: true, as_of: Time.now)
-        render_output(line, defer_output: defer_output, as_of: as_of) if to_output
-        render_interactive(line) if to_interactive
+      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
       end
 
       def close!
-        if defer_output
-          @lines.each do |line|
-            output_buffer.puts(line)
-          end
-        end
+        interactive_buffer.close!
+        output_buffer.close!
       end
 
       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
@@ -34,27 +34,48 @@ module Gm
       # 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)
+        else
+          @interactive_buffer = BufferWrapper.new(buffer, as: :interactive)
+        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)
+        else
+          @output_buffer = BufferWrapper.new(buffer, as: :output)
+        end
+      end
+
+
       # When writing to output_buffer, should we prefix with a timestamp?
       def with_timestamp?
-        @with_timestamp
+        config.fetch(:with_timestamp, false)
       end
 
-      def render_output(line, defer_output:, as_of:)
-        if with_timestamp?
-          line = "#{as_of}\t#{line}"
-        end
-        if defer_output
-          @lines << line
-        else
-          output_buffer.puts(line)
+      def render_output(lines, defer_output:, as_of:)
+        Array(lines).each do |line|
+          if with_timestamp?
+            line = "#{as_of}\t#{line}"
+          end
+          if defer_output
+            output_buffer.defer(line)
+          else
+            output_buffer.puts(line)
+          end
         end
       end
 
-      def render_interactive(line)
-        interactive_buffer.puts("=>\t#{line}")
+      def render_interactive(lines)
+        Array(lines).each do |line|
+          interactive_buffer.puts("=>\t#{line}")
+        end
       end
 
       def default_output_buffer
@@ -65,5 +86,37 @@ module Gm
         $stderr
       end
     end
+
+    # To provide a means for colorizing the output
+    class BufferWrapper
+      attr_reader :buffer, :color, :as
+      def initialize(buffer, color: false, as:)
+        @buffer = buffer
+        @buffer.extend(Term::ANSIColor)
+        @color = color
+        @as = as
+        @lines = []
+      end
+
+      def puts(text)
+        if color
+          buffer.puts("#{buffer.public_send(color)}#{text}#{buffer.reset}")
+        else
+          buffer.puts("#{text}")
+        end
+      end
+
+      def defer(line)
+        @lines << line
+      end
+
+      def close!
+        buffer.print("\n") if as == :interactive
+        @lines.each do |line|
+          puts(line)
+        end
+      end
+    end
+    private_constant :BufferWrapper
   end
 end

data/lib/gm/notepad/pad.rb

@@ -27,37 +27,38 @@ module Gm
 
       attr_reader :renderer
       def open!
-        return unless config[:config_reporting]
-        renderer.call("# Configuration Parameters:", to_interactive: true, to_output: true)
-        config.each do |key, value|
-          line = "#   config[#{key.inspect}] = #{value.inspect}"
-          renderer.call(line, to_interactive: true, to_output: true)
+        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]
+        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_relative "input_processor"
+        require "gm/notepad/input_processor"
         InputProcessor.new(table_registry: table_registry)
       end
 
       def default_table_registry
-        require_relative "table_registry"
-        TableRegistry.load_for(
-          paths: config.fetch(:paths, []),
-          table_extension: config.fetch(:table_extension, ".txt")
-        )
+        require "gm/notepad/table_registry"
+        TableRegistry.load_for(**config)
       end
 
       def default_renderer
-        require_relative 'line_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)
+          interactive_buffer: config.fetch(:interactive_buffer, default_interactive_buffer),
+          **config
         )
       end
 

data/lib/gm/notepad/readline.rb

@@ -0,0 +1,31 @@
+require 'readline'
+module Gm
+  module Notepad
+    # A configuration module for the Readline module
+    module Readline
+
+      # Check history for existing matches
+      completion_function = proc do |string|
+        ::Readline::HISTORY.grep(/^#{Regexp.escape(string)}/)
+      end
+      if ::Readline.respond_to?("basic_word_break_characters=")
+        ::Readline.basic_word_break_characters= " \t\n`><=;|&{("
+      end
+
+      # With a sucessful completion add this to the end
+      ::Readline.completion_append_character = " "
+
+      # Without this, when I had in history the following: ["{name}"]
+      # And would type `{\t` into the shell, I would get the following
+      # result: "{{name}".
+      ::Readline.completer_word_break_characters = ""
+
+      # Hook-in the above completion function
+      ::Readline.completion_proc = completion_function
+
+      def self.input_getter(**config)
+        -> { ::Readline.readline("#{config.fetch(:shell_prompt, ">")}  ", true) }
+      end
+    end
+  end
+end

data/lib/gm/notepad/table.rb

@@ -1,10 +1,11 @@
-require_relative "exceptions"
-require_relative "table_entry"
+require "gm/notepad/exceptions"
+require "gm/notepad/table_entry"
 
 module Gm
   module Notepad
     class Table
-      def initialize(table_name:, lines:, filename: nil)
+      def initialize(table_name:, lines:, filename: nil, **config)
+        self.config = config
         self.table_name = table_name
         self.filename = filename
         process(lines: lines)
@@ -19,7 +20,7 @@ module Gm
       end
 
       def all
-        @table.values
+        @table.values.uniq
       end
 
       def grep(expression)
@@ -43,7 +44,7 @@ module Gm
 
       private
 
-      attr_accessor :table_name, :filename
+      attr_accessor :table_name, :filename, :config
 
       def random_index
         rand(@table.size)
@@ -52,7 +53,7 @@ module Gm
       def process(lines:)
         @table = {}
         lines.each do |line|
-          entry = TableEntry.new(line: line)
+          entry = TableEntry.new(line: line, **config)
           entry.lookup_range.each do |i|
             key = i.to_s
             raise DuplicateKeyError.new(key: table_name, object: self) if @table.key?(key)

data/lib/gm/notepad/table_entry.rb

@@ -1,10 +1,11 @@
+require 'gm/notepad/defaults'
 module Gm
   module Notepad
-    TABLE_ENTRY_SEPARATOR = "|".freeze
     TABLE_ENTRY_RANGE_MARKER = "-".freeze
     class TableEntry
-      def initialize(line:)
-        self.lookup_column, self.entry_column = line.split(TABLE_ENTRY_SEPARATOR)
+      def initialize(line:, column_delimiter: DEFAULT_COLUMN_DELIMITER, **config)
+        self.column_delimiter = column_delimiter
+        self.lookup_column, self.entry_column = line.split(column_delimiter)
       end
 
       include Comparable
@@ -23,11 +24,15 @@ module Gm
 
       attr_reader :lookup_column, :entry_column
 
-      alias to_s entry_column
+      def to_s
+        "[#{lookup_column}]\t#{entry_column}"
+      end
       alias to_str entry_column
 
       private
 
+      attr_accessor :column_delimiter
+
       def lookup_column=(input)
         @lookup_column = input.strip.freeze
       end

data/lib/gm/notepad/table_registry.rb

@@ -1,30 +1,36 @@
-require_relative "table"
-require_relative "exceptions"
+require "gm/notepad/table"
+require "gm/notepad/exceptions"
 
 module Gm
   module Notepad
     # Responsible for loading and registering all of the named tables
     class TableRegistry
-      def self.load_for(paths:, table_extension: ".txt")
-        table_registry = new(paths: paths, table_extension: table_extension)
-        paths.each do |path|
-          Dir.glob(File.join(path, "**/*#{table_extension}")).each do |filename|
-            table_name = File.basename(filename, table_extension)
-            table_registry.register_by_filename(table_name: table_name, filename: filename)
-          end
-        end
+      def self.load_for(**config)
+        table_registry = new(**config)
+        table_registry.load!
         table_registry
       end
 
-      def initialize(line_evaluator: default_line_evaluator, paths: [], table_extension: ".txt")
+      def initialize(line_evaluator: default_line_evaluator, **config)
+        self.config = config
         self.line_evaluator = line_evaluator
-        self.table_extension = table_extension
-        self.paths = paths
+        self.paths = config.fetch(:paths) { [] }
+        self.table_extension = config.fetch(:table_extension) { ".txt" }
+        self.filesystem_directory = config.fetch(:filesystem_directory) { "." }
         @registry = {}
       end
 
+      def load!
+        paths.each do |path|
+          Dir.glob(File.join(path, "**/*#{table_extension}")).each do |filename|
+            table_name = File.basename(filename, table_extension)
+            register_by_filename(table_name: table_name, filename: filename)
+          end
+        end
+      end
+
       private
-      attr_accessor :line_evaluator, :paths, :table_extension
+      attr_accessor :line_evaluator, :paths, :table_extension, :filesystem_directory, :config
       public
 
       def table_names
@@ -39,8 +45,8 @@ module Gm
         table = nil
         begin
           table = fetch_table(name: table_name)
-        rescue KeyError => e
-          filename = File.join(paths.first || ".", "#{table_name}#{table_extension}")
+        rescue KeyError
+          filename = File.join(filesystem_directory, "#{table_name}#{table_extension}")
           table = register(table_name: table_name, lines: [], filename: filename)
         end
         table.append(line: line, write: write)
@@ -70,7 +76,7 @@ module Gm
 
       def register(table_name:, lines:, filename: nil)
         raise DuplicateKeyError.new(key: table_name, object: self) if @registry.key?(table_name)
-        @registry[table_name] = Table.new(table_name: table_name, lines: lines, filename: filename)
+        @registry[table_name] = Table.new(table_name: table_name, lines: lines, filename: filename, **config)
       end
 
       def default_line_evaluator

data/lib/gm/notepad/version.rb

@@ -1,5 +1,5 @@
 module Gm
   module Notepad
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/lib/gm/notepad.rb

@@ -1,4 +1,5 @@
 require "gm/notepad/version"
+require "gm/notepad/defaults"
 require "gm/notepad/pad"
 module Gm
   module Notepad

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gm-notepad
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jeremy Friesen
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  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: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: A command line tool for GM-ing
 email:
 - jeremy.n.friesen@gmail.com
@@ -107,15 +135,19 @@ files:
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- examples/basic_example_file
 - exe/gm-notepad
 - gm-notepad.gemspec
 - lib/gm/notepad.rb
+- lib/gm/notepad/defaults.rb
 - lib/gm/notepad/exceptions.rb
 - lib/gm/notepad/input_handler_registry.rb
+- lib/gm/notepad/input_handlers/comment_handler.rb
 - lib/gm/notepad/input_handlers/default_handler.rb
 - lib/gm/notepad/input_handlers/help_handler.rb
 - lib/gm/notepad/input_handlers/query_table_handler.rb
@@ -126,12 +158,14 @@ files:
 - lib/gm/notepad/line_evaluator.rb
 - lib/gm/notepad/line_renderer.rb
 - lib/gm/notepad/pad.rb
+- lib/gm/notepad/readline.rb
 - lib/gm/notepad/table.rb
 - lib/gm/notepad/table_entry.rb
 - lib/gm/notepad/table_registry.rb
 - lib/gm/notepad/version.rb
 homepage: https://github.com/jeremyf/gm-notepad
-licenses: []
+licenses:
+- APACHE2
 metadata: {}
 post_install_message: 
 rdoc_options: []