gm-notepad 0.0.10 → 0.0.11

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

@@ -6,17 +6,11 @@ module Gm
         HELP_PREFIX = '?'.freeze
 
         def self.handles?(input:)
-          return false unless input[0] == HELP_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
           [
             "Prefixes:",
             "\t? - Help (this command)",
@@ -28,7 +22,9 @@ module Gm
             "\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'"
-          ]
+          ].each do |text|
+            input.for_rendering(text: text, to_interactive: true, to_output: false, expand_line: false)
+          end
         end
       end
     end

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

@@ -9,46 +9,48 @@ module Gm
         QUERY_TABLE_NAMES_PREFIX = '+'.freeze
         def self.handles?(input:)
           # Does not have the table prefix
-          return false unless input[0] == QUERY_TABLE_NAMES_PREFIX
+          return false unless input.match(/^\+/)
           # It is only the table prefix
-          return false if input == QUERY_TABLE_NAMES_PREFIX
+          return false if input.match(/^\+$/)
           # It is querying all tables by way of grep
-          return false if input[0..1] == "#{QUERY_TABLE_NAMES_PREFIX}/"
+          return false if input.match(/^\+\//)
           true
         end
 
         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
           @table_lookup_parameters = Parameters::TableLookup.new(text: line)
+          evaluate_lines!
         end
 
         extend Forwardable
         def_delegators :@table_lookup_parameters, :index, :grep, :table_name
 
-        def lines
+        def evaluate_lines!
           begin
             table = table_registry.fetch_table(name: table_name)
           rescue MissingTableError
             message = "Unknown table #{table_name.inspect}. Did you mean: "
             message += table_registry.table_names.grep(/\A#{table_name}/).map(&:inspect).join(", ")
-            return [message]
+            input.for_rendering(text: message, to_output: false, to_interactive: true, expand_line: false)
+            return
           end
           if index
             begin
-              [table.lookup(index: index)]
+              text = table.lookup(index: index)
+              input.for_rendering(text: text, to_output: false, to_interactive: true, expand_line: false)
             rescue MissingTableEntryError
-              [%(Entry with index "#{index}" not found in "#{table_name}" table)]
+              input.for_rendering(text: %(Entry with index "#{index}" not found in "#{table_name}" table), to_interactive: true, to_output: false)
             end
           elsif grep
             regexp = %r{#{grep}}i
-            table.grep(regexp)
+            table.grep(regexp).each do |text|
+              input.for_rendering(text: text, to_output: false, to_interactive: true, expand_line: false)
+            end
           else
-            table.all
+            table.all.each do |text|
+              input.for_rendering(text: text, to_output: false, to_interactive: true, expand_line: false)
+            end
           end
         end
       end

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

@@ -7,33 +7,28 @@ module Gm
         QUERY_TABLE_NAMES_PREFIX = '+'.freeze
         def self.handles?(input:)
           # Does not have the table prefix
-          return false unless input[0] == QUERY_TABLE_NAMES_PREFIX
+          return false unless input.match(/^\+/)
           # It is only the table prefix
-          return true if input == QUERY_TABLE_NAMES_PREFIX
+          return true if input.match(/^\+$/)
           # It is querying all tables by way of grep
-          return true if input[0..1] == "#{QUERY_TABLE_NAMES_PREFIX}/"
+          return true if input.match(/^\+\//)
           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]
+          grep = nil
+          input.sub!(/^./,'')
+          if match = input.match(WITH_GREP_REGEXP)
+            input.sub!(match[:declaration], '')
+            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}})
+          table_names = table_names.grep(%r{#{grep}}) if grep
+          table_names.each do |table_name|
+            input.render_current_text(text: table_name, to_interactive: true, to_output: false, expand_line: false)
+          end
         end
       end
     end

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

@@ -9,22 +9,14 @@ module Gm
           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
+            input.sub!(/^\!/,'')
+            expand_line = false
           else
-            self.line = input.strip
-            self.expand_line = true
+            expand_line = true
           end
-        end
-
-        def lines
-          [line]
+          input.render_current_text(to_interactive: true, to_output: true, expand_line: expand_line)
         end
       end
     end

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

@@ -6,7 +6,7 @@ module Gm
       class WriteToTableHandler < DefaultHandler
         HANDLED_PREFIX = "<".freeze
         def self.handles?(input:)
-          return true if input[0] == HANDLED_PREFIX
+          return true if input.match(/^\</)
         end
 
         attr_accessor :index, :grep, :table_name, :line
@@ -15,11 +15,8 @@ module Gm
         WITH_GREP_REGEXP = %r{(?<declaration>\/(?<grep>[^\/]+)/)}
         WITH_WRITE_TARGET_REGEXP = %r{\A#{HANDLED_PREFIX}(?<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
+          if match = input.match(WITH_WRITE_TARGET_REGEXP)
+            input.text_to_evaluate = 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], '')
@@ -32,13 +29,13 @@ module Gm
           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]
