lsl 0.0.1 → 0.1.0

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/lsl.rb

@@ -6,55 +6,52 @@ require 'mharris_ext'
   require File.dirname(__FILE__) + "/lsl/grammars/#{g}"
 end
 
-class Object
-  def blank?
-    to_s.strip == ''
-  end
-  def present?
-    !blank?
-  end
-  def unquoted
-    ((self[0..0]+self[-1..-1]) == '""') ? self[1..-2] : self
-  end
+%w(single compound execution).each do |f|
+  require File.dirname(__FILE__) + "/lsl/command/#{f}"
 end
 
-class Object
-  def list_values
-    elements.map { |x| x.text_value.strip }.select { |x| x.present? }.map { |x| x.unquoted }
-  end
-  def find_child_node(node)
-    
-    elements.each do |e|
-      return e.send(node) if e.respond_to?(node)
+%w(ext).each do |f|
+  require File.dirname(__FILE__) + "/lsl/ext/#{f}"
+end
+
+%w(mapping).each do |f|
+  require File.dirname(__FILE__) + "/lsl/mapping/#{f}"
+end
+
+%w(shell).each do |f|
+  require File.dirname(__FILE__) + "/lsl/#{f}"
+end
+
+module LSL
+  module ExecutionStrategy
+    class Base
     end
-    #return send(node) if respond_to?(node)
-    nil
-  end
-  def find_child_node2(node)
-    
-    elements.each do |e|
-      return e.send(node) if e.respond_to?(node)
+    class Shell < Base
+      def call(cmd)
+        str = "#{cmd.ex} " + cmd.args.join(" ")
+        `#{str}`
+      end
     end
-    #return send(node) if respond_to?(node)
-    nil
+    class Eval < Base
+      def str(cmd)
+        "#{cmd.ex} " + cmd.args.map { |x| x.quoted }.join(" ")
+      end
+      def call(cmd)
+        eval(str(cmd))
+      end
+    end
+    
+    
   end
-        
 end
 
-class SingleCommandObj
-  attr_accessor :ex, :args, :options
-  include FromHash
-  def to_h
-    {:ex => ex, :args => args, :options => options}
-  end
-  def url
-    "http://localhost:4567/#{ex}" + args.map { |x| "/#{x}" }.join
-  end
-  def method
-    ex.split(".").last
-  end
-  def obj
-    a = ex.split(".")
-    (a.size > 1) ? eval(a.first) : nil
-  end
-end
+def with_debug
+  $debug = true
+  yield
+ensure
+  $debug = false
+end
+
+
+
+

data/lib/lsl/command/compound.rb

@@ -0,0 +1,16 @@
+module LSL
+  module Command
+    class Compound
+      fattr(:commands) { [] }
+      attr_accessor :output_filename
+      include FromHash
+      def each_command
+        args = []
+        commands.each do |c|
+          args = yield(c,args)
+        end
+        args
+      end
+    end
+  end
+end

data/lib/lsl/command/execution.rb

@@ -0,0 +1,111 @@
+class Array
+  def each_with_expansion(&b)
+    return if empty?
+    first.array_aware_each do |x|
+      if size == 1
+        yield([x])
+      else
+        self[1..-1].each_with_expansion do |args|
+          yield([x] + args)
+        end
+      end
+    end
+  end
+end
+
+class Object
+  def array_aware_each(&b)
+    if kind_of?(Array)
+      each(&b)
+    else
+      yield(self)
+    end
+  end
+  def send_with_expansion(sym,*args,&b)
+    return send(sym,&b) if args.empty?
+    res = []
+    args.each_with_expansion do |a|
+      res << send(sym,*a,&b)
+    end
+    res = res.select { |x| x.present? }
+    if res.size == 1
+      res = res.first 
+    elsif res.empty?
+      res = nil
+    end
+    res
+  end
+end
+
+module LSL
+  module CommandExecution
+    #a CommandExecution is method independant
+    class Base
+      attr_accessor :command_str, :shell
+      include FromHash
+    end
+    class Single < Base
+      attr_accessor :command, :input_args
+      fattr(:simple_obj) { command.obj || shell.env }
+      fattr(:obj) do
+        m = LSL::Mapping.new
+        m.method(command) || simple_obj
+      end
+      fattr(:command_args) do
+        res = command.args
+        res << [command.options] unless command.options.empty?
+        res
+      end
+      def fixed_input_args
+        return [] unless input_args
+        return [] if input_args.respond_to?("empty?") && input_args.empty?
+        res = input_args
+        res = [res] unless res.kind_of?(Array)
+        #puts "ia #{res.inspect}"
+        res
+        [res]
+      end
+      fattr(:args) do
+        command_args + fixed_input_args
+      end
+      fattr(:result) do
+        if obj.respond_to?(command.method)
+          res = obj.send_with_expansion(command.method,*args)
+          #puts "RES #{res.inspect}" if res
+          res
+        else
+          `#{command.raw}`.output_to_array
+        end
+      end
+      def run!
+        result
+      rescue => exp
+        puts "command failed #{exp.message}"
+      end
+    end
+    class Compound < Base
+      fattr(:command) { shell.parser.parse(command_str).command_hash }
+      fattr(:command_executions) do
+        exes = []
+        input_args = lambda { exes.last.andand.result || [] }
+        command.each_command do |c,args|
+          c = LSL::CommandExecution::Single.new(:shell => shell, :command => c, :input_args => input_args[])
+          c.run!
+          exes << c
+        end
+        exes
+      end
+      def run!
+        command_executions
+        if command.output_filename
+          ::File.create(command.output_filename,result.join("\n"))
+        else
+          puts result.join("\n") if result
+        end
+      end
+      def result
+        command_executions.last.result
+      end
+    end
+  end
+end

