travis-conditions 0.0.2 → 1.0.0

data/spec/v1/parser/boolean_spec.rb

@@ -0,0 +1,215 @@
+class BooleanParser
+  extend Forwardable
+  include Travis::Conditions::V1::Boolean
+  include Travis::Conditions::V1::Helper
+
+  def_delegators :str, :scan, :skip, :string, :pos, :peek
+  attr_reader :str
+
+  VAR = /[A-Z]{1}/
+
+  def initialize(str)
+    @str = StringScanner.new(str)
+  end
+
+  def term
+    space { scan(VAR) }
+  end
+end
+
+describe BooleanParser, 'expr' do
+  let(:str)     { |e| e.description }
+  let(:subject) { described_class.new(str).expr }
+
+  # one term
+
+  it 'A' do
+    should eq 'A'
+  end
+
+  it '(A)' do
+    should eq 'A'
+  end
+
+  it 'not A' do
+    should eq [:not, 'A']
+  end
+
+  it 'not (A)' do
+    should eq [:not, 'A']
+  end
+
+  it '(not A)' do
+    should eq [:not, 'A']
+  end
+
+  it '!A' do
+    should eq [:not, 'A']
+  end
+
+  it '! A' do
+    should eq [:not, 'A']
+  end
+
+  it '!(A)' do
+    should eq [:not, 'A']
+  end
+
+  it '! (A)' do
+    should eq [:not, 'A']
+  end
+
+  # two terms
+
+  it 'A and B' do
+    should eq [:and, 'A', 'B']
+  end
+
+  it '(A) and B' do
+    should eq [:and, 'A', 'B']
+  end
+
+  it 'A and (B)' do
+    should eq [:and, 'A', 'B']
+  end
+
+  it '(A) and (B)' do
+    should eq [:and, 'A', 'B']
+  end
+
+  it 'not A and B' do
+    should eq [:and, [:not, 'A'], 'B']
+  end
+
+  it 'A and not B' do
+    should eq [:and, 'A', [:not, 'B']]
+  end
+
+  it 'not A and not B' do
+    should eq [:and, [:not, 'A'], [:not, 'B']]
+  end
+
+  it 'not (A) and B' do
+    should eq [:and, [:not, 'A'], 'B']
+  end
+
+  it '(A) and not B' do
+    should eq [:and, 'A', [:not, 'B']]
+  end
+
+  it 'not (A) and not B' do
+    should eq [:and, [:not, 'A'], [:not, 'B']]
+  end
+
+  it 'not (A) and (B)' do
+    should eq [:and, [:not, 'A'], 'B']
+  end
+
+  it '(A) and not (B)' do
+    should eq [:and, 'A', [:not, 'B']]
+  end
+
+  it 'not (A) and not (B)' do
+    should eq [:and, [:not, 'A'], [:not, 'B']]
+  end
+
+  it '(not A) and B' do
+    should eq [:and, [:not, 'A'], 'B']
+  end
+
+  it '(A) and not B' do
+    should eq [:and, 'A', [:not, 'B']]
+  end
+
+  it '(not A) and not B' do
+    should eq [:and, [:not, 'A'], [:not, 'B']]
+  end
+
+  it '(not A) and (B)' do
+    should eq [:and, [:not, 'A'], 'B']
+  end
+
+  it '(A) and (not B)' do
+    should eq [:and, 'A', [:not, 'B']]
+  end
+
+  it '(not A) and (not B)' do
+    should eq [:and, [:not, 'A'], [:not, 'B']]
+  end
+
+  it '(! A) && !B' do
+    should eq [:and, [:not, 'A'], [:not, 'B']]
+  end
+
+  # three terms
+
+  it 'A and B and C' do
+    should eq [:and, [:and, 'A', 'B'], 'C']
+  end
+
+  it 'A and B or C' do
+    should eq [:or, [:and, 'A', 'B'], 'C']
+  end
+
+  it 'A or B and C' do
+    should eq [:or, 'A', [:and, 'B', 'C']]
+  end
+
+  it 'A or B or C' do
+    should eq [:or, [:or, 'A', 'B'], 'C']
+  end
+
+  it '(A and B and C)' do
+    should eq [:and, [:and, 'A', 'B'], 'C']
+  end
+
+  it '(A and B) and C' do
+    should eq [:and, [:and, 'A', 'B'], 'C']
+  end
+
+  it 'A and (B and C)' do
+    should eq [:and, 'A', [:and, 'B', 'C']]
+  end
+
+  it '(A or B) and C' do
+    should eq [:and, [:or, 'A', 'B'], 'C']
+  end
+
+  it 'A and (B or C)' do
+    should eq [:and, 'A', [:or, 'B', 'C']]
+  end
+
+  it '(not A and not B and not C)' do
+    should eq [:and, [:and, [:not, 'A'], [:not, 'B']], [:not, 'C']]
+  end
+
+  it 'not (not A and not B and not C)' do
+    should eq [:not, [:and, [:and, [:not, 'A'], [:not, 'B']], [:not, 'C']]]
+  end
+
+  it '(not A or not B) and not C' do
+    should eq [:and, [:or, [:not, 'A'], [:not, 'B']], [:not, 'C']]
+  end
+
+  it 'not (not A or not B) and not C' do
+    should eq [:and, [:not, [:or, [:not, 'A'], [:not, 'B']]], [:not, 'C']]
+  end
+
+  it 'not(not A and not (not B or not C))' do
+    should eq [:not, [:and, [:not, 'A'], [:not, [:or, [:not, 'B'], [:not, 'C']]]]]
+  end
+
+  # six terms
+
+  it 'A or B and C or D and E or F' do
+    should eq [:or, [:or, [:or, 'A', [:and, 'B', 'C']], [:and, 'D', 'E']], 'F']
+  end
+
+  it '(A or B) and C or D and (E or F)' do
+    should eq [:or, [:and, [:or, 'A', 'B'], 'C'], [:and, 'D', [:or, 'E', 'F']]]
+  end
+
+  it '(A or B) and (C or D) and (E or F)' do
+    should eq [:and, [:and, [:or, 'A', 'B'], [:or, 'C', 'D']], [:or, 'E', 'F']]
+  end
+end

