yap-shell 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4e3c7118e864187750ddf674697554b760e3853
-  data.tar.gz: 8dc3b7e693b4cd35bd48935135cb9b8c37b13bd8
+  metadata.gz: 246c3bc588c78cfde392f379b5ca086e6aac79e0
+  data.tar.gz: f1c54403abc8e95a96f255582b6b3af4fcb511ba
 SHA512:
-  metadata.gz: cfa9336a5d7756b646fe4de4f75830d9162a729351f2f710d4f18a74bde8c3a5708785becb519e32a9513724ebdf5591ffa4f65872dee3a52c02426fd685487d
-  data.tar.gz: dce637e76f850540d3aaad4352bad5254abe9d8a7c4ec38b4ef819bb1babd39f9304b3d54e06999717c85b33e94cfd4a79e99eeb8932a8508efad0d0ddc4e0ce
+  metadata.gz: 61414d9cc1b15a58661bca3aac9911798fe6b8aabc99e4d03732109c29d4c2fa2d9928f2c43d0cadfb736a45f4ca056c41657226d654c3b04d2dc9ce14f1ae35
+  data.tar.gz: a3999e8f5fcbcaab03450309ecfc1a7942d3bf2f072a75862e96f203a5b9c3b89ee31ffde11ba3eedd59780a1f75a519107f04b9aa816b48a16cceef6b510eaa

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/Gemfile

@@ -2,3 +2,8 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in yap.gemspec
 gemspec
+# gem 'yap-shell-parser', path: "../yap-shell-parser"
+# gem 'yap-shell-parser', git: 'git@github.com:zdennis/yap-shell-parser.git'
+# gem "rawline", git: 'git@github.com:zdennis/rawline.git', branch: 'issues/input-issues'
+# gem "rawline", path: '/Users/zdennis/source/opensource_projects/rawline'
+# gem "pry-byebug"

data/WISHLIST.md