data/lib/lsl/command/single.rb

@@ -0,0 +1,21 @@
+module LSL
+  module Command
+    class Single
+      attr_accessor :ex, :args, :options, :raw
+      include FromHash
+      def to_h
+        {:ex => ex, :args => args, :options => options}
+      end
+      def url
+        "http://localhost:4567/#{ex}" + args.map { |x| "/#{x}" }.join
+      end
+      def method
+        ex.split(".").last
+      end
+      def obj
+        a = ex.split(".")
+        (a.size > 1) ? eval(a.first) : nil
+      end
+    end
+  end
+end

data/lib/lsl/ext/ext.rb

@@ -0,0 +1,43 @@
+class Object
+  def blank?
+    to_s.strip == ''
+  end
+  def present?
+    !blank?
+  end
+  def quoted?
+    ((self[0..0]+self[-1..-1]) == '""')
+  end
+  def unquoted
+    quoted? ? self[1..-2] : self
+  end
+  def quoted
+    quoted? ? self : "\"#{self}\""
+  end
+end
+
+class Object
+  def list_values
+    elements.map { |x| x.text_value.strip }.map { |x| x.split(" ") }.flatten.map { |x| x.strip }.select { |x| x.present? }.map { |x| x.unquoted }
+  end
+  def find_child_node(node)
+    find_child_nodes(node).first
+  end
+  def find_child_nodes(node)
+    return [] unless elements
+    res = []
+    elements.each do |e|
+      #puts e.inspect if $debug and node.to_s == 'single_command'
+      if e.respond_to?(node)
+        res << e.send(node) 
+      else
+        res += e.find_child_nodes(node)
+      end
+    end
+    #return send(node) if respond_to?(node)
+    res
+  end
+  def find_child_node2(node)
+    find_child_node(node)
+  end     
+end

data/lib/lsl/grammars/base.treetop

@@ -1,7 +1,7 @@
 module LSL
   grammar Base
     rule word
-      [a-zA-Z\.\/\\]+
+      [0-9a-zA-Z\.\/\\:\*_]+
     end
     rule ws1
       ' '

data/lib/lsl/grammars/compound_command.treetop

@@ -3,7 +3,23 @@ module LSL
     include LSL::SingleCommand
     include LSL::File
     rule full_command
-      single_command (ows ">" ows filename)?
+      single_command (ows "|" ows single_command)* (ows ">" ows filename)? {
+        def filename
+          find_child_node(:filename)
+        end
+        def single_commands
+
+          res = [single_command.command_hash]
+          rest = find_child_nodes(:single_command).map { |x| x.command_hash }
+          #puts "rest #{rest.size}"
+          res + rest
+        end
+        def command_hash
+          res = LSL::Command::Compound.new(:commands => single_commands)
+          res.output_filename = filename.text_value if filename
+          res
+        end
+      }
     end
   end
 end

data/lib/lsl/grammars/single_command.treetop

@@ -11,7 +11,8 @@ module LSL
           find_child_node(:options)
         end
         def command_hash
