yap-shell 0.1.1 → 0.3.0

data/lib/yap/shell/version.rb

@@ -1,5 +1,5 @@
 module Yap
   module Shell
-    VERSION = "0.1.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/yap/world.rb

@@ -1,44 +1,178 @@
 require 'term/ansicolor'
 require 'forwardable'
+
+require 'rawline'
 require 'yap/shell/execution'
+require 'yap/shell/prompt'
+require 'yap/world/addons'
+require 'termios'
 
 module Yap
   class World
     include Term::ANSIColor
     extend Forwardable
 
-    attr_accessor :prompt, :contents, :addons
+    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
+
+      @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])
 
-    def initialize(options)
-      (options || {}).each do |k,v|
-        self.send "#{k}=", v
+      @repl = Yap::Shell::Repl.new(world:self)
+
+      @addons = addons.reduce(Hash.new) do |hsh, addon|
+        hsh[addon.addon_name] = addon
+        hsh
       end
 
-      addons.each do |addon|
-        addon.initialize_world(self)
+      # initialize after they are all loaded in case they reference each other.
+      addons.each { |addon| addon.initialize_world(self) }
+    end
+
+    def [](addon_name)
+      @addons.fetch(addon_name){ raise(ArgumentError, "No addon loaded registered as #{addon_name}") }
+    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 func(name, &blk)
       Yap::Shell::ShellCommand.define_shell_function(name, &blk)
     end
 
-    def readline
-      ::Readline
+    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)
+        end
+      end
+
+      @last_result
+    end
+
+    def foreground?
+      Process.getpgrp == Termios.tcgetpgrp($stdout)
+    end
+
+    def history
+      @editor.history
+    end
+
+    def interactive!
+      refresh_prompt
+      @editor.start
     end
 
     def prompt
-      if @prompt.respond_to? :call
-        @prompt.call
-      else
-        @prompt
+      @prompt
+    end
+
+    def prompt=(prompt=nil, &blk)
+      # TODO if prompt_controller then undefine, cancel events, etc
+      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
 
-    (String.instance_methods - Object.instance_methods).each do |m|
-      next if [:object_id, :__send__, :initialize].include?(m)
-      def_delegator :@contents, m
+    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
+      end
+    end
   end
 end

data/lib/yap/world/addons.rb

