lsl 0.1.1 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/lsl.rb

@@ -6,7 +6,7 @@ require 'mharris_ext'
   require File.dirname(__FILE__) + "/lsl/grammars/#{g}"
 end
 
-%w(single compound execution).each do |f|
+%w(args single compound execution completion).each do |f|
   require File.dirname(__FILE__) + "/lsl/command/#{f}"
 end
 
@@ -22,6 +22,21 @@ end
   require File.dirname(__FILE__) + "/lsl/#{f}"
 end
 
+%w(dsl).each do |f|
+  f = File.expand_path(File.dirname(__FILE__)) + "/lsl/dsl/#{f}"
+  #puts f
+  require f
+end
+
+def load_config!
+  f = ENV['HOME'] + "/.lsl"
+  if FileTest.exist?(f)
+    eval(File.read(f))
+  end
+end
+
+load_config!
+
 module LSL
   module ExecutionStrategy
     class Base

data/lib/lsl/command/args.rb

@@ -0,0 +1,43 @@
+module LSL
+  module CommandExecution
+    class Args
+      class ArrayWithBlanks
+        include Enumerable
+        fattr(:list) { [] }
+        def each(&b); list.each(&b); end
+        fattr(:blank_spots) do
+          res = []
+          list.each_with_index do |x,i|
+            res << i if x == '_'
+          end
+          res
+        end
+        def <<(x)
+          i = blank_spots.shift || list.length
+          list[i] = x
+        end
+        def add_list(l)
+          blank_spots!
+          l.each { |x| self << x }
+        end
+      end
+      include FromHash
+      fattr(:list) { [] }
+      fattr(:options) { {} }
+      fattr(:lists) do
+        list.select { |x| x }.reject { |x| x.flat_all_nil? }#.map { |x| x.kind_of?(Array) ? x : [x] }
+      end
+      fattr(:flat_args) do
+        res = ArrayWithBlanks.new
+        lists.each do |a|
+          res.add_list(a)
+        end
+        res << options unless options.empty?
+        res.list
+      end
+      def each(&b)
+        flat_args.each(&b)
+      end
+    end
+  end
+end

data/lib/lsl/command/completion.rb

