yap-shell-addon-tab-completion 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 17f0d28a12033e862e37d1fb8cde3087567f02a8
+  data.tar.gz: 931b2fecaad8de83abeb99f497f0d5eca0859a8e
+SHA512:
+  metadata.gz: 88a04ac6f611fd87a381ca5bcd8bea6f6a068257d524297826db1d40af302ab95bb19a64d05cc7092b19ae30265722b579f75c47c9249cda51a846f0655a6766
+  data.tar.gz: df594f455eb5d59e4b27802edbea32ab0fdaeb10e4f2d5135a0a602a303fdc33113843f5165ac959efaa7dc1bb251673497ab69f8da789de670e10713b0b1ac2

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+wiki/

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in yap-shell-addon-tab-completion.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Zach Dennis
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# tab-completion for yap-shell
+
+Welcome to your new yap addon! In this directory, you'll find the files you need to be able to package up your addon into a gem. Put your Ruby code in the file `lib/yap-shell-addon-tab-completion`.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yap-shell-addon-tab-completion'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yap-shell-addon-tab-completion
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/yap-shell-addon-tab-completion.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "yap/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/yap-shell-addon-tab-completion.rb

@@ -0,0 +1,178 @@
+require 'yap/addon'
+require 'yap-shell-addon-tab-completion/basic_completion'
+require 'yap-shell-addon-tab-completion/completer'
+require 'yap-shell-addon-tab-completion/completion_result'
+require 'yap-shell-addon-tab-completion/custom_completion'
+require 'yap-shell-addon-tab-completion/dsl_methods'
+require 'yap-shell-addon-tab-completion/version'
+
+module YapShellAddonTabCompletion
+  class Addon < ::Yap::Addon::Base
+    self.export_as :'tab-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 YapShellAddonTabCompletion::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|
+        logger.puts "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|
+        logger.puts "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|
+        logger.puts "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?
+      logger.puts "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?
+      logger.puts "set_decoration for type=#{name.inspect}"
+      @style_procs[type] = blk
+    end
+
+    def complete(word, words, word_index)
+      logger.puts "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
+
+      logger.puts "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
+end

data/lib/yap-shell-addon-tab-completion/basic_completion.rb

@@ -0,0 +1,151 @@
+module YapShellAddonTabCompletion
+  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/lib/yap-shell-addon-tab-completion/completer.rb

@@ -0,0 +1,61 @@
+module YapShellAddonTabCompletion
+  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/lib/yap-shell-addon-tab-completion/completion_result.rb

@@ -0,0 +1,25 @@
+module YapShellAddonTabCompletion
+  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
+end

data/lib/yap-shell-addon-tab-completion/custom_completion.rb

@@ -0,0 +1,33 @@
+module YapShellAddonTabCompletion
+  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/lib/yap-shell-addon-tab-completion/dsl_methods.rb

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

data/lib/yap-shell-addon-tab-completion/version.rb

@@ -0,0 +1,3 @@
+module YapShellAddonTabCompletion
+  VERSION = '0.1.0'
+end

data/yap-shell-addon-tab-completion.gemspec

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/lib/yap-shell-addon-tab-completion/version'
+
+Gem::Specification.new do |spec|
+  spec.name    = 'yap-shell-addon-tab-completion'
+  spec.version = YapShellAddonTabCompletion::VERSION
+  spec.authors  = ['Your name']
+  spec.email    = 'you@example.com'
+  spec.date    = Date.today.to_s
+
+  spec.summary = 'tab-completion summary goes here.'
+  spec.description = 'tab-completion description goes here.'
+  spec.homepage = ''
+  spec.license = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(/^(test|spec|features)\//) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(/^exe\//) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "yap-shell", "~> 0.6"
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 11.2"
+  spec.add_development_dependency "rspec", "~> 3.4"
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: yap-shell-addon-tab-completion
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Your name
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yap-shell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: tab-completion description goes here.
+email: you@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/yap-shell-addon-tab-completion.rb
+- lib/yap-shell-addon-tab-completion/basic_completion.rb
+- lib/yap-shell-addon-tab-completion/completer.rb
+- lib/yap-shell-addon-tab-completion/completion_result.rb
+- lib/yap-shell-addon-tab-completion/custom_completion.rb
+- lib/yap-shell-addon-tab-completion/dsl_methods.rb
+- lib/yap-shell-addon-tab-completion/version.rb
+- yap-shell-addon-tab-completion.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: tab-completion summary goes here.
+test_files: []
+has_rdoc: