travis-yaml 0.1.0

data/lib/travis/yaml/nodes/language_specific.rb

@@ -0,0 +1,45 @@
+module Travis::Yaml
+  module Nodes
+    module LanguageSpecific
+      LANGUAGE_SPECIFIC = {
+        bundler_args:     %w[ruby],
+        compiler:         %w[c cpp],
+        lein:             %w[clojure],
+        otp_release:      %w[erlang],
+        gobuild_args:     %w[go],
+        go:               %w[go],
+        jdk:              %w[clojure groovy java ruby scala android],
+        ghc:              %w[haskell],
+        node_js:          %w[node_js],
+        ruby:             %w[ruby objective-c],
+        xcode_sdk:        %w[objective-c],
+        xcode_scheme:     %w[objective-c],
+        xcode_project:    %w[objective-c],
+        xcode_workspace:  %w[objective-c],
+        xctool_args:      %w[objective-c],
+        perl:             %w[perl],
+        php:              %w[php],
+        python:           %w[python],
+        virtualenv:       %w[python],
+        gemfile:          %w[ruby objective-c],
+        composer_args:    %w[php],
+        npm_args:         %w[node_js],
+        sdk_components:   %w[android]
+      }
+
+      def verify_language(language)
+        LANGUAGE_SPECIFIC.each do |key, languages|
+          next unless include? key and not languages.include? language
+          mapping.delete mapped_key(key)
+          warning "specified %p, but setting is not relevant for %p", key.to_s, language
+        end
+
+        mapping.each_value do |value|
+          value.verify_language(language) if value.respond_to? :verify_language
+        end
+
+        verify_errors
+      end
+    end
+  end
+end

data/lib/travis/yaml/nodes/mapping.rb

