yap-shell 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23d1c68c8e4cb9e3531fef656445654b3e5fd0d7
-  data.tar.gz: 59e2297008fecdfe423b9c97d1e897bd138f9e31
+  metadata.gz: 70c4b7a17173c5d2f16dd2d318ad7fca64121c2b
+  data.tar.gz: f17c759ac10afbb5ed4d9bac3c47cdfc2e8590f8
 SHA512:
-  metadata.gz: 764180407fb136d9495b713805d7b1ac372405faa4a4505bffaa1b4bc29e84151172547f560c31e60c66463cd993fe9ca446cb4cd8828c43da5abf18e2027acc
-  data.tar.gz: d41da1cc4a590125e529a746c3d182a9da4764e9f0f7da37a37f62b87e5eb1075883556c302ed4b07a6e8f81afe2164d5d07509864f060d193ca17fdbb89b799
+  metadata.gz: e998bdac5eccd88ff29438bed0dc970371453a11e300049988b328174940a179c94d3f3ce90e061500ff3c87022517baa7380ae7d88d41304c31c234d092fea9
+  data.tar.gz: 6c7b6164c54f5dc7a3a1cca6a2a78d15dd7a31af58782cb7a7f4b0ff57cce86d3893aa920d668d3f054602a48e80be5b7ef331ca1720af0ca637d766c2ee3e69

data/Gemfile

@@ -6,4 +6,4 @@ gemspec
 # 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"
+gem "pry-byebug"

data/addons/history/README.md

@@ -0,0 +1,16 @@
+# 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,101 +1,55 @@
-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
+  attr_reader :file
+  attr_reader :position
 
   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
+    @file = world.configuration.path_for('history')
+    @position = 0
 
-  def show_history(editor, redraw_prompt:true, ignore_history_item:nil, history_item_formatter:nil)
-    editor.puts @history
-  end
+    load_history
 
-  def executing(command:, started_at:)
-    # raise "Cannot acknowledge execution beginning of a command when no group has been started!" unless history.last
-  end
+    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
 
-  def executed(command:, stopped_at:)
-    # raise "Cannot complete execution of a command when no command has been started!" unless history.last
+      # 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
-    File.open(history_file, "a") do |file|
+    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.
-      file.write @world.editor.history.to_yaml(@history_start_position..-1).gsub(/^---.*/, '')
+      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 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)
+    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
 
-    history_elements = YAML.load_file(history_file) || []
-    @history_start_position = history_elements.length
-    @world.editor.history.replace(history_elements)
+      # Rely on the builtin history for now.
+      @world.editor.history.replace(history)
+    end
   end
 end

data/addons/keyboard_macros/keyboard_macros.rb

@@ -1,4 +1,6 @@
 class KeyboardMacros < Addon
+  require 'keyboard_macros/cycle'
+
   DEFAULT_TRIGGER_KEY = :ctrl_g
   DEFAULT_CANCEL_KEY = " "
   DEFAULT_TIMEOUT_IN_MS = 500
@@ -35,7 +37,8 @@ class KeyboardMacros < Addon
     configuration = Configuration.new(
       keymap: world.editor.terminal.keys,
       trigger_key: trigger_key,
-      cancellation: Cancellation.new(cancel_key: cancel_key, &cancel_blk)
+      cancellation: Cancellation.new(cancel_key: cancel_key, &cancel_blk),
+      editor: world.editor,
     )
 
     blk.call configuration if blk
@@ -43,7 +46,8 @@ class KeyboardMacros < Addon
     world.unbind(trigger_key)
     world.bind(trigger_key) do
       begin
-        @stack << configuration
+        @previous_result = nil
+        @stack << OpenStruct.new(configuration: configuration)
         configuration.start.call if configuration.start
         world.editor.keyboard_input_processors.push(self)
         world.editor.input.wait_timeout_in_seconds = 0.1
@@ -55,28 +59,47 @@ class KeyboardMacros < Addon
     @configurations << configuration
   end
 
+  def cycle(name, &cycle_thru_blk)
+    @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)
-    configuration = @stack.last
-    bytes.each do |byte|
+    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
-      if configuration
-        configuration.start.call if configuration.start
-        @stack << configuration
-      end
+      configuration.start.call if configuration.start
+      @stack << definition
 
       result = definition.process
 
       if result =~ /\n$/
-        world.editor.write result.chomp
+        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
@@ -84,18 +107,31 @@ class KeyboardMacros < Addon
         break
       end
 
-      @stack.pop if definition.fragment?
+      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
-      world.editor.write result if result.is_a?(String)
+
+      process_result(result)
     end
   end
 
   private
 
+  def process_result(result)
+    if result.is_a?(String)
+      $z.puts "WRITING: #{result}"
+      @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
 
@@ -111,8 +147,8 @@ class KeyboardMacros < Addon
 
   def cancel_processing
     @event_id = nil
-    @stack.reverse.each do |configuration|
-      configuration.stop.call if configuration.stop
+    @stack.reverse.each do |definition|
+      definition.configuration.stop.call if definition.configuration.stop
     end
     @stack.clear
     if world.editor.keyboard_input_processors.last == self
