travis-conditions 0.0.2 → 1.0.0

data/spec/v1/parser/list_spec.rb

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

data/spec/v1/parser/operand_spec.rb

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

data/spec/v1/parser/parens_spec.rb

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

data/spec/v1/parser/quoted_spec.rb

@@ -0,0 +1,24 @@
+describe Travis::Conditions::V1::Parser, 'quoted' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).quoted }
+
+  it "'foo'" do
+    should eq 'foo'
+  end
+
+  it '"foo"' do
+    should eq 'foo'
+  end
+
+  it "'\"foo\"'" do
+    should eq '"foo"'
+  end
+
+  it '"\'foo\'"' do
+    should eq "'foo'"
+  end
+
+  it '"&.foo bar!?"' do
+    should eq '&.foo bar!?'
+  end
+end

data/spec/v1/parser/re_spec.rb

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

data/spec/v1/parser/regex_spec.rb

@@ -0,0 +1,12 @@
+describe Travis::Conditions::V1::Parser, 'regex' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).regex }
+
+  it '^.*-bar$' do
+    should eq [:reg, '^.*-bar$']
+  end
+
+  it '/^.* bar$/' do
+    should eq [:reg, '^.* bar$']
+  end
+end

data/spec/v1/parser/space_spec.rb

@@ -0,0 +1,40 @@
+describe Travis::Conditions::V1::Parser, 'space' do
+  let(:str) { |e| e.description }
+
+  let(:subject) do
+    parser = described_class.new(str)
+    parser.space { parser.word }
+  end
+
+  it 'foo' do
+    should eq 'foo'
+  end
+
+  it ' foo' do
+    should eq 'foo'
+  end
+
+  it 'foo ' do
+    should eq 'foo'
+  end
+
+  it '  foo  ' do
+    should eq 'foo'
+  end
+
+  it "foo\t" do
+    should eq 'foo'
+  end
+
+  it "\tfoo" do
+    should eq 'foo'
+  end
+
+  it "foo\n" do
+    should eq 'foo'
+  end
+
+  it "\nfoo" do
+    should eq 'foo'
+  end
+end

data/spec/v1/parser/term_spec.rb

@@ -0,0 +1,84 @@
+describe Travis::Conditions::V1::Parser, 'term' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).term }
+
+  it 'type = "foo"' do
+    should eq [:eq, [:var, :type], [:val, 'foo']]
+  end
+
+  it '"foo" = type' do
+    should eq [:eq, [:val, 'foo'], [:var, :type]]
+  end
+
+  it 'type = env(foo)' do
+    should eq [:eq, [:var, :type], [:call, :env, [[:val, 'foo']]]]
+  end
+
+  it 'env(foo) = type' do
+    should eq [:eq, [:call, :env, [[:val, 'foo']]], [:var, :type]]
+  end
+
+  it '"foo" = env(foo)' do
+    should eq [:eq, [:val, 'foo'], [:call, :env, [[:val, 'foo']]]]
+  end
+
+  it 'env(foo) = "foo"' do
+    should eq [:eq, [:call, :env, [[:val, 'foo']]], [:val, 'foo']]
+  end
+
+  it 'type = type' do
+    should eq [:eq, [:var, :type], [:var, :type]]
+  end
+
+  it '"foo" = "foo"' do
+    should eq [:eq, [:val, 'foo'], [:val, 'foo']]
+  end
+
+  it 'env(foo) = env(bar)' do
+    should eq [:eq, [:call, :env, [[:val, 'foo']]], [:call, :env, [[:val, 'bar']]]]
+  end
+
+  it 'tag =~ foo' do
+    should eq [:match, [:var, :tag], [:reg, 'foo']]
+  end
+
+  it 'tag =~ /foo/' do
+    should eq [:match, [:var, :tag], [:reg, 'foo']]
+  end
+
+  it 'tag =~ env(foo)' do
+    should eq [:match, [:var, :tag], [:reg, [:call, :env, [[:val, 'foo']]]]]
+  end
+
+  it 'tag =~ concat(^foo-, env(foo))' do
+    should eq [:match, [:var, :tag], [:reg, [:call, :concat, [[:val, "^foo-"], [:call, :env, [[:val, 'foo']]]]]]]
+  end
+
+  it 'type IN (foo)' do
+    should eq [:in, [:var, :type], [[:val, 'foo']]]
+  end
+
+  it '"foo" IN (foo)' do
+    should eq [:in, [:val, 'foo'], [[:val, 'foo']]]
+  end
+
+  it 'env(foo) IN (foo)' do
+    should eq [:in, [:call, :env, [[:val, 'foo']]], [[:val, 'foo']]]
+  end
+
+  it 'type IS present' do
+    should eq [:is, [:var, :type], :present]
+  end
+
+  it '"foo" IS present' do
+    should eq [:is, [:val, 'foo'], :present]
+  end
+
+  it 'env(foo) IS present' do
+    should eq [:is, [:call, :env, [[:val, 'foo']]], :present]
+  end
+
+  it 'sender = sender-foo' do
+    should eq [:eq, [:var, :sender], [:val, 'sender-foo']]
+  end
+end

data/spec/v1/parser/val_spec.rb

@@ -0,0 +1,24 @@
+describe Travis::Conditions::V1::Parser, 'val' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).val }
+
+  it 'foo' do
+    should eq [:val, 'foo']
+  end
+
+  it '"foo"' do
+    should eq [:val, 'foo']
+  end
+
+  it "'foo'" do
+    should eq [:val, 'foo']
+  end
+
+  it 'typescript' do
+    should eq [:val, 'typescript']
+  end
+
+  it 'sender-foo' do
+    should eq [:val, 'sender-foo']
+  end
+end

data/spec/v1/parser/var_spec.rb

@@ -0,0 +1,16 @@
+describe Travis::Conditions::V1::Parser, 'var' do
+  let(:str) { |e| e.description }
+  let(:subject) { described_class.new(str).var }
+
+  it 'type' do
+    should eq [:var, :type]
+  end
+
+  it 'repo' do
+    should eq [:var, :repo]
+  end
+
+  it 'nope' do
+    should be_nil
+  end
+end

data/spec/v1/parser_spec.rb

@@ -0,0 +1,486 @@
+describe Travis::Conditions::V1::Parser do
+  let(:str)     { |e| e.description }
+  let(:subject) { described_class.new(str).parse }
+
+  # single term
+
+  it '1' do
+    should eq \
+      [:val, '1']
+  end
+
+  it 'true' do
+    should eq \
+      [:val, 'true']
+  end
+
+  it 'type' do
+    should eq \
+      [:var, :type]
+  end
+
+  it 'env(FOO)' do
+    should eq \
+      [:call, :env, [[:val, 'FOO']]]
+  end
+
+  # one operand
+
+  it '1=1' do
+    should eq \
+      [:eq, [:val, '1'], [:val, '1']]
+  end
+
+  it 'true=true' do
+    should eq \
+      [:eq, [:val, 'true'], [:val, 'true']]
+  end
+
+  it 'true!=false' do
+    should eq \
+      [:not_eq, [:val, 'true'], [:val, 'false']]
+  end
+
+  it '1 = 1' do
+    should eq \
+      [:eq, [:val, '1'], [:val, '1']]
+  end
+
+  it 'true = true' do
+    should eq \
+      [:eq, [:val, 'true'], [:val, 'true']]
+  end
+
+  it 'type = foo' do
+    should eq \
+      [:eq, [:var, :type], [:val, 'foo']]
+  end
+
+  it '(type = foo)' do
+    should eq \
+      [:eq, [:var, :type], [:val, 'foo']]
+  end
+
+  # two operands
+
+  it 'type = foo OR type = bar' do
+    should eq \
+      [:or,
+        [:eq, [:var, :type], [:val, 'foo']],
+        [:eq, [:var, :type], [:val, 'bar']]]
+  end
+
+  it '(type = foo OR type = bar)' do
+    should eq \
+      [:or,
+        [:eq, [:var, :type], [:val, 'foo']],
+        [:eq, [:var, :type], [:val, 'bar']]]
+  end
+
+  # three operands
+
+  it 'type = foo OR type = bar OR type = baz' do
+    should eq \
+      [:or,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it 'type = foo AND type = bar OR type = baz' do
+    should eq \
+      [:or,
+        [:and,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it 'type = foo OR type = bar AND type = baz' do
+    should eq \
+      [:or,
+        [:eq, [:var, :type], [:val, 'foo']],
+        [:and,
+          [:eq, [:var, :type], [:val, 'bar']],
+          [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it 'type = foo AND type = bar AND type = baz' do
+    should eq \
+      [:and,
+        [:and,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it '(type = foo OR type = bar OR type = baz)' do
+    should eq \
+      [:or,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it '(type = foo OR type = bar) AND type = baz' do
+    should eq \
+      [:and,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it 'type = foo AND (type = bar OR type = baz)' do
+    should eq \
+      [:and,
+        [:eq, [:var, :type], [:val, 'foo']],
+        [:or,
+          [:eq, [:var, :type], [:val, 'bar']],
+          [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  # four operands
+
+  it '(type = foo OR type = bar) AND (type = baz OR type = buz)' do
+    should eq \
+      [:and,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:or,
+          [:eq, [:var, :type], [:val, 'baz']],
+          [:eq, [:var, :type], [:val, 'buz']]]]
+  end
+
+  it 'type = foo AND (type = bar OR type = baz) AND type = buz' do
+    should eq \
+      [:and,
+        [:and,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:or,
+            [:eq, [:var, :type], [:val, 'bar']],
+            [:eq, [:var, :type], [:val, 'baz']]]],
+        [:eq, [:var, :type], [:val, 'buz']]]
+  end
+
+  it 'type = foo AND (type = bar OR type = baz OR type = buz)' do
+    should eq \
+      [:and,
+        [:eq, [:var, :type], [:val, 'foo']],
+        [:or,
+          [:or,
+            [:eq, [:var, :type], [:val, 'bar']],
+            [:eq, [:var, :type], [:val, 'baz']]],
+          [:eq, [:var, :type], [:val, 'buz']]]]
+  end
+
+  it '(type = foo AND (type = bar OR type = baz)) OR type = buz' do
+    should eq \
+      [:or,
+        [:and,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:or,
+            [:eq, [:var, :type], [:val, 'bar']],
+            [:eq, [:var, :type], [:val, 'baz']]]],
+        [:eq, [:var, :type], [:val, 'buz']]]
+  end
+
+  # one operand negated
+
+  it 'NOT type = foo' do
+    should eq \
+      [:not, [:eq, [:var, :type], [:val, 'foo']]]
+  end
+
+  # two operands negated
+
+  it 'NOT type = foo OR type = bar' do
+    should eq \
+      [:or,
+        [:not, [:eq, [:var, :type], [:val, 'foo']]],
+        [:eq, [:var, :type], [:val, 'bar']]]
+  end
+
+  it 'type = foo OR NOT type = bar' do
+    should eq \
+      [:or,
+        [:eq, [:var, :type], [:val, 'foo']],
+        [:not, [:eq, [:var, :type], [:val, 'bar']]]]
+  end
+
+  it 'NOT type = foo OR NOT type = bar' do
+    should eq \
+      [:or,
+        [:not, [:eq, [:var, :type], [:val, 'foo']]],
+        [:not, [:eq, [:var, :type], [:val, 'bar']]]]
+  end
+
+  it 'NOT (type = foo OR type = bar)' do
+    should eq \
+      [:not,
+        [:or, [:eq, [:var, :type], [:val, 'foo']],
+        [:eq, [:var, :type], [:val, 'bar']]]]
+  end
+
+  # three operands negated
+
+  it 'NOT type = foo OR type = bar OR type = baz' do
+    should eq \
+      [:or,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it '(NOT type = foo OR type = bar OR type = baz)' do
+    should eq \
+      [:or,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it 'type = foo OR NOT type = bar OR type = baz' do
+    should eq \
+      [:or,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it '(type = foo OR NOT type = bar OR type = baz)' do
+    should eq \
+      [:or,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it 'type = foo OR type = bar OR NOT type = baz' do
+    should eq \
+      [:or,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it '(type = foo OR type = bar OR NOT type = baz)' do
+    should eq \
+      [:or,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it 'NOT type = foo OR NOT type = bar OR type = baz' do
+    should eq \
+      [:or,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it '(NOT type = foo OR NOT type = bar OR type = baz)' do
+    should eq \
+      [:or,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it 'NOT type = foo OR type = bar OR NOT type = baz' do
+    should eq \
+      [:or,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it '(NOT type = foo OR type = bar OR NOT type = baz)' do
+    should eq \
+      [:or,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it 'type = foo OR NOT type = bar OR NOT type = baz' do
+    should eq \
+      [:or,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it '(type = foo OR NOT type = bar OR NOT type = baz)' do
+    should eq \
+      [:or,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it 'NOT type = foo OR NOT type = bar OR NOT type = baz' do
+    should eq \
+      [:or,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it '(NOT type = foo OR NOT type = bar OR NOT type = baz)' do
+    should eq \
+      [:or,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+         [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it 'NOT (type = foo OR type = bar OR type = baz)' do
+    should eq \
+      [:not,
+        [:or,
+          [:or,
+            [:eq, [:var, :type], [:val, 'foo']],
+            [:eq, [:var, :type], [:val, 'bar']]],
+          [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it 'NOT (type = foo OR type = bar) AND type = baz' do
+    should eq \
+      [:and,
+        [:not,
+          [:or,
+            [:eq, [:var, :type], [:val, 'foo']],
+            [:eq, [:var, :type], [:val, 'bar']]]],
+        [:eq, [:var, :type], [:val, 'baz']]]
+  end
+
+  it '(type = foo OR type = bar) AND NOT type = baz' do
+    should eq \
+      [:and,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:eq, [:var, :type], [:val, 'bar']]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it 'NOT (type = foo OR type = bar) AND NOT type = baz' do
+    should eq \
+      [:and,
+        [:not,
+          [:or,
+            [:eq, [:var, :type], [:val, 'foo']],
+            [:eq, [:var, :type], [:val, 'bar']]]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it '(NOT type = foo OR type = bar) AND NOT type = baz' do
+    should eq \
+      [:and,
+        [:or,
+           [:not, [:eq, [:var, :type], [:val, 'foo']]],
+           [:eq, [:var, :type], [:val, 'bar']]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  it '(type = foo OR NOT type = bar) AND NOT type = baz' do
+    should eq \
+      [:and,
+        [:or,
+          [:eq, [:var, :type], [:val, 'foo']],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:not, [:eq, [:var, :type], [:val, 'baz']]]]
+  end
+
+  # four operands negated
+
+  it 'NOT (type = foo OR type = bar) AND NOT (type = baz OR type = buz)' do
+    should eq \
+      [:and,
+        [:not,
+          [:or,
+            [:eq, [:var, :type], [:val, 'foo']],
+            [:eq, [:var, :type], [:val, 'bar']]]],
+        [:not,
+          [:or,
+            [:eq, [:var, :type], [:val, 'baz']],
+            [:eq, [:var, :type], [:val, 'buz']]]]]
+  end
+
+  it '(NOT type = foo OR NOT type = bar) AND (NOT type = baz OR NOT type = buz)' do
+    should eq \
+      [:and,
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'foo']]],
+          [:not, [:eq, [:var, :type], [:val, 'bar']]]],
+        [:or,
+          [:not, [:eq, [:var, :type], [:val, 'baz']]],
+          [:not, [:eq, [:var, :type], [:val, 'buz']]]]]
+  end
+
+  it 'NOT type = foo AND NOT (type = bar OR type = baz) AND NOT type = buz' do
+    should eq \
+      [:and,
+        [:and,
+          [:not,
+            [:eq, [:var, :type], [:val, 'foo']]],
+          [:not,
+            [:or,
+              [:eq, [:var, :type], [:val, 'bar']],
+              [:eq, [:var, :type], [:val, 'baz']]]]],
+        [:not, [:eq, [:var, :type], [:val, 'buz']]]]
+  end
+
+  it 'NOT type = foo AND (NOT type = bar OR NOT type = baz) AND NOT type = buz' do
+    should eq \
+      [:and,
+        [:and,
+          [:not,
+            [:eq, [:var, :type], [:val, 'foo']]],
+          [:or,
+            [:not, [:eq, [:var, :type], [:val, 'bar']]],
+            [:not, [:eq, [:var, :type], [:val, 'baz']]]]],
+        [:not, [:eq, [:var, :type], [:val, 'buz']]]]
+  end
+
+  it 'NOT (NOT type = foo AND NOT (NOT type = bar OR NOT type = baz)) OR NOT type = buz' do
+    should eq \
+      [:or,
+        [:not,
+          [:and,
+            [:not,
+              [:eq, [:var, :type], [:val, 'foo']]],
+            [:not,
+              [:or,
+                [:not, [:eq, [:var, :type], [:val, 'bar']]],
+                [:not, [:eq, [:var, :type], [:val, 'baz']]]]]]],
+        [:not,
+          [:eq, [:var, :type], [:val, 'buz']]]]
+  end
+
+  it 'branch = $FOO' do
+    expect { subject }.to raise_error(Travis::Conditions::ParseError)
+  end
+
+  it '$FOO = bar' do
+    expect { subject }.to raise_error(Travis::Conditions::ParseError)
+  end
+end