@@ -0,0 +1,79 @@
+require 'readline'
+
+Readline.basic_word_break_characters = ""
+Readline.completion_proc = lambda do |s|
+  #puts [s].inspect
+  LSL::Completion::Base.instance.new_instance(:full_command => s).matching_options
+end
+
+module LSL
+  module Completion
+    class Base
+      class << self
+        fattr(:instance) { new }
+      end
+      fattr(:mappings) { LSL::Completion::Mappings.new }
+      fattr(:instances) { [] }
+      include FromHash
+      def shell
+        LSL::Shell.instance
+      end
+      def new_instance(ops)
+        res = LSL::Completion::Instance.new(ops)
+        self.instances << res
+        res
+      end
+    end
+    class Mapping
+      include FromHash
+      fattr(:base) { LSL::Completion::Base.instance }
+      attr_accessor :command_matcher, :option_generator
+      def options
+        res = if option_generator.kind_of?(String)
+          base.shell.run(option_generator).result
+        else
+          option_generator.call
+        end
+        [res].flatten.select { |x| x }
+      end
+      def match?(cmd)
+        cmd =~ command_matcher
+      end
+      class << self
+        fattr(:file_matcher) do
+          new(:option_generator => "ls")
+        end
+      end
+    end
+    class Mappings
+      fattr(:all) { [] }
+      def add(ops)
+        self.all << LSL::Completion::Mapping.new(ops)
+      end
+      def options(cmd)
+        res = all.find { |x| x.match?(cmd) }
+        return res.options if res
+        LSL::Completion::Mapping.file_matcher.options
+      end
+      
+    end
+    class Instance
+      include FromHash
+      fattr(:base) { LSL::Completion::Base.instance }
+      def shell; base.shell; end
+      attr_accessor :full_command
+      fattr(:options) do
+        base.mappings.options(full_command)
+      end
+      fattr(:prefix) { full_command.split(" ").last }
+      fattr(:preceding) { full_command.split(" ")[0..-2].join(" ") }
+      
+      fattr(:matching_options) do
+        options.grep(/^#{prefix}/i).map { |x| "#{preceding} #{x}".strip }
+      end
+      
+    end
+  end
+end
+
+      

data/lib/lsl/command/execution.rb

@@ -15,11 +15,7 @@ end
 
 class Object
   def array_aware_each(&b)
-    if kind_of?(Array)
-      each(&b)
-    else
-      yield(self)
-    end
+    [self].flatten.each(&b)
   end
   def send_with_expansion(sym,*args,&b)
     return send(sym,&b) if args.empty?
@@ -51,24 +47,10 @@ module LSL
         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
+        LSL::CommandExecution::Args.new(:list => [command.args, [input_args]], :options => command.options).flat_args
       end
-      def my_eval(ops,str)
+      def my_eval(str,ops)
         OpenStruct.new(ops).instance_eval(str)
       rescue => exp
         puts "failed #{exp.message}"
@@ -83,12 +65,13 @@ module LSL
               res << my_eval(command.raw[1..-2],:args => a, :arg => a.first)
             end
           end
-          #puts res.inspect
           res
         elsif obj.respond_to?(command.method)
-          res = obj.send_with_expansion(command.method,*args)
-          #puts "RES #{res.inspect}" if res
-          res
+          if command.inbound_pipe == '^'
+            obj.send(command.method,*args)
+          else
+            obj.send_with_expansion(command.method,*args)
+          end
         else
           `#{command.raw}`.output_to_array
         end
@@ -113,16 +96,20 @@ module LSL
       end
       def run!
         if !command
-          puts "can't parse"
+          #puts "|#{command_str}|"
+          puts "can't parsex"
           return
         end
         command_executions
         if command.output_filename
           ::File.create(command.output_filename,result.join("\n"))
         else
-          puts result_str if result
+          #puts result_str if result
         end
       end
+      def print!
+        puts result_str if result
+      end
       def result
         command_executions.last.result
       end

data/lib/lsl/command/single.rb

@@ -1,7 +1,7 @@
 module LSL
   module Command
     class Single
-      attr_accessor :ex, :args, :options, :raw
+      attr_accessor :ex, :args, :options, :raw, :inbound_pipe
       include FromHash
       def eval?
         raw[0..0] == "{"

data/lib/lsl/dsl/dsl.rb

@@ -0,0 +1,22 @@
+module LSL
+  def self.configure
+    d = LSL::DSL::Base.new
+    yield(d)
+    d.run!
+  end
+  module DSL
+    class Base
+      dsl_method_arr :completion  
+      def run!
+        completion.each do |c|
+          LSL::Completion::Base.instance.mappings.add(c)
+        end
+      end
+      def mapping(n,&b)
+        LSL::ShellLike.send(:define_method,n) do |*args|
+          b.call
+        end
+      end
+    end
+  end
+end

data/lib/lsl/ext/ext.rb

@@ -16,28 +16,63 @@ class Object
   end
 end
 
+class Object
+  def send_if_respond(meth)
+    respond_to?(meth) ? send(meth) : nil
+  end
+  def get_spaced_node(meth)
+    parent = send("spaced_#{meth}")
+    parent.send_if_respond(meth)
+  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
+
+class Array
+  def flat_all_nil?
+    flatten.select { |x| x }.empty?
+  end
+end
+
+class Object
+  def dsl_method(meth,ops={})
+    define_method(meth) do |*args|
+      if args.size > 0
+        send("#{meth}=",*args)
+      elsif false && b
+        send("#{meth}=",b)
+      else
+        instance_variable_get("@#{meth}")
+      end
+    end
+    attr_writer meth
+    define_method("#{meth}!") do
+      send("#{meth}=",true)
+    end
   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) 
+  def dsl_method_arr(meth,ops={},&obj_blk)
+    define_method(meth) do |*args|
+      #puts 'start'
+      send("#{meth}=",[]) unless instance_variable_get("@#{meth}")
+      #puts 'start set'
+      if args.size == 1
+        instance_variable_get("@#{meth}") << args.first
+      elsif args.size == 2
+        arg = args[1]
+        arg[:name] = args.first
+        instance_variable_get("@#{meth}") << arg
+      elsif false && b
+        instance_variable_get("@#{meth}") << b
       else
