yap-shell 0.6.0 → 0.7.0

data/addons/history/README.md

@@ -1,16 +0,0 @@
-# History Addon
-
-The History addon is provides primitive history capabilities:
-
-* Loads history from ~/.yap/history when yap is loaded
-* Saves history to ~/.yap/history when yap exits
-* Saving is an append-only operation
-* ~/.yap/history is in YAML format
-
-## Shell Functions
-
-The history addon provides the `history` shell function that prints the contents of the history.
-
-## Limitations
-
-The history addon currently does not support any kind of advanced history operations.

data/addons/history/history.rb

@@ -1,58 +0,0 @@
-class History < Addon
-  attr_reader :file
-  attr_reader :position
-
-  def initialize_world(world)
-    return unless world.configuration.use_history?
-    @world = world
-
-    @file = world.configuration.path_for('history')
-    @position = 0
-
-    load_history
-
-    world.func(:history) do |args:, stdin:, stdout:, stderr:|
-      history_length = @world.editor.history.length
-      first_arg = args.first.to_i
-      size = first_arg > 0 ? first_arg + 1 : history_length
-
-      # start from -2 since we don't want to include the current history
-      # command being run.
-      stdout.puts @world.editor.history[history_length-size..-2]
-    end
-  end
-
-  def save
-    debug_log "saving history file=#{file.inspect}"
-    File.open(file, "a") do |file|
-      # Don't write the YAML header because we're going to append to the
-      # history file, not overwrite. YAML works fine without it.
-      unwritten_history = @world.editor.history.to_a[@position..-1]
-      if unwritten_history.any?
-        contents = unwritten_history
-          .each_with_object([]) { |line, arr| arr << line unless line == arr.last  }
-          .map { |str| str.respond_to?(:without_ansi) ? str.without_ansi : str }
-          .to_yaml
-          .gsub(/^---.*?^/m, '')
-        file.write contents
-      end
-    end
-  end
-
-  private
-
-  def load_history
-    debug_log "loading history file=#{file.inspect}"
-    at_exit { save }
-
-    if File.exists?(file) && File.readable?(file)
-      history = YAML.load_file(file) || []
-
-      # History starts at the end of the history loaded from file.
-      @position = history.length
-
-      # Rely on the builtin history for now.
-      @world.editor.history.replace(history)
-    end
-  end
-end

data/addons/history_search/history_search.rb