data/spec/v1/parser/call_spec.rb

@@ -0,0 +1,68 @@
+describe Travis::Conditions::V1::Parser, 'call' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).call }
+
+  it 'env()' do
+    should eq [:call, :env, []]
+  end
+
+  it 'env(foo)' do
+    should eq [:call, :env, [[:val, 'foo']]]
+  end
+
+  it 'env(type)' do
+    should eq [:call, :env, [[:var, :type]]]
+  end
+
+  it 'env(env(foo))' do
+    should eq [:call, :env, [[:call, :env, [[:val, 'foo']]]]]
+  end
+
+  it 'env(env(env(foo)))' do
+    should eq [:call, :env, [[:call, :env, [[:call, :env, [[:val, 'foo']]]]]]]
+  end
+
+  it 'env(foo, bar)' do
+    should eq [:call, :env, [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'env("foo")' do
+    should eq [:call, :env, [[:val, 'foo']]]
+  end
+
+  it 'env("foo", "bar")' do
+    should eq [:call, :env, [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it "env('foo')" do
+    should eq [:call, :env, [[:val, 'foo']]]
+  end
+
+  it "env('foo', 'bar')" do
+    should eq [:call, :env, [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'concat()' do
+    should eq [:call, :concat, []]
+  end
+
+  it 'concat(foo)' do
+    should eq [:call, :concat, [[:val, 'foo']]]
+  end
+
+  it 'concat(foo, bar)' do
+    should eq [:call, :concat, [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'concat(foo, env(bar))' do
+    should eq [:call, :concat, [[:val, 'foo'], [:call, :env, [[:val, 'bar']]]]]
+  end
+
+  it 'concat(branch, foo)' do
+    should eq [:call, :concat, [[:var, :branch], [:val, 'foo']]]
+  end
+
+  it 'bar()' do
+    should be_nil
+  end
+end

data/spec/v1/parser/comma_spec.rb

@@ -0,0 +1,28 @@
+describe Travis::Conditions::V1::Parser, 'comma' do
+  let(:str) { |e| e.description }
+
+  let(:subject) do
+    p = described_class.new(str)
+    [p.word.tap { p.comma }, p.word]
+  end
+
+  it 'foo,bar' do
+    should eq ['foo', 'bar']
+  end
+
+  it 'foo, bar' do
+    should eq ['foo', 'bar']
+  end
+
+  it 'foo ,bar' do
+    should eq ['foo', 'bar']
+  end
+
+  it 'foo , bar' do
+    should eq ['foo', 'bar']
+  end
+
+  it 'foo' do
+    should eq ['foo', nil]
+  end
+end

data/spec/v1/parser/cont_spec.rb

@@ -0,0 +1,41 @@
+describe Travis::Conditions::V1::Parser, 'line continuation' do
+  let(:str)     { |e| e.description }
+  let(:subject) { described_class.new(str).parse }
+
+  # backslashes
+
+  it "1 = 1 AND\\\n2 = 2" do
+    should eq \
+      [:and,
+        [:eq, [:val, '1'], [:val, '1']],
+        [:eq, [:val, '2'], [:val, '2']]]
+  end
+
+  it "1 = 1 AND \\\n 2 = 2" do
+    should eq \
+      [:and,
+        [:eq, [:val, '1'], [:val, '1']],
+        [:eq, [:val, '2'], [:val, '2']]]
+  end
+
+  it "1 = 1 AND \\ \n 2 = 2" do
+    should eq \
+      [:and,
+        [:eq, [:val, '1'], [:val, '1']],
+        [:eq, [:val, '2'], [:val, '2']]]
+  end
+
+  it "\\\n1 = 1 AND\\\n2 = 2" do
+    should eq \
+      [:and,
+        [:eq, [:val, '1'], [:val, '1']],
+        [:eq, [:val, '2'], [:val, '2']]]
+  end
+
+  it "\\\n1 = 1 AND\\\n2 = 2\\\n" do
+    should eq \
+      [:and,
+        [:eq, [:val, '1'], [:val, '1']],
+        [:eq, [:val, '2'], [:val, '2']]]
+  end
+end

data/spec/v1/parser/eq_spec.rb

@@ -0,0 +1,16 @@
+describe Travis::Conditions::V1::Parser, 'eq' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).eq }
+
+  it '=' do
+    should eq :eq
+  end
+
+  it '==' do
+    should eq :eq
+  end
+
+  it '!=' do
+    should eq :not_eq
+  end
+end

data/spec/v1/parser/in_list_spec.rb

@@ -0,0 +1,60 @@
+describe Travis::Conditions::V1::Parser, 'in_list' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).in_list('foo') }
+
+  it 'in (foo)' do
+    should eq [:in, 'foo', [[:val, 'foo']]]
+  end
+
+  it 'in (type)' do
+    should eq [:in, 'foo', [[:var, :type]]]
+  end
+
+  it 'in (env(foo))' do
+    should eq [:in, 'foo', [[:call, :env, [[:val, 'foo']]]]]
+  end
+
+  it 'in (env(env(foo)))' do
+    should eq [:in, 'foo', [[:call, :env, [[:call, :env, [[:val, 'foo']]]]]]]
+  end
+
+  it 'in ( foo,bar)' do
+    should eq [:in, 'foo', [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'in (foo, bar )' do
+    should eq [:in, 'foo', [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'in (foo ,bar)' do
+    should eq [:in, 'foo', [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'in ("foo")' do
+    should eq [:in, 'foo', [[:val, 'foo']]]
+  end
+
+  it 'not in (foo )' do
+    should eq [:not_in, 'foo', [[:val, 'foo']]]
+  end
+
+  it 'not in ( foo,bar)' do
+    should eq [:not_in, 'foo', [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'not in (foo, bar )' do
+    should eq [:not_in, 'foo', [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'not in (foo ,bar)' do
+    should eq [:not_in, 'foo', [[:val, 'foo'], [:val, 'bar']]]
+  end
+
+  it 'not in ("foo")' do
+    should eq [:not_in, 'foo', [[:val, 'foo']]]
+  end
+
+  it 'in ()' do
+    expect { subject }.to raise_error Travis::Conditions::ParseError, 'expected a list of values at position 4 in: "in ()"'
+  end
+end

data/spec/v1/parser/is_pred_spec.rb

@@ -0,0 +1,24 @@
+describe Travis::Conditions::V1::Parser, 'is_pred' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).is_pred(:type) }
+
+  it 'is  present' do
+    should eq [:is, :type, :present]
+  end
+
+  it 'is present' do
+    should eq [:is, :type, :present]
+  end
+
+  it 'IS present' do
+    should eq [:is, :type, :present]
+  end
+
+  it 'is blank' do
+    should eq [:is, :type, :blank]
+  end
+
+  it 'IS blank' do
+    should eq [:is, :type, :blank]
+  end
+end