naksh 0.2.0

data/lib/rust/parsers/bash.rb

@@ -0,0 +1,220 @@
+#!/usr/local/bin/ruby
+# 2011 Mahmut Bulut, thefed, and Antonio Salazar
+
+# This file is part of Naksh.
+#
+# Naksh is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Naksh is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Naksh.  If not, see <http://www.gnu.org/licenses/>.
+
+# this is bash.rb with piping removed
+
+require "rubygems"
+require 'gettext'
+#require "../helpers/parser.rb"
+#require "bash/stdlibext.rb"
+#require "../commands/builtins.rb"
+Dir[File.join(File.dirname(__FILE__), "bash/*")].each {|l| require l }
+
+module Naksh
+  module Syntax
+    module Bash
+
+      extend ::Parser
+      #executes a script
+      #entrance point
+      def Bash.execute(script_str)
+        end_res = []
+        styles = []
+        #splits at ';'
+        Bash.split_script(Bash.clean_script(script_str)).each do |pipeline|
+
+          result=[]
+
+          #splits at '|'
+          pipeline=Bash.split_pipeline(Bash.clean_pipeline(pipeline))
+          pipeline.each_index do |i|
+
+            #split into [command_name,['array','of','space',"separated arguments"]]
+            d=Bash.split_command(Bash.clean_command(pipeline[i]))
+
+            result<<[d[0],d[1]]
+
+            #if an error gets thrown by a command, just quit
+            #            return nil if Naksh.stopped?
+
+          end
+          
+          styles = result.map do |part| 
+            if builtin_commands.include? part[0].strip.to_sym
+              :builtin
+            else
+              :cmd
+            end
+          end
+
+          end_res.concat result
+
+        end
+        end_res << styles
+        print run(*end_res)
+      end
+
+      #should call any tidying methods helpful to other steps
+      #currently just removes comments
+      def Bash.clean_script(script_str)
+        Bash.remove_comments(script_str)
+      end
+
+
+      #should remove all comments from script
+      def Bash.remove_comments(script_str)
+        loop do
+          start=Bash.find_unescaped_nonstring(script_str,'#')
+          return script_str unless start
+          close=Bash.find_unescaped_nonstring(script_str,"\n",start)
+          return script_str[0..start-1] unless close
+          script_str=script_str[0..start-1]<<script_str[close+1..script_str.length]
+        end
+      end
+
+
+      #splits a script into wholly independant segments
+      def Bash.split_script(str)
+        Bash.split_unescaped(str,';')
+      end
+
+
+      #should call any tidying methods helpful to other steps
+      #currently returns input
+      def Bash.clean_pipeline(pipe_str)
+        pipe_str
+      end
+
+
+      #separate commands in a pipeline
+      def Bash.split_pipeline(str)
+        Bash.split_unescaped(str,'|')
+      end
+
+
+      #prepares for Bash.split_command
+      #by unifying syntax variations
+      #removing excess whitespace, etc
+
+      #it wraps the actual command in single quotes
+      def Bash.clean_command(com_str)
+
+        #remove leading whitespace
+        com_str.sub!(/\A\s+/,'')
+
+        #need to evaluate variables before this
+        com_str.sub!(/\A'([^']+)'(\S*)/,'\'\1\2\'')
+        com_str.sub!(/\A"([^"]+)"(\S*)/,'\'\1\2\'')
+        com_str.sub!(/\A(\S+)/,'\'\1\'')
+
+        #I think this section may be useless, not belong here, etc.
+        invalid_starting_characters=%w[; | #]
+        invalid_starting_characters.each do |chr|
+          if (/^/+chr).match(com_str)
+            err _('commands cannot begin with the following character')<<' '<<chr
+          end
+        end
+
+        com_str
+      end
+
+
+      #I couldn't make a good regexp version, but THIS WORKS
+      #takes into account escaping (\) and quotation ("')
+      def Bash.find_unescaped_nonstring(str,search_char,starting_index=0)
+        search_char=search_char.chr if search_char.kind_of? Integer
+        raise ArgumentError,"Naksh::Syntax::Bash.find_unescaped_nonstring(#{re.inspect},#{str.inspect})" unless search_char.kind_of? String and str.kind_of? String and search_char.length==1 and starting_index.kind_of? Integer
+        return nil if str.length<=starting_index
+        escaped=false
+        string_open=false
+        starting_index.upto str.length-1 do |i|
+          next if i<starting_index
+          if str[i].chr==search_char
+            return i unless escaped or string_open
+          elsif str[i].chr=="\\"
+            escaped=!escaped
+          elsif not escaped and str[i].chr=='\''
+            case string_open
+            when false
+              string_open='\''
+            when '\''
+              string_open=false
+            end
+          elsif not escaped and str[i].chr=='"'
+            case string_open
+            when false
+              string_open='"'
+            when '"'
+              string_open=false
+            end
+          else
+            escaped=false
+          end
+        end
+        #Regexp requires zero-width negative lookbehind
+        #/\A(([^\\](\\\\)*)(("[^"]*")|('[^']*'))*/<<re
+        nil
+      end
+
+
+      def Bash.split_command(com_str)
+        com_arr=Bash.split_unescaped(com_str,' ')
+        com_arr=[com_str,[]] unless com_arr
+        raise RuntimeError,'single quotes should have been added around command earlier in processing'<<"\ncommand as recieved = #{com_str.inspect}" unless /\A'.*'\z/.match(com_arr[0])
+        com_arr[0].replace(com_arr[0][1,com_arr[0].length-2])
+        [com_arr[0],com_arr[1,com_arr.length]]
+      end
+
+
+
+      #returns an Array of Strings,
+      #made of str split at every unescaped instance of char
+      #not enclosed in an unescaped string delimiter ('")
+      def Bash.split_unescaped(str,char)
+        result=[]
+        split_index=0
+        loop do
+          split_index=Bash.find_unescaped_nonstring(str,char)
+          return result<<str unless split_index
+          result<<str[0,split_index] unless split_index.zero?
+          str=str[split_index+1,str.length]
+          return result if str.empty?
+        end
+      end
+
+
+
+      def Bash.complete(command)
+        possible = []
+        builtin_commands.each do |com|
+          possible << com if com.to_s.match command # only if it matches
+          break if com[0] > command[0] # break if we're after it
+        end
+        if possible.length > 1 # if we found multiple matches
+          raise Hell, "Too ambiguous of a command" # raise Hell
+        else # else its size = 1
+          return possible[0] # return the chosen one
+        end
+      end
+
+
+    end
+  end
+end
+
+#Naksh::Syntax::Bash.execute('ls | wc -l')

data/lib/rust/parsers/bash/stdlibext.rb

@@ -0,0 +1,32 @@
+#!/usr/local/bin/ruby
+# 2011 Mahmut Bulut
+
+# This file is part of Naksh.
+#
+# Naksh is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Naksh is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Naksh.  If not, see <http://www.gnu.org/licenses/>.
+
+def Regexp.join(re_list,preserve_options=true)
+  raise ArgumentError,"Regexp.join: 1st argument should be an array #{re_list}" unless re_list.respond_to? :collect and re_list.respond_to? :join
+  re_list.collect! do |re|
+    re= Regexp.new(Regexp.escape(re)) if re.kind_of? String
+    re= Regexp.new(re) unless re.kind_of? Regexp
+    preserve_options ? re.to_s : '(?:'<<re.source<<')'
+  end
+  Regexp.compile(re_list.join('').gsub(/\(\?[\w\-]*\:\)/,''))
+end
+class Regexp
+  def +(other)
+    Regexp.join([self,other],false)
+  end
+end

data/lib/rust/parsers/ren.rb

@@ -0,0 +1,57 @@
+#!/usr/local/bin/ruby
+#
+#  Created by me on 2011-12-15.
+#  Copyright (c) 2011. All pwnage reserved.
+
+#
+# run_as_ruby is not allowed in Ren
+
+module Ren
+  class << self
+    include Parser
+    
+    def execute(line)
+      (eval(line); return) if line.strip.slice(0).chr =~ /!/
+      
+      package = check_for_pipes(line)
+      p package
+      print run_standard(package[0], package[1])
+      
+      # Gotta catch 'em all
+#    rescue NameError => e
+#      err "Internal Command Unknown"
+    rescue ArgumentError => e
+      err "Improper use of command syntax"
+    rescue SyntaxError => e
+      err "Incorrect Ruby Grammar"
+    rescue Errno::ENOENT => e
+      err "Command not found"
+    rescue => e
+      raise e
+    end
+
+    def check_for_pipes(line)
+      cmd_parts = (line.match('|') ? line.split('|') : [line] )   # check for pipelining
+      # because between the pipes,
+      # it's nothing but commands
+      
+      clean_whitespace!(cmd_parts)
+      
+      styles = cmd_parts.map do |cmd_part|
+        parts = cmd_part.split(' ')
+        cmd = parts[0]
+        if builtin_commands.include? cmd.strip.to_sym
+          :builtin
+        else
+          :cmd
+        end
+      end
+      [cmd_parts, styles]
+    end
+    
+    def clean_whitespace!(parts)
+      parts.map! {|p| p.strip }
+    end
+
+  end
+end

data/lib/rust/rust.rb

@@ -0,0 +1,75 @@
+#!/usr/local/bin/ruby
+#
+#  Created by me on 2011-12-07.
+#  Copyright (c) 2011. All pwnage reserved.
+
+require "rubygems"
+require "highline/system_extensions"
+require "shellwords"
+
+require "helpers/trollop.rb"
+
+
+require "commands/builtins.rb"
+require "syntax/paths.rb"
+require "syntax/pipes.rb"
+require "helpers/array.rb"
+require "helpers/command_center.rb"
+require "helpers/constants.rb"
+require "helpers/io.rb"
+require "helpers/parser.rb"
+require "helpers/string.rb"
+
+Dir['parsers/*'].each {|l| require l }
+require "helpers/rush_control.rb" # needs to be loaded AFTER the parsers
+
+include HighLine::SystemExtensions
+
+class Rust
+
+  ###
+  # Used by the parser
+  def self.io
+    @@io
+  end
+
+  def initialize(stdin=$stdin, stdout=$stdout, stderr=$stderr)
+    $stdin, $stdout, $stderr = stdin, stdout, stderr
+
+    $keys ||= {}
+    @history = []
+    @io = InOut.new(stdin, stdout, stderr, $keys)
+    @@io = @io # a nice hack for parser compatiblity
+
+    run
+  end
+
+  def run
+    ######
+    ## Read the user's .rustrc file
+    if File.exist? "#{ENV['HOME']}/.rustrc"
+      CommandCenter.instance_eval(File.read("#{ENV['HOME']}/.rustrc"))
+    else
+      File.open("#{ENV['HOME']}/.rustrc", 'w')
+    end
+
+    prompt
+  end
+
+
+  def prompt
+    line = ''
+    loop {
+      line += ask($prompt)
+      #      unless line.slice(-1) =~ /\\/
+      @history << line
+      $parser.execute line.strip unless line.strip =~ /^$/ # $parser.execute line
+      line = ''
+      #      end
+    }
+  end
+
+end
+
+
+Rust.new

data/lib/rust/syntax/command.rb

@@ -0,0 +1,23 @@
+#!/usr/local/bin/ruby
+#
+#  Created by me on 2011-12-07.
+#  Copyright (c) 2011. All pwnage reserved.
+
+# NO LONGER IN USE
+# BUT USED TO BE USED BY CommandCenter
+
+class Command
+
+  attr_reader :command, :arguments
+
+  def initialize(name, args, str={:stdin => STDIN, :stdout => STDOUT, :stderr => STDERR})
+    @command = name
+    @arguments = args
+    @streams = { :stdin => str[:in], :stdout => str[:out], :stderr => str[:err] }
+  end
+
+  def run
+    exec(@command, @arguments)
+  end
+
+end

data/lib/rust/syntax/paths.rb

@@ -0,0 +1,31 @@
+#!/usr/local/bin/ruby
+#
+#  Created by me on 2011-12-07.
+#  Copyright (c) 2011. All pwnage reserved.
+#$path = ['/bin', '/usr/bin', '/usr/local/bin']
+
+module Paths
+  class << self
+    
+    ############
+    public
+    ############
+    
+    # linear search
+    # checks if file if on path
+    def on_path? file
+      $path.each do |f|
+        return f if Dir[File.join(f, file)]
+      end
+      false
+    end
+
+    def find_path(file)
+      return Dir.pwd + file unless on_path? file
+      return File.join(on_path?(file), file)
+    end
+    
+  end
+end
+
+#p Paths.find_path('ls')

data/lib/rust/syntax/pipes.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+#
+#  Created by me on 2011-12-07.
+#  Copyright (c) 2011. All pwnage reserved.
+
+#require File.join(File.dirname(__FILE__), "../commands/builtins.rb")
+#require File.join(File.dirname(__FILE__), "../helpers/command_center.rb")
+
+module Pipes
+
+  #################
+  # Shamelessly borrowed from RS, written by kittensoft
+  # This totally rocks, despite it being pretty much popen3/4
+  #################
+  def self.pipe_to(*args)
+    error = nil
+    # Custom streams?
+    args, ios = if args.last.kind_of? Hash
+      [args[0...-1], args.last]
+    else
+      [args, {}]
+    end
+    style = ios[:style]
+    ios.reject! {|key, i| key == :style }
+
+    # pipe.first is read, pipe.last is write
+    in_pipe, out_pipe, err_pipe = IO.pipe, IO.pipe, IO.pipe
+
+    # Adjust the pipes if we have custom streams
+    ios.each {|n, stream| raise ArgumentError.new("#{n} must be an IO!") unless stream.kind_of? IO}
+
+    in_pipe[0]  = ios[:stdin] if ios[:stdin]
+    out_pipe[1] = ios[:stdout] if ios[:stdout]
+    err_pipe[1] = ios[:stderr] if ios[:stderr]
+
+    child = fork do
+      # Reconfigure the standard I/O
+      in_pipe.last.close          # Cannot write to STDIN
+      (IO.open(0)).reopen in_pipe.first  # Input comes from reading in_pipe
+      in_pipe.first.close         # Unnecessary, replaced above
+
+      out_pipe.first.close        # Cannot read from STDOUT
+      (IO.open(1)).reopen out_pipe.last # Output goes to writing side of out_pipe
+      out_pipe.last.close         # Close old read
+
+      err_pipe.first.close        # Cannot read from STDERR
+      (IO.open(2)).reopen err_pipe.last # Error output  goes to writing side of err_pipe
+      err_pipe.last.close         # Close old read
+
+      # Run the command with the new environment
+
+      case style
+      when :standard
+        ::CommandCenter.run_standard(args.join(' '))
+      when :ruby
+        ::CommandCenter.run_as_ruby(args.join(' '))
+      when :builtin
+        ::CommandCenter.run_as_builtin(args.join(' '))
+      when :cmd
+        arr = ::Shellwords.shellwords(args.join(''))
+        cmd = arr.shift
+        exec(::Paths.find_path(cmd), *arr)
+      end
+    end                                 # fork
+
+
+    # Close unnecessary sides
+    #    in_pipe.first.close           # Cannot read from other program's STDIN
+    out_pipe.last.close           # Cannot write to other program's STDOUT
+    err_pipe.last.close           # Cannot write to other program's STDERR
+
+    # Do not wait for child
+    res = [child, in_pipe.last, out_pipe.first, err_pipe.first] 
+
+    # Block-form
+    if block_given?
+      begin
+        value = yield(*res)
+      ensure
+        Process.waitpid child
+        res[1..-1].each {|pipe| pipe.close unless pipe.closed?} 
+        value
+      end
+      # Raw 
+    else
+      res
+    end                               # if block_given?
+  end                                 # self.pipe_to
+
+end
+
+
+__END__
+run(["ls", []], ["wc", ["-l"]], [:builtin, :cmd])
+run_standard(["ls", "wc"], [:builtin, :cmd])
+run_standard(["echo foo", "cat", "cat"], [:cmd, :cmd, :cmd])
+
+Pipes.pipe_to('ls') {|pid, i, o, e| 
+  Pipes.pipe_to('wc -l', :stdin => o) {|ppid, ii, oo, ee| oo.read.should.equal res}
+}
+
+def |(other)
+  Pipes.pipe_to(self.to_s) {|p, i, o, e|
+    Pipes.pipe_to(other.to_s, :stdin => o) {|pid, in, out, err| say out.read}
+  }
+end
+
+def run_standard(parts, styles)
+  # Please note that this will
+  # work for even single commands!
+  # :stding is STDIN and :stdout is STDOUT
+
+  # this is the actual pipage
+  inp = STDIN
+  res = []
+  parts.each_with_index do |part, i|
+    # pipe_to returns the pid, in, out, and err
+    pipes = ::Pipes.pipe_to(part, :stdin => inp, :style => styles[i])
+    inp = pipes[2]
+    res.concat pipes[1..-1]
+  end
+  #  p res
+  puts res[-2].read
+  # close them all off
+  res.each {|pipe| pipe.close unless pipe.closed? }
+end
+
+
+def line(args)
+  pipes = []
+  pipes << ::Pipes.pipe_to(args[0])
+  #  pipes << ::Pipes.pipe_to(args[1],:stdin => pipes[0][2])
+  ::Pipes.pipe_to(args[1], :stdin => pipes[0][2]) {|pid, inp, out, err| puts out.read}
+  pipes.each{|p| p[1..-1].each{|l| l.close unless l.closed? } }
+end
+
+
+case style
+when :standard
+  CommandCenter.run_standard(args.join(' '))
+when :ruby
+  CommandCenter.run_as_ruby(args.join(' '))
+when :builtin
+  CommandCenter.run_as_builtin(args.join(' '))
+when :cmd
+  exec(*args)
+end