travis-conditions 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c260f529b4432a50705b9296e7f5bff49fdb199a
+  data.tar.gz: 75623d8e139dcd3c7b34e152a72e80d7b49ffeb7
+SHA512:
+  metadata.gz: 14a0df58f59d5d04c76830f506c4f080e3b50c6fa0b95d21612786a25c499f7fc64526792983b544b85bb5e260adf3ecaac40bc6a8a772dbe23e718db3c287f6
+  data.tar.gz: 1a4f2b466d2c85c858d018a88dd2bfdd02f973756d880ffa69d058a6724ddaf4606cd0fbed7e48846b31d48b7d437a97af040e7103bdc6718c64c88672940e60

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'parslet'
+
+group :test do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    parslet (1.8.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  parslet
+  rspec
+
+BUNDLED WITH
+   1.15.4

data/README.md

@@ -0,0 +1,46 @@
+# Boolean language for conditional builds, stages, jobs (draft)
+
+```
+(NOT [term] OR [term]) AND [term]
+```
+
+A term can be can be:
+
+#### Equality
+
+```
+branch = master
+env(foo) = bar
+```
+
+#### Match
+
+```
+branch =~ ^master$
+env(foo) =~ ^bar$
+```
+
+#### Include
+
+```
+branch IN (master, dev)
+env(foo) IN (bar, baz)
+```
+
+#### Presence
+
+```
+branch IS present
+branch IS blank
+env(foo) IS present
+env(foo) IS blank
+```
+
+## Usage
+
+```ruby
+str  = 'branch IN (foo, bar) AND env(baz) =~ ^baz- OR tag IS present'
+data = { branch: 'foo', env: { baz: 'baz-1' }, tag: 'v.1.0.0' }
+Travis::Conditions.apply(str, data)
+# => true
+```

data/lib/travis/conditions.rb

@@ -0,0 +1,26 @@
+require 'travis/conditions/data'
+require 'travis/conditions/eval'
+require 'travis/conditions/parser'
+
+module Travis
+  module Conditions
+    class << self
+      def eval(str, data)
+        Eval.new(parse(str, keys: data.keys), Data.new(data)).apply
+      end
+
+      def parse(str, opts = {})
+        tree = parser(opts).parse(str)
+        Transform.new.apply(tree)
+      end
+
+      def parser(opts)
+        parsers[opts] ||= Parser.new(opts)
+      end
+
+      def parsers
+        @parsers ||= {}
+      end
+    end
+  end
+end

data/lib/travis/conditions/data.rb

@@ -0,0 +1,45 @@
+module Travis
+  module Conditions
+    class Data < Struct.new(:data)
+      def initialize(data)
+        data = symbolize(data)
+        data[:env] = symbolize(to_h(data[:env] || {}))
+        super(data)
+      end
+
+      def [](key)
+        data[key.to_sym]
+      end
+
+      def env(key)
+        data.fetch(:env, {})[key.to_sym]
+      end
+
+      private
+
+        def to_h(obj)
+          case obj
+          when Hash
+            obj
+          else
+            Array(obj).map { |value| split(value.to_s) }.to_h
+          end
+        end
+
+        def split(str)
+          str.split('=', 2)
+        end
+
+        def symbolize(value)
+          case value
+          when Hash
+            value.map { |key, value| [key.to_sym, symbolize(value)] }.to_h
+          when Array
+            value.map { |value| symbolize(value) }
+          else
+            value
+          end
+        end
+    end
+  end
+end

data/lib/travis/conditions/eval.rb

@@ -0,0 +1,68 @@
+module Travis
+  module Conditions
+    class Eval < Struct.new(:sexp, :data)
+      def apply
+        !!evl(sexp)
+      end
+
+      private
+
+        def evl(value)
+          case value
+          when Array
+            send(*value)
+          else
+            data[value]
+          end
+        end
+
+        def not(lft)
+          !evl(lft)
+        end
+
+        def or(lft, rgt)
+          evl(lft) || evl(rgt)
+        end
+
+        def and(lft, rgt)
+          evl(lft) && evl(rgt)
+        end
+
+        def eq(lft, rgt)
+          evl(lft) == rgt
+        end
+
+        def not_eq(lft, rgt)
+          not eq(lft, rgt)
+        end
+
+        def match(lft, rgt)
+          evl(lft) =~ Regexp.new(rgt)
+        end
+
+        def not_match(lft, rgt)
+          not match(lft, rgt)
+        end
+
+        def in(lft, rgt)
+          rgt.include?(evl(lft))
+        end
+
+        def is(lft, rgt)
+          send(rgt, evl(lft))
+        end
+
+        def env(key)
+          data.env(key)
+        end
+
+        def present(value)
+          value.respond_to?(:empty?) && !value.empty?
+        end
+
+        def blank(value)
+          !present(value)
+        end
+    end
+  end
+end

data/lib/travis/conditions/parser.rb

@@ -0,0 +1,202 @@
+require 'parslet'
+
+module Travis
+  module Conditions
+    class Parser < Struct.new(:opts)
+      FUNCS    = %w(env)
+      PRESENCE = %w(present blank)
+
+      def parse(str)
+        parser.parse(str)
+      end
+
+      private
+
+        def parser
+          @parser ||= define_parser(opts[:keys]).new
+        end
+
+        def define_parser(keywords)
+          Class.new(Parslet::Parser) do
+            root :expr_or
+
+            rule :expr_or  do
+              spaced(expr_and.as(:lft), op_or, expr_or.as(:rgt)).as(:or) | expr_and
+            end
+
+            rule :expr_and do
+              spaced(expr_inner.as(:lft), op_and, expr_and.as(:rgt)).as(:and) | expr_inner
+            end
+
+            rule :expr_inner do
+              lnot(parens(expr_or) | expr_incl | expr_is | expr_regex | expr_cmp)
+            end
+
+            rule :expr_cmp do
+              spaced(lhs.as(:lft), op_cmp.as(:op), value.as(:rgt)).as(:cmp)
+            end
+
+            rule :expr_regex do
+              spaced(lhs.as(:lft), op_regex.as(:op), regex.as(:rgt)).as(:cmp)
+            end
+
+            rule :expr_incl do
+              spaced(lhs.as(:lft), op_incl, parens(list).as(:rgt)).as(:incl)
+            end
+
+            rule :expr_is do
+              spaced(lhs.as(:lft), op_is, presence.as(:rgt)).as(:is)
+            end
+
+            def lnot(node)
+              (stri('not').maybe >> space >> node.as(:rgt)).as(:not) | node
+            end
+
+            rule :list do
+              (value >> (ts(str(',')) >> value).repeat)
+            end
+
+            rule :lhs do
+              func | keyword
+            end
+
+            rule :keyword do
+              stris(*keywords)
+            end
+
+            rule :func do
+              (stris(*FUNCS).as(:name) >> parens(word)).as(:func)
+            end
+
+            rule :word do
+              match('[\w_\-]').repeat(1).as(:str)
+            end
+
+            rule :regex do
+              quoted('/') | match('[\S]').repeat(1).as(:str)
+            end
+
+            rule :value do
+              unquoted | quoted('"') | quoted("'")
+            end
+
+            rule :unquoted do
+              match('[^\s\"\'\(\),]').repeat(1).as(:str)
+            end
+
+            def quoted(chr)
+              str(chr) >> match("[^#{chr}]").repeat.as(:str) >> str(chr)
+            end
+
+            rule :presence do
+              (stris(*PRESENCE)).as(:str)
+            end
+
+            rule :op_is do
+              stri('is')
+            end
+
+            rule :op_cmp do
+              str('=') | str('!=')
+            end
+
+            rule :op_regex do
+              str('=~') | str('!~')
+            end
+
+            rule :op_incl do
+              stri('in')
+            end
+
+            rule :op_or do
+              stri('or')
+            end
+
+            rule :op_and do
+              stri('and')
+            end
+
+            rule :space do
+              match('\s').repeat(1)
+            end
+
+            rule :space? do
+              space.maybe
+            end
+
+            def stris(*strs)
+              strs.inject(stri(strs.shift)) { |node, str| node | stri(str) }
+            end
+
+            def stri(str)
+              str(str) | str(str.upcase)
+            end
+
+            def parens?(node)
+              spaced?(str('(').maybe, node, str(')').maybe)
+            end
+
+            def parens(node)
+              spaced?(str('('), node, str(')'))
+            end
+
+            def spaced?(*nodes)
+              nodes.zip([space?] * nodes.size).flatten[0..-2].inject(&:>>)
+            end
+
+            def spaced(*nodes)
+              # nodes.zip([space] * nodes.size).flatten[0..-2].inject(&:>>)
+              nodes.zip([space?] * nodes.size).flatten[0..-2].inject(&:>>)
+            end
+
+            def ls(node)
+              space? >> node
+            end
+
+            def ts(node)
+              node >> space?
+            end
+          end
+      end
+    end
+
+    class Transform < Parslet::Transform
+      OP = {
+        '='  => :eq,
+        '!=' => :not_eq,
+        '=~' => :match,
+        '!~' => :not_match,
+      }
+
+      str  = ->(node) { node.is_a?(Hash) ? node[:str].to_s : node.to_s }
+      sym  = ->(node) { str.(node).downcase.to_sym }
+      func = ->(node) { [sym.(node[:func][:name]), str.(node[:func])] }
+      list = ->(node) { node.is_a?(Array) ? node.map { |v| str.(v) } : [str.(node)] }
+      lhs  = ->(node) { node.is_a?(Hash) && node.key?(:func) ? func.(node) : str.(node) }
+
+      rule not: { rgt: subtree(:rgt) } do
+        [:not, rgt]
+      end
+
+      rule or: { lft: subtree(:lft), rgt: subtree(:rgt) } do
+        [:or, lft, rgt]
+      end
+
+      rule and: { lft: subtree(:lft), rgt: subtree(:rgt) } do
+        [:and, lft, rgt]
+      end
+
+      rule cmp: { op: simple(:op), lft: subtree(:lft), rgt: subtree(:rgt) } do
+        [OP[op.to_s], lhs.(lft), str.(rgt)]
+      end
+
+      rule incl: { lft: subtree(:lft), rgt: subtree(:rgt) } do
+        [:in, lhs.(lft), list.(rgt)]
+      end
+
+      rule is: { lft: subtree(:lft), rgt: subtree(:rgt) } do
+        [:is, lhs.(lft), sym.(rgt)]
+      end
+    end
+  end
+end

data/lib/travis/conditions/version.rb

@@ -0,0 +1,5 @@
+module Travis
+  module Conditions
+    VERSION = '0.0.1'
+  end
+end

data/spec/data_spec.rb

@@ -0,0 +1,20 @@
+describe Travis::Conditions::Data do
+  let(:env)  { nil }
+  let(:data) { { branch: 'branch', env: env } }
+  subject { described_class.new(data) }
+
+  it { expect(subject[:branch]).to eq 'branch' }
+  it { expect(subject['branch']).to eq 'branch' }
+
+  describe 'given an env hash' do
+    let(:env) { { foo: 'FOO' } }
+    it { expect(subject.env(:foo)).to eq 'FOO' }
+    it { expect(subject.env('foo')).to eq 'FOO' }
+  end
+
+  describe 'given an env array' do
+    let(:env) { ['foo=FOO'] }
+    it { expect(subject.env(:foo)).to eq 'FOO' }
+    it { expect(subject.env('foo')).to eq 'FOO' }
+  end
+end

data/spec/eval_spec.rb

@@ -0,0 +1,148 @@
+describe Travis::Conditions, 'eval' do
+  let(:tag)  { nil }
+  let(:data) { { branch: 'master', tag: tag, env: { foo: 'foo' } } }
+  subject { described_class.eval(str, data) }
+
+  describe 'expressions' do
+    context do
+      let(:str) { 'NOT branch = foo AND (env(foo) = foo OR tag = wat)' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'branch = foo OR env(foo) = foo AND NOT tag = wat' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'branch = foo OR env(foo) = foo AND tag = wat' }
+      it { should be false }
+    end
+
+    context do
+      let(:tag) { '0.0.1' }
+      let(:str) { 'tag =~ /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?(?:\.(0|[1-9]\d*))?(?:-([\w.-]+))?(?:\+([\w.-]+))?$ AND type IN (push, api)/' }
+      it { should be false }
+    end
+  end
+
+  describe 'eq' do
+    context do
+      let(:str) { 'branch = master' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'branch = foo' }
+      it { should be false }
+    end
+
+    context do
+      let(:str) { 'env(foo) = foo' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'env(foo) = bar' }
+      it { should be false }
+    end
+  end
+
+  describe 'not eq' do
+    context do
+      let(:str) { 'branch != master' }
+      it { should be false }
+    end
+
+    context do
+      let(:str) { 'branch != foo' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'env(foo) != foo' }
+      it { should be false }
+    end
+
+    context do
+      let(:str) { 'env(foo) != bar' }
+      it { should be true }
+    end
+  end
+
+  describe 'match' do
+    context do
+      let(:str) { 'branch =~ ^ma.*$' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'branch =~ ^foo.*$' }
+      it { should be false }
+    end
+
+    context do
+      let(:str) { 'env(foo) =~ ^foo.*$' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'env(foo) =~ ^bar.*$' }
+      it { should be false }
+    end
+  end
+
+  describe 'in' do
+    context do
+      let(:str) { 'branch IN (foo, master, bar)' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'branch IN (foo, bar)' }
+      it { should be false }
+    end
+
+    context do
+      let(:str) { 'env(foo) IN (foo, bar, baz)' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'env(foo) IN (bar, baz)' }
+      it { should be false }
+    end
+  end
+
+  describe 'is' do
+    context do
+      let(:str) { 'branch IS present' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'tag IS present' }
+      it { should be false }
+    end
+
+    context do
+      let(:str) { 'branch IS blank' }
+      it { should be false }
+    end
+
+    context do
+      let(:str) { 'tag IS blank' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'env(foo) IS present' }
+      it { should be true }
+    end
+
+    context do
+      let(:str) { 'env(bar) IS blank' }
+      it { should be true }
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,275 @@
+describe Travis::Conditions do
+  let(:keys) { [:foo] }
+  subject { described_class.parse(str, keys: keys) }
+
+  describe 'eq' do
+    context do
+      let(:str) { 'foo = bar' }
+      it { should eq [:eq, 'foo', 'bar'] }
+    end
+
+    context do
+      let(:str) { 'foo =bar' }
+      it { should eq [:eq, 'foo', 'bar'] }
+    end
+
+    context do
+      let(:str) { 'foo= bar' }
+      it { should eq [:eq, 'foo', 'bar'] }
+    end
+
+    context do
+      let(:str) { 'foo=bar' }
+      it { should eq [:eq, 'foo', 'bar'] }
+    end
+
+    context do
+      let(:str) { 'foo = "bar baz"' }
+      it { should eq [:eq, 'foo', 'bar baz'] }
+    end
+
+    context do
+      let(:str) { 'foo="bar baz"' }
+      it { should eq [:eq, 'foo', 'bar baz'] }
+    end
+
+    context do
+      let(:str) { 'env(foo) = "bar baz"' }
+      it { should eq [:eq, [:env, 'foo'], 'bar baz'] }
+    end
+
+    context do
+      let(:str) { 'foo = true' }
+      it { should eq [:eq, 'foo', 'true'] }
+    end
+  end
+
+  describe 'not eq' do
+    context do
+      let(:str) { 'foo != bar' }
+      it { should eq [:not_eq, 'foo', 'bar'] }
+    end
+
+    context do
+      let(:str) { 'foo !=bar' }
+      it { should eq [:not_eq, 'foo', 'bar'] }
+    end
+
+    context do
+      let(:str) { 'foo!= bar' }
+      it { should eq [:not_eq, 'foo', 'bar'] }
+    end
+
+    context do
+      let(:str) { 'foo!=bar' }
+      it { should eq [:not_eq, 'foo', 'bar'] }
+    end
+
+    context do
+      let(:str) { 'foo != "bar baz"' }
+      it { should eq [:not_eq, 'foo', 'bar baz'] }
+    end
+
+    context do
+      let(:str) { 'foo!="bar baz"' }
+      it { should eq [:not_eq, 'foo', 'bar baz'] }
+    end
+
+    context do
+      let(:str) { 'env(foo) != "bar baz"' }
+      it { should eq [:not_eq, [:env, 'foo'], 'bar baz'] }
+    end
+  end
+
+  describe 'match' do
+    context do
+      let(:str) { 'foo =~ ^v[0-9]$' }
+      it { should eq [:match, 'foo', '^v[0-9]$'] }
+    end
+
+    context do
+      let(:str) { 'env(foo) =~ ^v[0-9]$' }
+      it { should eq [:match, [:env, 'foo'], '^v[0-9]$'] }
+    end
+
+    context do
+      let(:str) { 'foo =~ /^v[0-9]$/' }
+      it { should eq [:match, 'foo', '^v[0-9]$'] }
+    end
+
+    context do
+      let(:str) { 'NOT (foo =~ /^v[0-9]$/)' }
+      it { should eq [:not, [:match, 'foo', '^v[0-9]$']] }
+    end
+  end
+
+  describe 'not match' do
+    context do
+      let(:str) { 'foo !~ ^v[0-9]$' }
+      it { should eq [:not_match, 'foo', '^v[0-9]$'] }
+    end
+
+    context do
+      let(:str) { 'env(foo) !~ ^v[0-9]$' }
+      it { should eq [:not_match, [:env, 'foo'], '^v[0-9]$'] }
+    end
+  end
+
+  describe 'in' do
+    context do
+      let(:str) { 'foo IN (bar)' }
+      it { should eq [:in, 'foo', ['bar']] }
+    end
+
+    context do
+      let(:str) { 'foo IN (bar, baz, buz)' }
+      it { should eq [:in, 'foo', ['bar', 'baz', 'buz']] }
+    end
+
+    context do
+      let(:str) { 'foo IN (bar, "baz, buz")' }
+      it { should eq [:in, 'foo', ['bar', 'baz, buz']] }
+    end
+
+    context do
+      let(:str) { 'env(foo) IN (bar, "baz, buz")' }
+      it { should eq [:in, [:env, 'foo'], ['bar', 'baz, buz']] }
+    end
+  end
+
+  describe 'is' do
+    context do
+      let(:str) { 'foo IS present' }
+      it { should eq [:is, 'foo', :present] }
+    end
+
+    context do
+      let(:str) { 'foo IS PRESENT' }
+      it { should eq [:is, 'foo', :present] }
+    end
+
+    context do
+      let(:str) { 'foo IS blank' }
+      it { should eq [:is, 'foo', :blank] }
+    end
+
+    context do
+      let(:str) { 'foo IS BLANK' }
+      it { should eq [:is, 'foo', :blank] }
+    end
+
+    context do
+      let(:str) { 'env(foo) IS BLANK' }
+      it { should eq [:is, [:env, 'foo'], :blank] }
+    end
+  end
+
+  describe 'boolean' do
+    let(:keys) { [:a, :b, :c, :d] }
+
+    context do
+      let(:str) { 'a=1 OR b=2 AND c=3 OR d=4' }
+      it { should eq [:or, [:eq, 'a', '1'], [:or, [:and, [:eq, 'b', '2'], [:eq, 'c', '3']], [:eq, 'd', '4']]] }
+    end
+
+    context do
+      let(:str) { '(a=1) OR (b=2) AND (c=3) OR (d=4)' }
+      it { should eq [:or, [:eq, 'a', '1'], [:or, [:and, [:eq, 'b', '2'], [:eq, 'c', '3']], [:eq, 'd', '4']]] }
+    end
+
+    context do
+      let(:str) { '(a=1 OR b=2) AND (c=3 OR d=4)' }
+      it { should eq [:and, [:or, [:eq, 'a', '1'], [:eq, 'b', '2']], [:or, [:eq, 'c', '3'], [:eq, 'd', '4']]] }
+    end
+
+    context do
+      let(:str) { 'env(a)=1 OR env(b)=2 AND c=3' }
+      it { should eq [:or, [:eq, [:env, 'a'], '1'], [:and, [:eq, [:env, 'b'], '2'], [:eq, 'c', '3']]] }
+    end
+
+    context do
+      let(:str) { '(env(a)=1) OR (env(b)=2) AND (c=3)' }
+      it { should eq [:or, [:eq, [:env, 'a'], '1'], [:and, [:eq, [:env, 'b'], '2'], [:eq, 'c', '3']]] }
+    end
+
+    context do
+      let(:str) { '(env(a)=1 OR env(b)=2) AND c=3' }
+      it { should eq [:and, [:or, [:eq, [:env, 'a'], '1'], [:eq, [:env, 'b'], '2']], [:eq, 'c', '3']] }
+    end
+
+    context do
+      let(:str) { 'a IN (1) OR b IN (2) AND c IN (3)' }
+      it { should eq [:or, [:in, 'a', ['1']], [:and, [:in, 'b', ['2']], [:in, 'c', ['3']]]] }
+    end
+
+    context do
+      let(:str) { '(a IN (1) OR b IN (2)) AND (c IN (3))' }
+      it { should eq [:and, [:or, [:in, 'a', ['1']], [:in, 'b', ['2']]], [:in, 'c', ['3']]] }
+    end
+
+    context do
+      let(:str) { 'a IS present OR b IS blank AND c IS present' }
+      it { should eq [:or, [:is, 'a', :present], [:and, [:is, 'b', :blank], [:is, 'c', :present]]] }
+    end
+
+    context do
+      let(:str) { '(a IS present OR (b IS blank)) AND (c IS present)' }
+      it { should eq [:and, [:or, [:is, 'a', :present], [:is, 'b', :blank]], [:is, 'c', :present]] }
+    end
+
+    context do
+      let(:str) { 'NOT a=1' }
+      it { should eq [:not, [:eq, 'a', '1']] }
+    end
+
+    context do
+      let(:str) { 'NOT (a=1)' }
+      it { should eq [:not, [:eq, 'a', '1']] }
+    end
+
+    context do
+      let(:str) { 'NOT a=1 OR b=2' }
+      it { should eq [:or, [:not, [:eq, 'a', '1']], [:eq, 'b', '2']] }
+    end
+
+    context do
+      let(:str) { 'NOT (a=1 OR b=2)' }
+      it { should eq [:not, [:or, [:eq, 'a', '1'], [:eq, 'b', '2']]] }
+    end
+
+    context do
+      let(:str) { 'NOT a=1 OR NOT b=2' }
+      it { should eq [:or, [:not, [:eq, 'a', '1']], [:not, [:eq, 'b', '2']]] }
+    end
+
+    context do
+      let(:str) { 'NOT a=1 AND b=2' }
+      it { should eq [:and, [:not, [:eq, 'a', '1']], [:eq, 'b', '2']] }
+    end
+
+    context do
+      let(:str) { 'NOT (a=1 OR b=2)' }
+      it { should eq [:not, [:or, [:eq, 'a', '1'], [:eq, 'b', '2']]] }
+    end
+
+    context do
+      let(:str) { 'NOT (NOT (a=1) OR b=2) AND NOT (c=3) OR d=4' }
+      it { should eq [:or, [:and, [:not, [:or, [:not, [:eq, 'a', '1']], [:eq, 'b', '2']]], [:not, [:eq, 'c', '3']]], [:eq, 'd', '4']] }
+    end
+
+    context do
+      let(:str) { 'NOT env(a)=1' }
+      it { should eq [:not, [:eq, [:env, 'a'], '1']] }
+    end
+
+    context do
+      let(:str) { 'NOT (env(a)=1)' }
+      it { should eq [:not, [:eq, [:env, 'a'], '1']] }
+    end
+
+    context do
+      let(:str) { 'NOT (env(a)=1 OR env(b)=2)' }
+      it { should eq [:not, [:or, [:eq, [:env, 'a'], '1'],[:eq, [:env, 'b'], '2']]] }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'travis/conditions'

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: travis-conditions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Travis CI
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: contact@travis-ci.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/travis/conditions.rb
+- lib/travis/conditions/data.rb
+- lib/travis/conditions/eval.rb
+- lib/travis/conditions/parser.rb
+- lib/travis/conditions/version.rb
+- spec/data_spec.rb
+- spec/eval_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/travis-ci/travis-conditions
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Boolean language for conditional builds, stages, jobs
+test_files: []