yap-shell-parser 0.2.2 → 0.3.1

data/spec/yap/shell/lexer_spec.rb

@@ -3,16 +3,297 @@ require 'yap/shell/parser/lexer'
 
 describe Yap::Shell::Parser::Lexer do
   subject { described_class.new.tokenize(str) }
+  let(:str){ self.class.description }
 
   def t(tag, val, lineno:0, attrs:{})
     [tag, Yap::Shell::Parser::Lexer::Token.new(tag, val, lineno:lineno, attrs:attrs)]
   end
 
+  describe "block expressions" do
+    describe "can follow any command" do
+      describe "ls { this_is_a_block }" do
+        it { should eq [
+          t(:Command, "ls", lineno:0),
+          t(:BlockBegin, '{', lineno: 0),
+          t(:Command, "this_is_a_block", lineno:0),
+          t(:BlockEnd, '}', lineno: 0)
+        ]}
+      end
+
+      describe "whitespace before/after the range doesn't matter" do
+        describe "   ls        {     this_is_a_block    }   " do
+          it { should eq [
+            t(:Command, "ls", lineno:0),
+            t(:BlockBegin, '{', lineno: 0),
+            t(:Command, "this_is_a_block", lineno:0),
+            t(:BlockEnd, '}', lineno: 0)
+          ]}
+        end
+
+        describe "ls {echo n}" do
+          it { should eq [
+            t(:Command, "ls", lineno:0),
+            t(:BlockBegin, '{', lineno: 0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "n", lineno:0),
+            t(:BlockEnd, '}', lineno: 0)
+          ]}
+        end
+      end
+    end
+
+    describe "can take block params" do
+      describe "ls { |a| this_is_a_block }" do
+        it { should eq [
+          t(:Command, "ls", lineno:0),
+          t(:BlockBegin, '{', lineno: 0),
+          t(:BlockParams, ['a'], lineno: 0),
+          t(:Command, "this_is_a_block", lineno:0),
+          t(:BlockEnd, '}', lineno: 0)
+        ]}
+      end
+
+      describe "ls { |a,b| this_is_a_block }" do
+        it { should eq [
+          t(:Command, "ls", lineno:0),
+          t(:BlockBegin, '{', lineno: 0),
+          t(:BlockParams, ['a', 'b'], lineno: 0),
+          t(:Command, "this_is_a_block", lineno:0),
+          t(:BlockEnd, '}', lineno: 0)
+        ]}
+      end
+
+      describe "ls { |a,  b,  c| this_is_a_block }" do
+        it { should eq [
+          t(:Command, "ls", lineno:0),
+          t(:BlockBegin, '{', lineno: 0),
+          t(:BlockParams, ['a', 'b', 'c'], lineno: 0),
+          t(:Command, "this_is_a_block", lineno:0),
+          t(:BlockEnd, '}', lineno: 0)
+        ]}
+      end
+    end
+
+    describe "can contain multiple statements" do
+      describe "ls { |a| ls ; ls2 || ls3 && ls4 ; ls5 }" do
+        it { should eq [
+          t(:Command, "ls", lineno:0),
+          t(:BlockBegin, '{', lineno: 0),
+          t(:BlockParams, ['a'], lineno: 0),
+          t(:Command, 'ls', lineno: 0),
+          t(:Separator, ';', lineno: 0),
+          t(:Command, 'ls2', lineno: 0),
+          t(:Conditional, '||', lineno: 0),
+          t(:Command, 'ls3', lineno: 0),
+          t(:Conditional, '&&', lineno: 0),
+          t(:Command, 'ls4', lineno: 0),
+          t(:Separator, ';', lineno: 0),
+          t(:Command, 'ls5', lineno: 0),
+          t(:BlockEnd, '}', lineno: 0)
+        ]}
+      end
+    end
+  end
+
+  describe "looping constructs" do
+    describe "standalone" do
+      describe "(1..100)" do
+        it { should eq [
+          t(:Range, (1..100), lineno:0),
+        ]}
+      end
+    end
+
+    describe "start of line" do
+      describe "numerical range (no reference variable)" do
+        describe "(0..3): echo hi" do
+          it { should eq [
+            t(:Range, (0..3), lineno:0),
+            t(:BlockBegin, '{', lineno: 0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "hi", lineno:0),
+            t(:BlockEnd, '}', lineno: 0)
+          ]}
+        end
+
+        describe "whitespace before/after the range doesn't matter" do
+          describe "    (0..3)     : echo hi" do
+            it { should eq [
+              t(:Range, (0..3), lineno:0),
+              t(:BlockBegin, '{', lineno: 0),
+              t(:Command, "echo", lineno:0),
+              t(:Argument, "hi", lineno:0),
+              t(:BlockEnd, '}', lineno: 0)
+            ]}
+          end
+        end
+      end
+
+      describe "numerical range $n (reference variable)" do
+        describe "(0..3) as n: echo $n" do
+          it { should eq [
+            t(:Range, (0..3), lineno:0),
+            t(:BlockBegin, '{', lineno: 0),
+            t(:BlockParams, ['n'], lineno: 0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "$n", lineno:0),
+            t(:BlockEnd, '}', lineno:0)
+          ]}
+        end
+
+        describe "whitespace before/after the range/reference doesn't matter" do
+          describe "    (0..3)  as    n   : echo $n" do
+            it { should eq [
+              t(:Range, (0..3), lineno:0),
+              t(:BlockBegin, '{', lineno: 0),
+              t(:BlockParams, ['n'], lineno: 0),
+              t(:Command, "echo", lineno:0),
+              t(:Argument, "$n", lineno:0),
+              t(:BlockEnd, '}', lineno:0)
+            ]}
+          end
+        end
+      end
+
+      describe "<number>.times w/block" do
+        describe "3.times { |n| echo hi }" do
+          it { should eq [
+            t(:Range, (1..3), lineno:0),
+            t(:BlockBegin, '{', lineno: 0),
+            t(:BlockParams, ['n'], lineno: 0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "hi", lineno:0),
+            t(:BlockEnd, '}', lineno:0)
+          ]}
+        end
+
+        describe "3.times { |a, b,c| echo hi }" do
+          it { should eq [
+            t(:Range, (1..3), lineno:0),
+            t(:BlockBegin, '{', lineno: 0),
+            t(:BlockParams, ['a', 'b', 'c'], lineno: 0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "hi", lineno:0),
+            t(:BlockEnd, '}', lineno:0)
+          ]}
+        end
+      end
+
+      describe "<number>.times (no reference variable)" do
+        describe "3.times: echo hi" do
+          it { should eq [
+            t(:Range, (1..3), lineno:0),
+            t(:BlockBegin, '{', lineno: 0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "hi", lineno:0),
+            t(:BlockEnd, '}', lineno:0)
+          ]}
+        end
+
+        describe "whitespace before/after the range doesn't matter" do
+          describe "    3.times    : echo hi" do
+            it { should eq [
+              t(:Range, (1..3), lineno:0),
+              t(:BlockBegin, '{', lineno: 0),
+              t(:Command, "echo", lineno:0),
+              t(:Argument, "hi", lineno:0),
+              t(:BlockEnd, '}', lineno:0)
+            ]}
+          end
+        end
+      end
+
+      describe "<number>.times $n (w/reference variable)" do
+        describe "3.times as n: echo $n" do
+          it { should eq [
+            t(:Range, (1..3), lineno:0),
+            t(:BlockBegin, '{', lineno: 0),
+            t(:BlockParams, ['n'], lineno: 0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "$n", lineno:0),
+            t(:BlockEnd, '}', lineno:0)
+          ]}
+        end
+
+        describe "whitespace before/after the range/reference doesn't matter" do
+          describe "    3.times  as   n  : echo $n" do
+            it { should eq [
+              t(:Range, (1..3), lineno:0),
+              t(:BlockBegin, '{', lineno: 0),
+              t(:BlockParams, ['n'], lineno: 0),
+              t(:Command, "echo", lineno:0),
+              t(:Argument, "$n", lineno:0),
+              t(:BlockEnd, '}', lineno:0)
+            ]}
+          end
+        end
+      end
+    end
+
+    describe "statement mixed with other statements" do
+      describe "numerical range (no reference variable)" do
+        describe "foo { echo foo }" do
+          it { should eq [
+            t(:Command, "foo", lineno:0),
+            t(:BlockBegin, '{', lineno:0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "foo", lineno:0),
+            t(:BlockEnd, '}', lineno:0),
+          ]}
+        end
+
+        describe "foo { |n| echo foo }" do
+          it { should eq [
+            t(:Command, "foo", lineno:0),
+            t(:BlockBegin, '{', lineno:0),
+            t(:BlockParams, ['n'], lineno:0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "foo", lineno:0),
+            t(:BlockEnd, '}', lineno:0),
+          ]}
+        end
+
+        describe "(0..3).each { echo foo }" do
+          it { should eq [
+            t(:Range, (0..3), lineno:0),
+            t(:BlockBegin, '{', lineno:0),
+            t(:Command, "echo", lineno:0),
+            t(:Argument, "foo", lineno:0),
+            t(:BlockEnd, '}', lineno:0),
+          ]}
+        end
+
+        describe "whitespace before/after the range doesn't matter" do
+          describe "     (0..3).each     {      echo foo   }     " do
+            it { should eq [
+              t(:Range, (0..3), lineno:0),
+              t(:BlockBegin, '{', lineno:0),
+              t(:Command, "echo", lineno:0),
+              t(:Argument, "foo", lineno:0),
+              t(:BlockEnd, '}', lineno:0),
+            ]}
+          end
+        end
+      end
+    end
+  end
+
   describe "empty string" do
     let(:str){ "" }
     it { should eq [] }
   end
 