-        res += e.find_child_nodes(node)
+        res = instance_variable_get("@#{meth}")
+        res = res.map { |x| obj_blk[x,self] } if obj_blk
+        res
       end
     end
-    #return send(node) if respond_to?(node)
-    res
+    attr_writer meth
   end
-  def find_child_node2(node)
-    find_child_node(node)
-  end     
-end
+end

data/lib/lsl/grammars/compound_command.treetop

@@ -3,25 +3,27 @@ module LSL
     include LSL::SingleCommand
     include LSL::File
     rule full_command
-      some_command (ows "|" ows some_command)* (ows ">" ows filename)? {
+      some_command more:(ows pipe ows some_command)* spaced_filename:(ows ">" ows filename)? {
         def filename
-          find_child_node(:filename)
+          get_spaced_node(:filename)
         end
         def single_commands
-          
           res = [some_command.command_hash]
-          #res = [elements.first.command_hash]
-          rest = find_child_nodes(:some_command).map { |x| x.command_hash }
-          #puts "rest #{rest.size}"
-          res + rest
+          res += more.elements.map do |x| 
+            single = x.some_command.command_hash
+            single.inbound_pipe = x.pipe.text_value
+            single
+          end if more
+          res
         end
         def command_hash
-          res = LSL::Command::Compound.new(:commands => single_commands)
-          res.output_filename = filename.text_value if filename
-          res
+          LSL::Command::Compound.new(:commands => single_commands, :output_filename => filename.andand.text_value)
         end
       }
     end
+    rule pipe
+      "|" / "^"
+    end
     rule eval_str
       "{" (!"}" .)+ "}" {
         def command_hash

data/lib/lsl/grammars/list.treetop

@@ -2,7 +2,11 @@ module LSL
   grammar List
     include LSL::Base
     rule comma_list
-      optionally_quoted_string ("," comma_list)*
+      optionally_quoted_string ("," comma_list)* {
+        def unquotedx
+          optionally_quoted_string.unquotedx
+        end
+      }
     end
   end
 end

data/lib/lsl/grammars/quoting.treetop

@@ -2,10 +2,21 @@ module LSL
   grammar Quoting
     include LSL::Base
     rule optionally_quoted_string
-      quoted_string / word
+      quoted_string / unquoted_word
+    end
+    rule unquoted_word
+      word {
+        def unquotedx
+          text_value
+        end
+      }
     end
     rule quoted_string
-      '"' quoteless_string '"'
+      '"' quoteless_string '"' {
+        def unquotedx
+          quoteless_string.text_value
+        end
+      }
     end
     rule quoteless_string
       (!'"' . quoteless_string) / ""

data/lib/lsl/grammars/single_command.treetop

@@ -3,16 +3,16 @@ module LSL
     include LSL::Quoting
     include LSL::List
     rule single_command
-      ex (ws args)? (ws options)? {
+      ex spaced_args:(ws args)? spaced_options:(ws options)? {
         def args
-          find_child_node(:args)
+          get_spaced_node(:args)
         end
         def options
-          find_child_node(:options)
+          get_spaced_node(:options)
         end
         def command_hash
           LSL::Command::Single.new(:raw => text_value, :ex => ex.text_value, 
-                               :args => args.andand.list_values || [], :options => options.andand.hash_values || {})
+                               :args => args.andand.arg_values || [], :options => options.andand.hash_values || {})
         end
       }
     end
@@ -25,29 +25,27 @@ module LSL
       comma_list
     end
     rule args
-      arg (ws arg)*
+      arg spaced_args:(ws args)? {
+        def arg_values
+          [arg.unquotedx] + (get_spaced_node(:args).andand.arg_values || [])
+        end
+      }
     end
     
     rule option_flag
-      '-' word
+      '-' 1..2 word
     end
     rule option
-      option_flag (ws optionally_quoted_string)? {
+      option_flag spaced_option_value:(ws option_value:optionally_quoted_string)? {
         def kv
-          n = find_child_node2(:optionally_quoted_string)
-          {option_flag.word.text_value => n.andand.text_value}
+          {option_flag.word.text_value => get_spaced_node(:option_value).andand.unquotedx}
         end
       }
     end
     rule options
-      option (ws option)* {
+      option spaced_options:(ws options)? {
         def hash_values
-          res = option.kv
-          elements[1..-1].each do |e|
-            n = e.find_child_node2(:option)
-            res = res.merge(n.kv) if n
-          end
-          res
+          option.kv.merge(get_spaced_node(:options).andand.hash_values || {})
         end
       }
     end

data/lib/lsl/junk.rb

@@ -0,0 +1,25 @@
+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_nodexx(node)
+    find_child_nodes(node).first
+  end
+  def find_child_nodesxx(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_node2x(node)
+    find_child_node(node)
+  end     
+end

data/lib/lsl/shell.rb

@@ -15,13 +15,16 @@ $printed ||= []
 module LSL
   module ShellLike
     module Inner
+      def pipe(*args)
+        args
+      end
       def echo(*args)
         #puts args.inspect
         ops = (args.last.kind_of?(Hash) ? args.pop : {})
         str = args.join(" ")
         str = str.upcase if ops.has_key?('upper')
-        puts str
-        nil
+        #puts str
+        str
       end
       def echot(*args)
         echo(*args)
@@ -47,6 +50,7 @@ module LSL
         puts a.length * b.length
       end
       def cc(*args)
+        puts "cc args #{args.inspect}"
         args.reverse.join("")
       end
       def la(*args)
@@ -68,6 +72,35 @@ module LSL
       def pt(a,b)
         puts a==b
       end
+      def get(url)
+        require 'open-uri'
+        open(url).read
+      end
+      def p(*args)
+        ec "python -c " + args.join(" ")
+      end
+      def without_left(n,arg)
+        arg[n.to_i..-1]
+      end
+      def sub(a,b,arg)
+        arg[a.to_i..b.to_i]
+      end
+      def crop_top(arr,i)
+        arr[i.to_i..-1]
+      end
+      def column(arr,a,b)
+        arr.map { |x| x[a.to_i..b.to_i].andand.strip }
+      end
+      def sum(*args)
+        args.flatten.inject(0.0) { |s,i| s + i.to_f }
+      end
+      def sumt(*args)
+        args.flatten.inject { |s,i| s + (i.kind_of?(String) ? i.to_f : i) }
+      end
+      def remove(str,c)
+        str.gsub(c,"").strip
+      end
+        
     end
     include FileUtils
     include Inner
@@ -79,26 +112,32 @@ module LSL
   end
 
   class Shell
+    class << self
+      fattr(:instance) { new }
+    end
+    attr_accessor :last_execution
     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! }
+      self.last_execution = LSL::CommandExecution::Compound.new(:command_str => str, :shell => self).tap { |x| x.run! }
     end
     def get_input
-      STDIN.gets.strip
+      #STDIN.gets.strip
+      require 'readline'
+      Readline.readline("#{Dir.getwd}> ",true).strip
     end
     def run_loop
       loop do
-        print "#{Dir.getwd}> "
         str = get_input
         run(str)
+        last_execution.print!
       end
     end
   end
 end
 
 def run_shell!(obj=nil)
-  s = LSL::Shell.new
+  s = LSL::Shell.instance
   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.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["mharris717"]
-  s.date = %q{2010-12-31}
+  s.date = %q{2011-01-03}
   s.default_executable = %q{lsl}
   s.description = %q{little shell language}
   s.email = %q{mharris717@gmail.com}
@@ -29,9 +29,12 @@ Gem::Specification.new do |s|
     "VERSION",
     "bin/lsl",
     "lib/lsl.rb",
+    "lib/lsl/command/args.rb",
+    "lib/lsl/command/completion.rb",
     "lib/lsl/command/compound.rb",
     "lib/lsl/command/execution.rb",
     "lib/lsl/command/single.rb",
+    "lib/lsl/dsl/dsl.rb",
     "lib/lsl/ext/ext.rb",
     "lib/lsl/grammars/base.treetop",
     "lib/lsl/grammars/compound_command.treetop",
@@ -39,6 +42,7 @@ Gem::Specification.new do |s|
     "lib/lsl/grammars/list.treetop",
     "lib/lsl/grammars/quoting.treetop",
     "lib/lsl/grammars/single_command.treetop",
+    "lib/lsl/junk.rb",
     "lib/lsl/mapping/mapping.rb",
     "lib/lsl/sandbox.rb",
     "lib/lsl/server.rb",

data/spec/compound_command_spec.rb

@@ -36,6 +36,12 @@ describe "CompoundCommand" do
     c.ex.should == 'ls'
     c.args.should == ['c','d']
   end
+  it 'many pipes' do
+    parse("cp a b | cp c d | cp e f | cp g h").command_hash.commands.size.should == 4
+  end
+  it 'inbound pipe' do
+    parse("cp a b ^ cp c d").command_hash.commands.last.inbound_pipe.should == '^'
+  end
   describe "execution" do
     it "each_command args" do
       res = []

data/spec/quoting_spec.rb

@@ -20,6 +20,12 @@ describe "Quoting" do
   it "unquoted phrase" do
     parser.should_not be_parsed("abc xyz")
   end
+  it 'has unquoted method for quoted phrase' do
+    parser.parse('"abc xyz"').unquotedx.should == 'abc xyz'
+  end
+  it 'has unquoted method for unquoted word' do
+    parser.parse('abc').unquotedx.should == 'abc'
+  end
   #it "escaped quotes"
 end
 

data/spec/shell_spec.rb

@@ -14,7 +14,7 @@ describe "Shell" do
   end
   it 'piping' do
     @shell.run('ls VERSION | pf')
-    $printed.should == ['0.1.0']
+    $printed.should == ['0.1.1']
   end
   it 'foo' do
     #30.times do
@@ -28,15 +28,28 @@ describe "Shell" 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")
+    #run("remote_call foo").result.should == 'rc'
+    #run("remote_call foo | echo")
   end
   it 'rake' do
     #run("abc").result.should == "ran"
   end
   it 'eval' do
-    run("{2 + 2}").result.should == 4
+    run("{2 + 2}").result.should == [4]
   end
+  it 'underscore' do
+    run("echo \"Gemfile*\" | ls").result.should == ['Gemfile','Gemfile.lock']
+    run("echo \"Gemfile*\" | ls _").result.should == ['Gemfile','Gemfile.lock']
+  end
+  it 'underscore 2' do
+    run("pipe a b | cc _ x").result.should == ['xa','xb']
+    run("echo a | cc _ x").result.should == 'xa'
+  end
+  it 'splat pipe' do
+    run('pipe a b | echo').result.should == ['a','b']
+    run('pipe a b ^ echo').result.should == 'a b'
+  end
+
   describe 'output redirection' do
     before do
       @file = "spec/mock_dir/output.txt"

data/spec/single_command_spec.rb

@@ -76,6 +76,7 @@ describe "Command" do
     it 'raw string' do
       parse("cp a b").command_hash.raw.should == 'cp a b'
     end
+
   end
   
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - mharris717
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-31 00:00:00 -05:00
+date: 2011-01-03 00:00:00 -05:00
 default_executable: lsl
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -127,9 +127,12 @@ files:
 - VERSION
 - bin/lsl
 - lib/lsl.rb
+- lib/lsl/command/args.rb
+- lib/lsl/command/completion.rb
 - lib/lsl/command/compound.rb
 - lib/lsl/command/execution.rb
 - lib/lsl/command/single.rb
+- lib/lsl/dsl/dsl.rb
 - lib/lsl/ext/ext.rb
 - lib/lsl/grammars/base.treetop
 - lib/lsl/grammars/compound_command.treetop
@@ -137,6 +140,7 @@ files:
 - lib/lsl/grammars/list.treetop
 - lib/lsl/grammars/quoting.treetop
 - lib/lsl/grammars/single_command.treetop
+- lib/lsl/junk.rb
 - lib/lsl/mapping/mapping.rb
 - lib/lsl/sandbox.rb
 - lib/lsl/server.rb