@@ -1,3 +1,7 @@
+CLI
+
+* yap install right-prompt
+
 
 * need to add custom tab completion for aliases, builtins, shell commands, and file system commands
 * support user-specified gems to install (so they're available for rc files)
@@ -38,3 +42,13 @@ Others requests.
 * @dylanized: themeable
 * @dylanized: browser-based
 * @dylanized: bookmarks
+
+
+### Tab completion
+* sort completions for printing
+* print completion in groups?
+* match on command, command with arguments, arguments, env var args
+* supply the completion text
+* supply the descriptive text
+* alias one completion for another
+* cache completions? invalidate cached completions

data/addons/history/Gemfile

@@ -0,0 +1,2 @@
+gem "chronic", "~> 0.10.2"
+gem "term-ansicolor", "~> 1.3.2"

data/addons/history/history.rb

@@ -0,0 +1,101 @@
+require 'forwardable'
+require 'term/ansicolor'
+require 'ostruct'
+
+class History < Addon
+  require 'history/buffer'
+  require 'history/events'
+
+  Color = Object.extend Term::ANSIColor
+
+  class << self
+    attr_accessor :history_item_formatter, :ignore_history_item
+  end
+
+  self.ignore_history_item = ->(item:) do
+    item.command == "exit"
+  end
+
+  self.history_item_formatter = ->(item:, options:{}) do
+    if item.duration
+      sprintf(
+        "%#{options[:max_position_width]}d %-s %s",
+        item.position,
+        item.command,
+        Color.negative(Color.intense_black(item.duration))
+      )
+    else
+      sprintf("%#{options[:max_position_width]}d %-s", item.position, item.command)
+    end
+  end
+
+  def initialize_world(world)
+    @world = world
+    load_history
+
+    world.editor.bind(:ctrl_h) { show_history(@world.editor) }
+
+    world.func(:history) do |args:, stdin:, stdout:, stderr:|
+      first_arg = args.first
+      case first_arg
+      when String
+        if first_arg.start_with?("/")
+          regex = first_arg.gsub(/(^\|\/$)/, '')
+          ignore_history_item = ->(item:, options:{}) do
+            item.command !~ /#{regex}/
+          end
+        else
+          ignore_history_item = ->(item:, options:{}) do
+            item.command !~ /#{first_arg}/
+          end
+        end
+        show_history(world.editor, redraw_prompt:false, ignore_history_item:ignore_history_item)
+      else
+        show_history(world.editor, redraw_prompt:false)
+      end
+    end
+  end
+
+  def show_history(editor, redraw_prompt:true, ignore_history_item:nil, history_item_formatter:nil)
+    editor.puts @history
+  end
+
+  def executing(command:, started_at:)
+    # raise "Cannot acknowledge execution beginning of a command when no group has been started!" unless history.last
+  end
+
+  def executed(command:, stopped_at:)
+    # raise "Cannot complete execution of a command when no command has been started!" unless history.last
+  end
+
+  def save
+    File.open(history_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.
+      file.write @world.editor.history.to_yaml(@history_start_position..-1).gsub(/^---.*/, '')
+    end
+  end
+
+  private
+
+  def history
+    @history
+  end
+
+  def history_file
+    @history_file ||= File.expand_path('~') + '/.yap-history'
+  end
+
+  def load_history
+    @world.editor.history = @history = History::Buffer.new(Float::INFINITY)
+    @history_start_position = 0
+
+    at_exit { save }
+
+    return unless File.exists?(history_file) && File.readable?(history_file)
+
+    history_elements = YAML.load_file(history_file) || []
+    @history_start_position = history_elements.length
+    @world.editor.history.replace(history_elements)
+  end
+end

data/addons/history/lib/history/buffer.rb

@@ -0,0 +1,204 @@
+class History
+  class Buffer < Array
+    attr_reader :position, :size
+    attr_accessor :duplicates, :exclude, :cycle
+
+    #
+    # Create an instance of History::Buffer.
+    # This method takes an optional block used to override the
+    # following instance attributes:
+    # * <tt>@duplicates</tt> - whether or not duplicate items will be stored in the buffer.
+    # * <tt>@exclude</tt> - a Proc object defining exclusion rules to prevent items from being added to the buffer.
+    # * <tt>@cycle</tt> - Whether or not the buffer is cyclic.
+    #
+    def initialize(size)
+      @duplicates = true
+      @exclude = lambda{|a|}
+      @cycle = false
+      yield self if block_given?
+      @size = size
+      @position = nil
+    end
+
+    def supports_partial_text_matching?
+      true
+    end
+
+    def supports_matching_text?
+      true
+    end
+
+    #
+    # Clears the current position on the history object. Useful when deciding
+    # to cancel/reset history navigation.
+    #
+    def clear_position
+      @position = nil
+    end
+
+    def searching?
+      !!@position
+    end
+
+    #
+    # Resize the buffer, resetting <tt>@position</tt> to nil.
+    #
+    def resize(new_size)
+      if new_size < @size
+        @size-new_size.times { pop }
+      end
+      @size = new_size
+      @position = nil
+    end
+
+    #
+    # Clear the content of the buffer and reset <tt>@position</tt> to nil.
+    #
+    def empty
+      @position = nil
+      clear
+    end
+
+    #
+    # Retrieve a copy of the element at <tt>@position</tt>.
+    #
+    def get
+      return nil unless length > 0
+      return nil unless @position
+      at(@position).dup
+    end
+
+    #
+    # Return true if <tt>@position</tt> is at the end of the buffer.
+    #
+    def end?
+      @position == length-1
+    end
+
+    #
+    # Return true if <tt>@position</tt> is at the start of the buffer.
+    #
+    def start?
+      @position == 0
+    end
+
+    #
+    # Decrement <tt>@position</tt>. By default the history will become
+    # positioned at the previous item.
+    #
+    def back(matching_text: nil)
+      return nil unless length > 0
+      @position = search_back(matching_text: matching_text) || @position
+    end
+
+    #
+    # Increment <tt>@position</tt>. By default the history will become
+    # positioned at the next item.
+    #
+    def forward(matching_text: nil)
+      return nil unless length > 0
+      @position = search_forward(matching_text: matching_text) || @position
+    end
+
+    #
+    # Add a new item to the buffer.
+    #
+    def push(item)
+      item = item.without_ansi if item.respond_to?(:without_ansi)
+
+      if !@duplicates && self[-1] == item
+        # skip adding this line
+        return
+      end
+
+      unless @exclude.call(item)
+        # Remove the oldest element if size is exceeded
+        if @size <= length
+          reverse!.pop
+          reverse!
+        end
+        # Add the new item and reset the position
+        super(item)
+        @position = nil
+      end
+    end
+
+    alias << push
+
+    def to_yaml(range=(0..-1))
+      self[range].map do |element|
+        element.kind_of?(String) ? element : element.to_h
+      end.to_yaml
+    end
+
+    private
+
+    def search_back(matching_text:)
+      if !matching_text
+        matching_text = ""
+      elsif matching_text.respond_to?(:without_ansi)
+        matching_text = matching_text.without_ansi
+      end
+
+      command_history = self
+      upto_index = (position || length) - 1
+      current = get
+
+      # $z.puts
+      # $z.puts <<-EOS.gsub(/^\s*\|/, '')
+      #   |Search backward:
+      #   |    current:#{current.inspect}
+      #   |    history: #{command_history.inspect}
+      #   |    history position: #{position}
+      #   |    matching_text: #{matching_text.inspect}
+      #   |    upto_index: #{upto_index}
+      #   |    snapshot: #{command_history[0..upto_index].reverse.inspect}
+      # EOS
+
+      return position unless upto_index >= 0
+
+      snapshot = command_history[0..upto_index].reverse
+      no_match = nil
+
+      position = snapshot.each_with_index.reduce(no_match) do |no_match, (text, i)|
+        # $z.print "    - matching #{text.inspect} =~ /^#{matching_text.to_s}/ && #{current} != #{text} : "
+        if text =~ /^#{Regexp.escape(matching_text)}/ && current != text
+          # $z.puts "  match #{i}, returning position #{snapshot.length - (i + 1)}"
+
+          # convert to non-reversed indexing
+          position = snapshot.length - (i + 1)
+          break position
+        else
+          # $z.puts " no match."
+          no_match
+        end
+      end
+    end
+
+    def search_forward(matching_text:)
+      if !matching_text
+        matching_text = ""
+      elsif matching_text.respond_to?(:without_ansi)
+        matching_text = matching_text.without_ansi
+      end
+
+      command_history = self
+      return nil unless position
+
+      start_index = position + 1
+      snapshot = command_history[start_index..-1].dup
+      no_match = nil
+      current = get
+
+      position = snapshot.each_with_index.reduce(no_match) do |no_match, (text, i)|
+        if text =~ /^#{Regexp.escape(matching_text.to_s)}/ && current != text
+          position = start_index + i
+          break position
+        else
+          no_match
+        end
+      end
+    end
+  end
+
+end

data/addons/history/lib/history/events.rb

@@ -0,0 +1,13 @@
+Yap::Shell::Execution::Context.on(:before_statements_execute) do |world|
+end
+
+Yap::Shell::Execution::Context.on(:after_statements_execute) do |world|
+end
+
+Yap::Shell::Execution::Context.on(:before_execute) do |world, command:|
+  # world[:history].executing command:command.str, started_at:Time.now
+end
+
+Yap::Shell::Execution::Context.on(:after_execute) do |world, command:, result:|
+  # world[:history].executed command:command.str, stopped_at:Time.now
+end

data/addons/keyboard_macros/keyboard_macros.rb

@@ -0,0 +1,295 @@
+class KeyboardMacros < Addon
+  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 configure(cancel_key: nil, trigger_key: nil, &blk)
+    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)
+    )
+
+    blk.call configuration if blk
+
+    world.unbind(trigger_key)
+    world.bind(trigger_key) do
+      begin
+        @stack << configuration
+        configuration.start.call if configuration.start
+        world.editor.keyboard_input_processors.push(self)
+        world.editor.input.wait_timeout_in_seconds = 0.1
+      ensure
+        queue_up_remove_input_processor(&configuration.stop)
+      end
+    end
+
+    @configurations << configuration
+  end
+
+  #
+  # InputProcessor Methods
+  #
+
+  def read_bytes(bytes)
+    configuration = @stack.last
+    bytes.each do |byte|
+      definition = configuration[byte]
+      if !definition
+        cancel_processing if cancel_on_unknown_sequences
+        break
+      end
+      configuration = definition.configuration
+      if configuration
+        configuration.start.call if configuration.start
+        @stack << configuration
+      end
+
+      result = definition.process
+
+      if result =~ /\n$/
+        world.editor.write result.chomp
+        world.editor.event_loop.clear @event_id if @event_id
+        cancel_processing
+        world.editor.newline # add_to_history
+        world.editor.process_line
+        break
+      end
+
+      @stack.pop if definition.fragment?
+
+      if @event_id
+        world.editor.event_loop.clear @event_id
+        @event_id = queue_up_remove_input_processor
+      end
+      world.editor.write result if result.is_a?(String)
+    end
+  end
+
+  private
+
+  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
+    @event_id = nil
+    @stack.reverse.each do |configuration|
+      configuration.stop.call if configuration.stop
+    end
+    @stack.clear
+    if world.editor.keyboard_input_processors.last == self
+      world.editor.keyboard_input_processors.pop
+      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
+    attr_reader :cancellation, :trigger_key, :keymap
+
+    def initialize(cancellation: nil, keymap: {}, trigger_key: nil)
+      @cancellation = cancellation
+      @keymap = keymap
+      @trigger_key = trigger_key
+      @storage = {}
+      @on_start_blk = nil
+      @on_stop_blk = nil
+
+      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 fragment(sequence, result)
+      define(sequence, result).tap do |definition|
+        definition.fragment!
+      end
+    end
+
+    def define(sequence, result, &blk)
+      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,
+          &blk
+        )
+      when Symbol
+        recursively_define_sequence_for_bytes(
+          self,
+          @keymap.fetch(sequence){
+            fail "Cannot bind unknown sequence #{sequence.inspect}"
+          },
+          result,
+          &blk
+        )
+      when Regexp
+        define_sequence_for_regex(sequence, result, &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
+
+    private
+
+    def define_sequence_for_regex(regex, result, &blk)
+      @storage[regex] = Definition.new(
+        configuration: Configuration.new(
+          cancellation: @cancellation,
+          keymap: @keymap
+        ),
+        sequence: regex,
+        result: result,
+        &blk
+      )
+    end
+
+    def recursively_define_sequence_for_bytes(configuration, bytes, result, &blk)
+      byte, rest = bytes[0], bytes[1..-1]
+      if rest.any?
+        definition = Definition.new(
+          configuration: Configuration.new(
+            cancellation: @cancellation,
+            keymap: @keymap
+          ),
+          sequence: byte,
+          result: nil,
+          &blk
+        )
+        configuration[byte] = definition
+        recursively_define_sequence_for_bytes(
+          definition.configuration,
+          rest,
+          result,
+          &blk
+        )
+      else
+        configuration[byte] = Definition.new(
+          configuration: Configuration.new(keymap: @keymap),
+          sequence: byte,
+          result: result,
+          &blk
+        )
+      end
+    end
+  end
+
+  class Definition
+    attr_reader :bytes, :configuration, :result, :sequence
+
+    def initialize(configuration: nil, sequence:, result: nil, &blk)
+      @fragment = false
+      @configuration = configuration
+      @sequence = sequence
+      @result = result
+      blk.call(@configuration) if blk
+    end
+
+    def fragment?
+      @fragment
+    end
+
+    def fragment!
+      @fragment = true
+    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