gm-notepad 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4666e0ae345ed21a19074c884d3d5052287d70f79d61c005598c0176b5305a4c
+  data.tar.gz: fbe40603b8d2c7ac16176e04c8dd4c314728891a07cf291fc84522071faca9ef
+SHA512:
+  metadata.gz: 29cc37dc451ebb46573cf70c39353d6c73f65962c2956f18ddbd0abedaaa3f9a921c3ce828c10c22f2afda7268fe51099a3255fae938ca0171bfa8ab0ccfde6f
+  data.tar.gz: d1d5a709afe55264d2bd694463837b14afaaec529c84f238ca6c6374b706c3dbaea41971d70badd6229a506aed7cdab2dcf4c660c798d22d6d91dae583be594e

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at jeremy.n.friesen@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in gm-notepad.gemspec
+gemspec

data/README.md

@@ -0,0 +1,118 @@
+# GM::Notepad
+
+A command-line tool to help with your GM-ing.
+
+## Todo
+
+- [ ] Colorize puts to `interactive` buffer
+- [ ] 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
+
+## To install
+
+`$ gem install gm-notepad`
+
+## Introduction
+
+By default `gm-notepad` interacts with `$stdout` and `$stderr`. There are
+three conceptual buffers:
+
+* interactive (defaults to `$stderr`)
+* output (defaults to `$stderr`)
+* filesystem (defaults to your file system)
+
+When you type a line, and hit \<enter\>, `gm-notepad` will evaluate the
+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
+Usage: gm-notepad [options] [files]
+Note taking tool with random table expansion.
+
+Examples:
+	$ gm-notepad
+	$ gm-notepad rolls.txt
+	$ echo '{name}' | gm-notepad
+
+Specific options:
+        --timestamp                  Append a timestamp to the note (Default: false)
+    -c, --config_reporting           Dump the configuration data (Default: false)
+    -d, --defer_output               Defer output until system close (Default: true)
+    -p, --path=PATH                  Path for {table_name}.<config.table_extension> files (Default: ["."])
+    -tTABLE_EXTENSION,               Path for {table_name}.<config.table_extension> files (Default: ".txt")
+        --table_extension
+    -l, --list_tables                List tables loaded (Default: nil)
+    -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`
+
+Which writes the following to the `interactive` buffer (eg. `$stderr`)::
+
+```console
+=>	# Configuration Parameters:
+=>	#   config[:config_reporting] = true
+=>	#   config[:defer_output] = true
+=>	#   config[:interactive_buffer] = #<IO:<STDERR>>
+=>	#   config[:output_buffer] = #<IO:<STDOUT>>
+=>	#   config[:paths] = ["."]
+=>	#   config[:table_extension] = ".txt"
+=>	#   config[:with_timestamp] = false
+```
+
+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:
+
+* `./spec/fixtures/name.txt`
+* `./spec/fixtures/first-name.txt`
+* `./spec/fixtures/last-name.txt`
+
+When I run `gm-notepad -l`, `gm-notepad` does the following:
+
+* load all found tables
+* puts the config (see above) to the `interactive` buffer
+* puts the table_names to the `interactive` buffer
+* exits
+
+Below are the table names when you run the `gm-notepad` against the
+repository:
+
+```console
+=>	first-name
+=>	last-name
+=>	name
+```
+
+Now let's load `gm-notepad` for interaction. In the terminal, type:
+`$ gm-notepad`
+
+You now have an interactive shell for `gm-notepad`. Type `?` and hit
+\<enter\>.
+
+`gm-notepad` will write the following to `interactive` buffer (eg. `$stderr`):
+
+```console
+=>	Prefixes:
+=>		? - Help (this command)
+=>		+ - Query table names and contents
+=>		<table_name> - Write the results to the given table
+=>
+=>	Tokens:
+=>		! - Skip expansion
+=>		/search/ - Grep for the given 'search' within the prefix
+=>		[index] - Target a specific 'index'
+=>		{table_name} - expand_line the given 'table_name'
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gm/notepad"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/gm-notepad

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+require 'gm/notepad'
+
+require 'optparse'
+config = {
+  config_reporting: false,
+  defer_output: true,
+  interactive_buffer: $stderr,
+  output_buffer: $stdout,
+  paths: ['.'],
+  table_extension: '.txt',
+  with_timestamp: false
+}
+
+command_name = File.basename(__FILE__)
+
+OptionParser.new do |options|
+  # This banner is the first line of your help documentation.
+  options.set_banner "Usage: #{command_name} [options] [files]\n" \
+    "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}"
+
+  # 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
+  end
+
+  options.on("-c", "--config_reporting", "Dump the configuration data (Default: #{config[:config_reporting].inspect})") do |config_reporting|
+    config[:config_reporting] = config_reporting
+  end
+
+  options.on("-d", "--defer_output", "Defer output until system close (Default: #{config[:defer_output].inspect})") do |defer_output|
+    config[:defer_output] = defer_output
+  end
+
+  options.on("-pPATH", "--path=PATH", String, "Path for {table_name}.<config.table_extension> files (Default: #{config[:paths].inspect})") do |path|
+    config[:paths] << path
+  end
+
+  options.on("-tTABLE_EXTENSION", "--table_extension=TABLE_EXTENSION", String, "Path for {table_name}.<config.table_extension> files (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
+  end
+
+  options.on_tail("-h", "--help", "You're looking at it!") do
+    $stderr.puts options
+    exit 1
+  end
+end.parse!
+
+if config[:list_tables]
+  notepad = Gm::Notepad.new(config.merge(config_reporting: 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
+    input.each_line do |input|
+      begin
+        @notepad.process(input: input)
+      rescue Errno::EPIPE
+        # sysexits(3) specifies that exit code 74 represent an IO error,
+        # which is the likely situation
+        @notepad.close!
+        exit(74)
+      end
+    end
+  end
+ensure
+  @notepad.close!
+end

data/gm-notepad.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "gm/notepad/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "gm-notepad"
+  spec.version       = Gm::Notepad::VERSION
+  spec.authors       = ["Jeremy Friesen"]
+  spec.email         = ["jeremy.n.friesen@gmail.com"]
+
+  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.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "dice_parser"
+  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"
+end

data/lib/gm/notepad/exceptions.rb

@@ -0,0 +1,9 @@
+module Gm
+  module Notepad
+    class DuplicateKeyError < RuntimeError
+      def initialize(key:, object:)
+        super("Duplicate key for #{key.inspect} in #{object}")
+      end
+    end
+  end
+end

data/lib/gm/notepad/input_handler_registry.rb

@@ -0,0 +1,32 @@
+require_relative 'input_handlers/default_handler'
+module Gm
+  module Notepad
+    # Responsible for registering the various input handlers
+    class InputHandlerRegistry
+      def initialize
+        @registry = []
+        yield(self) if block_given?
+      end
+
+      def handler_for(input:, skip_default: false)
+        handler = nil
+        @registry.each do |handler_builder|
+          if handler = handler_builder.build_if_handled(input: input)
+            break
+          end
+        end
+        return handler if handler
+        return nil if skip_default
+        default_handler_builder.build_if_handled(input: input)
+      end
+
+      def register(handler:)
+        @registry << handler
+      end
+
+      def default_handler_builder
+        InputHandlers::DefaultHandler
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Gm
+  module Notepad
+    module InputHandlers
+      class DefaultHandler
+        def self.build_if_handled(input:)
+          return false unless handles?(input: input)
+          new(input: input)
+        end
+
+        def self.handles?(input:)
+          true
+        end
+
+        def initialize(input:, table_registry: nil)
+          self.to_interactive = false
+          self.to_output = false
+          self.to_filesystem = false
+          self.expand_line = false
+          self.input = input
+          self.table_registry = table_registry
+          after_initialize!
+        end
+        attr_accessor :table_registry, :to_interactive, :to_output, :expand_line, :input, :to_filesystem
+
+        def after_initialize!
+        end
+
+        def lines
+          []
+        end
+
+        alias expand_line? expand_line
+
+        def each_line_with_parameters
+          lines.each do |line|
+            line = table_registry.evaluate(line: line.to_s.strip) if expand_line?
+            yield(line, to_output: to_output, to_interactive: to_interactive)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_relative "default_handler"
+module Gm
+  module Notepad
+    module InputHandlers
+      class HelpHandler < DefaultHandler
+        HELP_PREFIX = '?'.freeze
+
+        def self.handles?(input:)
+          return false unless input[0] == HELP_PREFIX
+          true
+        end
+
+        def after_initialize!
+          self.to_interactive = true
+          self.to_output = false
+          self.expand_line = false
+        end
+
+        def lines
+          [
+            "Prefixes:",
+            "\t? - Help (this command)",
+            "\t+ - Query table names and contents",
+            "\t<table_name> - Write the results to the given table",
+            "",
+            "Tokens:",
+            "\t! - Skip expansion",
+            "\t/search/ - Grep for the given 'search' within the prefix",
+            "\t[index] - Target a specific 'index'",
+            "\t{table_name} - expand_line the given 'table_name'"
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require_relative "default_handler"
+module Gm
+  module Notepad
+    module InputHandlers
+      class QueryTableHandler < DefaultHandler
+        QUERY_TABLE_NAMES_PREFIX = '+'.freeze
+        def self.handles?(input:)
+          # Does not have the table prefix
+          return false unless input[0] == QUERY_TABLE_NAMES_PREFIX
+          # It is only the table prefix
+          return false if input == QUERY_TABLE_NAMES_PREFIX
+          # It is querying all tables by way of grep
+          return false if input[0..1] == "#{QUERY_TABLE_NAMES_PREFIX}/"
+          true
+        end
+
+        WITH_GREP_REGEXP = %r{(?<declaration>\/(?<grep>[^\/]+)/)}
+        WITH_INDEX_REGEXP = %r{(?<declaration>\[(?<index>[^\]]+)\])}
+        NON_EXPANDING_CHARATER = '!'.freeze
+        def after_initialize!
+          self.expand_line = false
+          self.to_output = false
+          self.to_interactive = true
+
+          line = input[1..-1].to_s
+          self.expand_line = false
+          if match = WITH_INDEX_REGEXP.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]
+            self.grep = grep
+          end
+          if line[-1] == NON_EXPANDING_CHARATER
+            line = line[0..-2]
+          end
+          self.table_name = line.downcase
+        end
+
+        attr_accessor :index, :grep, :table_name
+
+        def lines
+          begin
+            table = table_registry.fetch_table(name: table_name)
+          rescue KeyError
+            message = "Unknown table #{table_name.inspect}. Did you mean: "
+            message += table_registry.table_names.grep(/\A#{table_name}/).map(&:inspect).join(", ")
+            return [message]
+          end
+          if index
+            [table.lookup(index: index)]
+          elsif grep
+            regexp = %r{#{grep}}i
+            table.grep(regexp)
+          else
+            table.all
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require_relative "default_handler"
+
+module Gm
+  module Notepad
+    module InputHandlers
+      class QueryTableNamesHandler < DefaultHandler
+        QUERY_TABLE_NAMES_PREFIX = '+'.freeze
+        def self.handles?(input:)
+          # Does not have the table prefix
+          return false unless input[0] == QUERY_TABLE_NAMES_PREFIX
+          # It is only the table prefix
+          return true if input == QUERY_TABLE_NAMES_PREFIX
+          # It is querying all tables by way of grep
+          return true if input[0..1] == "#{QUERY_TABLE_NAMES_PREFIX}/"
+          false
+        end
+
+        WITH_GREP_REGEXP = %r{(?<declaration>\/(?<grep>[^\/]+)/)}
+        def after_initialize!
+          self.expand_line = false
+          self.to_output = false
+          self.to_interactive = true
+
+          line = input[1..-1]
+          if match = WITH_GREP_REGEXP.match(line)
+            line = line.sub(match[:declaration], '')
+            self.grep = match[:grep]
+          end
+        end
+
+        attr_accessor :grep
+
+        def lines
+          table_names = table_registry.table_names
+          return table_names unless grep
+          table_names.grep(%r{#{grep}})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require_relative "default_handler"
+
+module Gm
+  module Notepad
+    module InputHandlers
+      class WriteLineHandler < DefaultHandler
+        NON_EXPANDING_CHARATER = '!'.freeze
+        def self.handles?(input:)
+          true
+        end
+
+        attr_accessor :line
+        def after_initialize!
+          self.expand_line = false
+          self.to_output = true
+          self.to_interactive = true
+          if input[0] == NON_EXPANDING_CHARATER
+            self.line = input[1..-1].strip
+            self.expand_line = false
+          else
+            self.line = input.strip
+            self.expand_line = true
+          end
+        end
+
+        def lines
+          [line]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require_relative "default_handler"
+
+module Gm
+  module Notepad
+    module InputHandlers
+      class WriteToTableHandler < DefaultHandler
+        def self.handles?(input:)
+          return true if input[0] == "<"
+        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>.*)}
+        def after_initialize!
+          self.to_filesystem = true
+          self.to_interactive = true
+
+          if match = WITH_WRITE_TARGET_REGEXP.match(input)
+            line = match[:line].strip
+            table_name = match[:table_name]
+            if index_match = WITH_INDEX_REGEXP.match(table_name)
+              table_name = table_name.sub(index_match[:declaration], '')
+              self.index = index_match[:index]
+            elsif grep_match = WITH_GREP_REGEXP.match(table_name)
+              table_name = table_name.sub(grep_match[:declaration], '')
+              self.grep = grep_match[:grep]
+            end
+            self.table_name = table_name.downcase
+          else
+            raise "I don't know what to do"
+          end
+          if line[0] == NON_EXPANDING_CHARATER
+            self.expand_line = false
+            self.line = line[1..-1]
+          else
+            self.expand_line = true
+          end
+          self.line = line.strip
+        end
+
+        def lines
+          if index
+          elsif grep
+          end
+          if expand_line
+          else
+          end
+          table_registry.append(table_name: table_name, line: line, write: true)
+          []
+        end
+      end
+    end
+  end
+end

data/lib/gm/notepad/input_processor.rb

@@ -0,0 +1,46 @@
+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
+
+      def process(input:)
+        processor = build_for(input: input)
+        processor.each_line_with_parameters do |*args|
+          yield(*args)
+        end
+      end
+
+      attr_accessor :table_registry, :input_handler_registry
+      private :table_registry=, :input_handler_registry
+
+      private
+
+      def build_for(input:)
+        input = input.to_s.strip
+        handler = input_handler_registry.handler_for(input: input)
+        handler.table_registry = table_registry
+        handler
+      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"
+        InputHandlerRegistry.new do |registry|
+          registry.register(handler: InputHandlers::HelpHandler)
+          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

@@ -0,0 +1,26 @@
+require 'dice'
+module Gm
+  module Notepad
+    # Responsible for recording entries and then dumping them accordingly.
+    class LineEvaluator
+      TABLE_NAME_REGEXP = %r{(?<table_name_container>\{(?<table_name>[^\}]+)\})}
+      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)
+          evaluated_table_name = table_lookup_function.call(table_name: match[:table_name].strip)
+          line = line.sub(match[:table_name_container], evaluated_table_name)
+        end
+        while match = line.match(DICE_REGEXP)
+          if parsed_dice = Dice.parse(match[:dice])
+            evaluated_dice = "#{parsed_dice.evaluate} (#{match[:dice]})"
+          else
+            evaluated_dice = "(#{match[:dice]})"
+          end
+          line = line.sub(match[:dice_container], evaluated_dice)
+        end
+        line
+      end
+    end
+  end
+end

data/lib/gm/notepad/line_renderer.rb

@@ -0,0 +1,69 @@
+require 'time'
+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
+        @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
+      end
+
+      def close!
+        if defer_output
+          @lines.each do |line|
+            output_buffer.puts(line)
+          end
+        end
+      end
+
+      private
+
+      # 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
+
+      # The receiver of output
+      attr_reader :output_buffer
+
+      # When writing to output_buffer, should we prefix with a timestamp?
+      def with_timestamp?
+        @with_timestamp
+      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)
+        end
+      end
+
+      def render_interactive(line)
+        interactive_buffer.puts("=>\t#{line}")
+      end
+
+      def default_output_buffer
+        $stdout
+      end
+
+      def default_interactive_buffer
+        $stderr
+      end
+    end
+  end
+end

data/lib/gm/notepad/pad.rb

@@ -0,0 +1,73 @@
+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 }
+        open!
+      end
+
+      def process(input:)
+        input_processor.process(input: input) do |*args|
+          renderer.call(*args)
+        end
+      end
+
+      def close!
+        @renderer.close!
+      end
+
+      attr_reader :table_registry
+
+      private
+
+      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)
+        end
+      end
+
+      attr_accessor :renderer, :input_processor
+      attr_writer :config, :table_registry
+
+      def default_input_processor
+        require_relative "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")
+        )
+      end
+
+      def default_renderer
+        require_relative '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)
+        )
+      end
+
+      def default_output_buffer
+        $stdout
+      end
+
+      def default_interactive_buffer
+        $stderr
+      end
+    end
+  end
+end