@@ -137,13 +173,15 @@ class KeyboardMacros < Addon
   class Configuration
     attr_reader :cancellation, :trigger_key, :keymap
 
-    def initialize(cancellation: nil, keymap: {}, trigger_key: nil)
+    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 = {}
 
       if @cancellation
         define @cancellation.cancel_key, -> { @cancellation.call }
@@ -160,13 +198,25 @@ class KeyboardMacros < Addon
       @on_stop_blk
     end
 
-    def fragment(sequence, result)
-      define(sequence, result).tap do |definition|
-        definition.fragment!
+    def cycle(name, &cycle_thru_blk)
+      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 define(sequence, result, &blk)
+    def fragment(sequence, result)
+      define(sequence, result, fragment: true)
+    end
+
+    def define(sequence, result=nil, fragment: false, &blk)
       unless result.respond_to?(:call)
         string_result = result
         result = -> { string_result }
@@ -178,6 +228,7 @@ class KeyboardMacros < Addon
           self,
           sequence.bytes,
           result,
+          fragment: fragment,
           &blk
         )
       when Symbol
@@ -187,10 +238,11 @@ class KeyboardMacros < Addon
             fail "Cannot bind unknown sequence #{sequence.inspect}"
           },
           result,
+          fragment: fragment,
           &blk
         )
       when Regexp
-        define_sequence_for_regex(sequence, result, &blk)
+        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}
@@ -206,67 +258,87 @@ class KeyboardMacros < Addon
       @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, &blk)
+    def define_sequence_for_regex(regex, result, fragment: false, &blk)
       @storage[regex] = Definition.new(
         configuration: Configuration.new(
           cancellation: @cancellation,
-          keymap: @keymap
+          keymap: @keymap,
+          editor: @editor
         ),
+        fragment: fragment,
         sequence: regex,
         result: result,
         &blk
       )
     end
 