@@ -0,0 +1,135 @@
+require 'pathname'
+
+module Yap
+  class World
+    module UserAddons
+    end
+
+    module AddonMethods
+      module ClassMethods
+        def load_addon
+          # no-op, override in subclass if you need to do anything special
+          # when your addon is first loaded when the shell starts
+        end
+
+        def addon_name
+          @addon_name ||= self.name.split(/::/).last.scan(/[A-Z][^A-Z]+/).map(&:downcase).reject{ |f| f == "addon" }.join("_").to_sym
+        end
+
+        def require(name)
+          directory = File.dirname caller[0].split(':').first
+          lib_path = File.join directory, "lib"
+          support_file = File.join lib_path, "#{name}.rb"
+          namespace = self.name.split('::').reduce(Object) do |context,n|
+            o = context.const_get(n)
+            break o if o.is_a?(Namespace)
+            o
+          end
+          if File.exists?(support_file) && namespace
+            namespace.module_eval IO.read(support_file), support_file, lineno=1
+          else
+            super(name)
+          end
+        end
+      end
+
+      module InstanceMethods
+        def addon_name
+          @addon_name ||= self.class.addon_name
+        end
+      end
+    end
+
+    module Namespace
+    end
+
+    class Addon
+      extend AddonMethods::ClassMethods
+      include AddonMethods::InstanceMethods
+    end
+
+    module Addons
+      def self.syntax_ok?(file)
+        `ruby -c #{file}`
+        $?.exitstatus == 0
+      end
+
+      def self.load_rcfiles(files)
+        files.map do |file|
+          RcFile.new IO.read(file)
+        end
+      end
+
+      def self.load_directories(directories)
+        directories.map do |d|
+          next unless File.directory?(d)
+          load_directory(d).map(&:new)
+        end.flatten
+      end
+
+      class RcFile < Addon
+        def initialize(contents)
+          @contents = contents
+        end
+
+        def initialize_world(world)
+          world.instance_eval @contents
+        end
+      end
+
+      def self.load_directory(directory)
+        namespace = File.basename(directory).
+          split(/[_-]/).
+          map(&:capitalize).join
+        namespace = "#{namespace}Addon"
+
+        if Yap::World::UserAddons.const_defined?(namespace)
+          raise LoadError, "#{namespace} is already defined! Failed loading #{file}"
+        end
+
+        # Create a wrapper module for every add-on. This is to eliminate
+        # namespace collision.
+        addon_module = Module.new do
+          extend Namespace
+          extend AddonMethods::ClassMethods
+          const_set :Addon, Addon
+        end
+
+        Yap::World::UserAddons.const_set namespace, addon_module
+
+        lib_path = File.join directory, "lib"
+        $LOAD_PATH.unshift lib_path
+
+        gemfiles =   Dir["#{directory}/Gemfile"]
+        gemfiles.each do |gemfile|
+          eval File.read(gemfile)
+        end
+
+        Dir["#{directory}/*.rb"].map do |addon_file|
+          load_file(addon_file, namespace:namespace, dir:directory, addon_module:addon_module)
+        end
+      ensure
+        $LOAD_PATH.delete(lib_path) if lib_path
+      end
+
+      def self.load_file(file, dir:, namespace:, addon_module:)
+        klass_name = file.sub(dir, "").
+          sub(/^#{Regexp.escape(File::Separator)}/, "").
+          sub(File.extname(file.to_s), "").
+          split(File::Separator).
+          map{ |m| m.split(/[_-]/).map(&:capitalize).join }.
+          join("::")
+
+        addon_module.module_eval IO.read(file), file, lineno=1
+
+        klass_name.split("::").reduce(addon_module) do |ns,name|
+          if ns.const_defined?(name)
+            ns.const_get(name)
+          else
+            raise("Did not find #{klass_name} in #{file}")
+          end
+        end
+      end
+    end
+  end
+end

data/rcfiles/.yaprc

@@ -1,25 +1,80 @@
 #!/usr/bin/ruby
 
-ENV["PATH"] = "/Applications/Postgres.app/Contents/MacOS/bin:/usr/local/share/npm/bin/:/usr/local/heroku/bin:/Users/zdennis/.bin:/Users/zdennis/.rvm/gems/ruby-2.1.5/bin:/Users/zdennis/.rvm/gems/ruby-2.1.5@global/bin:/Users/zdennis/.rvm/rubies/ruby-2.1.5/bin:/usr/local/bin:/usr/local/sbin:/Users/zdennis/bin:/bin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/usr/local/CrossPack-AVR/bin:/private/tmp/.tidbits/bin:/Users/zdennis/source/playground/AdobeAir/AdobeAIRSDK/bin:/Users/zdennis/.rvm/bin:/Users/zdennis/Downloads/adt-bundle-mac-x86_64-20130219/sdk/tools/:/Users/zdennis/.rvm/bin"
-ENV["GEM_HOME"] = "/Users/zdennis/.rvm/gems/ruby-2.1.5:/Users/zdennis/.rvm/gems/ruby-2.1.5@global"
+# ENV["PATH"] = "/Applications/Postgres.app/Contents/MacOS/bin:/usr/local/share/npm/bin/:/usr/local/heroku/bin:/Users/zdennis/.bin:/Users/zdennis/.rvm/gems/ruby-2.1.5/bin:/Users/zdennis/.rvm/gems/ruby-2.1.5@global/bin:/Users/zdennis/.rvm/rubies/ruby-2.1.5/bin:/usr/local/bin:/usr/local/sbin:/Users/zdennis/bin:/bin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/usr/local/CrossPack-AVR/bin:/private/tmp/.tidbits/bin:/Users/zdennis/source/playground/AdobeAir/AdobeAIRSDK/bin:/Users/zdennis/.rvm/bin:/Users/zdennis/Downloads/adt-bundle-mac-x86_64-20130219/sdk/tools/:/Users/zdennis/.rvm/bin"
+# ENV["GEM_HOME"] = "/Users/zdennis/.rvm/gems/ruby-2.1.5:/Users/zdennis/.rvm/gems/ruby-2.1.5@global"
 
-# require 'chronic'
-# require 'term/ansicolor'
+# This is only necessary when starting yap from another shell as it inherits that shell's
+# environment.
+keys2keep = %w(COLORFGBG DISPLAY EDITOR HOME LANG LOGNAME MAIL PATH PS1 PWD SHELL SHLVL SSH_AUTH_SOCK SUDO_COMMAND SUDO_GID SUDO_UID SUDO_USER TERM USER USERNAME _ __CF_USER_TEXT_ENCODING)
+world.env.keys.sort.each do |key|
+  unless keys2keep.include?(key)
+    world.env.delete(key)
+  end
+end
+
+world.env["PATH"] = [
+  world.env["HOME"] + "/.rbenv/shims",
+  "/usr/local/bin",
+  world.env["PATH"]
+].join(":")
+
+world.env.delete("RBENV_DIR")
+world.env.delete("RBENV_DIR")
+world.env.delete("RBENV_HOOK_PATH")
+world.env.delete("RBENV_ROOT")
+world.env.delete("RBENV_VERSION")
+
+require 'chronic'
+require 'term/ansicolor'
+require 'terminfo'
+
+env.delete("BUNDLE_GEMFILE")
+# env.delete("BUNDLE_BIN_PATH")
+
+func :reload! do |args:, stdin:, stdout:, stderr:|
+  stdout.puts "Reloading shell:"
+  stdout.print "  Saving history "
+  world.addons[:history].save
+  stdout.puts Term::ANSIColor.green("done")
+  exec File.expand_path($0)
+end
+
+completion_cache = {}
+
+# tab_completion_display do |matches|
+#
+# end
+
+tab_completion :rake, /^(rake|be rake)\s+(.*)/ do |input_fragment, match_data|
+  # |config|
+  # config.completions do |input_fragment, match_data|
+  results = completion_cache[Dir.pwd] ||= `bundle exec rake -T`.gsub(/^rake\s*/, '').split(/\n/)
+
+  task_rgx = /^#{Regexp.escape(input_fragment.word[:text])}/
+  results.grep(task_rgx).map do |text|
+    {
+      type: :rake,
+      text: text.gsub(/\s*#.*$/, ''),
+      descriptive_text: Term::ANSIColor.yellow(text)
+    }
+    # end
+  end
+end
 
 #
 # Configuring your prompt. This can be set to a static value or to a
 # Proc like object that responds to #call. If it responds to call it will
 # be used every time the prompt is to be re-drawn
 #
-
+last_prompt = nil
 self.prompt = -> do
   pwd = Dir.pwd.sub Regexp.new(ENV['HOME']), '~'
 
-  git_current_branch = `git cbranch 2>/dev/null`.chomp
+  git_current_branch = `git branch 2>/dev/null | sed -n '/\* /s///p'`.chomp
   if git_current_branch.length > 0
     git_current_branch += " "
-    git_dirty_not_cached = `git diff --shortstat`.length > 0
-    git_dirty_cached = `git diff --shortstat --cached`.length > 0
+    git_dirty_not_cached = `git diff --shortstat 2>/dev/null`.length > 0
+    git_dirty_cached = `git diff --shortstat --cached 2>/dev/null`.length > 0
 
     if git_dirty_not_cached || git_dirty_cached
       git_branch = intense_cyan(git_current_branch)
@@ -33,11 +88,186 @@ self.prompt = -> do
   arrow = '➜'
 
   # ~/source/playground/yap master ➜
-  "#{dark(green('£'))} #{yellow(pwd)} #{git_branch}#{red(arrow)} "
+  last_prompt = "#{dark(green('£'))} #{yellow(pwd)} #{git_branch}#{red(arrow)} "
 end
 
 
-func :upcase do |args:, stdin:, stdout:, stderr:|
+###############################################################################
+#                               KEYBOARD MACROS
+#------------------------------------------------------------------------------
+# Keyboard macros allow you to define key/byte sequences that run code
+# when typed. Perhaps the simpest macro is one that takes the tediousness
+# out of typing a long command. For example, pressing "Ctrl-g l" might
+# type in "git log --name-status -n100" just as if the user had typed it.
+#
+# There are five things to know about macros in Yap:
+#
+# * Macros are initialized by a trigger key. The default is Ctrl-g.
+# * Macros require at least one character/key/byte sequence beyond the trigger \
+#   key in order to fire
+# * Macros can be bound to code blocks or a string.
+# * When a macro returns a string that string is inserted as user input \
+#   at the current cursor position
+# * When a macro returns a string that ends in a new line it will process the \
+#   line as if the user hit enter
+#
+# == Example
+#
+#    world.addons[:keyboard_macros].configure(trigger_key: :ctrl_g) do |macros|
+#      macros.define :z, 'git open-pull'
+#      macros.define 'l', "git log -n1\n"
+#    end
+#
+# It's a little bit wordy right now to setup because macros are not special
+# in Yap. They are provided as a standard yap-addon. You could even provide
+# your own macro addon replacement if you so desired.
+#
+# Following, are a few examples showcasing macros.
+###############################################################################
+
+# Sets the default trigger key for all keyboard macros
+world.addons[:keyboard_macros].trigger_key = ?\C-g
+
+# Sets the default cancel key for all keyboard macros
+world.addons[:keyboard_macros].cancel_key = " "
+
+# Sets the default timeout for macros. When set to nil you will have to
+# use the cancel key to exit out of macros.
+world.addons[:keyboard_macros].timeout_in_ms = nil
+
+# Forgiveness-mode: Automatically cancel if the sequence is unknown. When
+# set to false you can keep attempting to type in your macro.
+world.addons[:keyboard_macros].cancel_on_unknown_sequences = true
+
+# Or, you can set the trigger key for a particular set of macros
+# by specifying it when you call .configure(...).
+world.addons[:keyboard_macros].configure(trigger_key: ?\C-g) do |macro|
+  macro.start do
+    world.editor.content_box.children = [
+      TerminalLayout::Box.new(content: "am i floating1?", style: {display: :float, float: :right, height: 1, width: "am i floating1?".length}),
+      TerminalLayout::Box.new(content: "What up12?", style: {display: :block}),
+      TerminalLayout::Box.new(content: "Not much21", style: {display: :block}),
+      TerminalLayout::Box.new(content: "am i floating3?", style: {display: :float, float: :left, height: 1, width: "am i floating1?".length}),
+    ]
+  end
+
+  macro.stop do
+    world.editor.content_box.children = []
+  end
+
+  macro.define 'z', 'git open-pull'
+  # macro.define 'abc', 'echo abc'
+  # macro.define 'u', -> { world.editor.undo }
+  macro.define :up_arrow, -> {   }
+
+  macro.define 'l', 'git log ' do |macro|
+    macro.fragment 'n', '--name-status '
+    macro.fragment 'o', '--oneline '
+    macro.fragment /\d/, -> (a) { "-n#{a} " }
+  end
+
+  macro.define 'd', 'git diff ' do |macro|
+    macro.define 'n', '--name-status ' do |macro|
+      macro.define 'm', "master..HEAD"
+    end
+    macro.define 'm', "master..HEAD"
+  end
+end
+
+# world.addons[:keyboard_macros].configure(trigger_key: :ctrl_h) do |macros|
+#   macros.define 'h123', -> {
+#     box = TerminalLayout::Box.new(content: "Right?", style: { display: :block, float: :right, height: 1, width: 50 })
+#     world.editor.content_box.children = [box]
+#     'echo this was with a code block'
+#   }
+# end
+
+
+###############################################################################
+#                          USER-DEFINED FUNCTIONS
+#------------------------------------------------------------------------------
+# User-defined functions can be accessed in the shell like any command. They
+# take precedence over programs found on the file-system, but they do not
+# take precedent over user-defined aliases.
+#
+# For example, take `upcase` below:
+#
+#    func :upcase do |stdin:, stdout:|
+#      str = stdin.read
+#      stdout.puts str.upcase
+#    end
+#
+# You can issue "upcase" in the shell where-ever you'd expect to place the name
+# of a command.
+#
+# == Function Parameters
+#
+# User-defined functions can receive the following arguments:
+#
+#  * command: the name of the command the user-entered
+#  * args: the list of arguments supplied to the command
+#  * stdin: the way to access stdin (e.g. DO NOT CALL STDIN or $stdin)
+#  * stdout: the way to access stdout (e.g. DO NOT CALL STDOUT or $stdout)
+#  * stderr: the way to access stderr (e.g. DO NOT CALL STDERR or $stderr)
+#  * world: the Shell's currently known world
+#
+# These arguments are all optional. You only need to specify what your
+# function is going to use.
+#
+# Following, are a number of examples showcasing their power and flexibility.
+###############################################################################
+
+# upcase is reads from stdin and upcases every letter.
+#
+# Example:
+#   yap> echo "hi there" | upcase
+#   HI THERE
+func :upcase do |stdin:, stdout:|
   str = stdin.read
   stdout.puts str.upcase
 end
+
+func :'run-modified-specs' do |stdin:, stdout:|
+  str = `git status`
+  specs = str.scan(/\S+_spec.rb/)
+  cmd = "bundle exec rspec #{specs.join(' ')}"
+  stdout.puts cmd
+  shell cmd
+end
+
+# This shell function uses a  Regexp to match on a command of 2 or more dots.
+# It's for traversing up N directories. Two dots ("..") is the minimum and
+# is used to go to the parent. Every dot after that goes up one more directory
+# level.
+#
+# Example:
+#   ~/foo/bar/baz> ..
+#   ~/foo/bar> ...
+#   ~/
+func /^\.{2,}$/ do |command:|
+  (command.length - 1).times { Dir.chdir("..") }
+end
+
+func /^\+(.*)/ do |command:, args:|
+  puts command
+  puts args.inspect
+end
+
+# This shell function uses a custom object that responds to the #match(...)
+# method. This is nothing more than an basic "history" implementation.
+#
+history_matcher = Object.new
+def history_matcher.match(command)
+  command == ".h"
+end
+
+# Allows for a single numeric argument which will be used to determine
+# how many history items to show (not including this command). If no argument
+# if provided then it will show the entire shell history.
+func history_matcher do |world:, args:, stdout:|
+  num_commands = args.first.to_i
+  num_commands = world.history.length - 1 if num_commands == 0
+  world.history[-(num_commands + 1)...-1].each_with_index do |command, i|
+    stdout.puts "    #{i}   #{command}"
+  end
+end