gm-notepad 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a9f77aeaa803fe169c27b96242f16fcfe1ebaaf0db7c61aae75a2be0f9ba1c7
-  data.tar.gz: 3a3728f49177fb88631f9e2c08df8ca9ca7148e7405b0df37986a861a80d950e
+  metadata.gz: 72cbb20c02dd2fa334bf57d7d88c40e7772d05ccf03bee599ddbf651e416c645
+  data.tar.gz: 1e474a0b888297ae5655e68710f5d40efcfbb59030aac36dab60e4fc765043de
 SHA512:
-  metadata.gz: a89494760fa29c73d63381a6737e2b0e540fc88a82cb8abaf2c71c902af2ec2cc8c5d297b20824b50bd96d6cc42ca5c9fcf0432b35a16476a581ed775a2332bc
-  data.tar.gz: a380d0f07547ff3c3e4f552033e97569e1539c6d82d441f913f4a906625c69e26e63a36479a78f7d6185745ccc68ae33af75c4d99b38f2d7b5777c2f0e94dcb2
+  metadata.gz: 49a06ad0a6f85eddaefa70f9f05dd358f39f163cc3c7555f0116d2c645436260910ef8f4ec4b955e26bbf8d332a0957a6dfa401c39b3a7664a44c6f787f6be60
+  data.tar.gz: a0f8bd008eb2220a4f8c68726aa96fcd68b110f50725b01091dc7ef5c57096e41d908674d4fa1bd46c0a552f61f01e68dddac3c508a499674d305361845363b4

data/README.md

@@ -4,6 +4,10 @@ A command-line tool to help with your GM-ing.
 
 ## To install
 
+First, you will need a working copy of Ruby. I recommend following the [instructions over at rbenv's Github page](https://github.com/rbenv/rbenv#installation).
+
+Next, you'll want to install the `gm-notepad` gem.
+
 `$ gem install gm-notepad`
 
 ## Background
@@ -61,7 +65,6 @@ Options:
     -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)
 
 Color options:
     -i, --skip-interactive-color     Disable color rendering for interactive buffer (Default: false)
