travis-conditions 0.0.2 → 1.0.0

data/lib/travis/conditions/v1/boolean.rb

@@ -0,0 +1,71 @@
+# https://www.engr.mun.ca/~theo/Misc/exp_parsing.htm
+#
+# term = 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
+#
+# not  = 'not' | 'NOT';
+# and  = 'and' | 'AND' | '&&';
+# or   = 'or'  | 'OR' | '||';
+#
+# expr = expr or expr
+#      | expr and expr
+#      | not expr
+#      | '(' expr ')'
+#      | var
+
+# E --> T {( "or" ) T}
+# T --> P {( "and" ) P}
+# P --> v | "(" E ")" | "NOT" E
+
+# expr = exp2 { or exp2 }
+# exp2 = oprd { and oprd }
+# oprd = term | '(' expr ')' | not expr
+
+module Travis
+  module Conditions
+    module V1
+      module Boolean
+        AND   = /(and|&&)/i
+        OR    = /(or|\|\|)/i
+        NOT   = /(not|!)/i
+
+        BOP = {
+          'and' => :and,
+          '&&'  => :and,
+          'or'  => :or,
+          '||'  => :and,
+          'not' => :not
+        }
+
+        def expr
+          lft = expr_
+          lft = [:or, lft, expr_] while op(OR)
+          lft
+        end
+
+        def expr_
+          lft = oprd
+          lft = [:and, lft, oprd] while op(AND)
+          lft
+        end
+
+        def oprd
+          t = parens { expr } and return t
+          t = not_ { oprd } and return t
+          term
+        end
+
+        def not_
+          pos = self.pos
+          space { scan(NOT) } or return
+          t = yield and return [:not, t]
+          str.pos = pos
+          nil
+        end
+
+        def op(op)
+          op = space { scan(op) } and BOP[op.downcase]
+        end
+      end
+    end
+  end
+end

data/lib/travis/conditions/v1/data.rb

@@ -0,0 +1,75 @@
+module Travis
+  module Conditions
+    module V1
+      class Data < Struct.new(:data)
+        def initialize(data)
+          super(normalize(data))
+        end
+
+        def [](key)
+          data[key.to_sym]
+        end
+
+        def env(key)
+          data.fetch(:env, {})[key.to_sym]
+        end
+
+        private
+
+          def symbolize(obj)
+            case obj
+            when Hash
+              obj.map { |key, value| [key&.to_sym, symbolize(value)] }.to_h
+            when Array
+              obj.map { |obj| symbolize(obj) }
+            else
+              obj
+            end
+          end
+
+          def cast(obj)
+            case obj.to_s.downcase
+            when 'false'
+              false
+            when 'true'
+              true
+            else
+              obj
+            end
+          end
+
+          def normalize(data)
+            data = symbolize(data)
+            data[:env] = normalize_env(data[:env])
+            data
+          end
+
+          def normalize_env(env)
+            symbolize(to_h(env || {}))
+          rescue TypeError
+            raise arg_error(env)
+          end
+
+          def to_h(obj)
+            case obj
+            when Hash
+              obj
+            else
+              Array(obj).map { |obj| split(obj.to_s) }.to_h
+            end
+          end
+
+          def split(str)
+            str = str.strip
+            raise arg_error(str) if str.empty? || !str.include?("=")
+            lft, rgt = str.split('=', 2)
+            [lft, cast(rgt)]
+          end
+
+          def arg_error(arg)
+            ArgumentError.new("Invalid env data (#{arg.inspect} given)")
+          end
+      end
+    end
+  end
+end

data/lib/travis/conditions/v1/eval.rb