-          SingleCommandObj.new(:ex => ex.text_value, :args => args.andand.list_values || [], :options => options.andand.hash_values || {})
+          LSL::Command::Single.new(:raw => text_value, :ex => ex.text_value, 
+                               :args => args.andand.list_values || [], :options => options.andand.hash_values || {})
         end
       }
     end

data/lib/lsl/mapping/mapping.rb

@@ -0,0 +1,32 @@
+require 'rake'
+task :abc do
+  puts "task abc"
+end
+
+class RemoteCall
+  def remote_call(*args)
+    require 'open-uri'
+    open("http://localhost:4567/remote_call").read
+  end
+end
+
+class RakeRunner
+  def method_missing(sym,*args,&b)
+    Rake::Task[sym].invoke
+    "ran"
+  end
+end
+
+module LSL
+  class Mapping
+    def method(cmd)
+      if cmd.ex == 'remote_call'
+        RemoteCall.new
+      elsif cmd.ex == 'abc'
+        RakeRunner.new
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/lsl/sandbox.rb

@@ -1,43 +1,5 @@
 require File.dirname(__FILE__) + "/../lsl"
-require 'open-uri'
-require 'fileutils'
+#require 'open-uri'
 
-class CommandEnv
-  def echo(str)
-    puts "ECHOING #{str}"
-  end
-  def cp(a,b)
-    puts "gonna copy #{a} to #{b}"
-  end
-  def del(a)
-    puts "deleting #{a}"
-  end
-end
 
-class Foo
-  def self.bar(*args)
-    puts "bar #{args.inspect}"
-  end
-end
-
-class Shell
-  fattr(:env) { CommandEnv.new }
-  fattr(:parser) { LSL::SingleCommandParser.new }
-  def run(str)
-    command = parser.parse(str).command_hash
-    obj = command.obj || env
-    obj.send(command.method,*command.args)
-    #open(command.url)
-  rescue => exp
-    puts "command failed #{exp.message}"
-  end
-  def run_loop
-    loop do
-      str = STDIN.gets.strip
-      run(str)
-    end
-  end
-end
-
-s = Shell.new
-s.run_loop
+run_shell!

data/lib/lsl/server.rb

@@ -3,4 +3,8 @@ require 'mharris_ext'
 
 get "/echo/:str" do
   puts params[:str]
+end
+
+get "/remote_call" do
+  "rc"
 end

data/lib/lsl/shell.rb

@@ -0,0 +1,88 @@
+require 'fileutils'
+
+class String
+  def output_to_array
+    split("\n").select { |x| x.present? }.map { |x| x.strip }
+  end
+end
+
+def ec_array(cmd)
+  `#{cmd}`.output_to_array
+end
+
+
+$printed ||= []
+module LSL
+  module ShellLike
+    module Inner
+      def echo(*args)
+        #puts args.inspect
+        puts args.join(" ")
+        nil
+      end
+      def ls(d=".")
+        ec_array "ls #{d}"
+      end
+      def pf(f)
+        str = ::File.read(f)
+        $printed << str
+        puts str
+      end
+      def foo
+        ["foo"]
+      end
+      def longest(*args)
+        res = args.sort_by { |x| x.size }.last
+        #puts "Longest: #{res}"
+        res
+      end
+      def pm(a,b)
+        puts a.length * b.length
+      end
+      def cc(*args)
+        args.reverse.join("")
+      end
+      def la(*args)
+        ::File.append("spec/mock_dir/log.txt","LOG #{Time.now} " + args.join(",") + "\n")
+      end
+      def cd(d)
+        Dir.chdir(d)
+      end
+      def exit(*args)
+        puts "Exiting"
+        Kernel.exit(*args)
+      end
+    end
+    include FileUtils
+    include Inner
+  end
+
+
+  class CommandEnv
+    include LSL::ShellLike
+  end
+
+  class Shell
+    fattr(:env) { LSL::CommandEnv.new }
+    fattr(:parser) { LSL::CompoundCommandParser.new }
+    def run(str)
+      LSL::CommandExecution::Compound.new(:command_str => str, :shell => self).tap { |x| x.run! }
+    end
+    def get_input
+      STDIN.gets.strip
+    end
+    def run_loop
+      loop do
+        print "#{Dir.getwd}> "
+        str = get_input
+        run(str)
+      end
+    end
+  end
+end
+
+def run_shell!(obj=nil)
+  s = LSL::Shell.new
+  s.env = obj if obj
+  s.run_loop
+end