@@ -79,7 +82,6 @@ Which writes the following to the `interactive` buffer (eg. `$stderr`)::
 ```console
 # Configuration Parameters:
 #   config[:report_config] = true
-#   config[:defer_output] = false
 #   config[:filesystem_directory] = "."
 #   config[:interactive_buffer] = #<IO:<STDERR>>
 #   config[:interactive_color] = true
@@ -227,15 +229,17 @@ columns. _I am still working on retrieving by column names as well as rendering
 - [ ] Gracefully handle loading a malformed data file (maybe?)
 - [X] Add concept of history
 - [X] 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] 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.
 - [X] Add column handling `{table[][]}`
-- [ ] Gracefully handle cell lookup when named cell for entry is not found
+- [X] Gracefully handle cell lookup when named cell for entry is not found
 - [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
 - [ ] Create a "To Render Object"; When you parse the input, you push relevant lines to that "To Render Object". When you look at a table, you want to know what the column names are.
+- [X] Remove "defer" printing concept
+- [ ] Add ability to shell out; I would love to leverage the [swnt](https://github.com/nboughton/swnt) command line tool
 
 ### Stretch TODO
 

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 = 98
+      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,7 +2,8 @@
 require 'gm/notepad'
 
 require 'optparse'
-config = Gm::Notepad::Configuration::CLI_CONFIG_DEFAULTS.clone
+defaults = Gm::Notepad::Config
+config = {}
 
 command_name = File.basename(__FILE__)
 
@@ -16,50 +17,47 @@ OptionParser.new do |options|
     "\t$ echo '{name}' | #{command_name}\n\n" \
     "Options:\n"
 
-  options.on_head("-l", "--list_tables", "List tables loaded and exit (Default: #{config[:list_tables].inspect})") do |list_tables|
+  options.on_head("-l", "--list_tables", "List tables loaded and exit (Default: #{defaults.list_tables.inspect})") do |list_tables|
     config[:list_tables] = list_tables
   end
 
-  options.on("-r", "--report_config", "Dump the configuration data (Default: #{config[:report_config].inspect})") do |report_config|
+  options.on("-r", "--report_config", "Dump the configuration data (Default: #{defaults.report_config.inspect})") do |report_config|
     config[:report_config] = report_config
   end
 
-  options.on("-pPATH", "--path=PATH", String, "Path(s) for {table_name}.<config.table_extension> files (Default: [\".\"])") do |path|
+  options.on("-pPATH", "--path=PATH", String, "Path(s) for {table_name}.<config.table_extension> files (Default: #{defaults.paths.inspect})") do |path|
+    config[:paths] ||= []
     config[:paths] << path
   end
 
-  options.on("-fDIR", "--filesystem_directory=DIR", String, "Path to dump tables (Default: #{config[:filesystem_directory].inspect})") do |filesystem_directory|
+  options.on("-fDIR", "--filesystem_directory=DIR", String, "Path to dump tables (Default: #{defaults.filesystem_directory.inspect})") do |filesystem_directory|
     # Should we guard that this exists?
     config[:filesystem_directory] = filesystem_directory
   end
 
-  options.on("-xEXT", "--table_extension=EXT", String, "Extension to use for selecting tables (Default: #{config[:table_extension].inspect})") do |table_extension|
+  options.on("-xEXT", "--table_extension=EXT", String, "Extension to use for selecting tables (Default: #{defaults.table_extension.inspect})") do |table_extension|
     config[:table_extension] = table_extension
   end
 
-  options.on("-dDELIM", "--delimiter=DELIM", String, "Default column delimiter for tables (Default: #{config[:column_delimiter].inspect})") do |column_delimiter|
+  options.on("-dDELIM", "--delimiter=DELIM", String, "Default column delimiter for tables (Default: #{defaults.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|
+  options.on("-t", "--timestamp", "Append a timestamp to the note (Default: #{defaults.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|
+  options.on("-i", "--skip-interactive-color", "Disable color rendering for interactive buffer (Default: #{(!defaults.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|
+  options.on("-o", "--with-output-color", "Enable color rendering for output buffer (Default: #{(!defaults.output_color).inspect})") do |output_color|
     config[:output_color] = output_color
   end
 
@@ -72,14 +70,14 @@ OptionParser.new do |options|
 end.parse!
 
 if config[:list_tables]
-  notepad = Gm::Notepad.new(config.merge(report_config: true))
-  notepad.process(input: "+")
+  notepad = Gm::Notepad.new(finalize: true, **config.merge(report_config: true))
+  notepad.process(text: "+")
   exit(1)
 end
 
 begin
-  @notepad = Gm::Notepad.new(**config)
-  if config.fetch(:skip_readlines)
+  @notepad = Gm::Notepad.new(finalize: true, **config)
+  if Gm::Notepad::Config.skip_readlines
     input_getter = ARGF.method(:gets)
   else
     require 'gm/notepad/readline'
@@ -87,9 +85,9 @@ begin
   end
   while input = input_getter.call
   # # Keep reading lines of input as long as they're coming.
-    input.each_line do |input|
+    input.each_line do |text|
       begin
-        @notepad.process(input: input)
+        @notepad.process(text: text)
       rescue Errno::EPIPE
         @notepad.close!
 

data/gm-notepad.gemspec

@@ -22,6 +22,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "dice_parser"
+  spec.add_dependency "dry-configurable"
+  spec.add_dependency "dry-container"
+  spec.add_dependency "dry-initializer"
   spec.add_dependency "term-ansicolor"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/lib/gm/notepad.rb

@@ -1,12 +1,14 @@
 require "gm/notepad/version"
-require "gm/notepad/defaults"
-require "gm/notepad/pad"
-require "gm/notepad/configuration"
+require 'gm/notepad/config'
+require "gm/notepad/app"
 module Gm
   module Notepad
-    def self.new(*args)
-      config = Configuration.new(*args)
-      Pad.new(config: config)
+    def self.new(finalize: false, **config_parameters)
+      config_parameters.each_pair do |key, value|
+        Config.config.public_send("#{key}=", value)
+      end
+      Config.finalize! if finalize
+      App.new
     end
   end
 end

data/lib/gm/notepad/app.rb

@@ -0,0 +1,45 @@
+require 'dry-initializer'
+require 'gm/notepad/container'
+require 'gm/notepad/throughput_text'
+
+module Gm
+  module Notepad
+    # Responsible for recording entries and then dumping them accordingly.
+    class App
+      extend Dry::Initializer
+      option :renderer, default: -> { Container.resolve(:renderer) }
+      option :input_processor, default: -> { Container.resolve(:input_processor) }
+      option :report_config, default: -> { Container.resolve(:config).report_config }, reader: :private
+      option :list_tables, default: -> { Container.resolve(:config).list_tables }, reader: :private
+
+      def initialize(*args)
+        super
+        open!
+      end
+
+      def process(text:)
+        output = input_processor.convert_to_output(input: text)
+        renderer.render(output: output)
+      end
+
+      def close!
+        renderer.close!
+      end
+
+      private
+
+      def open!
+        renderer.call("Welcome to gm-notepad. type \"?\" for help.", to_interactive: true, to_output: false)
+        return unless report_config
+        lines = ["# Configuration Parameters:"]
+        Config.settings.each do |setting|
+          lines << "#   config[#{setting.inspect}] = #{Config.public_send(setting).inspect}"
+        end
+        # When running :list_tables by default I don't want to report
+        # that to the output buffer.
+        to_output = !list_tables
+        renderer.call(lines, to_interactive: true, to_output: to_output)
+      end
+    end
+  end
+end

data/lib/gm/notepad/buffer_wrapper.rb

@@ -0,0 +1,47 @@
+require 'dry-initializer'
+require 'term/ansicolor'
+require 'gm/notepad/container'
+
+module Gm
+  module Notepad
+    # To provide a means for colorizing the output and defering output
+    class BufferWrapper
+      def self.for_interactive(buffer:)
+        new(buffer: buffer, color: Container[:config].interactive_color, append_new_line_on_close: true)
+      end
+
+      def self.for_output(buffer:)
+        new(buffer: buffer, color: Container[:config].output_color, append_new_line_on_close: false)
+      end
+      private_class_method :new
+
+      extend Dry::Initializer
+      option :buffer
+      option :color, default: -> { false }
+      option :append_new_line_on_close, default: -> { false }
+      option :lines, default: -> { [] }
+
+      def initialize(*args)
+        super
+        if color
+          buffer.extend(Term::ANSIColor)
+        end
+      end
+
+      def puts(text)
+        if color
+          buffer.puts("#{buffer.public_send(color)}#{text}#{buffer.reset}")
+        else
+          buffer.puts("#{text}")
+        end
+      end
+
+      def close!
+        self.lines.each do |line|
+          puts(line)
+        end
+        buffer.print("\n") if append_new_line_on_close
+      end
+    end
+  end
+end

data/lib/gm/notepad/config.rb

@@ -0,0 +1,31 @@
+require 'dry-container'
+module Gm
+  module Notepad
+    class Config
+      extend Dry::Configurable
+
+      setting :report_config, false, reader: true
+      setting :filesystem_directory, '.', reader: true
+      setting :index_entry_prefix, "index", reader: true
+      setting :interactive_buffer, $stderr, reader: true
+      setting :interactive_color, :faint, reader: true
+      setting :output_color, false, reader: true
+      setting :list_tables, false, reader: true
+      setting :output_buffer, $stdout, reader: true
+      setting :paths, ['.'], reader: true
+      setting :column_delimiter, "|", reader: true
+      setting :skip_readlines, false, reader: true
+      setting :include_original_command_as_comment, true, reader: true
+      setting :table_extension, '.txt', reader: true
+      setting :with_timestamp, false, reader: true
+
+      def self.index_entry_prefix_regexp
+        %r{^#{Regexp.escape(index_entry_prefix)} *#{Regexp.escape(column_delimiter)}}i
+      end
+
+      def index_entry_prefix_regexp
+        %r{^#{Regexp.escape(index_entry_prefix)} *#{Regexp.escape(column_delimiter)}}i
+      end
+    end
+  end
+end

data/lib/gm/notepad/container.rb

@@ -0,0 +1,50 @@
+require 'dry-container'
+
+module Gm
+  module Notepad
+    # A container for dependency injection
+    class Container
+      extend Dry::Container::Mixin
+
+      register "input_processor" do
+        require 'gm/notepad/input_processor'
+        InputProcessor.new
+      end
+
+      register "config" do
+        require 'gm/notepad/config'
+        Config
+      end
+
+      register "table_registry" do
+        require 'gm/notepad/table_registry'
+        TableRegistry.build_and_load
+      end
+
+      register "renderer" do
+        require 'gm/notepad/line_renderer'
+        LineRenderer.new
+      end
+
+      register "input_handler_registry" do
+        # 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/exceptions.rb

@@ -10,7 +10,7 @@ module Gm
     class MissingTableError < RuntimeError
       def initialize(name:)
         @name = name
-        super(%(Missing table "#{name}"))
+        super(%((Missing table "#{name}")))
       end
       alias to_buffer_message to_s
     end

data/lib/gm/notepad/input_handler_registry.rb

@@ -8,16 +8,16 @@ module Gm
         yield(self) if block_given?
       end
 
-      def handler_for(input:, skip_default: false)
+      def handler_for(input:, skip_default: false, table_registry: Container.resolve(:table_registry))
         handler = nil
         @registry.each do |handler_builder|
-          if handler = handler_builder.build_if_handled(input: input)
+          if handler = handler_builder.build_if_handled(input: input, table_registry: table_registry)
             break
           end
         end
         return handler if handler
         return nil if skip_default
-        default_handler_builder.build_if_handled(input: input)
+        default_handler_builder.build_if_handled(input: input, table_registry: table_registry)
       end
 
       def register(handler:)

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

@@ -6,18 +6,16 @@ module Gm
         COMMENT_PREFIX = '#'.freeze
 
         def self.handles?(input:)
-          return false unless input[0] == COMMENT_PREFIX
+          return false unless input.match(/^#/)
           true
         end
 
         def after_initialize!
-          self.to_interactive = true
-          self.to_output = false
-          self.expand_line = false
-        end
-
-        def lines
-          [input]
+          input.render_current_text(
+            to_interactive: true,
+            to_output: false,
+            expand_line: false
+          )
         end
       end
     end

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

@@ -1,41 +1,33 @@
+require 'gm/notepad/throughput_text'
+require 'dry-initializer'
 module Gm
   module Notepad
     module InputHandlers
       class DefaultHandler
-        def self.build_if_handled(input:)
+        def self.build_if_handled(input:, table_registry: Container.resolve(:table_registry))
           return false unless handles?(input: input)
-          new(input: input)
+          new(input: input, table_registry: table_registry)
         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
+        extend Dry::Initializer
+        option :input
+        option :table_registry, default: -> { Container.resolve(:table_registry) }
+        def initialize(*args)
+          super
           after_initialize!
         end
-        attr_accessor :table_registry, :to_interactive, :to_output, :expand_line, :input, :to_filesystem
-
-        def after_initialize!
-        end
 
         def lines
-          []
+          input.lines
         end
 
-        alias expand_line? expand_line
+        private
 
-        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
+        def after_initialize!
         end
       end
     end