arsh 1.0.1

data/bin/arsh

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+ARSH_INSTALL_PATH=File.expand_path("../../",__FILE__)
+require 'rb-readline'
+
+Dir.glob("#{ARSH_INSTALL_PATH}/libs/*.rb").each { |mod| load(mod) }
+trap('QUIT',"IGNORE")
+trap('INT') do
+  begin
+    break
+  rescue
+    print "^C"
+  end
+end
+## Set up some default variables
+$ps1="(arsh)<% ENV['USER'] %>@<% Dir.pwd %>$ "
+$ps2=">"
+
+## Setup readline's completion
+Readline.completion_append_character = nil 
+Readline.completion_proc = lambda do |search|
+  # Complete files and directories
+  # Complete programs and files within the path.
+  files = []
+  case search
+  when ""
+    files = ArshCommands.search_current_directory(files,search)
+    files = ArshCommands.search_path(files)
+  else
+    files = ArshCommands.search_current_directory(files,search)
+    if files.select { |f| f =~ %r[^#{search}] }.empty?
+      files = ArshCommands.search_path(files)
+    end
+  end
+  # Complete builtin methods
+  ArshCommands.singleton_methods.each { |method| files << method if method =~ /^#{search}/ }
+  files.uniq
+  files = files.select { |f| f =~ %r[^#{search}] }
+end
+
+# Builtin commands
+
+module ArshCommands
+  INTHIST = Array.new
+  def internal_history
+    @internal_history
+  end
+  def internal_history=(input)
+    @internal_history << input
+  end
+  # Exit with exit code.
+  def self.exit(code)
+   Kernel.exit(code.to_s.to_i)
+  end
+
+  # Determine if a file is included in the path.
+  def self.in_path?(cmd,parms)
+   ENV['PATH'].split(/:/).each do |path|
+     if File.exists?("#{path}/#{cmd}") && File.executable?("#{path}/#{cmd}")
+       system("#{path}/#{cmd} #{parms.join(" ")}")
+       return true
+     end
+   end
+   return false
+  end
+
+  def self.parseinput(input)
+   cmd = input.split(/\s/)[0]
+   parms = replacestring(input).split(/\s/)[1..-1]
+    if ArshCommands.respond_to? cmd
+      begin 
+        ArshCommands.send(replacestring(cmd),parms) 
+      rescue 
+        puts "#{$!}" 
+      end
+    # If (full path) file is executable..
+    elsif File.exists?(cmd) && File.executable?(cmd) 
+      system("#{cmd} #{parms}")
+    # If file is in PATH
+    elsif ArshCommands.in_path?(cmd,parms) == false
+    # Try to run input as ruby code.
+       ArshCommands.ruby_eval(input)
+    end
+  end
+
+  def self.search_current_directory(files,search)
+    Dir["#{search.gsub(%r[^/],"")}*"].each { |f| files << f }
+
+    files.map! { |f| f.gsub(%r[#{Dir.pwd}/],"") }.map! { |f| File.directory?(f) ? f + "/" : f }
+
+    return files
+  end
+
+  def self.search_path(files)
+    ENV['PATH'].split(":").each do |path|
+      begin
+        Dir.entries(path).each do |prog|
+          files << prog if File.executable?("#{path}/#{prog}")
+        end
+      rescue Errno::ENOENT
+        next
+      end
+    end
+    return files
+  end
+end
+
+# Load Plugins
+begin
+ Dir.glob("#{ARSH_INSTALL_PATH}/plugins/*.rb").each { |plugin| require plugin }
+rescue
+ puts "Error loading plugin: #{$!}"
+end
+# Main Loop
+
+# Load rbshrc's
+["/etc/arshrc","#{ENV['HOME']}/.arshrc"].each do |arshrc|
+  File.open(arshrc,"r").readlines.each do |line|
+    ArshCommands.parseinput(line) if line != ""
+  end if File.exist?(arshrc)
+end
+
+while true
+  
+# Get input
+  begin
+   prompt = ArshCommands.rubyeval_indent == 0 ? $ps1 : "#{$ps2 * ArshCommands.rubyeval_indent} "
+   input = Readline::readline(ArshCommands.replacestring(prompt)).to_s.strip
+  rescue 
+    puts ""
+    input = ""
+  end
+  next if input == "" # don't error on blank input
+  #begin  puts input.gsub(/\#\{*\}/,'\1') rescue puts "#{$!}" end
+  Readline::HISTORY.push("#{input}") # Add command to history
+  ArshCommands::INTHIST.push("[#{Time.now.strftime("%a %b %d %H:%M:%S")}] #{input}")
+  # If command is builtin to shell...
+  ArshCommands.parseinput(input)
+end

data/libs/alias.rb

@@ -0,0 +1,21 @@
+module ArshCommands
+  def self.alias(args)
+    args = args.join(" ")
+    alias_cmd, alias_body = args.split(/=/,2)
+    alias_body_cmd, alias_body_params = alias_body.split(/ /,2)
+    alias_cmd.strip!
+    alias_body_cmd.strip!
+    if alias_body_params != nil then
+      alias_body_params.strip
+    else
+      alias_body_params = ""
+    end
+    new_alias =<<-EOS
+ 	    def self.#{alias_cmd}(args=[])
+	    	args = ["#{alias_body_params} "] + args
+	    	system("#{alias_body_cmd} \#{args.join(' ')}")
+	    end
+	  EOS
+    ArshCommands.module_eval(new_alias)
+    end
+  end

data/libs/cd.rb

@@ -0,0 +1,13 @@
+module ArshCommands
+  # Change directory
+  def self.cd(dir)
+    dir = ["#{ENV['HOME']}"] if dir.nitems == 0
+    if File.directory?(File.expand_path(dir.join(" ")))
+      Dir.chdir(File.expand_path(dir.join(" ")))
+    elsif dir =~ /~/
+      dir.gsub("~","#{ENV['HOME']}")
+    else
+      puts "Invalid Directory #{dir.to_s}"
+    end
+  end
+end

data/libs/compat.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/ruby
+if ! String.respond_to?("each") then
+  class String
+    def each(splitter)
+      return self.split(splitter)
+    end
+  end
+end
+
+if ! Array.respond_to?("nitems") then
+ class Array
+  alias :nitems :count
+ end
+end

data/libs/replacestring.rb

@@ -0,0 +1,19 @@
+module ArshCommands
+  def self.replacestring(string)
+    @rep_new_string = string
+    begin
+      repstring = /<%(.*?)%>/.match(@rep_new_string)
+      loop do
+        rep_original = repstring[0]
+        rep_new = eval(repstring[1]).to_s
+        @rep_new_string = @rep_new_string.gsub(rep_original,rep_new)
+        repstring = /<%(.*?)%>/.match(@rep_new_string)
+        break if repstring == nil
+      end if /<%(.*?)%>/.match(@rep_new_string) != nil
+    rescue
+      puts $!
+      @rep_new_string.gsub!(repstring[0],"[ERR]")
+    end
+    return @rep_new_string
+  end
+end

data/libs/rubyeval.rb

@@ -0,0 +1,31 @@
+# Evaluate ruby code typed into command line.  Allow multiple lines of code before evaluting blcoks.
+module ArshCommands
+    @rubyeval_proc = Proc.new {}
+    @rubyeval_indent = 0
+    @rubyeval_history = Array.new
+    def self.rubyeval_indent
+      return @rubyeval_indent
+    end
+    def self.ruby_eval(input)
+    # keywords that start a block
+    start_strings = ["class,","module","def","do","{","("]
+    # Keywords that end a block
+    end_strings = ["end","}",")"]
+    # Add last line typed to
+    @rubyeval_history << input
+    start_strings.each {|string| @rubyeval_indent += 1 if input.include? string}
+    end_strings.each {|string| @rubyeval_indent -=1 if input.include? string}
+    #input.strip.each(" ") {|string| @rubyeval_indent += 1 if start_strings.include? string }
+    #input.strip.each(" ") {|string| @rubyeval_indent -= 1 if end_strings.include? string }
+    if @rubyeval_indent <= 0
+      @rubyeval_indent = 0
+      begin
+        eval(@rubyeval_history.join("\n"),@rubyeval_proc.binding)
+        @rubyeval_history = Array.new
+      rescue ScriptError, StandardError
+        @rubyeval_history = Array.new
+        puts "#{$!}"
+      end
+    end
+  end
+end

data/libs/version.rb

@@ -0,0 +1,3 @@
+module Arsh
+  VERSION = "1.0.1"
+end

data/plugins/history.rb

@@ -0,0 +1,5 @@
+module ArshCommands
+  def self.history(args)
+    puts ArshCommands::INTHIST.find_all { |x| puts x }
+  end
+end

data/plugins/ls.rb

@@ -0,0 +1,17 @@
+# ls.rb v0.1.0
+# ls.rb - A partial implentation of ls all written in ruby.
+#
+# This example shows how easy it is to create a plugin for arsh.
+
+# The ArshCommands module holds all internal commands.
+module ArshCommands
+  def self.lsa(args = "")
+  directories = Dir.entries("#{Dir.pwd}").sort
+    directories.delete_if { |x| x =~ /^\./ unless args.include?("-a") }
+    directories.map! { |x| "#{("0x"+File.stat(x).mode.to_s)} #{File.stat(x).uid} #{File.stat(x).gid} #{File.stat(x).mtime} #{x} "} if args.include?("-l")
+     return directories
+    end
+  def self.lsx(args) # Each command is a method.
+    puts self.lsa(args)
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: arsh
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+  prerelease: 
+platform: ruby
+authors:
+- James Paterni
+- Brian Faga
+- Eugene Howe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb-readline
+  requirement: &9188080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9188080
+description: Provides a shell that can run pure Ruby code as well as ordinary linux
+  commands.
+email:
+- james@ruby-code.com
+- eugene@xtreme-computers.net
+executables:
+- arsh
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/arsh
+- plugins/ls.rb
+- plugins/history.rb
+- libs/replacestring.rb
+- libs/compat.rb
+- libs/rubyeval.rb
+- libs/cd.rb
+- libs/alias.rb
+- libs/version.rb
+homepage: http://github.com/jamez01/arsh
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Linux shell implemented in pure Ruby
+test_files: []