-    def recursively_define_sequence_for_bytes(configuration, bytes, result, &blk)
+    def recursively_define_sequence_for_bytes(configuration, bytes, result, fragment: false, &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
-        )
+        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
-        configuration[byte] = Definition.new(
-          configuration: Configuration.new(keymap: @keymap),
+        definition = Definition.new(
+          configuration: Configuration.new(
+            keymap: @keymap,
+            editor: @editor
+          ),
+          fragment: fragment,
           sequence: byte,
-          result: result,
-          &blk
+          result: result
         )
+        configuration[byte] = definition
+        blk.call(definition.configuration) if blk
+        definition
       end
     end
   end
 
   class Definition
-    attr_reader :bytes, :configuration, :result, :sequence
+    attr_reader :configuration, :result, :sequence
 
-    def initialize(configuration: nil, sequence:, result: nil, &blk)
-      @fragment = false
+    def initialize(configuration: nil, fragment: false, sequence:, result: nil)
+      @fragment = fragment
       @configuration = configuration
       @sequence = sequence
       @result = result
-      blk.call(@configuration) if blk
     end
 
-    def fragment?
-      @fragment
+    def inspect
+      "<Definition fragment=#{@fragment.inspect} sequence=#{@sequence.inspect} result=#{@result.inspect} configuration=#{@configuration.inspect}>"
     end
 
-    def fragment!
-      @fragment = true
+    def fragment?
+      @fragment
     end
 
     def matches?(byte)

data/addons/keyboard_macros/lib/keyboard_macros/cycle.rb

@@ -0,0 +1,38 @@
+class KeyboardMacros
+  class Cycle
+    def initialize(cycle_proc:, on_cycle_proc: nil)
+      @cycle_proc = cycle_proc
+      @on_cycle_proc = on_cycle_proc
+      @previous_result = nil
+      reset
+    end
+
+    def next
+      @index = -1 if @index >= cycle_values.length - 1
+      on_cycle cycle_values[@index += 1]
+    end
+
+    def previous
+      @index = cycle_values.length if @index < 0
+      on_cycle cycle_values[@index -= 1]
+    end
+
+    def reset
+      @index = -1
+      @previous_result = nil
+      @cycle_values = nil
+    end
+
+    private
+
+    def cycle_values
+      @cycle_values ||= @cycle_proc.call
+    end
+
+    def on_cycle(new_value)
+      @on_cycle_proc.call(@previous_result, new_value) if @on_cycle_proc
+      @previous_result = new_value
+      new_value
+    end
+  end
+end

data/addons/prompt_updates/prompt_updates.rb

@@ -22,7 +22,7 @@ class PromptUpdates < Addon
   private
 
   def determine_branch
-    `git branch`.scan(/\*\s*(.*)$/).flatten.first
+    `git branch 2>/dev/null`.scan(/\*\s*(.*)$/).flatten.first
   end
 
 end

data/addons/tab_completion/lib/tab_completion/basic_completion.rb

@@ -0,0 +1,151 @@
+class TabCompletion
+  class BasicCompletion
+    class << self
+      attr_accessor :priority
+    end
+    self.priority = 1
+
+    attr_reader :world
+
+    def initialize(world:, word_break_characters:, path:nil)
+      @world = world
+      @word_break_characters = word_break_characters
+      path ||= @world.env["PATH"]
+      @paths = path.split(":")
+    end
+
+    def completions_for(word, words, word_index)
+      completions_by_name = {}
+      if looking_for_command?(word, words, word_index)
+        # Lowest Priority
+        completions_by_name.merge! command_completion_matches_for(word, words)
+
+        # Low Priority
+        completions_by_name.merge! builtin_completion_matches_for(word, words)
+
+        # Medium Priority
+        completions_by_name.merge! executable_filename_completion_matches_for(word, words)
+
+        # High Priority
+        completions_by_name.merge! shell_command_completion_matches_for(word, words)
+
+        # Highest Priority
+        completions_by_name.merge! alias_completion_matches_for(word, words)
+      else
+        completions_by_name.merge! filename_completion_matches_for(word, words)
+      end
+      completions_by_name.merge! environment_variable_completions_for(word, words)
+      completions_by_name.values
+    end
+
+    private
+
+    def looking_for_command?(word, words, word_index)
+      return false unless word_index
+      return true if word_index == 0
+      return true if words[word_index - 1] =~ /[;&]/
+      false
+    end
+
+    def alias_completion_matches_for(word, words)
+      @world.aliases.names.each_with_object({}) do |name, result|
+        if name =~ /^#{Regexp.escape(word)}/
+          result[name] ||=  CompletionResult.new(
+            type: :alias,
+            text: name
+          )
+        end
+      end
+    end
+
+    def builtin_completion_matches_for(word, words)
+      @world.builtins.each_with_object({}) do |builtin, result|
+        if builtin =~ /^#{Regexp.escape(word)}/
+          result[builtin] ||= CompletionResult.new(
+            type: :builtin,
+            text: builtin
+          )
+        end
+      end
+    end
+
+    def command_completion_matches_for(word, words)
+      @paths.each_with_object({}) do |path, matches|
+        glob = File.join(path, "#{word}*")
+        arr = Dir[glob].select { |path| File.executable?(path) && File.file?(path) }
+        arr.map { |path| File.basename(path) }.uniq.each do |command|
+          matches[command] = CompletionResult.new(type: :command, text: command)
+        end
+      end
+    end
+
+    def environment_variable_completions_for(word, words)
+      return {} unless word =~ /^\$/
+      prefix, word_sans_prefix = word[0], word[1..-1]
+      @world.env.keys.each_with_object({}) do |env_var, result|
+        if env_var =~ /^#{Regexp.escape(word_sans_prefix)}/
+          result[env_var] ||= CompletionResult.new(
+            type: :env_var,
+            text: prefix + env_var
+          )
+        end
+      end
+    end
+
+    def executable_filename_completion_matches_for(word, words)
+      glob = "#{word}*"
+      glob.gsub!("~", world.env["HOME"])
+      Dir.glob(glob, File::FNM_CASEFOLD).each_with_object({}) do |path, result|
+        text = path.gsub(filtered_work_break_characters_rgx, '\\\\\1')
+        descriptive_text = File.basename(text)
+        if !File.directory?(path) && File.executable?(path)
+          result[path] =  CompletionResult.new(
+            type: :command,
+            text: text,
+            descriptive_text: descriptive_text
+          )
+        end
+      end
+    end
+
+    def shell_command_completion_matches_for(word, words)
+      @world.shell_commands.each_with_object({}) do |shell_command, result|
+        if shell_command =~ /^#{Regexp.escape(word)}/
+          result[shell_command] ||= CompletionResult.new(
+            type: :shell_command,
+            text: shell_command
+          )
+        end
+      end
+    end
+
+    def filename_completion_matches_for(word, line)
+      glob = "#{word}*"
+      glob.gsub!("~", world.env["HOME"])
+      Dir.glob(glob, File::FNM_CASEFOLD).each_with_object({}) do |path, result|
+        text = path.gsub(filtered_work_break_characters_rgx, '\\\\\1')
+        descriptive_text = File.basename(text)
+        result[path] = if File.directory?(path)
+          CompletionResult.new(type: :directory, text: text, descriptive_text: descriptive_text)
+        elsif File.symlink?(path)
+          CompletionResult.new(type: :symlink, text: text, descriptive_text: descriptive_text)
+        elsif File.file?(path) && File.executable?(path)
+          CompletionResult.new(type: :command, text: text, descriptive_text: descriptive_text)
+        else
+          CompletionResult.new(type: :file, text: text, descriptive_text: descriptive_text)
+        end
+      end
+    end
+
+    # Remove file separator and the back-slash from word break characters when determining
+    # the pre-word-context
+    def filtered_word_break_characters
+      @word_break_characters.sub(File::Separator, "").sub('\\', '')
+    end
+
+    def filtered_work_break_characters_rgx
+      /([#{Regexp.escape(filtered_word_break_characters)}])/
+    end
+
+  end
+end