@@ -1,197 +0,0 @@
-class HistorySearch < Addon
-  attr_reader :editor
-
-  def initialize_world(world)
-    @editor = world.editor
-  end
-
-  def prompt_user_to_search
-    label_text = "(reverse-search): "
-    search_label = ::TerminalLayout::Box.new(
-      content: label_text,
-      style: {
-        display: :inline,
-        height: 1
-      }
-    )
-    search_box = ::TerminalLayout::InputBox.new(
-      content: "",
-      style: {
-        display: :inline,
-        height: 1
-      }
-    )
-    search_box.name = "focused-input-box"
-
-    Treefell['shell'].puts "editor.content_box.children: #{editor.content_box.children.inspect}"
-    history_search_env = editor.new_env
-    history_search = Search.new(editor.history,
-      line: ::RawLine::LineEditor.new(::RawLine::Line.new, sync_with: -> { search_box }),
-      keys: history_search_env.keys,
-      search: -> (term:, result:){
-        # when there is no match, result will be nil, #to_s clears out the content
-        editor.input_box.content = result.to_s
-      },
-      done: -> (execute:, result:){
-        editor.content_box.children = []
-        editor.pop_env
-        editor.focus_input_box(editor.input_box)
-        editor.overwrite_line(result.to_s)
-        editor.process_line if execute
-      }
-    )
-
-    editor.push_env history_search_env
-    editor.push_keyboard_input_processor(history_search)
-
-    editor.content_box.children = [search_label, search_box]
-    editor.focus_input_box(search_box)
-  end
-
-  class Search
-    attr_reader :keys
-
-    def initialize(history, keys:, line:, search:, done:)
-      @history = history
-      @keys = keys
-      @line = line
-      @search_proc = search || -> {}
-      @done_proc = done || -> {}
-
-      initialize_key_bindings
-    end
-
-    def initialize_key_bindings
-      @keys.bind(:return){ execute }
-      @keys.bind(:ctrl_j){ accept }
-      @keys.bind(:ctrl_r){ search_again_backward }
-      @keys.bind(:ctrl_n){ search_again_forward }
-      @keys.bind(:ctrl_a){ @line.move_to_beginning_of_input }
-      @keys.bind(:ctrl_e){ @line.move_to_end_of_input }
-      @keys.bind(:backspace) do
-        @line.delete_left_character
-        perform_search(type: @last_search_was)
-      end
-      @keys.bind(:escape){ cancel }
-      @keys.bind(:ctrl_c){ cancel }
-    end
-
-    def read_bytes(bytes)
-      if bytes.any?
-        Treefell['shell'].puts "history search found bytes: #{bytes.inspect}"
-
-        search_bytes = process_bytes(bytes)
-
-        if search_bytes.any?
-          Treefell['shell'].puts "history searching with bytes=#{bytes.inspect}"
-          search_with_bytes(bytes)
-        end
-      end
-    end
-
-    private
-
-    # given [1,2,3] first try [1,2,3]. If no key binding
-    # matches, then try [1,2]. If no keybinding matches try [1].
-    # Execution should flow in left to right, positional order.
-    # This returns an array of left over bytes in the order they
-    # appeared that did not match any keybinding
-    def process_bytes bytes, leftover=[]
-      if bytes.empty?
-        leftover
-      elsif @keys[bytes]
-        @keys[bytes].call
-        leftover
-      else
-        process_bytes(
-          bytes[0..-2],
-          [bytes[-1]].concat(leftover)
-        )
-      end
-    end
-
-    def accept
-      @done_proc.call(execute: false, result: result)
-    end
-
-    def cancel
-      @done_proc.call(execute: false, result: nil)
-    end
-
-    def execute
-      @done_proc.call(execute: true, result: result)
-    end
-
-    def found_match(result:)
-      @search_proc.call(term: @line.text, result: result)
-    end
-
-    def no_match_found
-      @last_match_index = nil
-      @search_proc.call(term: @line.text, result: result)
-    end
-
-    def result
-      @history2search[@last_match_index] if @last_match_index
-    end
-
-    def search_again_backward
-      Treefell['shell'].puts "history searching again backward"
-      if @last_search_was == :forward
-        @last_match_index = @history.length - @last_match_index - 1
-        @history2search = @history.reverse
-      end
-      perform_search(starting_index: @last_match_index, type: :backward)
-    end
-
-    def search_again_forward
-      Treefell['shell'].puts "history searching again forward"
-      if @last_search_was == :backward
-        @last_match_index = @history.length - @last_match_index - 1
-        @history2search = @history
-      end
-      perform_search(starting_index: @last_match_index, type: :forward)
-    end
-
-    def search_with_bytes(bytes)
-      part = bytes.map(&:chr).join
-      @line.write(part.scan(/[[:print:]]/).join)
-      @history2search = @history.reverse
-      perform_search(type: :backward)
-    end
-
-    def perform_search(starting_index: -1, type:)
-      if @line.text.empty?
-        no_match_found
-        return
-      end
-
-      # fuzzy search
-      characters = @line.text.split('').map { |ch| Regexp.escape(ch) }
-      fuzzy_search_regex = /#{characters.join('.*?')}/
-
-      # non-fuzzy-search
-      # fuzzy_search_regex = /#{Regexp.escape(@line.text)}/
-
-      Treefell['shell'].puts "history search matching on regex=#{fuzzy_search_regex.inspect} starting_index=#{starting_index}"
-      @last_search_was = type
-
-      match = @history2search.detect.with_index do |item, i|
-        next if i <= starting_index
-
-        # Treefell['shell'].puts "history search matching #{(item + @line.text).inspect} =~ #{fuzzy_search_regex}"
-        md = (item + @line.text).match(fuzzy_search_regex)
-        if md && md.end(0) <= item.length
-          # Treefell['shell'].puts "history search match #{item} at #{i}"
-          @last_match_index = i
-        end
-      end
-
-      if match
-        found_match(result: match)
-      else
-        no_match_found
-      end
-    end
-  end
-end