@@ -0,0 +1,204 @@
+module Travis::Yaml
+  module Nodes
+    class Mapping < Node
+      def self.mapping
+        @mapping ||= superclass.respond_to?(:mapping) ? superclass.mapping.dup : {}
+      end
+
+      def self.required
+        @required ||= superclass.respond_to?(:required) ? superclass.required.dup : []
+      end
+
+      def self.experimental
+        @experimental ||= superclass.respond_to?(:experimental) ? superclass.experimental.dup : []
+      end
+
+      def self.drop_empty
+        @drop_empty ||= superclass.respond_to?(:drop_empty) ? superclass.drop_empty.dup : []
+      end
+
+      def self.aliases
+        @aliases ||= superclass.respond_to?(:aliases) ? superclass.aliases.dup : {}
+      end
+
+      def self.map(*list)
+        options = Hash === list.last ? list.pop : {}
+        list.each do |key|
+          drop_empty   << key.to_s if options.fetch(:drop_empty, true)
+          required     << key.to_s if options[:required]
+          experimental << key.to_s if options[:experimental]
+          define_map_accessor(key)
+          case options[:to]
+          when Symbol then aliases[key.to_s] = options[:to].to_s
+          when Module then mapping[key.to_s] = options[:to]
+          when nil    then mapping[key.to_s] = Nodes[key]
+          else raise ArgumentError, 'unexpected value for to: %p' % options[:to]
+          end
+        end
+      end
+
+      def self.auto_prefix(key)
+        prefix_sequence(key)
+        prefix_scalar(key)
+      end
+
+      def self.prefix_sequence(key)
+        define_method(:visit_sequence) do |visitor, value|
+          visit_key_value(visitor, key, value)
+        end
+      end
+
+      def self.prefix_scalar(key, *types)
+        define_method(:visit_scalar) do |visitor, type, value, implicit = true|
+          return super(visitor, type, value, implicit = true) if types.any? and not types.include?(type)
+          visit_key_value(visitor, key, value)
+        end
+      end
+
+      def self.define_map_accessor(key)
+        define_method(key)       { | | self[key]       } unless method_defined? key
+        define_method("#{key}=") { |v| self[key] = v   } unless method_defined? "#{key}="
+        define_method("#{key}?") { | | !!self[key]     } unless method_defined? "#{key}?"
+      end
+
+      def self.subnode_for(key)
+        mapping[aliases.fetch(key.to_s, key.to_s)]
+      end
+
+      attr_reader :mapping
+      alias_method :__getobj__, :mapping
+
+      def prepare
+        @mapping = {}
+        super
+      end
+
+      def visit_mapping(visitor, value)
+        visitor.apply_mapping(self, value)
+      end
+
+      def visit_pair(visitor, key, value)
+        key = visitor.generate_key(self, key)
+        visit_key_value(visitor, key, value)
+      end
+
+      def visit_key_value(visitor, key, value)
+        return warning("unexpected key %p, dropping", key) unless node = subnode_for(key)
+        self[key] = node
+        visitor.accept(node, value)
+      end
+
+      def drop_empty?(key)
+        self.class.drop_empty.include? mapped_key(key)
+      end
+
+      def []=(key, value)
+        if key = mapped_key(key)
+          unless value.is_a? Node
+            node  = subnode_for(key)
+            value = node if Parser::Ruby.new(value).parse(node)
+          end
+          @mapping[key] = value
+        else
+          warning("unexpected key %p, dropping", key)
+        end
+      end
+
+      def [](key)
+        @mapping[mapped_key(key)]
+      end
+
+      def include?(key)
+        @mapping.include? mapped_key(key)
+      end
+
+      def empty?
+        @mapping.empty?
+      end
+
+      def mapped_key(key)
+        key = self.class.aliases.fetch(key.to_s, key.to_s)
+        key if accept_key?(key)
+      end
+
+      def accept_key?(key)
+        self.class.mapping.include? key
+      end
+
+      def subnode_for(key)
+        type = self.class.subnode_for(key)
+        type.new(self) if type
+      end
+
+      def inspect
+        @mapping.inspect
+      end
+
+      def ==(other)
+        other = other.mapping if other.is_a? Mapping
+        if other.respond_to? :to_hash and other.to_hash.size == @mapping.size
+          other.to_hash.all? { |k, v| include?(k) and self[k] == v }
+        else
+          false
+        end
+      end
+
+      def verify
+        verify_experimental
+        verify_errors
+        verify_empty
+        verify_required
+        verify_errors
+      end
+
+      def verify_experimental
+        self.class.experimental.each do |key|
+          next unless @mapping.include? key
+          warning "%p is experimental and might be removed in the future", key
+        end
+      end
+
+      def verify_empty
+        @mapping.delete_if do |key, value|
+          next unless drop_empty? key and value.empty?
+          value.nested_warnings.each { |p, w| nested_warning(w, key, *p) }
+          warning('value for %p section is empty, dropping', key)
+          true
+        end
+      end
+
+      def verify_required
+        self.class.required.each do |key|
+          next if @mapping.include? key
+          type = self.class.subnode_for(key)
+          if type.has_default?
+            warning "missing key %p, defaulting to %p", key, type.default
+            @mapping[key] = type.new(self)
+          else
+            error "missing key %p", key
+          end
+        end
+      end
+
+      def verify_errors
+        @mapping.delete_if do |key, value|
+          if value.errors?
+            warning "dropping %p section: %s", key, value.errors.join(', ')
+            true
+          end
+        end
+      end
+
+      def deep_verify
+        @mapping.each_value(&:deep_verify)
+        super
+      end
+
+      def nested_warnings(*prefix)
+        @mapping.inject(super) do |list, (key, value)|
+          list = value.nested_warnings(*prefix, key) + list
+        end
+      end
+    end
+  end
+end

data/lib/travis/yaml/nodes/matrix.rb

@@ -0,0 +1,36 @@
+module Travis::Yaml
+  module Nodes
+    class Matrix < Mapping
+      class Matcher < Mapping
+        include LanguageSpecific
+
+        map :ruby, :jdk, :lein, :otp_release, :go, :ghc, :node_js, :xcode_sdk,
+          :xcode_scheme, :perl, :php, :python, :gemfile, to: Version
+        map :rvm, to: :ruby
+        map :otp, to: :otp_release
+        map :node, to: :node_js
+        map :env, to: Env::Variables
+        map :os, to: OSEntry
+        map :compiler, to: CompilerEntry
+      end
+
+      class MatcherList < Sequence
+        type Matcher
+
+        def verify_language(language)
+          children.each { |c| c.verify_language(language) }
+          verify_children
+        end
+      end
+
+      map :include, :exclude, :allow_failures, to: MatcherList
+      map :fast_finish, to: Scalar[:bool]
+
+      def verify_language(language)
+        values.each { |v| v.verify_language(language) }
+        verify_empty
+        verify_errors
+      end
+    end
+  end
+end

data/lib/travis/yaml/nodes/node.rb