+          if input.match(/^\!/)
+            expand_line = false
+            input.sub!(/^\!/, '')
           else
-            self.expand_line = true
+            expand_line = true
           end
-          self.line = line.strip
+          input.render_current_text(to_interactive: true  , to_output: false, to_filesystem: true, expand_line: expand_line)
         end
 
         def lines
@@ -48,7 +45,7 @@ module Gm
           if expand_line
           else
           end
-          table_registry.append(table_name: table_name, line: line, write: true)
+          table_registry.append(table_name: table_name, line: input.text_to_evaluate, write: true)
           []
         end
       end

data/lib/gm/notepad/input_processor.rb

@@ -1,24 +1,23 @@
-require 'gm/notepad/configuration'
+require 'gm/notepad/container'
+require 'dry/configurable'
 module Gm
   module Notepad
     # Responsible for processing the given input into a renderable state
     class InputProcessor
-      Configuration.init!(target: self, from_config: [:table_registry, :input_handler_registry])
+      extend Dry::Initializer
+      option :table_registry, default: -> { Container.resolve(:table_registry) }
+      option :input_handler_registry, default: -> { Container.resolve(:input_handler_registry) }
 
-      def process(input:)
-        processor = build_for(input: input)
-        processor.each_line_with_parameters do |*args|
-          yield(*args)
-        end
+      def convert_to_output(input:)
+        input = ThroughputText.new(original_text: input, table_registry: table_registry)
+        build_for(input: input)
+        input
       end
 
       private
 
       def build_for(input:)
-        input = input.to_s.strip
-        handler = input_handler_registry.handler_for(input: input)
-        handler.table_registry = table_registry
-        handler
+        input_handler_registry.handler_for(input: input, table_registry: table_registry)
       end
     end
   end

data/lib/gm/notepad/line_evaluator.rb

@@ -1,39 +1,40 @@
 require 'dice'
+require 'dry-initializer'
+require 'gm/notepad/container'
 require 'gm/notepad/parameters/table_lookup'
+require 'gm/notepad/throughput_text'
 require 'gm/notepad/evaluators/dice_evaluator'
 module Gm
   module Notepad
     # Responsible for recording entries and then dumping them accordingly.
     class LineEvaluator
-      def initialize(table_registry:)
-        @table_registry = table_registry
-      end
-      attr_reader :table_registry
+      extend Dry::Initializer
+      option :table_registry, default: -> { Container.resolve(:table_registry) }, reader: :private
 
       TABLE_NAME_REGEXP = %r{(?<table_name_container>\{(?<table_name>[^\{\}]+)\})}
       def call(line:, expand_line: true)
-        return line unless expand_line
-        text = parse_table(text: line)
-        parse_dice(text: text)
+        input = ThroughputText.new(original_text: line, table_registry: table_registry)
+        return input unless expand_line
+        parse_table(input: input)
+        parse_dice(input: input)
+        input
       end
 
       private
 
-      def parse_table(text:)
-        while match = text.match(TABLE_NAME_REGEXP)
+      def parse_table(input:)
+        while match = input.match(TABLE_NAME_REGEXP)
           table_lookup = Parameters::TableLookup.new(text: match[:table_name].strip, roll_dice: true)
           entry = table_registry.lookup(**table_lookup.parameters)
-          text = text.sub(match[:table_name_container], entry)
+          input.sub!(match[:table_name_container], entry)
         end
-        text
       end
       DICE_REGEXP = %r{(?<dice_container>\[(?<dice>[^\]]+)\])}
-      def parse_dice(text:)
-        while match = text.match(DICE_REGEXP)
+      def parse_dice(input:)
+        while match = input.match(DICE_REGEXP)
           evaluated_dice = Evaluators::DiceEvaluator.call(text: match[:dice], fallback: "(#{match[:dice]})")
-          text = text.sub(match[:dice_container], evaluated_dice)
+          input.sub!(match[:dice_container], evaluated_dice)
         end
-        text
       end
     end
   end

data/lib/gm/notepad/line_renderer.rb

@@ -1,18 +1,32 @@
-require 'gm/notepad/configuration'
 require 'time'