@@ -0,0 +1,114 @@
+module Travis
+  module Conditions
+    module V1
+      class Eval < Struct.new(:sexp, :data)
+        def apply
+          !!evl(sexp)
+        end
+
+        private
+
+          def evl(expr)
+            expr = send(*expr) if expr.is_a?(Array)
+            cast(expr)
+          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) == evl(rgt)
+          end
+
+          def not_eq(lft, rgt)
+            not eq(lft, rgt)
+          end
+
+          def match(lft, rgt)
+            evl(lft) =~ evl(rgt)
+          end
+
+          def not_match(lft, rgt)
+            not match(lft, rgt)
+          end
+
+          def in(lft, rgt)
+            rgt = rgt.map { |rgt| evl(rgt) }
+            rgt.include?(evl(lft))
+          end
+
+          def not_in(lft, rgt)
+            not evl([:in, lft, rgt])
+          end
+
+          def is(lft, rgt)
+            send(rgt, evl(lft))
+          end
+
+          def is_not(lft, rgt)
+            not evl([:is, lft, rgt])
+          end
+
+          def val(str)
+            str
+          end
+
+          def reg(expr)
+            Regexp.new(evl(expr))
+          end
+
+          def var(name)
+            data[name]
+          end
+
+          def call(name, args)
+            send(name, *args.map { |arg| evl(arg) })
+          end
+
+          def env(key)
+            data.env(key)
+          end
+
+          def concat(*args)
+            args.inject('') { |str, arg| str + arg.to_s }
+          end
+
+          def present(value)
+            value.respond_to?(:empty?) && !value.empty?
+          end
+
+          def blank(value)
+            !present(value)
+          end
+
+          def true(value)
+            !!value
+          end
+
+          def false(value)
+            !value
+          end
+
+          def cast(obj)
+            case obj.to_s.downcase
+            when 'false'
+              false
+            when 'true'
+              true
+            else
+              obj
+            end
+          end
+      end
+    end
+  end
+end

data/lib/travis/conditions/v1/helper.rb