data/lib/gm/notepad/table.rb

@@ -0,0 +1,65 @@
+require_relative "exceptions"
+require_relative "table_entry"
+
+module Gm
+  module Notepad
+    class Table
+      def initialize(table_name:, lines:, filename: nil)
+        self.table_name = table_name
+        self.filename = filename
+        process(lines: lines)
+      end
+
+      def lookup(index: false)
+        if index
+          @table.fetch(index)
+        else
+          @table.values[random_index]
+        end
+      end
+
+      def all
+        @table.values
+      end
+
+      def grep(expression)
+        returning_value = []
+        @table.each_value do |entry|
+          if expression.match(entry.entry_column)
+            returning_value << entry
+          end
+        end
+        returning_value
+      end
+
+      def append(line:, write: false)
+        process(lines: [line])
+        return unless filename
+        return unless write
+        File.open(filename, "a") do |file|
+          file.puts(line)
+        end
+      end
+
+      private
+
+      attr_accessor :table_name, :filename
+
+      def random_index
+        rand(@table.size)
+      end
+
+      def process(lines:)
+        @table = {}
+        lines.each do |line|
+          entry = TableEntry.new(line: line)
+          entry.lookup_range.each do |i|
+            key = i.to_s
+            raise DuplicateKeyError.new(key: table_name, object: self) if @table.key?(key)
+            @table[key] = entry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gm/notepad/table_entry.rb

