yap-shell 0.7.1 → 0.7.2

data/lib/yap/shell/execution/result.rb

@@ -1,18 +0,0 @@
-module Yap::Shell::Execution
-  class Result
-    attr_reader :status_code, :directory, :n, :of
-
-    def initialize(status_code:, directory:, n:, of:)
-      @status_code = status_code
-      @directory = directory
-      @n = n
-      @of = of
-    end
-  end
-
-  class SuspendExecution < Result
-  end
-
-  class ResumeExecution < Result
-  end
-end

data/lib/yap/shell/execution/ruby_command_execution.rb

@@ -1,80 +0,0 @@
-module Yap::Shell::Execution
-  class RubyCommandExecution < CommandExecution
-    on_execute do |command:, n:, of:, wait:|
-      result = nil
-      stdin, stdout, stderr, world = @stdin, @stdout, @stderr, @world
-
-      exit_code = 0
-      first_command = n == 1
-
-      f = nil
-      ruby_result = nil
-      begin
-        ruby_command = command.to_executable_str
-
-        Treefell['shell'].puts "ruby execution: reading stdin from #{stdin.inspect}"
-        contents = if stdin.is_a?(String)
-          f = File.open stdin
-          f.read
-        elsif stdin != $stdin
-          stdin.read
-        end
-
-        Treefell['shell'].puts "ruby execution: contents=#{contents.inspect}, setting to world.content"
-        world.contents = contents
-
-        method = ruby_command.scan(/^(\w+(?:[!?]|\s*=)?)/).flatten.first.gsub(/\s/, '')
-        Treefell['shell'].puts "ruby execution: method=#{method.inspect}"
-
-        obj = if first_command
-          world
-        elsif contents.respond_to?(method)
-          contents
-        else
-          world
-        end
-
-        if ruby_command =~ /^[A-Z0-9]|::/
-          Treefell['shell'].puts "ruby executing: eval(#{ruby_command.inspect})"
-          ruby_result = eval ruby_command
-        else
-          ruby_command = "self.#{ruby_command}"
-          Treefell['shell'].puts "ruby executing: #{obj.class.name} instance instance_eval(#{ruby_command.inspect})"
-          ruby_result = obj.instance_eval ruby_command
-        end
-      rescue Exception => ex
-        ruby_result = <<-EOT.gsub(/^\s*\S/, '')
-          |Failed processing ruby: #{ruby_command}
-          |#{ex}
-          |#{ex.backtrace.join("\n")}
-        EOT
-        exit_code = 1
-      ensure
-        f.close if f && !f.closed?
-      end
-
-      # The next line  causes issues sometimes?
-      # puts "WRITING #{ruby_result.length} bytes" if ENV["DEBUG"]
-      ruby_result = ruby_result.to_s
-      ruby_result << "\n" unless ruby_result.end_with?("\n")
-
-      stdout.write ruby_result
-      stdout.flush
-      stderr.flush
-
-      stdout.close if stdout != $stdout && !stdout.closed?
-      stderr.close if stderr != $stderr && !stderr.closed?
-
-      # Pass current execution to give any other threads a chance
-      # to be scheduled before we send back our status code. This could
-      # probably use a more elaborate signal or message passing scheme,
-      # but that's for another day.
-      # Thread.pass
-
-      # Make up an exit code
-      Result.new(status_code:exit_code, directory:Dir.pwd, n:n, of:of).tap do |result|
-        Treefell['shell'].puts "ruby execution done with result=#{result.inspect}"
-      end
-    end
-  end
-end

data/lib/yap/shell/execution/shell_command_execution.rb

@@ -1,30 +0,0 @@
-module Yap::Shell::Execution
-  class ShellCommandExecution < CommandExecution
-    on_execute do |command:, n:, of:, wait:|
-      Treefell['shell'].puts "shell command execution: #{command}"
-
-      possible_parameters = {
-        command: command.str,
-        args: command.args,
-        stdin: (@stdin != $stdin ? @stdin : StringIO.new),
-        stdout: @stdout,
-        stderr: @stderr,
-        world: @world,
-        line: command.line
-      }
-
-      func = command.to_proc
-      params = func.parameters.reduce({}) do |h, (type, name)|
-        h[name] = possible_parameters[name]
-        h
-      end
-
-      Treefell['shell'].puts "shell command executing with params: #{params.inspect} $stdout=#{$stdout.inspect} $stderr=#{$stderr.inspect}"
-      func.call(**params)
-
-      @stdout.close if @stdout != $stdout && !@stdout.closed?
-      @stderr.close if @stderr != $stderr && !@stderr.closed?
-      @stdin.close if @stdin != $stdin && !@stdin.closed?
-    end
-  end
-end

