travis-conditions 0.0.2 → 1.0.0

data/bin/travis-conditions

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+$: << 'lib'
+
+require 'json'
+require 'optparse'
+require 'travis/conditions'
+
+def help
+  abort <<~help
+    Usage:
+      travis-conditions "branch = master" --data '{"branch": "master"}'
+      travis-conditions echo '{"branch": "master"}' | travis-conditions "branch = master"
+
+    The given data JSON hash can include known attributes (such as branch, tag,
+    repo) and an "env" key that can either hold a hash, or an array of strings:
+
+      {"env": {"foo": "bar"}}
+      {"env": ["foo=bar"]}
+  help
+end
+
+data = $stdin.read unless $stdin.tty?
+
+ARGV.options do |opts|
+  opts.on("-d", "--data DATA") { |val| data = val }
+  opts.on_tail("-h", "--help") { help }
+  opts.parse!
+end
+
+cond = ARGV.shift
+abort help unless cond && data
+
+p Travis::Conditions.eval(cond, JSON.parse(data), version: :v1)

data/lib/travis/conditions.rb

@@ -1,29 +1,23 @@
-require 'travis/conditions/data'
-require 'travis/conditions/eval'
-require 'travis/conditions/parser'
+require 'travis/conditions/v0'
+require 'travis/conditions/v1'
 
 module Travis
   module Conditions
-    ParseError = Class.new(StandardError)
+    Error = Class.new(::ArgumentError)
+    ArgumentError = Class.new(Error)
+    ParseError = Class.new(Error)
 
     class << self
-      def eval(str, data)
-        Eval.new(parse(str, keys: data.keys), Data.new(data)).apply
+      def eval(str, data, opts = {})
+        const(opts).eval(str, data)
       end
 
       def parse(str, opts = {})
-        tree = parser(opts).parse(str)
-        Transform.new.apply(tree)
-      rescue Parslet::ParseFailed
-        raise ParseError
+        const(opts).parse(str, opts)
       end
 
-      def parser(opts)
-        parsers[opts] ||= Parser.new(opts)
-      end
-
-      def parsers
-        @parsers ||= {}
+      def const(opts)
+        opts[:version] == :v1 ? V1 : V0
       end
     end
   end

data/lib/travis/conditions/v0.rb

@@ -0,0 +1,30 @@
+require 'travis/conditions/v0/data'
+require 'travis/conditions/v0/eval'
+require 'travis/conditions/v0/parser'
+
+module Travis
+  module Conditions
+    module V0
+      class << self
+        def eval(str, data, opts = {})
+          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)
+        rescue Parslet::ParseFailed
+          raise ParseError
+        end
+
+        def parser(opts)
+          parsers[opts] ||= Parser.new(opts)
+        end
+
+        def parsers
+          @parsers ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/travis/conditions/v0/data.rb

@@ -0,0 +1,57 @@
+module Travis
+  module Conditions
+    module V0
+      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 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
+
+          def normalize(data)
+            data = symbolize(data)
+            data[:env] = normalize_env(data[:env])
+            data
+          end
+
+          def normalize_env(env)
+            symbolize(to_h(env || {}))
+          rescue ::ArgumentError
+            raise ArgumentError.new("Cannot normalize data[:env] (#{env.inspect} given)")
+          end
+
+          def to_h(obj)
+            case obj
+            when Hash
+              obj
+            else
+              Array(obj).map { |obj| split(obj.to_s) }.to_h
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Travis
+  module Conditions
+    module V0
+      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
+end

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

@@ -0,0 +1,204 @@
+require 'parslet'
+
+module Travis
+  module Conditions
+    module V0
+      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
+end

data/lib/travis/conditions/v1.rb

@@ -0,0 +1,19 @@
+require 'travis/conditions/v1/data'
+require 'travis/conditions/v1/eval'
+require 'travis/conditions/v1/parser'
+
+module Travis
+  module Conditions
+    module V1
+      class << self
+        def eval(str, data)
+          Eval.new(parse(str), Data.new(data)).apply
+        end
+
+        def parse(str, _ = nil)
+          Parser.new(str).parse
+        end
+      end
+    end
+  end
+end