+  describe "string with newlines" do
+    let(:str){ "ls \n\nlib:\ntasks\nyap\nyap.rb" }
+    it { should eq [
+      t(:Command, "ls", lineno:0),
+      t(:Argument, "lib:", lineno:0),
+      t(:Argument, "tasks", lineno:0),
+      t(:Argument, "yap", lineno:0),
+      t(:Argument, "yap.rb", lineno:0)
+    ]}
+  end
+
   describe "env variables" do
     let(:str){ "foo $baz" }
     it { should eq [
@@ -354,12 +635,26 @@ describe Yap::Shell::Parser::Lexer do
       ]}
     end
 
-    describe "the ending line cannot have non-whitespace characters beyond the delimiter" do
-      let(:str){ "foo <<L337\nhere\nwe\ngo\n this is bad L337"}
+    describe <<-DESCRIPTION do
+      the delimiter doesn't have to be on its own line, just be the last thing.
+      It also will ignore any whitespace leading up to the delimiter.
+    DESCRIPTION
+      let(:str){ "foo <<L337\nhere\nwe\ngo\n this is great L337"}
+      it { should eq [
+        t(:Command, "foo", lineno:0),
+        t(:Heredoc, "here\nwe\ngo\n this is great", lineno:0)
+      ]}
+    end
+
+    describe "when there is no matching end delimiter found" do
+      let(:str){ "foo <<L337\nhere\nwe\ngo"}
       it "raises an error" do