data/lsl.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lsl}
-  s.version = "0.0.1"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["mharris717"]
-  s.date = %q{2010-12-27}
+  s.date = %q{2010-12-31}
   s.default_executable = %q{lsl}
   s.description = %q{little shell language}
   s.email = %q{mharris717@gmail.com}
@@ -29,20 +29,32 @@ Gem::Specification.new do |s|
     "VERSION",
     "bin/lsl",
     "lib/lsl.rb",
+    "lib/lsl/command/compound.rb",
+    "lib/lsl/command/execution.rb",
+    "lib/lsl/command/single.rb",
+    "lib/lsl/ext/ext.rb",
     "lib/lsl/grammars/base.treetop",
     "lib/lsl/grammars/compound_command.treetop",
     "lib/lsl/grammars/file.treetop",
     "lib/lsl/grammars/list.treetop",
     "lib/lsl/grammars/quoting.treetop",
     "lib/lsl/grammars/single_command.treetop",
+    "lib/lsl/mapping/mapping.rb",
     "lib/lsl/sandbox.rb",
     "lib/lsl/server.rb",
+    "lib/lsl/shell.rb",
     "lsl.gemspec",
     "spec/compound_command_spec.rb",
     "spec/lsl_spec.rb",
+    "spec/mock_dir/a.txt",
+    "spec/mock_dir/b.txt",
+    "spec/mock_dir/log.txt",
+    "spec/mock_dir/output.txt",
     "spec/quoting_spec.rb",
+    "spec/shell_spec.rb",
     "spec/single_command_spec.rb",
-    "spec/spec_helper.rb"
+    "spec/spec_helper.rb",
+    "to"
   ]
   s.homepage = %q{http://github.com/mharris717/lsl}
   s.licenses = ["MIT"]
@@ -53,6 +65,7 @@ Gem::Specification.new do |s|
     "spec/compound_command_spec.rb",
     "spec/lsl_spec.rb",
     "spec/quoting_spec.rb",
+    "spec/shell_spec.rb",
     "spec/single_command_spec.rb",
     "spec/spec_helper.rb"
   ]

data/spec/compound_command_spec.rb

@@ -5,11 +5,46 @@ describe "CompoundCommand" do
     @parser = LSL::CompoundCommandParser.new
   end
   def parser; @parser; end
+  def parse(*args); parser.parse(*args); end
+  def parse_obj(*args); parse(*args).command_hash; end
   it 'single_command' do
     parser.should be_parsed("cp a b -v a")
   end
   it 'command with output redirection' do
     parser.should be_parsed("cp a b > foo.txt")
   end
+  it 'command with output redirection 2' do
+    parser.parse("cp a b > foo.txt").command_hash.output_filename.should == 'foo.txt'
+  end
+  it 'makes command obj without output filename' do
+    parser.parse("cp a b").command_hash.output_filename.should be_nil
+  end
+  it 'pipes' do
+    parser.should be_parsed("cp a b | cp a b > foo.txt")
+  end
+  it 'has one command' do
+    parser.parse("cp a b").command_hash.commands.size.should == 1
+  end
+  it 'has multiple commands' do
+    parser.parse("cp a b | ls c d").command_hash.commands.size.should == 2 
+  end
+  it 'has 1st command' do
+    parse_obj("cp a b | ls c d").commands.first.ex.should == 'cp'
+  end
+  it 'has 2nd command' do
+    c = parse_obj("cp a b | ls c d").commands.last
+    c.ex.should == 'ls'
+    c.args.should == ['c','d']
+  end
+  describe "execution" do
+    it "each_command args" do
+      res = []
+      parse_obj("cp a b | ls c d").each_command do |c,args|
+        res << args
+        14
+      end
+      res.should == [[],14]
+    end
+  end
   
 end

data/spec/lsl_spec.rb

@@ -4,8 +4,3 @@ describe "Lsl" do
   
   
 end
-
-a = <<EOF
-output redirection
-quoting
-EOF

data/spec/mock_dir/log.txt

@@ -0,0 +1,5 @@
+LOG Fri Dec 31 14:21:26 -0500 2010 
+LOG Fri Dec 31 14:21:31 -0500 2010 
+LOG Fri Dec 31 14:21:36 -0500 2010 Gemfile
+LOG Fri Dec 31 14:21:36 -0500 2010 Gemfile.lock
+LOG Fri Dec 31 14:22:47 -0500 2010 

data/spec/mock_dir/output.txt

@@ -0,0 +1 @@
+VERSION

