yap-shell 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c9ea62ec24c22dea32da508a7616ddcb03eedbe
+  data.tar.gz: 19cb2c35c5806d94653782b5d5e06655bc734676
+SHA512:
+  metadata.gz: 496c9bd377d0e6fa56cd785d7efc751882af5c606690bfaaa1b08590c6bcd8f41ac7bdabaf1a51b21cb945d1c3ad709374a59c2c882b369e6baf23b1f6556f7d
+  data.tar.gz: 31c37db8f24ef5be951a7bd4ed6c36675ded870f9af6328d62e5a6b7af34f6d7265a99be063b44d50327f4a506fba31108d68794aa72372941ff2f1bf196f538

data/.gitignore

@@ -0,0 +1,22 @@
+*.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

data/DESIGN.md

@@ -0,0 +1,87 @@
+### Shell
+
+The shell takes input from the user, turns them into commands, and then runs them by evaluating or executing them. It is responsible for job control, and for providing useful information to the user such as a prompt and other line decorations.
+
+The shell collects input from the user by running a REPL. It then takes the input collected and turns in into a parse tree. The parse tree is then walked, evaluating nodes along the way, which is what evaluates/executes the command. Before each command is evaluated it is processed in order to expand aliases, environment variables, etc.
+
+The parse tree is generated by the yap/shell/line-parser. All nodes are defined by that library.
+
+### Nodes
+
+The nodes that the parse tree knows about are the following: AssignmentNode, ConditionalNode, CommandNode, EnvNode, EnvWrapperNode, InternalEvalNode, PipelineNode, RedirectionNode, and StatementsNode.
+
+These are evaluated by the Shell in the following manner.
+
+#### AssignmentNode, EnvNode, EnvWrapperNode
+
+An env node represents a type of assignment such as an expression "A=B". This node is evaluated to set environment variables for the current execution context.
+
+Currently an AssignmentNode is not used, but it may be used to replace an EnvNode as necessary. An EnvWrapperNode is a meta-EnvNode, all it does is wrap EnvNode(s). It is on the chopping block to go away with parser optimizations that would merge all of these types of concepts together.
+
+#### ConditionalNode
+
+A conditional node represents a conditional expression such as "&&" or "||". It is evaluated by processing its left child node and then processing its right child node based on its result.
+
+#### CommandNode
+
+A command node represents any command and arguments provided by the user such as the "ls" in "ls -al" or the "echo" in "echo foo bar baz".
+
+The command associated with a command node may be a shell function, an alias, a builtin, or an executable found on the file-system. This lookup and determination of what the command refers to is determined when processing a command node.
+
+Every command executed generates an exit status or a signal status.
+
+#### InternalEvalNode
+
+An internal eval node represents an expression that should be evaluated internally (currently only supports the ruby interpreter running the shell).
+
+It needs to generate an exit status or a signal status.
+
+#### PipelineNode
+
+A pipeline node represents a series of commands or statements where the output of one should be the input of another. For example, "ls | grep foo" is a pipeline.
+
+#### RedirectionNode
+
+A redirection node represents the intent to redirect STDOUT, STDERR, or both to file. For example, "echo foo > bar.txt".
+
+#### StatementsNode
+
+A statements node represents more than one statement and contains two nodes: a head and a tail. Either node can refer to any other node.
+
+
+### Commands
+
+In order to process a CommandNode it must first determine what type of command it represents. Since a CommandNode could refer to a shell function, alias, builtin, or executable on the file-system, we need to determine which one.
+
+The CommandFactory is used to do just this.
+
+
+### Execution
+
+Once a CommandNode is fully expanded, the resulting command will be executed in a corresponding ExecutionContext. There is an execution context for every type command that can be run.
+
+It is the job of the execution context to handle wiring up stdin, stdout, stderr before running a command as well as provide the exit status or signal status after a command has finished executing.
+
+
+#### Handling SIGINT
+
+The shell responds to a SIGINT signal (typically Ctrl-C) which will interrupt execution of the shell or any running process.
+
+When a process is not running and a SIGINT is received the REPL will print a "^C" and then put a new line and prompt. The shell will not abort itself.
+
+When a process is running and the SIGINT signal is received it will forwarded on to the currently running child process. In most cases, the child process will abort, but in some cases it will not. An example of this is program like `irb` that is itself an interactive REPL with the user.
+
+#### Handling SIGSTOP / SIGCONT
+
+The shell responds to a SIGSTOP signal (typically Ctrl-Z) by forwarding it to the currently running process.
+
+When no process is running it prints "^Z" in the REPL and prints a new line and prompt. The shell itself will not suspend.
+
+When a process is running and the SIGSTOP signal is received it will be forwarded on to the currently running child process. In most cases, the child process will suspend running.
+
+When the child process is suspended control will be returned to the REPL, a user will be able to run new commands. The suspended process can be restarted by sending it the SIGCONT signal. The `fg` builtin can be used to send the suspended process the SIGCONT signal.
+
+
+### Job Control
+
+.

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Zach Dennis
+
+MIT License
+
+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,29 @@
+# Yap
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'yap-shell'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yap-shell
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/zdennis/yap-shell/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+Dir[File.join(File.dirname(__FILE__), 'lib/tasks/**/*.rake')].each {|f| load f }