@@ -0,0 +1,40 @@
+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)
+      end
+
+      include Comparable
+      def <=>(other)
+        to_str <=> String(other)
+      end
+
+      NUMBER_RANGE_REGEXP = %r{(?<left>\d+) *- *(?<right>\d+)}
+      def lookup_range
+        if match = NUMBER_RANGE_REGEXP.match(lookup_column)
+          (match[:left].to_i..match[:right].to_i).map(&:to_s)
+        else
+          [lookup_column]
+        end
+      end
+
+      attr_reader :lookup_column, :entry_column
+
+      alias to_s entry_column
+      alias to_str entry_column
+
+      private
+
+      def lookup_column=(input)
+        @lookup_column = input.strip.freeze
+      end
+
+      def entry_column=(input)
+        @entry_column = input.strip.freeze
+      end
+    end
+  end
+end

data/lib/gm/notepad/table_registry.rb

@@ -0,0 +1,82 @@
+require_relative "table"
+require_relative "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
+        table_registry
+      end
+
+      def initialize(line_evaluator: default_line_evaluator, paths: [], table_extension: ".txt")
+        self.line_evaluator = line_evaluator
+        self.table_extension = table_extension
+        self.paths = paths
+        @registry = {}
+      end
+
+      private
+      attr_accessor :line_evaluator, :paths, :table_extension
+      public
+
+      def table_names
+        @registry.keys.sort
+      end
+
+      def fetch_table(name:)
+        @registry.fetch(name)
+      end
+
+      def append(table_name:, line:, write:)
+        table = nil
+        begin
+          table = fetch_table(name: table_name)
+        rescue KeyError => e
+          filename = File.join(paths.first || ".", "#{table_name}#{table_extension}")
+          table = register(table_name: table_name, lines: [], filename: filename)
+        end
+        table.append(line: line, write: write)
+      end
+
+      def register_by_filename(table_name:, filename:)
+        content = File.read(filename)
+        register(table_name: table_name, lines: content.split("\n"), filename: filename)
+      end
+
+      def register_by_string(table_name:, string:)
+        register(table_name: table_name, lines: string.split("\n"))
+      end
+
+      def lookup(table_name:, **kwargs)
+        table = @registry.fetch(table_name)
+        table.lookup(**kwargs)
+      rescue KeyError
+        "(undefined #{table_name})"
+      end
+
+      def evaluate(line:)
+        line_evaluator.call(line: line, table_lookup_function: method(:lookup))
+      end
+
+      private
+
+      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)
+      end
+
+      def default_line_evaluator
+        require_relative 'line_evaluator'
+        LineEvaluator.new
+      end
+    end
+  end
+end

data/lib/gm/notepad/version.rb

@@ -0,0 +1,5 @@
+module Gm
+  module Notepad
+    VERSION = "0.0.1"
+  end
+end

data/lib/gm/notepad.rb

@@ -0,0 +1,9 @@
+require "gm/notepad/version"
+require "gm/notepad/pad"
+module Gm
+  module Notepad
+    def self.new(*args)
+      Pad.new(*args)
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: gm-notepad
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeremy Friesen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dice_parser
+  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
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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
+executables:
+- gm-notepad
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/gm-notepad
+- gm-notepad.gemspec
+- lib/gm/notepad.rb
+- lib/gm/notepad/exceptions.rb
+- lib/gm/notepad/input_handler_registry.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
+- lib/gm/notepad/input_handlers/query_table_names_handler.rb
+- lib/gm/notepad/input_handlers/write_line_handler.rb
+- lib/gm/notepad/input_handlers/write_to_table_handler.rb
+- lib/gm/notepad/input_processor.rb
+- lib/gm/notepad/line_evaluator.rb
+- lib/gm/notepad/line_renderer.rb
+- lib/gm/notepad/pad.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: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: A command line tool for GM-ing
+test_files: []