@@ -0,0 +1,30 @@
+module Travis
+  module Conditions
+    module V1
+      module Helper
+        QUOTE = /["']{1}/
+        OPEN  = /\(/
+        CLOSE = /\)/
+        SPACE = /\s*/
+
+        def quoted
+          return unless quote = scan(QUOTE)
+          scan(/[^#{quote}]*/).tap { scan(/#{quote}/) || err(quote) }
+        end
+
+        def parens
+          space { skip(OPEN) } and space { yield }.tap { skip(CLOSE) || err(')') }
+        end
+
+        def space
+          skip(SPACE)
+          yield.tap { skip(SPACE) }
+        end
+
+        def err(char)
+          raise ParseError, "expected #{char} at position #{pos} in: #{string.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/travis/conditions/v1/parser.rb

@@ -0,0 +1,214 @@
+require 'strscan'
+require 'forwardable'
+require 'travis/conditions/v1/boolean'
+require 'travis/conditions/v1/helper'
+
+# var  = 'type'
+#      | 'repo'
+#      | 'head_repo'
+#      | 'os'
+#      | 'dist'
+#      | 'group'
+#      | 'sudo'
+#      | 'language'
+#      | 'sender'
+#      | 'fork'
+#      | 'branch'
+#      | 'head_branch'
+#      | 'tag'
+#      | 'commit_message';
+#
+# func = 'env' || 'concat';
+# pred = 'present' | 'blank';
+#
+# eq   = '=' | '==' | '!=';
+# re   = '=~' | '~=` | '!~';
+# in   = 'in' | 'not in' | 'IN' | 'NOT IN';
+# is   = 'is' | 'is not' | 'IS' | 'IS NOT';
+# or   = 'or' | 'OR' | '||';
+# and  = 'and' | 'AND' | '&&';
+#
+# list = oprd | oprd ',' list;
+# call = func '(' list ')';
+# val  = word | quoted;
+#
+# oprd = var | val | call;
+#
+# term = oprd is pred
+#      | oprd in '(' list ')'
+#      | oprd re regx
+#      | oprd eq oprd
+#      | oprd;
+#
+# expr = expr or expr
+#      | expr and expr
+#      | not expr
+#      | '(' expr ')'
+#      | term
+
+module Travis
+  module Conditions
+    module V1
+      class Parser
+        extend Forwardable
+        include Boolean, Helper
+
+        VAR   = /type|repo|head_repo|os|dist|group|sudo|language|sender|fork|
+                 branch|head_branch|tag|commit_message/ix
+
+        PRED  = /present|blank|true|false/i
+        FUNC  = /env|concat/i
+        IN    = /in|not in/i
+        IS    = /is not|is/i
+        EQ    = /==|=/
+        NEQ   = /!=/
+        RE    = /=~|~=/
+        NRE   = /!~/
+        COMMA = /,/
+        WORD  = /[^\s\(\)"',=!]+/
+        REGEX = %r(/.+/|\S*[^\s\)]+)
+        CONT  = /\\\s*[\n\r]/
+
+        OP = {
+          '='   => :eq,
+          '=='  => :eq,
+          '!='  => :not_eq,
+          '=~'  => :match,
+          '~='  => :match,
+          '!~'  => :not_match
+        }
+
+        MSGS = {
+          parse_error: 'Could not parse %s',
+          shell_var:   'Variable names cannot start with a dollar (shell code does not work). If you are trying to compare to an env var, please use env("name")',
+          shell_str:   'Strings cannot start with a dollar (shell code does not work). This can be bypassed by quoting the string.'
+        }
+
+        def_delegators :str, :scan, :skip, :string, :pos, :peek
+        attr_reader :str
+
+        def initialize(str)
+          @str = StringScanner.new(filter(str))
+        end
+
+        def filter(str)
+          str.gsub(CONT, ' ')
+        end
+
+        def parse
+          res = expr
+          error(:parse_error, string.inspect) unless res && !str.rest?
+          res
+        end
+
+        def term
+          lft = operand
+          lst = in_list(lft) and return lst
+          prd = is_pred(lft) and return prd
+          op  = re and return [op, lft, regex]
+          op  = eq and return [op, lft, operand]
+          lft
+        end
+
+        def operand
+          op = space { var || call || val }
+          op or err('an operand')
+        end
+
+        def regex
+          val = call
+          return [:reg, val] if val
+          reg = space { scan(REGEX) }
+          [:reg, reg.gsub(/^\/|\/$/, '')] or err('an operand')
+        end
+
+        def eq
+          op = space { scan(EQ) || scan(NEQ) } and OP[op]
+        end
+
+        def re
+          op = space { scan(RE) || scan(NRE) } and OP[op]
+        end
+
+        def var
+          pos = str.pos
+          var = scan(VAR)
+          error(:shell_var) if var && var[0] == '$'
+          return [:var, var.downcase.to_sym] if var && boundary?
+          str.pos = pos
+          nil
+        end
+
+        BOUND = /[\s,=)|]/
+
+        def boundary?
+          peek(1) =~ BOUND || str.eos?
+        end
+
+        def call
+          return unless name = func
+          args = parens { list }
+          args or return
+          return [:call, name.to_sym, args]
+        end
+
+        def val
+          val = quoted || word and [:val, val]
+        end
+
+        def is_pred(term)
+          op = is or return
+          pr = pred or return
+          [op.downcase.sub(' ', '_').to_sym, term, pr.downcase.to_sym]
+        end
+
+        def in_list(term)
+          op = self.in or return
+          list = parens { list! }
+          [op.downcase.sub(' ', '_').to_sym, term, list]
+        end
+
+        def list!
+          list.tap { |list| err 'a list of values' if list.empty? }
+        end
+
+        def list
+          return [] unless item = var || call || val
+          list = comma ? [item] + self.list : [item]
+          skip(COMMA)
+          list.compact
+        end
+
+        def func
+          space { scan(FUNC) }
+        end
+
+        def pred
+          space { scan(PRED)&.to_sym }
+        end
+
+        def word
+          str = space { scan(WORD) }
+          error(:shell_str) if str && str[0] == '$'
+          str
+        end
+
+        def in
+          space { scan(IN) }
+        end
+
+        def is
+          space { scan(IS) }
+        end
+
+        def comma
+          space { scan(COMMA) }
+        end
+
+        def error(key, *vals)
+          raise ParseError, MSGS[key] % vals
+        end
+      end
+    end
+  end
+end