data/WISHLIST.md

@@ -0,0 +1,40 @@
+
+* need to add custom tab completion for aliases, builtins, shell commands, and file system commands
+* support user-specified gems to install (so they're available for rc files)
+* truncate the prompt so you can type long commands
+* add right-prompt (similar to ZSH)
+* provide realtime updating prompt items
+* don't overwrite timestamp? (or have it disappear when you write over it altogether, similar to ZSH)
+* have configurable prompt components
+* interact with the "World" rather than just operating on string contents
+* communicate exit codes to user (w/color)
+* allow for a multiline smart prompt or at least some kind of status notifications
+* get readline's history to work between start and restops
+* fix reload! so it works again
+* handle stderr
+* intelligently handle pipes that show up in ruby blocks, e.g. map{ |a,b| a }
+* Fix shell builtins like pushd/popd. :(
+* Support user-requested background processes, e.g. "ls &"
+* You cannto load yap if you are within yap. Handle the error or let it happen.
+
+Others requests.
+
+*  Sam: Better text movement/manipulation tools
+** e.g. delete-forward-word
+** I spend a lot of time using my arrow keys (or equivalents) in my terminal and I hate that.
+
+* Jonah: The one thing that seems passive agressive to me is the lack of confirmation when something has gone well. You get barked at if things don’t work, but when they do you get nothing. I think that’s a BS way to behave. Everything. The long running processes give you feedback. Something short and sweet returns nothing. Consistent behavior would be nice.
+
+* EJ reply:  my shell’s prompt color changes depending on the success/failure of the last command
+
+* Sam: a way to say "make the last 7 items in my history into a script/macro”
+
+* Sam: I want my history to be dependent on the project, so when I go into an old project I can see the commands I had been running there months ago.
+
+* Sam: integration with ruby/python/etc interpreters and my editor, so I can interact with stack traces -- even just to open file and jump to line number.
+
+* Sam: sublime style fuzzy autocomplete* Sam: (ooh, but what about an 'oh shit please pipe this through less/paginate this' that you could run after a command has started. 6/3)
+
+* @dylanized: themeable
+* @dylanized: browser-based
+* @dylanized: bookmarks

data/bin/yap

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+file = __FILE__
+if File.symlink?(file)
+  file = File.readlink(file)
+end
+
+class SuspendSignalError < StandardError
+end
+
+trap("SIGTSTP") do
+  raise SuspendSignalError
+end
+
+$LOAD_PATH << File.dirname(file) + '/../lib'
+
+# loop do
+  load "yap.rb"
+  begin
+    Yap.run_shell
+  rescue StandardError => ex
+    puts ex.message
+    puts ex.backtrace
+  end
+# end

data/lib/tasks/gem.rake

@@ -0,0 +1,60 @@
+namespace :bump do
+  namespace :version do
+    class ProjectVersion
+      FILE = File.dirname(__FILE__) + '/../yap/shell/version.rb'
+      PATTERN = /VERSION\s*=\s*"(\d+)\.(\d+)\.(\d+)"/m
+
+      def initialize(file=FILE, pattern=PATTERN)
+        @file = file
+        @pattern = pattern
+      end
+
+      def bump(major:nil, minor:nil, patch:nil)
+        version = nil
+        contents.sub!(@pattern) do
+          _major = major.call($1) if major
+          _minor = minor.call($2) if minor
+          _patch = patch.call($3) if patch
+          version = %|VERSION = "#{_major}.#{_minor}.#{_patch}"|
+        end
+        File.write(@file, contents)
+        system "bundle"
+        system "git add #{ProjectVersion::FILE}\ && git commit -m 'Bumping version to #{version}'"
+      end
+
+      private
+
+      def contents
+        @contents ||= File.read(@file)
+      end
+    end
+
+    desc "Increments the patch number by 1 for the project"
+    task :patch do
+      ProjectVersion.new.bump(
+        major: ->(major){ major },
+        minor: ->(minor){ minor },
+        patch: ->(patch){ patch.succ }
+      )
+    end
+
+    desc "Increments the minor number by 1 for the project"
+    task :minor do
+      ProjectVersion.new.bump(
+        major: ->(major){ major },
+        minor: ->(minor){ minor.succ },
+        patch: ->(patch){ 0 }
+      )
+    end
+
+    desc "Increments the major number by 1 for the project"
+    task :major do
+      ProjectVersion.new.bump(
+        major: ->(major){ major.succ },
+        minor: ->(minor){ 0 },
+        patch: ->(patch){ 0 }
+      )
+    end
+
+  end
+end

data/lib/yap.rb

@@ -0,0 +1,30 @@
+require 'yap/shell'
+require 'yap/world'
+
+module Yap
+  module WorldAddons
+    def self.syntax_ok?(file)
+      `ruby -c #{file}`
+      $?.exitstatus == 0
+    end
+
+    def self.load_from_files(files:[])
+      files.map do |file|
+        (puts "Cannot load world addon: #{file} does not exist" and next) unless File.exist?(file)
+        (puts "Cannot load world addon: #{file} is not readable" and next) unless File.exist?(file)
+        (puts "Cannot load world addon: #{file} is a directory file" and next) if File.directory?(file)
+
+        # Module.new.tap { |m| m.module_eval IO.read(file) }
+        IO.read(file)
+      end
+    end
+  end
+
+
+  def self.run_shell
+    addons = WorldAddons.load_from_files(files: [
+      "#{ENV['HOME']}/.yaprc"
+    ])
+    Shell::Impl.new(addons: addons).repl
+  end
+end

data/lib/yap/shell.rb

@@ -0,0 +1,73 @@
+require 'readline'
+require 'yaml'
+require 'yap/shell/version'
+require 'yap/shell/builtins'
+
+module Yap
+  module Shell
+    autoload :Aliases, "yap/shell/aliases"
+
+    autoload :CommandFactory, "yap/shell/commands"
+    autoload :CommandError,  "yap/shell/commands"
+    autoload :CommandUnknownError,  "yap/shell/commands"
+    autoload :BuiltinCommand,  "yap/shell/commands"
+    autoload :FileSystemCommand,  "yap/shell/commands"
+    autoload :RubyCommand,  "yap/shell/commands"
+    autoload :ShellCommand,  "yap/shell/commands"
+
+    autoload :Execution,  "yap/shell/execution"
+
+    autoload :Evaluation, "yap/shell/evaluation"
+    autoload :Repl, "yap/shell/repl"
+
+    class Impl
+      def initialize(addons:)
+        @stdin = $stdin
+        @stdout = $stdout
+        @stderr = $stderr
+
+        @stdout.sync = true
+        @stderr.sync = true
+
+        @addons = addons
+      end
+
+      def repl
+        @world = Yap::World.new(addons:@addons)
+        context = Yap::Shell::Execution::Context.new(
+          stdin:  @stdin,
+          stdout: @stdout,
+          stderr: @stderr
+        )
+
+        @repl = Yap::Shell::Repl.new(world:@world)
+        @repl.loop_on_input do |input|
+          evaluation = Yap::Shell::Evaluation.new(stdin:@stdin, stdout:@stdout, stderr:@stderr)
+          evaluation.evaluate(input) do |command, stdin, stdout, stderr|
+            context.clear_commands
+            context.add_command_to_run command, stdin:stdin, stdout:stdout, stderr:stderr
+            context.execute(world:@world)
+          end
+        end
+      end
+
+      private
+
+      def history_file
+        File.expand_path('~') + '/.yap-history'
+      end
+
+      def load_history
+        return unless File.exists?(history_file) && File.readable?(history_file)
+        (YAML.load_file(history_file) || []).each do |item|
+          ::Readline::HISTORY.push item
+        end
+
+        at_exit do
+          File.write history_file, ::Readline::HISTORY.to_a.to_yaml
+        end
+      end
+    end
+
+  end
+end

data/lib/yap/shell/aliases.rb

@@ -0,0 +1,40 @@
+require 'singleton'
+
+module Yap::Shell
+  class Aliases
+    include Singleton
+
+    def initialize
+      @file = ENV["HOME"] + "/.yapaliases.yml"
+      @aliases = begin
+        YAML.load_file(@file)
+      rescue
+        {}
+      end
+    end
+
+    def fetch_alias(name)
+      @aliases[name]
+    end
+
+    def set_alias(name, command)
+      @aliases[name] = command
+      File.write @file, @aliases.to_yaml
+    end
+
+    def unset_alias(name)
+      @aliases.delete(name)
+    end
+
+    def has_key?(key)
+      @aliases.has_key?(key)
+    end
+
+    def to_h
+      @aliases.keys.sort.inject(Hash.new) do |h,k|
+        h[k] = @aliases[k]
+        h
+      end
+    end
+  end
+end