data/spec/shell_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Shell" do
+  before do
+    @shell = LSL::Shell.new
+  end
+  def run(*args); @shell.run(*args); end
+  it 'smoke' do
+    2.should == 2
+  end
+  it 'simple' do
+    @shell.run("ls VERSION").result.should == ['VERSION']
+    @shell.run("ls VERSIONX").result.should == []
+  end
+  it 'piping' do
+    @shell.run('ls VERSION | pf')
+    $printed.should == ['0.0.1']
+  end
+  it 'foo' do
+    #30.times do
+      #@shell.run("foo | echo")
+    #end
+    run("ls VERSION | longest").result.should == 'VERSION'
+    run("ls VERSION | longest abc").result.should == 'VERSION'
+    run("ls VERSION | longest abc abcdefgh").result.should == 'abcdefgh'
+  end
+  it 'star arg' do
+    run("ls Gemfile*").result.should == ['Gemfile','Gemfile.lock']
+  end
+  it 'remote call' do
+    run("remote_call foo").result.should == 'rc'
+    run("remote_call foo | echo")
+  end
+  it 'rake' do
+    run("abc").result.should == "ran"
+  end
+  describe 'output redirection' do
+    before do
+      @file = "spec/mock_dir/output.txt"
+      eat_exceptions { FileUtils.rm @file }
+    end
+    it "foo" do
+      run("ls VERSION > #{@file}")
+      File.read(@file).should == "VERSION"
+    end
+  end
+ 
+end

data/spec/single_command_spec.rb

@@ -55,6 +55,12 @@ describe "Command" do
     it "ex and args" do
       parse("cp a b").command_hash.to_h.should == {:ex => "cp", :args => ['a','b'], :options => {}}
     end
+    it "ex and args 2" do
+      parse("cp a b").command_hash.ex.should == 'cp'
+    end
+    it "ex and 3 args" do
+      parse("cp a b c").command_hash.to_h.should == {:ex => "cp", :args => ['a','b','c'], :options => {}}
+    end
     it 'quoted arg' do
       parse('cp "abc"').command_hash.args.should == ['abc']
     end
@@ -67,6 +73,9 @@ describe "Command" do
     it "ex and option value" do
       parse("cp -v a").command_hash.to_h.should == {:ex => "cp", :args => [], :options => {"v" => 'a'}}
     end
+    it 'raw string' do
+      parse("cp a b").command_hash.raw.should == 'cp a b'
+    end
   end
   
 end
@@ -78,4 +87,8 @@ quoting
 going to ignore list arguments for now
 how to i break out into raw code
 ability to bring code directly into the shell
+easy extensibility by anyone using the library
+pipes
+need a lesson on bash syntax
+piping inut, communicating in json.  what's diff between array and array of args
 EOF

data/to

@@ -0,0 +1,4 @@
+#! /usr/bin/ruby
+
+puts "a"
+puts "b"

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - mharris717
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-27 00:00:00 -05:00
+date: 2010-12-31 00:00:00 -05:00
 default_executable: lsl
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -127,20 +127,32 @@ files:
 - VERSION
 - bin/lsl
 - lib/lsl.rb
+- lib/lsl/command/compound.rb
+- lib/lsl/command/execution.rb
+- lib/lsl/command/single.rb
+- lib/lsl/ext/ext.rb
 - lib/lsl/grammars/base.treetop
 - lib/lsl/grammars/compound_command.treetop
 - lib/lsl/grammars/file.treetop
 - lib/lsl/grammars/list.treetop
 - lib/lsl/grammars/quoting.treetop
 - lib/lsl/grammars/single_command.treetop
+- lib/lsl/mapping/mapping.rb
 - lib/lsl/sandbox.rb
 - lib/lsl/server.rb
+- lib/lsl/shell.rb
 - lsl.gemspec
 - spec/compound_command_spec.rb
 - spec/lsl_spec.rb
+- spec/mock_dir/a.txt
+- spec/mock_dir/b.txt
+- spec/mock_dir/log.txt
+- spec/mock_dir/output.txt
 - spec/quoting_spec.rb
+- spec/shell_spec.rb
 - spec/single_command_spec.rb
 - spec/spec_helper.rb
+- to
 has_rdoc: true
 homepage: http://github.com/mharris717/lsl
 licenses: 
@@ -175,5 +187,6 @@ test_files:
 - spec/compound_command_spec.rb
 - spec/lsl_spec.rb
 - spec/quoting_spec.rb
+- spec/shell_spec.rb
 - spec/single_command_spec.rb
 - spec/spec_helper.rb