yarsh 0.1.1 → 0.3.0

data/lib/yarsh/multiline.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Yarsh
+  # Multiline input support: decides when a line is syntactically incomplete
+  # (keep reading) and transforms a finished buffer so shell lines can live
+  # inside Ruby blocks/defs/classes: shell lines are rewritten into __sh__ calls.
+  module Multiline
+    INCOMPLETE_MESSAGES = [
+      /unexpected end-of-input/,
+      /unterminated string/,
+      /unterminated heredoc/,
+      /unterminated regexp/,
+      /can't find string ".*" anywhere before EOF/,
+      /expected a `when` or `in` clause after `case`/,
+      /expected an `end` to close the/
+    ].freeze
+
+    # Keywords that must never be treated as shell, even though some of them
+    # (break, next, return, times, ...) are also bash builtins.
+    STRUCTURAL_KEYWORDS = %w[do end if else elsif when rescue ensure then begin
+                             case class def module while until for unless
+                             return break next yield].freeze
+    KEYWORD_REGEX = Regexp.new("\\A(?:#{STRUCTURAL_KEYWORDS.join('|')})\\b")
+
+    class IdentifierSurround
+      def initialize
+        @local_vars = {}
+      end
+
+      # detect if the line assign a new local variable
+      # if yes, save it's name
+      def save_local_vars(line)
+        tokens = Prism.lex(line).value.map { |token, _| token }
+        return unless tokens.any? { |token| token.type == :EQUAL }
+
+        tokens
+          .take_while { |token| token.type != :EQUAL }
+          .filter { |token| token.type == :IDENTIFIER }
+          .each do |token|
+          @local_vars[token.value] =
+            token
+        end
+      end
+
+      # surroud the local variable with 'bind.eval()'
+      # a local variable is an identifier who was registred
+      # in a precedent line
+      def surrond_with_bind(line, bind_name)
+        Prism.lex(line).value
+             .map { |token, _| token }
+             .filter { |token| token.type == :IDENTIFIER }
+             .each do |token|
+               next unless @local_vars[token.value]
+
+               location = token.location
+               line[location.start_column..(location.end_column - 1)] =
+                 "__yarsh__(\"#{token.value}\", #{bind_name})"
+             end
+        line
+      end
+    end
+
+    def self.incomplete?(src)
+      RubyVM::InstructionSequence.compile(src)
+      false
+    rescue SyntaxError => e
+      INCOMPLETE_MESSAGES.any? { |re| e.message =~ re }
+    end
+
+    # :ruby   - keep the line verbatim
+    # :shell  - rewrite the line into a __sh__ call
+    # :skip   - drop the line (blank)
+    def self.classify_line(line)
+      stripped = line.strip
+      return :skip if stripped.empty?
+      # return :ruby if structural?(stripped)
+      # return :shell if stripped.include?('-->') #FIXME: Should not be treated as a shell --> should allow multiline too
+      # return :shell if shell_command && shell_command.call(stripped) #FIXME: pwd = Dir.pwd is evaluated as a shell command instead of a ruby
+      # return :ruby if incomplete?(stripped)
+      # return :ruby if compiles?(stripped)
+      # #TODO: check what happend when it do not compile with another error message catched by incomplete? ?
+
+      # :shell
+      return :structural if structural?(stripped)
+
+      # return :shell if !compiles?(stripped) && shell_command&.call(stripped)
+
+      :yarsh
+    end
+
+    def self.transform(buffer, &shell_command)
+      heredoc_delim = nil
+      is_structural = false
+      print_binding = 'bind = binding'
+      ident_surround = IdentifierSurround.new
+      buffer.split("\n").map do |line|
+        if heredoc_delim
+          heredoc_delim = nil if line.strip == heredoc_delim
+          next line
+        end
+        if (delim = heredoc_delimiter(line))
+          heredoc_delim = delim
+          next line
+        end
+        case classify_line(line, &shell_command)
+        when :skip then nil
+        when :structural
+          next line if line.include? 'end'
+
+          if is_structural
+            line = ident_surround.surrond_with_bind(line, 'bind')
+            print_binding = 'bind = binding + bind'
+          end
+          is_structural = true
+          line + "\n" + print_binding
+        when :shell then "__sh__(#{line.strip.inspect})"
+        when :yarsh
+          ident_surround.save_local_vars(line)
+          "__yarsh__(#{line.strip.inspect}, #{is_structural ? 'bind' : 'nil'})"
+        end
+      end.join("\n")
+    end
+
+    def self.structural?(line)
+      # line.strip.match?(KEYWORD_REGEX)
+      Ripper.lex(line).any? { |token| STRUCTURAL_KEYWORDS.include?(token[2]) }
+    end
+
+    def self.compiles?(src)
+      RubyVM::InstructionSequence.compile(src)
+      true
+    rescue SyntaxError
+      false
+    end
+
+    def self.heredoc_delimiter(line)
+      return nil if line.include?('-->')
+      return nil unless line.include?('<<')
+
+      m = line.match(/<<(-|~)?(['"])([^'"]+)\2(?:\s*\.\w+)?\s*\z/)
+      return m[3] if m
+
+      m = line.match(/<<(-|~)?([A-Za-z_]\w*)(?:\s*\.\w+)?\s*\z/)
+      m && m[2]
+    end
+  end
+end

data/lib/yarsh/prompt.rb

@@ -8,8 +8,15 @@ module Yarsh
       seg = Dir.pwd.gsub(/^#{Dir.home}/, '~').split('/')
       seg = (seg.size > 3 ? [' …'] + seg[-3..-1] : seg)
       git_branch = ''
-      git_branch = `git status --porcelain -b`.split("\n")&.first&.gsub('## ', '') || '' if File.directory?('.git')
-      git_branch = '   ' + git_branch unless git_branch.empty?
+      if File.directory?('.git')
+        git_branch = `git status --porcelain -b`
+                     .split("\n")
+                     &.first
+                     &.gsub('## ', '')
+                     &.split('...', 2)
+                     &.first || ''
+      end
+      git_branch = '  ' + git_branch unless git_branch.empty?
       c.bg_color256(base_color)
        .fg_white("#{seg.join('  ')}#{git_branch}")
        .reset

data/lib/yarsh/shell.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
+
+require 'shellwords'
+
 module Yarsh
   class Shell
     include Yarsh
     include InstanceMethods
 
-    SHELL_BUILTINS = %w[alias bg bind break builtin cd command echo eval exec exit
+    attr_accessor :bind
+
+    SHELL_BUILTINS = %w[alias bg bind break builtin command echo eval exec exit
                         export false fc fg getopts hash help history jobs kill let
                         local logout mapfile popd printf pushd pwd read readonly
                         return set shift shopt source suspend test times trap true
@@ -16,8 +21,14 @@ module Yarsh
       @history_file = File.expand_path(HISTORY_FILE)
       @config_file = File.expand_path(CONFIG_FILE)
       @cf = Yarsh::AnsiColorFormatter.new
+      @typing = false
+      Yarsh.current_shell = self
+      setup_completion_registry
       setup_reline_history
       setup_reline_completion
+      setup_reline_prompt
+      setup_output_modifier_proc
+      setup_completion_dialog
     end
 
     def shell
@@ -25,7 +36,7 @@ module Yarsh
       load @config_file, InstanceMethods if File.exist? @config_file
       loop do
         input = begin
-          @core.readline(Config.instance.prompt, true)
+          read_input
         rescue Interrupt
           next
         end
@@ -37,42 +48,7 @@ module Yarsh
         append_history(input, @history_file)
 
         begin
-          if input.include?('-->')
-            fp execute_pipe(input, @bind)
-            next
-          end
-
-          if shell_path?(input)
-            execute(input)
-            next
-          end
-
-          if input == 'cd' || input.start_with?('cd ')
-            cd(input.split(' ', 2)[1])
-            next
-          end
-
-          begin
-            result = @bind.eval(input)
-            fp result
-          rescue NameError, SyntaxError, ArgumentError => rb_error
-            unless shell_command?(input) || rb_error.is_a?(NameError) || rb_error.is_a?(SyntaxError)
-              $rber = rb_error
-              puts @cf.fg_red("Error: ArgumentError: #{rb_error.message}")
-              next
-            end
-            info("Assuming it is not a ruby expression, the error: #{rb_error.message}")
-            debug("The detail: #{rb_error.backtrace.join("\n")}")
-            begin
-              input = Yarsh.expand_aliases(input, Config.instance.aliases)
-              execute(input)
-            rescue Exception => e
-              $sher = e
-              info("#{e.class}: #{e.message}")
-              puts "#{@cf.bold.underline.fg_blue('Shell:')} '#{input}': #{e.message}"
-              puts "#{@cf.bold.underline.fg_red('Ruby:')} '#{input}': #{rb_error.message}"
-            end
-          end
+          fp execute_multiline(input)
         rescue Interrupt
           next
         rescue SystemExit
@@ -82,6 +58,8 @@ module Yarsh
           puts @cf.fg_red("Error: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
         end
       end
+    ensure
+      Config.instance.logger.close
     end
 
     private
@@ -91,14 +69,106 @@ module Yarsh
     end
     alias fp format_output
 
+    def read_input
+      @typing = true
+      input = @core.readmultiline(Config.instance.prompt, true) do |buffer|
+        !incomplete_line?(buffer) || buffer.match?(/\n[ \t]*\n\z/)
+      end
+      @typing = false
+      input
+    end
+
+    # A line is "incomplete" (multiline continues) only when it is not a
+    # shell command: `cd /tmp`, `grep foo /etc/passwd` etc. fail to compile
+    # as Ruby (unterminated regexp) but must stay single-line.
+    def incomplete_line?(line)
+      return true if shell_command?(line) && unclosed_quote?(line)
+
+      Yarsh::Multiline.incomplete?(line) && !shell_command?(line) && !line&.start_with?('cd')
+    end
+
+    def unclosed_quote?(line)
+      return false if line.nil?
+      double_quotes = line.scan(/(?<!\\)"/).size
+      single_quotes = line.scan(/(?<!\\)'/).size
+      double_quotes.odd? || single_quotes.odd?
+    end
+
+    def inside_quote?(pre)
+      return false if pre.nil? || pre.empty?
+      double_quotes = pre.scan(/(?<!\\)"/).size
+      single_quotes = pre.scan(/(?<!\\)'/).size
+      double_quotes.odd? || single_quotes.odd?
+    end
+
+    def execute_multiline(input)
+      source = Yarsh::Multiline.transform(input) { |line| shell_command?(line) }
+      debug("What I will evaluate as multiline:\n#{@cf.bold.fg_blue(source)}")
+      @bind.eval(source)
+    end
+
+    # Evaluate a yarsh line. A yarsh line is a ruby expression or a shell syntax
+    def yarsh_eval(input)
+      debug("I want to evaluate the input: #{input}")
+      return execute_pipe(input, @bind) if input.include?('-->')
+
+      return execute(input) if shell_path?(input)
+
+      if input == 'cd' || input.start_with?('cd ')
+        cd(input.split(' ', 2)[1])
+        return nil
+      end
+
+      begin
+        @bind.eval(input)
+      rescue NameError, SyntaxError, ArgumentError => rb_error
+        unless shell_command?(input) || rb_error.is_a?(NameError) || rb_error.is_a?(SyntaxError)
+          $rber = rb_error
+          return @cf.fg_red("Error: ArgumentError: #{rb_error.message}")
+        end
+        info("Assuming it is not a ruby expression, the error: #{rb_error.message}")
+        debug("The detail: #{rb_error.backtrace.join("\n")}")
+        begin
+          input = Yarsh.expand_aliases(input, Config.instance.aliases)
+          execute(input)
+        rescue Exception => e
+          $sher = e
+          info("#{e.class}: #{e.message}")
+          puts "#{@cf.bold.underline.fg_blue('Shell:')} '#{input}': #{e.message}"
+          puts "#{@cf.bold.underline.fg_red('Ruby:')} '#{input}': #{rb_error.message}"
+        end
+      end
+    end
+
+    # Runs a shell line from inside a multiline Ruby buffer (via __sh__).
+    def __sh_exec(command)
+      command = Yarsh.expand_aliases(command, Config.instance.aliases)
+      if command.include?('-->')
+        puts execute_pipe(command, @bind)
+      else
+        execute(command)
+      end
+    end
+
+    def setup_reline_prompt
+      Reline.prompt_proc = proc do |lines|
+        [Config.instance.prompt] + Array.new([lines.size - 1, 0].max, '  > ')
+      end
+    end
+
     def cd(path = '~')
       Dir.chdir(File.expand_path(path || '~'))
     end
 
     def execute(cmd)
+      return system(cmd, exception: true) if cmd.match?(/[|;&`$(){}\[\]<>]/)
+      args = Shellwords.shellsplit(cmd)
+      system(*args, exception: true)
+    rescue ArgumentError
       system(cmd, exception: true)
     end
 
+    # TODO: Use exec_in_path?
     def shell_command?(input)
       first_token = input.strip.split(/\s+/, 2).first
       return true if shell_path?(first_token)
@@ -109,7 +179,39 @@ module Yarsh
       end
     end
 
+    def exec_in_path?(input)
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |dir|
+        File.executable?(File.join(dir, input))
+      end
+    end
+
     def complete_command(word)
+      registry = @completion_registry
+      return [] if word.nil?
+
+      if word.empty?
+        return ENV['PATH'].split(File::PATH_SEPARATOR)
+                   .flat_map { |dir| Dir["#{dir}/*"] }
+                   .map { |f| File.basename(f) }
+                   .uniq
+                   .sort
+      end
+
+      cmd = word.strip.split(/\s+/).first
+      return [] if cmd.nil? || cmd.empty?
+
+      # Strip privileged prefix (sudo, doas, etc.) — complete the real command
+      if Yarsh::Completion::Engine::PRIVILEGED_COMMANDS.include?(cmd)
+        remaining = word.sub(/\A#{Regexp.escape(cmd)}\s+/, '')
+        return complete_command(remaining)
+      end
+
+      completions = registry.complete(cmd, word)
+      return completions unless completions.empty?
+
+      builtins = SHELL_BUILTINS.select { |b| b.start_with?(word) }
+      return builtins unless builtins.empty?
+
       ENV['PATH'].split(File::PATH_SEPARATOR)
                  .flat_map { |dir| Dir["#{dir}/#{word}*"] }
                  .map { |f| File.basename(f) }
@@ -117,6 +219,62 @@ module Yarsh
                  .sort
     end
 
+    def setup_completion_registry
+      @completion_registry = Yarsh::Completion::Registry.new
+      @completion_registry.register(Yarsh::Completion::BashAutocomplete.new)
+      @completion_registry.register(Yarsh::Completion::GemCompletion.new)
+      @completion_registry.register(Yarsh::Completion::HelpCompletion.new)
+    end
+
+    def complete_ruby(word)
+      IRB::InputCompletor.retrieve_completion_data(word, bind: @bind)
+    rescue
+      []
+    end
+
+    def setup_output_modifier_proc
+      @core.output_modifier_proc = proc do |data|
+        if @typing
+          IRB::Color.colorize_code(data)
+        else
+          data
+        end
+      end
+    end
+
+    def setup_completion_dialog
+      Reline.add_dialog_proc(:docs, proc {
+        begin
+          dialog.trap_key = nil
+
+          next nil if just_cursor_moving && completion_journey_data.nil?
+
+          cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
+          next nil if result.nil? || pointer.nil? || pointer.negative?
+
+          selection = result[pointer]
+          help_command = Help::Command.new(screen_width, cursor_pos_to_render, autocomplete_dialog)
+          next nil unless help_command.info(result[pointer])
+
+          dialog.trap_key = Yarsh::ALT_D_SEQUENCES
+
+          if key.match?(dialog.name)
+            begin
+              print "\e[?1049h"
+              system(*Shellwords.shellsplit("man #{selection}"))
+            ensure
+              print "\e[?1049l"
+            end
+          end
+          help_command.render_dialog
+        rescue StandardError => e
+          extend Yarsh::InstanceMethods
+          debug("Error occurend for add help dialog: #{e.message}")
+          nil
+        end
+      }, Reline::DEFAULT_DIALOG_CONTEXT)
+    end
+
     def complete_path(word)
       word = './' if word.empty?
       glob_word = word.start_with?('~') ? File.expand_path(word) : word
@@ -161,23 +319,58 @@ module Yarsh
     end
 
     def setup_reline_completion
-      Reline.completion_proc = proc { |target, pre|
-        # puts "target='#{target}' pre='#{pre}'"
-        if target.match?(%r{\A\.\.?(/|\z)}) || target.start_with?('/', '~') || target.include?('/')
-          complete_path(target)
-        elsif target.empty? && pre.empty?
-          complete_command(target)
-        elsif pre.end_with?(' ')
-          complete_path(target)
-        else
-          complete_command(target)
-        end
+      Reline.autocompletion = Config.instance.autocompletion
+      Reline.completion_append_character = ' '
+      Reline.core.config.keyseq_timeout = 0.5
+      Reline.completion_proc = proc { |target, pre, post|
+        next [] if inside_quote?(pre)
+        full = pre.empty? ? target : pre.rstrip + ' ' + target
+        first_word = full.strip.split(/\s+/).first.to_s
+        ruby_completions = if !Config.instance.ruby_completion ||
+                              Yarsh::Completion::Engine::PRIVILEGED_COMMANDS.include?(first_word)
+                             []
+                           else
+                             complete_ruby(target).compact
+                           end
+        ruby_completions +
+          if target.match?(%r{\A\.\.?(/|\z)}) || target.start_with?('/', '~') || target.include?('/')
+            complete_path(target)
+          elsif target.empty? && pre.empty?
+            complete_command(target)
+          elsif pre.end_with?(' ')
+            complete_command(full)
+          else
+            complete_command(full)
+          end
       }
     end
 
     def setup_reline_history
       Dir.mkdir(File.dirname(@history_file)) unless Dir.exist?(File.dirname(@history_file))
-      File.readlines(@history_file, chomp: true).each { |line| Reline::HISTORY << line } if File.exist?(@history_file)
+      return unless File.exist?(@history_file)
+
+      pending = nil
+      File.readlines(@history_file, chomp: true).each do |line|
+        next if line.strip.empty?
+
+        unless pending
+          pending = line
+          next
+        end
+        if incomplete_line?(pending)
+          candidate = "#{pending}\n#{line}"
+          if Yarsh::Multiline.incomplete?(candidate)
+            pending = candidate
+          else
+            Reline::HISTORY << candidate
+            pending = nil
+          end
+        else
+          Reline::HISTORY << pending
+          pending = line
+        end
+      end
+      Reline::HISTORY << pending if pending
     end
   end
 end

data/lib/yarsh/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yarsh
-  VERSION = '0.1.1'
+  VERSION = '0.3.0'
 end

data/lib/yarsh.rb

@@ -4,19 +4,31 @@ require 'reline'
 require 'open3'
 require 'singleton'
 require 'logger'
+require 'irb/completion'
+require_relative 'yarsh/completion/gem_completion'
+require 'irb/color'
+require 'ripper'
+require 'prism'
 
 module Yarsh
   class Error < StandardError; end
 end
 
-Dir['lib/yarsh/**/*.rb'].each do |f|
-  require_relative File.join('..', f)
+Dir[File.expand_path('**/*.rb', __dir__)].each do |f|
+  require_relative f
 end
 
 module Yarsh
   YARSH_DIR = '~/.yarsh'
   HISTORY_FILE = File.join Yarsh::YARSH_DIR, 'history'
   CONFIG_FILE = File.join Yarsh::YARSH_DIR, 'config'
+  ALT_D_SEQUENCES = [
+      [27, 100], # Normal Alt+d when convert-meta isn't used.
+      # When option/alt is not configured as a meta key in terminal emulator,
+      # option/alt + d will send a unicode character depend on OS keyboard setting.
+      [195, 164], # "ä" in somewhere (FIXME: environment information is unknown).
+      [226, 136, 130] # "∂" Alt+d on Mac keyboard.
+    ].freeze
 
   class ExecOutput < String
     def initialize(string)
@@ -34,6 +46,14 @@ module Yarsh
 
   class Error < StandardError; end
 
+  def self.current_shell
+    @current_shell
+  end
+
+  def self.current_shell=(shell)
+    @current_shell = shell
+  end
+
   # in a Shell input, find all command matching the keys of aliases and replace them with
   # the values. Leading and trailing whitespace around the match is preserved.
   def self.expand_aliases(input, aliases)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yarsh
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - yarsh4all
@@ -44,8 +44,17 @@ files:
 - exe/yarsh
 - lib/yarsh.rb
 - lib/yarsh/ansi_color_formatter.rb
+- lib/yarsh/binding.rb
+- lib/yarsh/completion.rb
+- lib/yarsh/completion/bash_autocomplete.rb
+- lib/yarsh/completion/engine.rb
+- lib/yarsh/completion/gem_completion.rb
+- lib/yarsh/completion/help_completion.rb
+- lib/yarsh/completion/registry.rb
 - lib/yarsh/config.rb
+- lib/yarsh/help.rb
 - lib/yarsh/instance_methods.rb
+- lib/yarsh/multiline.rb
 - lib/yarsh/prompt.rb
 - lib/yarsh/shell.rb
 - lib/yarsh/version.rb