-        expect{ subject }.to raise_error
+        expect do
+          subject
+        end.to raise_error(Yap::Shell::Parser::Lexer::HeredocMissingEndDelimiter)
       end
     end
+
   end
 
   context "internal evaluations" do
@@ -980,7 +1275,5 @@ describe Yap::Shell::Parser::Lexer do
         )
       end
     end
-
   end
-
 end

data/spec/yap/shell/parser_spec.rb

@@ -1,28 +1,9 @@
 require 'spec_helper'
 require 'yap/shell/parser'
 require 'pry'
-
 describe Yap::Shell::Parser do
   subject(:parser){ Yap::Shell::Parser }
 
-  def self.it_parses(str)
-    context "#{str.inspect}" do
-      it "parses" do
-        expect { parser.parse(str) }.to_not raise_error
-      end
-    end
-  end
-
-  def self.it_errors(str)
-    context "#{str.inspect}" do
-      it "raises a Yap::Shell::Parser::ParseError" do
-        expect {
-          parser.parse(str)
-        }.to raise_error(Yap::Shell::Parser::ParseError)
-      end
-    end
-  end
-
   describe '.each_command_substitution_for' do
     let(:str){ "echo `echo hi`" }
 
@@ -33,41 +14,47 @@ describe Yap::Shell::Parser do
     end
   end
 