data/lib/yap/shell/prompt.rb

@@ -1,21 +0,0 @@
-module Yap::Shell
-  class Prompt
-    attr_reader :text
-
-    def initialize(text:, &blk)
-      @text = text
-      @blk = blk
-    end
-
-    def text=(text)
-      @text = text
-    end
-
-    def update
-      if @blk
-        @text = @blk.call
-      end
-      self
-    end
-  end
-end

data/lib/yap/shell/repl.rb

@@ -1,237 +0,0 @@
-require 'shellwords'
-require 'term/ansicolor'
-
-module Yap::Shell
-  module Color
-    extend Term::ANSIColor
-  end
-
-  class Repl
-    attr_reader :editor
-
-    def initialize(world:nil)
-      @world = world
-      @editor= world.editor
-
-      Treefell['shell'].puts "installing default keybindings"
-      install_default_keybindings
-
-      Treefell['shell'].puts "installing default tab completion"
-      install_default_tab_completion_proc
-    end
-
-    def on_input(&blk)
-      @blk = blk
-
-      @world.editor.on_read_line do |event|
-        line_read = event[:payload][:line]
-        Treefell['shell'].puts "editor line read: #{line_read.inspect}"
-        # editor.history = true?
-        line = line_read << "\n"
-        begin
-          @blk.call(line)
-        rescue Yap::Shell::Parser::Lexer::NonterminatedString,
-          Yap::Shell::Parser::Lexer::LineContinuationFound => ex
-          Treefell['shell'].puts "rescued #{ex}, asking user for more input"
-          more_input = read_another_line_of_input
-          if more_input
-            line << more_input
-            retry
-          end
-        rescue ::Yap::Shell::Parser::ParseError => ex
-          Treefell['shell'].puts "rescued #{ex}, telling user"
-          puts "  Parse error: #{ex.message}"
-        end
-
-        ensure_process_group_controls_the_tty
-        @world.refresh_prompt
-      end
-    end
-
-    private
-
-    def read_another_line_of_input
-      print @world.secondary_prompt.update.text
-      gets
-    end
-
-    def kill_ring
-      @kill_ring ||= []
-    end
-
-    def install_default_keybindings
-      editor.terminal.keys.merge!(enter: [13])
-      editor.bind(:return){ editor.newline }
-
-      # Move to beginning of line
-      editor.bind(:ctrl_a) { editor.move_to_beginning_of_input }
-
-      # Move to end of line
-      editor.bind(:ctrl_e) { editor.move_to_end_of_input }
-
-      # Move backward one word at a time
-      editor.bind(:ctrl_b) {
-        text = editor.line.text[0...editor.line.position].reverse
-        position = text.index(/\s+/, 1)
-        position = position ? (text.length - position) : 0
-        editor.move_to_position position
-      }
-
-      # Move forward one word at a time
-      editor.bind(:ctrl_f) {
-        text = editor.line.text
-        position = text.index(/\s+/, editor.line.position)
-        position = position ? (position + 1) : text.length
-        editor.move_to_position position
-      }
-
-      # Yank text from the kill ring and insert it at the cursor position
-      editor.bind(:ctrl_y){
-        text = kill_ring[-1]
-        if text
-          editor.yank_forward text.without_ansi
-        end
-      }
-
-      # Backwards delete one word
-      editor.bind(:ctrl_w){
-        before_text =  editor.line.text[0...editor.line.position]
-        after_text = editor.line.text[editor.line.position..-1]
-
-        have_only_seen_whitespace = true
-        position = 0
-
-        before_text.reverse.each_char.with_index do |ch, i|
-          if ch =~ /\s/ && !have_only_seen_whitespace
-            position = before_text.length - i
-            break
-          else
-            have_only_seen_whitespace = false
-          end
-        end
-
-        killed_text = before_text[position...editor.line.position]
-        kill_ring.push killed_text
-
-        text = [before_text.slice(0, position), after_text].join
-        editor.overwrite_line text
-        editor.move_to_position position
-      }
-
-      # History forward, but if at the end of the history then give user a
-      # blank line rather than remain on the last command
-      editor.bind(:down_arrow) {
-        if editor.history.searching? && !editor.history.end?
-          editor.history_forward
-        else
-          editor.overwrite_line ""
-        end
-      }
-
-      editor.bind(:enter) { editor.newline }
-      editor.bind(:tab) { editor.complete }
-      editor.bind(:backspace) { editor.delete_left_character }
-
-      # Delete to end of line from cursor position
-      editor.bind(:ctrl_k) {
-        kill_ring.push editor.kill_forward
-      }
-
-      # Delete to beginning of line from cursor position
-      editor.bind(:ctrl_u) {
-        kill_ring.push editor.line.text[0...editor.line.position]
-        editor.overwrite_line editor.line.text[editor.line.position..-1]
-        editor.move_to_position 0
-      }
-
-      # Forward delete a character, leaving the cursor in place
-      editor.bind("\e[3~") {
-        before_text =  editor.line.text[0...editor.line.position]
-        after_text = editor.line.text[(editor.line.position+1)..-1]
-        text = [before_text, after_text].join
-        position = editor.line.position
-        editor.overwrite_line text
-        editor.move_to_position position
-      }
-
-      editor.bind(:ctrl_l){
-        editor.clear_screen
-      }
-
-      editor.bind(:ctrl_r) {
-        $r = $r ? false : true
-        #  editor.redo
-      }
-      editor.bind(:left_arrow) { editor.move_left }
-      editor.bind(:right_arrow) { editor.move_right }
-      editor.bind(:up_arrow) { editor.history_back }
-      editor.bind(:down_arrow) { editor.history_forward }
-      editor.bind(:delete) { editor.delete_character }
-      editor.bind(:insert) { editor.toggle_mode }
-
-      editor.bind(:ctrl_g) { editor.clear_history }
-      # editor.bind(:ctrl_l) { editor.debug_line }
-      editor.bind(:ctrl_h) { editor.show_history }
-      editor.bind(:ctrl_d) { puts; puts "Exiting..."; exit }
-
-      # character-search; wraps around as necessary
-      editor.bind(:ctrl_n) {
-        line = editor.line
-        text, start_position = line.text, line.position
-        i, new_position = start_position, nil
-
-        break_on_bytes = [editor.terminal.keys[:ctrl_c]].flatten
-        byte = [editor.read_character].flatten.first
-
-        unless break_on_bytes.include?(byte)
-          loop do
-            i += 1
-            i = 0 if i >= text.length                                    # wrap-around to the beginning
-            break if i == start_position                                 # back to where we started
-            (editor.move_to_position(i) ; break) if text[i] == byte.chr  # found a match; move and break
-          end
-        end
-      }
-    end
-
-    def install_default_tab_completion_proc
-      editor.completion_proc = lambda do |word, line, word_index|
-        Dir["#{word}*"].map{ |str| str.gsub(/ /, '\ ')}
-      end
-    end
-
-    # This is to prevent the Errno::EIO error from occurring by ensuring that
-    # if we haven't been made the process group controlling the TTY that we
-    # become so. This method intentionally blocks.
-    def ensure_process_group_controls_the_tty
-      return unless STDIN.isatty
-
-      tty_pgrp = Termios.tcgetpgrp(STDIN)
-      while ![Process.pid, Process.getpgrp].include?(tty_pgrp)
-        Termios.tcsetpgrp(STDIN, Process.pid)
-        sleep 0.1
-      end
-    end
-
-    def process_heredoc(_input)
-      if _input =~ /<<-?([A-z0-9\-]+)\s*$/
-        input = _input.dup
-        marker = $1
-        input << "\n"
-      else
-        return _input
-      end
-
-      Treefell['shell'].puts "asking for heredoc input with @world.secondary_prompt"
-      loop do
-        str = editor.read(@world.secondary_prompt.update.text, false)
-        input << "#{str}\n"
-        if str =~ /^#{Regexp.escape(marker)}$/
-          Treefell['shell'].puts "done asking for heredoc input"
-          break
-        end
-      end
-      input
-    end
-  end
-end