data/addons/keyboard_macros/keyboard_macros.rb

@@ -1,425 +0,0 @@
-class KeyboardMacros < Addon
-  require 'keyboard_macros/cycle'
-
-  module PrettyPrintKey
-    # ppk means "pretty print key". For example, it returns \C-g if the given
-    # byte is 7.
-    def ppk(byte)
-      if byte && byte.ord <= 26
-        '\C-' + ('a'..'z').to_a[byte.ord - 1]
-      else
-        byte.inspect
-      end
-    end
-  end
-
-  include PrettyPrintKey
-
-  DEFAULT_TRIGGER_KEY = :ctrl_g
-  DEFAULT_CANCEL_KEY = " "
-  DEFAULT_TIMEOUT_IN_MS = 500
-
-  def self.load_addon
-    @instance ||= new
-  end
-
-  attr_reader :world
-  attr_accessor :timeout_in_ms
-  attr_accessor :cancel_key, :trigger_key
-  attr_accessor :cancel_on_unknown_sequences
-
-  def initialize_world(world)
-    @world = world
-    @configurations = []
-    @stack = []
-    @timeout_in_ms = DEFAULT_TIMEOUT_IN_MS
-    @cancel_key = DEFAULT_CANCEL_KEY
-    @trigger_key = DEFAULT_TRIGGER_KEY
-    @cancel_on_unknown_sequences = false
-  end
-
-  def cancel_key=(key)
-    debug_log "setting default cancel_key key=#{ppk(key)}"
-    @cancel_key = key
-  end
-
-  def cancel_on_unknown_sequences=(true_or_false)
-    debug_log "setting default cancel_on_unknown_sequences=#{true_or_false}"
-    @cancel_on_unknown_sequences = true_or_false
-  end
-
-  def timeout_in_ms=(milliseconds)
-    debug_log "setting default timeout_in_ms milliseconds=#{milliseconds.inspect}"
-    @timeout_in_ms = milliseconds
-  end
-
-  def trigger_key=(key)
-    debug_log "setting default trigger_key key=#{ppk(key)}"
-    @trigger_key = key
-  end
-
-  def configure(cancel_key: nil, trigger_key: nil, &blk)
-    debug_log "configure cancel_key=#{ppk(cancel_key)} trigger_key=#{ppk(trigger_key)} block_given?=#{block_given?}"
-
-    cancel_key ||= @cancel_key
-    trigger_key ||= @trigger_key
-
-    cancel_blk = lambda do
-      world.editor.event_loop.clear @event_id
-      cancel_processing
-      nil
-    end
-
-    configuration = Configuration.new(
-      keymap: world.editor.terminal.keys,
-      trigger_key: trigger_key,
-      cancellation: Cancellation.new(cancel_key: cancel_key, &cancel_blk),
-      editor: world.editor,
-    )
-
-    blk.call configuration if blk
-
-    world.unbind(trigger_key)
-    world.bind(trigger_key) do
-      debug_log "macro triggered key=#{ppk(trigger_key)}"
-
-      begin
-        @previous_result = nil
-        @stack << OpenStruct.new(configuration: configuration)
-        configuration.start.call if configuration.start
-
-        debug_log "taking over keyboard input processing from editor"
-        world.editor.push_keyboard_input_processor(self)
-
-        wait_timeout_in_seconds = 0.1
-        world.editor.input.wait_timeout_in_seconds = wait_timeout_in_seconds
-      ensure
-        queue_up_remove_input_processor(&configuration.stop)
-      end
-    end
-
-    @configurations << configuration
-  end
-
-  def cycle(name, &cycle_thru_blk)
-    debug_log "defining cycle name=#{name.inspect}"
-
-    @cycles ||= {}
-    if block_given?
-      cycle = KeyboardMacros::Cycle.new(
-        cycle_proc: cycle_thru_blk,
-        on_cycle_proc: -> (old_value, new_value) {
-          @world.editor.delete_n_characters(old_value.to_s.length)
-          process_result(new_value)
-        }
-      )
-      @cycles[name] = cycle
-    else
-      @cycles.fetch(name)
-    end
-  end
-
-  #
-  # InputProcessor Methods
-  #
-
-  def read_bytes(bytes)
-    if @stack.last
-      current_definition = @stack.last
-      configuration = current_definition.configuration
-    end
-
-    bytes.each_with_index do |byte, i|
-      definition = configuration[byte]
-      if !definition
-        cancel_processing if cancel_on_unknown_sequences
-        break
-      end
-
-      configuration = definition.configuration
-      configuration.start.call if configuration.start
-      @stack << definition
-
-      result = definition.process
-
-      if result =~ /\n$/
-        world.editor.write result.chomp, add_to_line_history: false
-        world.editor.event_loop.clear @event_id if @event_id
-        cancel_processing
-        world.editor.newline # add_to_history
-        world.editor.process_line
-        break
-      end
-
-      if i == bytes.length - 1
-        while @stack.last && @stack.last.fragment?
-          @stack.pop
-        end
-      end
-
-      if @event_id
-        world.editor.event_loop.clear @event_id
-        @event_id = queue_up_remove_input_processor
-      end
-
-      process_result(result)
-    end
-  end
-
-  private
-
-  def process_result(result)
-    if result.is_a?(String)
-      @world.editor.write result, add_to_line_history: false
-      @previous_result = result
-    end
-  end
-
-  def queue_up_remove_input_processor(&blk)
-    return unless @timeout_in_ms
-
-    event_args = {
-      name: 'remove_input_processor',
-      source: self,
-      interval_in_ms: @timeout_in_ms,
-    }
-    @event_id = world.editor.event_loop.once(event_args) do
-      cancel_processing
-    end
-  end
-
-  def cancel_processing
-    debug_log "cancel_processing"
-    @event_id = nil
-    @stack.reverse.each do |definition|
-      definition.configuration.stop.call if definition.configuration.stop
-    end
-    @stack.clear
-    if world.editor.keyboard_input_processor == self
-      debug_log "giving keyboard input processing control back"
-      world.editor.pop_keyboard_input_processor
-
-      debug_log "restoring default editor input timeout"
-      world.editor.input.restore_default_timeout
-    end
-  end
-
-  class Cancellation
-    attr_reader :cancel_key
-
-    def initialize(cancel_key: , &blk)
-      @cancel_key = cancel_key
-      @blk = blk
-    end
-
-    def call
-      @blk.call
-    end
-  end
-
-  class Configuration
-    include PrettyPrintKey
-
-    attr_reader :cancellation, :trigger_key, :keymap
-
-    def debug_log(*args)
-      KeyboardMacros.debug_log(*args)
-    end
-
-    def initialize(cancellation: nil, editor:, keymap: {}, trigger_key: nil)
-      @cancellation = cancellation
-      @editor = editor
-      @keymap = keymap
-      @trigger_key = trigger_key
-      @storage = {}
-      @on_start_blk = nil
-      @on_stop_blk = nil
-      @cycles = {}
-
-      debug_log "configuring a macro trigger_key=#{ppk(trigger_key)}"
-
-      if @cancellation
-        define @cancellation.cancel_key, -> { @cancellation.call }
-      end
-    end
-
-    def start(&blk)
-      @on_start_blk = blk if blk
-      @on_start_blk
-    end
-
-    def stop(&blk)
-      @on_stop_blk = blk if blk
-      @on_stop_blk
-    end
-
-    def cycle(name, &cycle_thru_blk)
-      debug_log "defining a cycle on macro name=#{name.inspect}"
-
-      if block_given?
-        cycle = KeyboardMacros::Cycle.new(
-          cycle_proc: cycle_thru_blk,
-          on_cycle_proc: -> (old_value, new_value) {
-            @editor.delete_n_characters(old_value.to_s.length)
-          }
-        )
-        @cycles[name] = cycle
-      else
-        @cycles.fetch(name)
-      end
-    end
-
-    def fragment(sequence, result)
-      define(sequence, result, fragment: true)
-    end
-
-    def define(sequence, result=nil, fragment: false, &blk)
-      debug_log "defining macro sequence=#{sequence.inspect} result=#{result.inspect} fragment=#{fragment.inspect} under macro #{ppk(trigger_key)}"
-      unless result.respond_to?(:call)
-        string_result = result
-        result = -> { string_result }
-      end
-
-      case sequence
-      when String
-        recursively_define_sequence_for_bytes(
-          self,
-          sequence.bytes,
-          result,
-          fragment: fragment,
-          &blk
-        )
-      when Symbol
-        recursively_define_sequence_for_bytes(
-          self,
-          @keymap.fetch(sequence){
-            fail "Cannot bind unknown sequence #{sequence.inspect}"
-          },
-          result,
-          fragment: fragment,
-          &blk
-        )
-      when Regexp
-        define_sequence_for_regex(sequence, result, fragment: fragment, &blk)
-      else
-        raise NotImplementedError, <<-EOT.gsub(/^\s*/, '')
-          Don't know how to define macro for sequence: #{sequence.inspect}
-        EOT
-      end
-    end
-
-    def [](byte)
-      @storage.values.detect { |definition| definition.matches?(byte) }
-    end
-
-    def []=(key, definition)
-      @storage[key] = definition
-    end
-
-    def inspect
-      str = @storage.map{ |k,v| "#{k}=#{v.inspect}" }.join("\n  ")
-      num_items = @storage.reduce(0) { |s, arr| s + arr.length }
-      "<Configuration num_items=#{num_items} stored_keys=#{str}>"
-    end
-
-    private
-
-    def define_sequence_for_regex(regex, result, fragment: false, &blk)
-      @storage[regex] = Definition.new(
-        configuration: Configuration.new(
-          cancellation: @cancellation,
-          keymap: @keymap,
-          editor: @editor
-        ),
-        fragment: fragment,
-        sequence: regex,
-        result: result,
-        &blk
-      )
-    end
-
-    def recursively_define_sequence_for_bytes(configuration, bytes, result, fragment: false, &blk)
-      byte, rest = bytes[0], bytes[1..-1]
-      if rest.any?
-        definition = if configuration[byte]
-          configuration[byte]
-        else
-          Definition.new(
-            configuration: Configuration.new(
-              cancellation: @cancellation,
-              keymap: @keymap,
-              editor: @editor
-            ),
-            fragment: fragment,
-            sequence: byte,
-            result: nil
-          )
-        end
-        blk.call(definition.configuration) if blk
-        configuration[byte] = definition
-        recursively_define_sequence_for_bytes(
-          definition.configuration,
-          rest,
-          result,
-          fragment: fragment,
-          &blk
-        )
-      else
-        definition = Definition.new(
-          configuration: Configuration.new(
-            keymap: @keymap,
-            editor: @editor
-          ),
-          fragment: fragment,
-          sequence: byte,
-          result: result
-        )
-        configuration[byte] = definition
-        blk.call(definition.configuration) if blk
-        definition
-      end
-    end
-  end
-
-  class Definition
-    attr_reader :configuration, :result, :sequence
-
-    def initialize(configuration: nil, fragment: false, sequence:, result: nil)
-      @fragment = fragment
-      @configuration = configuration
-      @sequence = sequence
-      @result = result
-    end
-
-    def inspect
-      "<Definition fragment=#{@fragment.inspect} sequence=#{@sequence.inspect} result=#{@result.inspect} configuration=#{@configuration.inspect}>"
-    end
-
-    def fragment?
-      @fragment
-    end
-
-    def matches?(byte)
-      if @sequence.is_a?(Regexp)
-        @match_data = @sequence.match(byte.chr)
-      else
-        @sequence == byte
-      end
-    end
-
-    def process
-      if @result
-        if @match_data
-          if @match_data.captures.empty?
-            @result.call(@match_data[0])
-          else
-            @result.call(*@match_data.captures)
-          end
-        else
-          @result.call
-        end
-      end
-    end
-  end
-
-end