yap-shell 0.6.0 → 0.7.0

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

@@ -1,38 +0,0 @@
-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/Gemfile

@@ -1 +0,0 @@
-gem "chronic", "~> 0.10.2"

data/addons/prompt/right_prompt.rb

@@ -1,17 +0,0 @@
-class RightPrompt < Addon
-  def self.load_addon
-    @instance ||= new
-  end
-
-  def initialize_world(world)
-    @world = world
-
-    # @world.subscribe(:refresh_right_prompt) do |event|
-    #   @world.right_prompt_text = Time.now.strftime("%H:%M:%S")
-    # end
-    #
-    # @world.events.recur(
-    #   name: "refresh_right_prompt", source: self, interval_in_ms: 1_000
-    # )
-  end
-end

data/addons/prompt_updates/prompt_updates.rb

@@ -1,28 +0,0 @@
-class PromptUpdates < Addon
-  attr_reader :world
-
-  def initialize_world(world)
-    current_branch = determine_branch
-
-    @world = world
-    @world.events.recur(
-      name: 'prompt_updates',
-      source: self,
-      interval_in_ms: 100
-    ) do
-      new_branch = determine_branch
-      if current_branch != new_branch
-        current_branch = new_branch
-        @world.refresh_prompt
-      end
-    end
-
-  end
-
-  private
-
-  def determine_branch
-    `git branch 2>/dev/null`.scan(/\*\s*(.*)$/).flatten.first
-  end
-
-end

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

@@ -1,151 +0,0 @@
-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

data/addons/tab_completion/lib/tab_completion/completer.rb

@@ -1,62 +0,0 @@
-class TabCompletion
-
-  class Completer
-    def initialize(char:, line:, completion:, completion_found:, completion_not_found:, done:)
-      @completion_char = char
-      @line = line
-      @completion_proc = completion
-      @completion_found_proc = completion_found
-      @completion_not_found_proc = completion_not_found
-      @done_proc = done
-
-      @completion_matches = HistoryBuffer.new(0) do |h|
-        h.duplicates = false
-        h.cycle = true
-      end
-      @completion_matches.empty
-
-      @first_time = true
-      @word_start = @line.word[:start]
-    end
-
-    def read_bytes(bytes)
-      return unless bytes.any?
-
-      if bytes.map(&:ord) != @completion_char
-        @done_proc.call(bytes)
-      elsif @first_time
-        matches = @completion_proc.call(sub_word) unless !@completion_proc || @completion_proc == []
-        matches = matches.to_a.compact.sort.reverse
-
-        if matches.any?
-          @completion_matches.resize(matches.length)
-          matches.each { |w| @completion_matches << w }
-
-          # Get first match
-          @completion_matches.back
-          match = @completion_matches.get
-
-          # completion matches is a history implementation and its in reverse order from what
-          # a user would expect
-          @completion_found_proc.call(completion: match, possible_completions: @completion_matches.reverse)
-        else
-          @completion_not_found_proc.call
-          @done_proc.call
-        end
-        @first_time = false
-      else
-        @completion_matches.back
-        match = @completion_matches.get
-
-        @completion_found_proc.call(completion: match, possible_completions: @completion_matches.reverse)
-      end
-    end
-
-    private
-
-    def sub_word
-      @line.text[@line.word[:start]..@line.position-1] || ""
-    end
-  end
-
-end

data/addons/tab_completion/lib/tab_completion/custom_completion.rb

@@ -1,33 +0,0 @@
-class TabCompletion
-  class CustomCompletion
-    PRIORITY = 2
-
-    attr_reader :name, :pattern, :priority
-
-    def initialize(world:, name:nil, pattern:nil, priority:PRIORITY, &blk)
-      @world = world
-      @name = name
-      @pattern = pattern
-      @priority = priority
-      @blk = blk
-    end
-
-    def new(world:)
-      @world = world
-      self
-    end
-
-    def completions_for(word, line)
-      # TODO
-      return []
-    end
-
-    private
-
-    def match_rgx
-      return // if pattern.nil?
-      return pattern if pattern.is_a?(Regexp)
-      /^#{Regexp.escape(pattern.to_s)}\s/
-    end
-  end
-end

data/addons/tab_completion/lib/tab_completion/dsl_methods.rb

@@ -1,7 +0,0 @@
-class TabCompletion
-  module DslMethods
-    def tab_completion(name, pattern, &blk)
-      self[:tab_completion].add_completion(name, pattern, &blk)
-    end
-  end
-end

data/addons/tab_completion/tab_completion.rb