-require 'term/ansicolor'
+require 'dry-initializer'
+require 'gm/notepad/container'
+require 'gm/notepad/buffer_wrapper'
+
 module Gm
   module Notepad
     # Responsible for rendering lines to the corresponding buffers
     class LineRenderer
-      Configuration.init!(target: self, from_config: [:with_timestamp, :defer_output, :output_buffer, :interactive_buffer]) do
-        @lines = []
-        yield(self) if block_given?
+      extend Dry::Initializer
+      option :with_timestamp, default: -> { Container[:config].with_timestamp }
+      option :interactive_buffer, type: -> (buffer, renderer) { BufferWrapper.for_interactive(buffer: buffer) }, default: -> { Container[:config].interactive_buffer }
+      option :output_buffer, type: -> (buffer, renderer) { BufferWrapper.for_output(buffer: buffer) }, default: -> { Container[:config].output_buffer }
+
+      def render(output:, as_of: Time.now)
+        output.evaluate!
+        output.lines_for_rendering.each do |line|
+          next unless line.to_interactive
+          render_interactive(line)
+        end
+        output.lines_for_rendering.each do |line|
+          next unless line.to_output
+          render_output(line, as_of: as_of)
+        end
       end
 
       def call(lines, to_output: false, to_interactive: true, as_of: Time.now)
         render_interactive(lines) if to_interactive
-        render_output(lines, defer_output: config[:defer_output], as_of: as_of) if to_output
+        render_output(lines, as_of: as_of) if to_output
       end
 
       def close!
@@ -22,32 +36,12 @@ module Gm
 
       private
 
-      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
-
-      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
-
-      def render_output(lines, defer_output:, as_of:)
+      def render_output(lines, as_of:)
         each_expanded_line(lines: lines) do |line|
-          if config[:with_timestamp]
+          if with_timestamp
             line = "#{as_of}\t#{line}"
           end
-          if defer_output
-            output_buffer.defer(line)
-          else
-            output_buffer.puts(line)
-          end
+          output_buffer.puts(line)
         end
       end
 
@@ -60,44 +54,12 @@ module Gm
       # Gracefully expand the \t and \n for the output buffer
       def each_expanded_line(lines:)
         Array(lines).each do |unexpanded_line|
-          unexpanded_line.to_s.split('\\n').each do |line|
+          String(unexpanded_line).split('\\n').each do |line|
             line = line.gsub('\\t', "\t")
             yield(line)
           end
         end
       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/table.rb

@@ -1,13 +1,20 @@
+require 'dry-initializer'
 require "gm/notepad/exceptions"
-require "gm/notepad/configuration"
 require "gm/notepad/table_entry"
 require "gm/notepad/table_column_set"
+require 'gm/notepad/container'
 
 module Gm
   module Notepad
     class Table
-      Configuration.init!(target: self, from_config: [:column_delimiter, :index_entry_prefix], additional_params: [:table_name, :filename, :lines]) do
-        @index_entry_prefix_regexp = %r{^#{Regexp.escape(index_entry_prefix)} *#{Regexp.escape(column_delimiter)}}i.freeze
+      extend Dry::Initializer
+      option :table_name, proc(&:to_s)
+      option :filename, optional: true
+      option :lines, type: method(:Array)
+      option :index_entry_prefix_regexp, default: -> { Container.resolve(:config).index_entry_prefix_regexp }
+
+      def initialize(*args)
+        super
         set_null_table_column_set!
         process(lines: lines)
       end
@@ -32,6 +39,10 @@ module Gm
         @table_column_set.names
       end
 
+      def column_index_for(cell:)
+        @table_column_set.column_index_for(cell: cell)
+      end
+
       def grep(expression)
         returning_value = []
         @table.each_value do |entry|
@@ -65,7 +76,7 @@ module Gm
         @table.values[random_index]
       end
 
-      attr_accessor :filename, :config
+      attr_accessor :filename
       attr_reader :table_name
 
       def table_name=(input)
@@ -98,11 +109,11 @@ module Gm
       end
 
       def register_index_declaration!(line:)
-        @table_column_set = TableColumnSet.new(table: self, line: line, config: config)
+        @table_column_set = TableColumnSet.new(table: self, line: line)
       end
 
       def make_entry!(line:)
-        entry = TableEntry.new(table: self, line: line, config: config)
+        entry = TableEntry.new(table: self, line: line)
         entry.lookup_range.each do |i|
           key = i.to_s
           raise DuplicateKeyError.new(key: table_name, object: self) if @table.key?(key)