@@ -0,0 +1,102 @@
+module Travis::Yaml
+  module Nodes
+    class Node
+      def self.has_default?
+        false
+      end
+
+      attr_accessor :partent
+      def initialize(parent)
+        @nested_warnings = []
+        @parent          = parent
+        prepare
+        yield self if block_given?
+      end
+
+      def warngings?
+        warnings.any?
+      end
+
+      def errors?
+        errors.any?
+      end
+
+      def warnings
+        @warnings ||= []
+      end
+
+      def nested_warning(message, *prefix)
+        @nested_warnings << [prefix, message]
+      end
+
+      def nested_warnings(*prefix)
+        messages  = errors + warnings
+        prefixed  = messages.map { |warning| [prefix, warning] }
+        prefixed += @nested_warnings.map { |p, w| [prefix + p, w] }
+        prefixed
+      end
+
+      def errors
+        @errors ||= []
+      end
+
+      def warning(message, *params)
+        warnings << message % params
+      end
+
+      def error(message, *params)
+        errors << message % params
+      end
+
+      def prepare
+      end
+
+      def verify
+      end
+
+      def verify_language(language)
+      end
+
+      def deep_verify
+        verify
+      end
+
+      def visit_unexpected(visitor, value, message = nil)
+        error(message || "unexpected %p", value)
+      end
+
+      def visit_mapping(visitor, value)
+        error("unexpected mapping")
+      end
+
+      def visit_pair(visitor, key, value)
+        error("unexpected pair")
+      end
+
+      def visit_scalar(visitor, type, value, implicit = true)
+        error("unexpected scalar") unless type == :null
+      end
+
+      def visit_sequence(visitor, value)
+        error("unexpected sequence")
+      end
+
+      def visit_child(visitor, value)
+        error("unexpected child")
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        __getobj__.respond_to?(method, false)
+      end
+
+      def method_missing(method, *args, &block)
+        return super unless __getobj__.respond_to?(method)
+        __getobj__.public_send(method, *args, &block)
+      end
+
+      def to_s
+        __getobj__.to_s
+      end
+    end
+  end
+end

data/lib/travis/yaml/nodes/notifications.rb

@@ -0,0 +1,77 @@
+module Travis::Yaml
+  module Nodes
+    class Notifications < Mapping
+      Callbacks ||= FixedValue[:always, :never, :change]
+
+      class Notification < Mapping
+        map :enabled, :disabled, to: Scalar[:bool]
+        map :on_success, :on_failure, :on_start, to: Callbacks
+
+        def self.[](name)
+          Class.new(self) { list(name) }
+        end
+
+        def self.list(name)
+          map name, to: Sequence
+          prefix_sequence name
+          prefix_scalar name, :str, :secure
+        end
+
+        def visit_scalar(visitor, type, value, implicit = true)
+          return super unless type == :bool
+          visit_key_value(visitor, :enabled, value)
+        end
+
+        def enabled?
+          @mapping.fetch('enabled', !@mapping['disabled'])
+        end
+
+        def disabled?
+          !enabled?
+        end
+      end
+
+      class Template < Sequence
+        VARIABLES = %w[repository_slug repository_name repository build_number branch commit author message duration compare_url build_url]
+
+        def verify
+          super
+          @children.each do |child|
+            child.to_s.scan(/%{([^}]+)}/) do |match|
+              next if VARIABLES.include? match.first
+              warning 'unknown "template" variable %p', match.first
+            end
+          end
+        end
+      end
+
+      class WithTemplate < Notification
+        map :template, to: Template
+      end
+
+      class IRC < WithTemplate
+        list :channels
+        map :channel_key, :password, :nickserv_password, :nick, to: Scalar[:str, :secure]
+        map :use_notice, :skip_join, to: Scalar[:bool]
+      end
+
+      class Hipchat < WithTemplate
+        map :format, to: FixedValue[:html, :text]
+        list :rooms
+      end
+
+      class Flowdoc < Notification
+        map :api_token, to: Scalar[:str, :secure]
+        prefix_scalar name, :str, :secure
+      end
+
+      map :webhooks,                    to: Notification[:urls]
+      map :email,                       to: Notification[:recipients]
+      map :sqwiggle, :slack, :campfire, to: WithTemplate[:rooms]
+      map :flowdoc,                     to: Flowdoc
+      map :hipchat,                     to: Hipchat
+      map :irc,                         to: IRC
+      map :webhook,                     to: :webhooks
+    end
+  end
+end