data/lib/yap/shell/version.rb

@@ -1,5 +0,0 @@
-module Yap
-  module Shell
-    VERSION = "0.7.1"
-  end
-end

data/lib/yap/world.rb

@@ -1,286 +0,0 @@
-require 'term/ansicolor'
-require 'fileutils'
-require 'forwardable'
-require 'rawline'
-require 'termios'
-
-module Yap
-  require 'yap/addon'
-  require 'yap/shell/execution'
-  require 'yap/shell/prompt'
-
-  class World
-    include Term::ANSIColor
-    extend Forwardable
-
-    DEFAULTS = {
-      primary_prompt_text: "yap> ",
-      secondary_prompt_text: "> "
-    }
-
-    attr_accessor :prompt, :secondary_prompt, :contents, :repl, :editor, :env
-    attr_reader :addons
-
-    attr_accessor :last_result
-
-    def self.instance(*args)
-      @instance ||= new(*args)
-    end
-
-    def initialize(addons:)
-      @env = ENV.to_h.dup
-      dom = build_editor_dom
-
-      # ensure yap directory exists
-      if !File.exists?(configuration.yap_path)
-        if configuration.skip_first_time?
-          # skipping first time
-        else
-          puts
-          puts yellow("Yap directory not found: #{configuration.yap_path}")
-          puts
-          puts "Initializing yap for the first time:"
-          puts
-
-          print "    Creating #{configuration.yap_path} "
-          FileUtils.mkdir_p configuration.yap_path
-          puts green("done")
-
-          print "    Creating default #{configuration.preferred_yaprc_path} "
-          FileUtils.cp configuration.yaprc_template_path, configuration.yap_path
-          puts green("done")
-          puts
-          puts "To tweak yap take a look at #{configuration.preferred_yaprc_path}."
-          puts
-          puts "Reloading shell"
-          reload!
-        end
-      end
-
-      @editor = RawLine::Editor.create(dom: dom)
-
-      self.prompt = Yap::Shell::Prompt.new(text: DEFAULTS[:primary_prompt_text])
-      self.secondary_prompt = Yap::Shell::Prompt.new(text: DEFAULTS[:secondary_prompt_text])
-
-      @repl = Yap::Shell::Repl.new(world:self)
-
-      @addons_initialized = []
-      @addons = AddonHash.new(
-        self
-      )
-
-      addons.each do |addon|
-        if addon.yap_enabled?
-          @addons[addon.export_as] = addon
-        end
-      end
-
-      @addons.values.select(&:yap_enabled?).each do |addon|
-        initialize_addon(addon) unless addon_initialized?(addon)
-        addon
-      end
-    end
-
-    def addon_initialized?(addon)
-      (@addons_initialized ||= []).include?(addon)
-    end
-
-    def initialize_addon(addon)
-      return unless addon
-      begin
-        addon.initialize_world(self)
-        (@addons_initialized ||= []) << addon
-      rescue Exception => ex
-        puts Term::ANSIColor.red(("The #{addon.addon_name} addon failed to initialize due to error:"))
-        puts ex.message
-        puts ex.backtrace[0..5]
-      end
-    end
-
-    class AddonHash < Hash
-      def initialize(world)
-        @world = world
-      end
-
-      def [](key)
-        addon = super
-        unless @world.addon_initialized?(addon)
-          @world.initialize_addon(addon)
-        end
-        addon
-      end
-    end
-
-    def configuration
-      ::Yap.configuration
-    end
-
-    def [](addon_name)
-      @addons.fetch(addon_name){ raise(ArgumentError, "No addon loaded registered as #{addon_name}") }
-    end
-
-    def aliases
-      Yap::Shell::Aliases.instance
-    end
-
-    def builtins
-      Yap::Shell::BuiltinCommand.builtins.keys.map(&:to_s)
-    end
-
-    def shell_commands
-      Yap::Shell::ShellCommand.registered_functions.keys.map(&:to_s)
-    end
-
-    def events
-      @editor.events
-    end
-
-    def bind(key, &blk)
-      @editor.bind(key) do
-        blk.call self
-      end
-    end
-
-    def unbind(key)
-      @editor.unbind(key)
-    end
-
-    def reload!
-      exec configuration.yap_binpath
-    end
-
-    def func(name, &blk)
-      Yap::Shell::ShellCommand.define_shell_function(name, &blk)
-    end
-
-    def shell(statement)
-      context = Yap::Shell::Execution::Context.new(
-        stdin:  $stdin,
-        stdout: $stdout,
-        stderr: $stderr
-      )
-      if statement.nil?
-        @last_result = Yap::Shell::Execution::Result.new(
-          status_code: 1,
-          directory: Dir.pwd,
-          n: 1,
-          of: 1
-        )
-      else
-        evaluation = Yap::Shell::Evaluation.new(stdin:$stdin, stdout:$stdout, stderr:$stderr, world:self)
-        evaluation.evaluate(statement) do |command, stdin, stdout, stderr, wait|
-          context.clear_commands
-          context.add_command_to_run command, stdin:stdin, stdout:stdout, stderr:stderr, wait:wait
-          @last_result = context.execute(world:self) || 0
-          if @last_result.is_a?(Integer)
-            Yap::Shell::Execution::Result.new(
-              status_code: @last_result,
-              directory: Dir.pwd,
-              n: 1,
-              of: 1
-            )
-          else
-            @last_result
-          end
-        end
-      end
-
-      @last_result
-    end
-
-    def foreground?
-      return unless STDIN.isatty
-      Process.getpgrp == Termios.tcgetpgrp($stdout)
-    end
-
-    def history
-      @editor.history
-    end
-
-    def interactive!
-      refresh_prompt
-      @editor.start
-    end
-
-    def prompt
-      @prompt
-    end
-
-    def prompt=(prompt=nil, &blk)
-      if prompt.is_a?(Yap::Shell::Prompt)
-        @prompt = prompt
-      elsif prompt.respond_to?(:call) # proc
-        @prompt = Yap::Shell::Prompt.new(text:prompt.call, &prompt)
-      else # text
-        @prompt = Yap::Shell::Prompt.new(text:prompt, &blk)
-      end
-    end
-
-    def secondary_prompt=(prompt=nil, &blk)
-      if prompt.is_a?(Yap::Shell::Prompt)
-        @secondary_prompt = prompt
-      elsif prompt.respond_to?(:call) # proc
-        @secondary_prompt = Yap::Shell::Prompt.new(text:prompt.call, &prompt)
-      else # text
-        @secondary_prompt = Yap::Shell::Prompt.new(text:prompt, &blk)
-      end
-    end
-
-    def refresh_prompt
-      @editor.prompt = @prompt.update.text
-    end
-
-    def right_prompt_text=(str)
-      @right_status_float.width = str.length
-      @right_status_box.content = str
-    end
-
-    def subscribe(*args, &blk)
-      @editor.subscribe(*args, &blk)
-    end
-
-    def build_editor_dom
-      @left_status_box = TerminalLayout::Box.new(content: "", style: {display: :inline})
-      @right_status_box = TerminalLayout::Box.new(content: "", style: {display: :inline})
-      @prompt_box = TerminalLayout::Box.new(content: "yap>", style: {display: :inline})
-      @input_box = TerminalLayout::InputBox.new(content: "", style: {display: :inline})
-
-      @content_box = TerminalLayout::Box.new(content: "", style: {display: :block})
-      @bottom_left_status_box = TerminalLayout::Box.new(content: "", style: {display: :inline})
-      @bottom_right_status_box = TerminalLayout::Box.new(content: "", style: {display: :inline})
-
-      @right_status_float = TerminalLayout::Box.new(style: {display: :float, float: :right, width: @right_status_box.content.length},
-        children: [
-          @right_status_box
-        ]
-      )
-
-      RawLine::DomTree.new(
-        children:[
-          @right_status_float,
-          @left_status_box,
-          @prompt_box,
-          @input_box,
-          @content_box,
-          TerminalLayout::Box.new(style: {display: :float, float: :left, width: @bottom_left_status_box.content.length},
-            children: [
-              @bottom_left_status_box
-            ]
-          ),
-          TerminalLayout::Box.new(style: {display: :float, float: :right, width: @bottom_right_status_box.content.length},
-            children: [
-              @bottom_right_status_box
-            ]
-          )
-        ]
-      ).tap do |dom|
-        dom.prompt_box = @prompt_box
-        dom.input_box = @input_box
-        dom.content_box = @content_box
-        @prompt_box.name = "prompt-box"
-        @input_box.name = "input-box"
-        @content_box.name = "content-box"
-      end
-    end
-  end
-end