-  it_parses "ls"
-  it_parses "echo foo"
-  it_parses "echo foo ; echo bar baz yep"
-  it_parses "echo foo && echo bar baz yep"
-  it_parses "echo foo && echo bar && ls foo && ls bar"
-  it_parses "echo foo ; echo bar baz yep ; ls foo"
-  it_parses "echo foo && echo bar ; ls baz"
-  it_parses "echo foo && echo bar ; ls baz ; echo zach || echo gretchen"
-  it_parses "echo foo | bar"
-  it_parses "echo foo | bar && foo | bar"
-  it_parses "foo && bar ; word || baz ; yep | grep -v foo"
-  it_parses "( foo )"
-  it_parses "( foo a b && bar c d )"
-  it_parses "( foo a b && (bar c d | baz e f))"
-  it_parses "((((foo))))"
-  it_parses "foo -b -c ; (this ;that ;the; other  ;thing) && yep"
-  it_parses "foo -b -c ; (this ;that && other  ;thing) && yep"
-  it_parses "4 + 5"
-  it_parses "!'hello' ; 4 - 4 && 10 + 3"
-  it_parses "\\foo <<-EOT\nbar\nEOT"
-  it_parses "ls | grep md | grep WISH"
-  it_parses "(!upcase)"
-  it_parses "echo foo > bar.txt"
-  it_parses "ls -l > a.txt ; echo f 2> b.txt ; cat b &> c.txt ; du -sh 1>&2 1>hey.txt"
-  it_parses "!Dir.chdir('..')"
-  it_parses "FOO=123"
-  it_parses "FOO=123 BAR=345"
-  it_parses "FOO=abc bar=2314 car=14ab ls -l"
-  it_parses "FOO=abc BAR='hello world' ls -l ; CAR=f echo foo && say hi"
-  it_parses "`git cbranch`"
-  it_parses "`git cbranch`.bak"
-  it_parses "echo `echo hi`"
-  it_parses "echo `echo hi` foo"
-  it_parses "`hi``bye` `what`"
-  it_parses "echo && `what` && where is `that`thing | `you know`"
+  it { is_expected.to parse "ls" }
+  it { is_expected.to parse "echo foo" }
+  it { is_expected.to parse "echo foo ; echo bar baz yep" }
+  it { is_expected.to parse "echo foo && echo bar baz yep" }
+  it { is_expected.to parse "echo foo && echo bar && ls foo && ls bar" }
+  it { is_expected.to parse "echo foo ; echo bar baz yep ; ls foo" }
+  it { is_expected.to parse "echo foo && echo bar ; ls baz" }
+  it { is_expected.to parse "echo foo && echo bar ; ls baz ; echo zach || echo gretchen" }
+  it { is_expected.to parse "echo foo | bar" }
+  it { is_expected.to parse "echo foo | bar && foo | bar" }
+  it { is_expected.to parse "foo && bar ; word || baz ; yep | grep -v foo" }
+  it { is_expected.to parse "( foo )" }
+  it { is_expected.to parse "( foo a b && bar c d )" }
+  it { is_expected.to parse "( foo a b && (bar c d | baz e f))" }
+  it { is_expected.to parse "((((foo))))" }
+  it { is_expected.to parse "foo -b -c ; (this ;that ;the; other  ;thing) && yep" }
+  it { is_expected.to parse "foo -b -c ; (this ;that && other  ;thing) && yep" }
+  it { is_expected.to parse "4 + 5" }
+  it { is_expected.to parse "!'hello' ; 4 - 4 && 10 + 3" }
+  it { is_expected.to parse "\\foo <<-EOT\nbar\nEOT" }
+  it { is_expected.to parse "ls | grep md | grep WISH" }
+  it { is_expected.to parse "(!upcase)" }
+  it { is_expected.to parse "echo foo > bar.txt" }
+  it { is_expected.to parse "ls -l > a.txt ; echo f 2> b.txt ; cat b &> c.txt ; du -sh 1>&2 1>hey.txt" }
+  it { is_expected.to parse "!Dir.chdir('..')" }
+  it { is_expected.to parse "FOO=123" }
+  it { is_expected.to parse "FOO=123 BAR=345" }
+  it { is_expected.to parse "FOO=abc bar=2314 car=14ab ls -l" }
+  it { is_expected.to parse "FOO=abc BAR='hello world' ls -l ; CAR=f echo foo && say hi" }
+  it { is_expected.to parse "`git cbranch`" }
+  it { is_expected.to parse "`git cbranch`.bak" }
+  it { is_expected.to parse "echo `echo hi`" }
+  it { is_expected.to parse "echo `echo hi` foo" }
+  it { is_expected.to parse "`hi``bye` `what`" }
+  it { is_expected.to parse "echo && `what` && where is `that`thing | `you know`" }
+  it { is_expected.to parse "(0..3)" }
+  it { is_expected.to parse "(0..3): echo hi" }
+  it { is_expected.to parse "(0..3) as n: echo hi $n" }
+  it { is_expected.to parse "echo hi ; (0..3) {echo hi $n}" }
+  it { is_expected.to parse "echo hi ; (0..3) { echo hi $n } ; echo bye" }
+  it { is_expected.to parse "ls *.rb { |f,g,h| echo $f && echo $h && echo $i }" }
 
-  it_errors "ls ()"
+  it { is_expected.to fail_parsing "ls ()" }
 end

data/yap-shell-parser.gemspec

@@ -22,5 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.2"
-  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yap-shell-parser
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.1
 platform: ruby
 authors:
 - Zach Dennis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-13 00:00:00.000000000 Z
+date: 2016-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -75,6 +75,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
@@ -113,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: The parser for the yap shell