travis-conditions 0.0.2 → 1.0.0

data/spec/v1/user_spec.rb

@@ -0,0 +1,223 @@
+# notes
+#
+# people seem to be confusing `=` (equality) with `IS` (predicate) a lot
+# reject builds that fail to parse the condition, instead of ignoring it
+#
+# docs: change docs to recommend quotes around values in `= "string"`
+# docs: change docs to recommend quotes around values in `IN ("list")`
+# docs: mention NO SHELL CODE PLEASE
+# docs: mention reqexp limitations, and recommend using `/.../` first
+# docs: make the warning about `env` only having the .travis.yml vars bigger and fatter
+
+describe Travis::Conditions::V1, 'real conditions' do
+  broken = <<~strs.split("\n")
+    branch =~ ^(!:release\/) or tag =~ ^version_code\/
+    tag =~ (^version_code\/)|(^$)
+    branch = develop/pipes=travis
+  strs
+
+  used = <<~strs.split("\n")
+    ((NOT branch =~ ^develop/.*$) OR (branch = develop/travis)) AND (tag IS blank)
+    (NOT branch =~ ^develop/.*$) AND (tag IS blank)
+    (branch != master OR type = cron OR type = api)
+    (branch = develop/travis) AND (tag IS blank)
+    (branch = master) AND (NOT (type IN (api, pull_request)))
+    (branch = master) AND (NOT (type IN (api,pull_request)))
+    (branch = master) AND (NOT (type IN (push, pull_request)))
+    (branch = master) AND (NOT (type IN (push,pull_request)))
+    (branch = master) AND (NOT(type IN (api, pull_request)))
+    (branch = master) AND (NOT(type IN (api,pull_request)))
+    (branch = master) AND (NOT(type IN (push ,pull_request)))
+    (branch = master) AND (NOT(type IN (push, pull_request)))
+    (branch = master) AND (NOT(type IN (push,pull_request)))
+    (type = pull_request) OR (tag IS present)
+    (type = push AND NOT (branch = develop)) OR (type = cron)
+    NOT branch = master
+    NOT branch =~ ^develop/.*$
+    NOT tag = "stable"
+    NOT tag = stable
+    NOT tag =~ \+d2$
+    branch = develop/hardening
+    branch = develop/pipes-travis
+    branch = develop/travis
+    branch = master
+    branch = master AND NOT(type IN (push,pull_request))
+    branch = master AND type = pull_request
+    branch = master AND type = push
+    branch = master OR tag =~ ^v\d+\.\d+$
+    branch = master OR tag IS present
+    branch = master OR type = pull_request OR branch =~ ^rc_.*
+    branch = staging
+    branch = task/ASI-93-auto-update-campaign-performance-summary-for-periscope
+    branch = travis
+    branch =~ /^release.*$/
+    branch =~ /release/
+    branch =~ ^develop
+    branch =~ ^develop OR branch =~ ^master OR branch =~ ^release
+    branch =~ ^release
+    branch =~ ^release.*$
+    branch =~ ^release/ or tag =~ ^version_code\/
+    branch IN (master, ^develop, ^release)
+    branch IN (master, develop) OR branch =~ ^release\/.+$ OR branch =~ ^hotfix\/.+$ OR branch =~ ^bugfix\/.+$ OR branch =~ ^support\/.+$ ORtag IS present OR type IN (pull_request, api)
+    branch IN (master, development, features)
+    branch is blank
+    env(TRAVIS_SECURE_ENV_VARS) = true
+    fork = false
+    not tag =~ ^autobuild
+    tag =~ ''
+    tag =~ /(^version_code\/)|(^$)/
+    tag =~ /^$|\s+/
+    tag =~ [0-9]+\.[0-9]+\.[0-9]+
+    tag =~ ^\d+(\.\d+)+(-.*)?
+    tag =~ ^\d+(\.\d+)+(-.*)? OR branch = travisbuilds-selenium
+    tag =~ ^travis*
+    tag =~ ^v
+    tag =~ ^v
+    tag =~ ^version_code/ OR (tag IS NOT present)
+    tag =~ ^version_code/ OR tag IS NOT present
+    tag =~ ^version_code\/ OR tag =~ ^$
+    tag =~ ^version_code\/|^$
+    tag IS blank
+    tag IS blank
+    tag IS present
+    tag is blank
+    type = push
+    type IN (api, cron)
+    type IN (push, pull_request)
+  strs
+
+  fixed = <<~strs.split("\n").reject(&:empty?)
+    true
+    1=1
+    ( branch NOT IN (master) OR fork = true ) AND type IN (push, api, pull_request)
+    (((type != pull_request) AND (branch = master)) OR (tag =~ ^\\d+\\.\\d+\\.\\d+$))
+    ((branch = master) OR (tag =~ ^\\d+\\.\\d+\\.\\d+$))
+    (branch = master AND type != pull_request) AND (NOT tag =~ ^v)
+    (branch = master AND type != pull_request) OR (tag =~ ^v)
+    (branch = master OR branch =~ ^infra/$) AND type = push
+    (branch = master OR tag =~ ^deploy/) AND (type != pull_request)
+    (branch = master) AND (NOT (tag =~prod_))
+    (branch = master) AND (tag =~ ^v\\d+\\.\\d+\\.\\d+.*$) AND (type IN (push, pull_request))
+    (branch = master) AND (tag =~ ^v\\d+\\.\\d+\\.\\d+.*$) AND type IN (push, pull_request)
+    (tag =~ ^prod_)
+    (tag =~ ^v) AND (branch = master)
+    (tag =~ ^v) AND (branch = release)
+    (tag =~ ^v) AND (repo = meniga/mobile-sdk-android)
+    (type IN (cron, api)) OR ((tag IS present) AND (tag =~ ^v))
+    (type IN (cron, api)) OR (tag =~ ^v)
+    (type IN (cron, api)) OR (tag =~ ^v?([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:(?:\\-|\\+)([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)){0,2}$)
+    NOT type IN (pull_request) AND (branch = master OR tag =~ ^v[1-9])
+    TRAVIS_PULL_REQUEST = false
+    branch = master AND tag is blank AND fork is false AND repo = head_repo AND type != pull_request
+    branch = master AND tag is blank AND fork is false AND type != pull_request
+    branch = master AND type = push
+    branch = master AND type == pull_request
+    branch IN (master, dev_package)
+    branch NOT IN (master) OR fork = true
+    branch in (master, dev) OR type == pull
+    env(FOO) = env(TRAVIS_SECURE_ENV_VARS)
+    env(IS_TAGS_ONLY) = env(NO)
+    env(IS_TAGS_ONLY) = env(NO) AND env(YES) IN (env(IS_FULL_REGRESSION), env(IS_READY_TO_BUILD))
+    env(PRIOR_VERSION) != env(RELEASE_VERSION)
+    env(PRIOR_VERSION) IS present AND env(PRIOR_VERSION) != env(RELEASE_VERSION) AND branch = master AND type = push AND repo = cotsog/travis_ci_prod_regular
+    env(PRIOR_VERSION) IS present AND env(PRIOR_VERSION) != env(RELEASE_VERSION) AND branch = master AND type = push AND repo = justien/travis_conditional_stages
+    env(PRIOR_VERSION) IS present AND env(PRIOR_VERSION) != env(RELEASE_VERSION) AND branch = master AND type = push AND repo = plus3it/terraform-aws-watchmaker
+    env(TRAVIS_SECURE_ENV_VARS) IS true
+    env(env_name) IS blank
+    env(env_name) IS present
+    tag =~ ^version_code/ OR tag IS NOT present
+    tag IS NOT blank
+    tag IS NOT present
+    tag IS blank
+    tag IS present
+    tag IS present OR branch == master
+    true = false
+    type = pull_request
+    type IN (api, cron)
+    type IN (push, cron) AND (NOT branch =~ [0-9]{8,})
+    type IN (push, cron) AND (tag =~ ^$)
+    type IN (push, cron) AND NOT (branch =~ [0-9]{8,})
+    type NOT IN (api, cron)
+    type NOT IN (cron)
+
+    env(FORCE_REBUILD) ~= ^true$
+    env(REBUILD) ~= ^true$ OR env(FORCE_REBUILD) ~= ^true$ OR (branch = master AND type = push)
+    type = cron OR env(TEST_SQLITE) ~= ^true$
+
+    branch = master AND tag is blank AND fork is false AND repo = head_repo AND type != pull_request
+    tags IS blank
+    type = cron OR env(TEST_SQLITE) IS true
+    tag !~ \\\n ^v-
+
+    env(REBUILD) OR env(FORCE_REBUILD) OR branch = master
+    env(DOCKER_BUILD)
+    env(DOCKER_PASSWORD)
+    type = cron OR env(TEST_SQLITE)
+
+    type != pull_request AND ( branch =~ ^release$ OR branch =~ ^release-(\d).(\d).(\d)$ )
+    type != pull_request AND (branch =~ ^release$ OR branch =~ ^release-(\d).(\d).(\d)$)
+    (branch = master) OR (branch =~ ^release/) OR (tag is present)
+  strs
+
+  kaputt = <<~strs.split("\n")
+    # IS used for comparison
+    (branch = dev) AND (type IS cron)
+    (repo IS 2m/sssio) AND (tag =~ ^v)
+    branch IS master
+    type IS push
+
+    # broken IN list
+    (type = pull_request) AND (branch IN dev)
+
+    # = followed by IN
+    branch = IN (master, dev_package)
+
+    # missing boolean operand
+    branch = master AND ( tag =~ ^deploy/ OR )
+
+    # NON instead of NOT
+    branch = master AND type NON IN (pull_request)
+
+    # missing AND or OR
+    branch = master NOT type = pull_request
+
+    # triple operator
+    branch = type = pull_request
+
+    # missing IS
+    tag NOT present
+
+    # bash code
+    env(FORCE_JOBS) IS blank && (branch = ${MASTER_BRANCH} OR type = pull_request)
+
+    # operator !=~
+    branch = master or branch !=~ ^renovate/
+
+    # needs /.../ around the pattern
+    env(TRAVIS_COMMIT_MESSAGE) =~ ^Replace Conditionalaaa$
+
+    # missing quotes
+    env(TRAVIS_COMMIT_MESSAGE) IN (Replace Conditional)
+    env(TRAVIS_COMMIT_MESSAGE) = Replace conditional
+  strs
+
+  strs = used + fixed
+
+  strs.each do |str|
+    context do
+      let(:subject) { described_class.parse(str) }
+      it(str) { expect { subject }.to_not raise_error }
+    end
+  end
+
+  context do
+    let(:str) do
+      %(
+        repo = iribeyri/travis-experiments
+        AND type != pull_request
+        AND (branch = master OR tag =~ ^v[0-9]+\.[0-9]+\.[0-9]+.*$)
+      )
+    end
+    it { expect { described_class.parse(str) }.to_not raise_error }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: travis-conditions
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Travis CI
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-17 00:00:00.000000000 Z
+date: 2018-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -26,23 +26,62 @@ dependencies:
         version: '1.8'
 description: 
 email: contact@travis-ci.org
-executables: []
+executables:
+- travis-conditions
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
+- NOTES.md
 - README.md
+- bin/travis-conditions
 - lib/travis/conditions.rb
-- lib/travis/conditions/data.rb
-- lib/travis/conditions/eval.rb
-- lib/travis/conditions/parser.rb
+- lib/travis/conditions/v0.rb
+- lib/travis/conditions/v0/data.rb
+- lib/travis/conditions/v0/eval.rb
+- lib/travis/conditions/v0/parser.rb
+- lib/travis/conditions/v1.rb
+- lib/travis/conditions/v1/boolean.rb
+- lib/travis/conditions/v1/data.rb
+- lib/travis/conditions/v1/eval.rb
+- lib/travis/conditions/v1/helper.rb
+- lib/travis/conditions/v1/parser.rb
 - lib/travis/conditions/version.rb
-- spec/data_spec.rb
-- spec/eval_spec.rb
-- spec/parser_spec.rb
+- spec/conditions_spec.rb
 - spec/spec_helper.rb
+- spec/v0/conditions_spec.rb
+- spec/v0/data_spec.rb
+- spec/v0/eval_spec.rb
+- spec/v0/fixtures/failures.txt
+- spec/v0/fixtures/passes.txt
+- spec/v0/parser_spec.rb
+- spec/v1/conditions_spec.rb
+- spec/v1/data_spec.rb
+- spec/v1/eval_spec.rb
+- spec/v1/fixtures/failures.txt
+- spec/v1/fixtures/passes.txt
+- spec/v1/parser/boolean_spec.rb
+- spec/v1/parser/call_spec.rb
+- spec/v1/parser/comma_spec.rb
+- spec/v1/parser/cont_spec.rb
+- spec/v1/parser/eq_spec.rb
+- spec/v1/parser/in_list_spec.rb
+- spec/v1/parser/is_pred_spec.rb
+- spec/v1/parser/list_spec.rb
+- spec/v1/parser/operand_spec.rb
+- spec/v1/parser/parens_spec.rb
+- spec/v1/parser/quoted_spec.rb
+- spec/v1/parser/re_spec.rb
+- spec/v1/parser/regex_spec.rb
+- spec/v1/parser/space_spec.rb
+- spec/v1/parser/term_spec.rb
+- spec/v1/parser/val_spec.rb
+- spec/v1/parser/var_spec.rb
+- spec/v1/parser_spec.rb
+- spec/v1/user_spec.rb
 homepage: https://github.com/travis-ci/travis-conditions
 licenses:
 - MIT

data/lib/travis/conditions/data.rb

@@ -1,45 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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