@@ -1,174 +0,0 @@
-require 'term/ansicolor'
-
-class TabCompletion < Addon
-  require 'tab_completion/completer'
-  require 'tab_completion/dsl_methods'
-  require 'tab_completion/custom_completion'
-  require 'tab_completion/basic_completion'
-
-  class CompletionResult
-    attr_accessor :text, :type, :descriptive_text
-
-    def initialize(text:, type:, descriptive_text: nil)
-      @descriptive_text = descriptive_text || text
-      @text = text
-      @type = type
-    end
-
-    def ==(other)
-      other.is_a?(self.class) && @text == other.text && @type == other.type
-    end
-
-    def <=>(other)
-      @text <=> other.text
-    end
-
-    def to_s
-      @text.to_s
-    end
-    alias_method :to_str, :to_s
-    alias_method :inspect, :to_s
-  end
-
-  COMPLETIONS = [ BasicCompletion ]
-
-  Color = Term::ANSIColor
-
-  DISPLAY_PROCS = Hash.new{ |h,k| h[k] = ->(text){ text } }.merge(
-    directory: -> (text){ text + "/" }
-  )
-
-  STYLE_PROCS = Hash.new{ |h,k| h[k] = ->(text){ text } }.merge(
-    alias:     -> (text){ Color.bold(Color.color("#ff00d7"){ text } ) },
-    builtin:   -> (text){ Color.bold(Color.color("#d7af00"){ text } ) },
-    directory: -> (text){ Color.bold(Color.red(text)) },
-    command:   -> (text){ Color.bold(Color.green(text)) },
-    shell_command: -> (text){ Color.bold(Color.color("#ffafff"){ text } ) },
-    symlink:   -> (text){ Color.bold(Color.cyan(text)) },
-    selected:  -> (text){ Color.negative(text) }
-  )
-
-  DECORATION_PROCS = Hash.new{ |h,k| h[k] = ->(text){ text } }.merge(
-    directory: -> (text){ text + "/" },
-    command:   -> (text){ text + "@" },
-    shell_command: -> (text) { text + "🐚" }
-  )
-
-  attr_reader :editor, :world
-
-  def initialize_world(world)
-    @world = world
-    @world.extend TabCompletion::DslMethods
-    @editor = @world.editor
-    @editor.completion_proc = -> (word, line, word_index){
-      complete(word, line, word_index)
-    }
-    @editor.bind(:tab){ @editor.complete }
-    @completions = COMPLETIONS.dup
-
-    @style_procs = STYLE_PROCS.dup
-    @decoration_procs = DECORATION_PROCS.dup
-    @display_procs = DISPLAY_PROCS.dup
-
-    editor.on_word_complete do |event|
-      debug_log "on_word_complete event: #{event}"
-
-      sub_word = event[:payload][:sub_word]
-      word = event[:payload][:word]
-      actual_completion = event[:payload][:completion]
-      possible_completions = event[:payload][:possible_completions]
-
-      semi_formatted_possibilities = possible_completions.map.with_index do |completion, i|
-        if completion == actual_completion
-          style_text_for_selected_match(completion) + "\e[0m"
-        else
-          style_text_for_nonselected_match(completion) + "\e[0m"
-        end
-      end
-
-      max_width = @editor.terminal_width
-      max_item_width = semi_formatted_possibilities.map(&:length).max + 2
-      most_per_line = max_width / max_item_width
-      padding_at_the_end = max_width % max_item_width
-
-      formatted_possibilities = semi_formatted_possibilities.map.with_index do |completion, i|
-        spaces_to_pad = max_item_width - completion.length
-        completion + (" " * spaces_to_pad)
-      end
-
-      editor.content_box.children = formatted_possibilities.map do |str|
-        TerminalLayout::Box.new(content: str, style: { display: :float, float: :left, height: 1, width: max_item_width })
-      end
-    end
-
-    editor.on_word_complete_no_match do |event|
-      debug_log "on_word_complete_no_match event: #{event}"
-
-      sub_word = event[:payload][:sub_word]
-      word = event[:payload][:word]
-      editor.content_box.children = []
-      # editor.content_box.content = "Failed to find a match to complete #{sub_word} portion of #{word}"
-    end
-
-    editor.on_word_complete_done do |event|
-      debug_log "on_word_complete_done event: #{event}"
-
-      # TODO: add a better way to clear content
-      editor.content_box.children = []
-    end
-  end
-
-  def add_completion(name, pattern, &blk)
-    raise ArgumentError, "Must supply block!" unless block_given?
-    debug_log "NO-OP add_completion for name=#{name.inspect} pattern=#{pattern.inspect} block?=#{block_given?}"
-    # @completions.push CustomCompletion.new(name:name, pattern:pattern, world:world, &blk)
-  end
-
-  def set_decoration(type, &blk)
-    raise ArgumentError, "Must supply block!" unless block_given?
-    debug_log "set_decoration for type=#{name.inspect}"
-    @style_procs[type] = blk
-  end
-
-  def complete(word, words, word_index)
-    debug_log "complete word=#{word.inspect} words=#{words.inspect} word_index=#{word_index.inspect}"
-
-    matches = @completions.sort_by(&:priority).reverse.map do |completion|
-      if completion.respond_to?(:call)
-        completion.call
-      else
-        completions = completion.new(
-          world: @world,
-          word_break_characters: editor.word_break_characters
-        ).completions_for(word, words, word_index)
-        completions.each do |completion|
-          completion.text = display_text_for_match(completion)
-        end
-      end
-    end.flatten
-
-    debug_log "complete possible matches are #{matches.inspect}"
-    matches
-  end
-
-  private
-
-  def display_text_for_match(match)
-    ANSIString.new @display_procs[match.type].call(match.text.dup)
-  end
-
-  def style_text_for_selected_match(match)
-    styled_text = @style_procs[match.type].call(match.descriptive_text.dup).to_s
-    styled_text = @decoration_procs[match.type].call(styled_text).to_s
-    uncolored_text = Color.uncolored(styled_text)
-    ANSIString.new @style_procs[:selected].call(uncolored_text)
-  end
-
-  def style_text_for_nonselected_match(match)
-    str = @decoration_procs[match.type].call(
-      @style_procs[match.type].call(match.descriptive_text.dup)
-    )
-    ANSIString.new str
-  end
-
-end