travis-yaml 0.1.0

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

@@ -0,0 +1,18 @@
+module Travis::Yaml
+  module Nodes
+    class OpenMapping < Mapping
+      def self.default_type(identifier = nil)
+        @default_type = Nodes[identifier] if identifier
+        @default_type ||= superclass.respond_to?(:default_type) ? superclass.default_type : Scalar
+      end
+
+      def self.subnode_for(key)
+        super(key) || default_type
+      end
+
+      def accept_key?(key)
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Travis::Yaml
+  module Nodes
+    class OS < Sequence
+      type OSEntry
+
+      def verify_language(language)
+        children.delete_if do |os|
+          next false if os.supports_language? language
+          warning "dropping %p, does not support %p", os, language
+          true
+        end
+
+        if children.empty?
+          default_os = language.respond_to?(:default_os) ? language.default_os : OSEntry.default
+          warning "no suitable operating system given for %p, using %p", language, default_os.to_s
+          children << OSEntry.new(self) { |os| os.value = default_os }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Travis::Yaml
+  module Nodes
+    class OSEntry < FixedValue
+      OSX = %w[objective-c ruby c cpp]
+
+      ignore_case
+      default :linux
+      value :linux, ubuntu: :linux
+      value :osx, mac: :osx, macos: :osx
+
+      def supports_language?(language)
+        case value
+        when 'linux' then language != 'objective-c'
+        when 'osx'   then OSX.include? language
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Travis::Yaml
+  module Nodes
+    class Root < Mapping
+      include LanguageSpecific
+
+      map :language, required: true
+      map :bundler_args, to: BundlerArgs
+      map :deploy, :ruby, :os, :compiler, :git, :jdk, :virtualenv, :matrix, :env, :notifications, :branches, :cache
+      map :lein, :otp_release, :go, :ghc, :node_js, :xcode_sdk, :xcode_scheme, :perl, :php, :python, :services, :gemfile, to: VersionList
+      map :rvm, to: :ruby
+      map :otp, to: :otp_release
+      map :node, to: :node_js
+      map :virtual_env, to: :virtualenv
+      map :osx_image, to: Version, experimental: true
+      map :gobuild_args, :xcode_project, :xcode_workspace, :xctool_args, :composer_args, :npm_args, to: Scalar[:str]
+      map :source_key, to: Scalar[:str, :secure]
+      map :sdk_components, to: Sequence
+      map :before_install, :install, :before_script, :script, :after_result, :after_script,
+            :after_success, :after_failure, :before_deploy, :after_deploy, to: Stage
+
+      def initialize
+        super(nil)
+      end
+
+      def verify
+        super
+        verify_os
+        verify_language(language)
+      end
+
+      def verify_os
+        self.os = language.default_os unless include? :os
+      end
+
+      def nested_warnings(*)
+        super.uniq
+      end
+
+      def inspect
+        "#<Travis::Yaml:#{super}>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Travis::Yaml
+  module Nodes
+    class Ruby < VersionList
+      def jruby?
+        @children.any? do |child|
+          child.start_with? 'jruby'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Travis::Yaml
+  module Nodes
+    class Scalar < Node
+      def self.[](*types)
+        Class.new(self) do
+          default_type(types.first)
+          cast(*types)
+        end
+      end
+
+      def self.cast?(type)
+        cast.include? type
+      end
+
+      def self.cast(*types)
+        @cast ||= superclass.respond_to?(:cast) ? superclass.cast.dup : []
+        @cast.concat(types) if types.any?
+        @cast
+      end
+
+      def self.default_type(type = nil)
+        @default_type = type if type
+        @default_type ||= superclass.respond_to?(:default_type) ? superclass.default_type : :str
+      end
+
+      def self.default(value = nil)
+        @default = value if value
+        @default ||= nil
+      end
+
+      def self.has_default?
+        !default.nil?
+      end
+
+      attr_accessor :value
+      alias_method :__getobj__, :value
+
+      def empty?
+        value.nil?
+      end
+
+      def prepare
+        self.value = self.class.default
+        @multiple  = false
+        super
+      end
+
+      def ==(other)
+        other = other.value if other.is_a? self.class
+        other == value
+      end
+
+      def default_type
+        self.class.default_type
+      end
+
+      def inspect
+        value.inspect
+      end
+
+      def visit_scalar(visitor, type, value, implicit = true)
+        return self.value = cast(visitor, type,         value) if cast? type
+        return self.value = cast(visitor, default_type, value) if implicit
+        error "%p not supported, dropping %p", type.to_s, cast(visitor, :str, value)
+      end
+
+      def visit_sequence(visitor, value)
+        @multiple = false
+        visitor.apply_sequence(self, value)
+      end
+
+      def visit_child(visitor, value)
+        if @multiple
+          value = cast(visitor, :str, value) rescue value
+          warning "does not support multiple values, dropping %p", value
+        else
+          @multiple = true
+          visitor.accept(self, value)
+        end
+      end
+
+      def cast(visitor, type, value)
+        visitor.cast(type, value)
+      rescue ArgumentError => error
+        error "failed to parse %p - %s", type.to_s, error.message
+      end
+
+      def cast?(type)
+        self.class.cast?(type) or type == default_type
+      end
+
+      def !@
+        !value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Travis::Yaml
+  module Nodes
+    class Sequence < Node
+      attr_reader :children
+      alias_method :__getobj__, :children
+
+      def self.type(identifier = nil)
+        @type = Nodes[identifier] if identifier
+        @type ||= superclass.respond_to?(:type) ? superclass.type : Scalar
+      end
+
+      def prepare
+        @children = []
+      end
+
+      def visit_sequence(visitor, value)
+        visitor.apply_sequence(self, value)
+      end
+
+      def visit_scalar(visitor, type, value, implicit = true)
+        visit_child(visitor, value) if type != :null
+      end
+
+      def visit_mapping(visitor, value)
+        visit_child(visitor, value)
+      end
+
+      def visit_child(visitor, value)
+        child = self.class.type.new(self)
+        visitor.accept(child, value)
+        @children << child
+      end
+
+      def nested_warnings(*prefix)
+        @children.inject(super) do |list, value|
+          list = value.nested_warnings(*prefix) + list
+        end
+      end
+
+      def ==(other)
+        other = other.children if other.is_a? Sequence
+        if other.respond_to? :to_a and other.to_a.size == children.size
+          children.zip(other.to_a).all? { |a, b| a == b }
+        else
+          identifier == other
+        end
+      end
+
+      def empty?
+        @children.empty?
+      end
+
+      def inspect
+        identifier.inspect
+      end
+
+      def to_s
+        identifier.to_s
+      end
+
+      def identifier
+        @children.size == 1 ? @children.first : @children
+      end
+
+      def verify
+        verify_children
+        super
+      end
+
+      def verify_children
+        @children.delete_if do |child|
+          next unless child.errors?
+          child.errors.each { |message| warning(message) }
+          true
+        end
+      end
+
+      def deep_verify
+        @children.each(&:deep_verify)
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Travis::Yaml
+  module Nodes
+    class Stage < Sequence
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Travis::Yaml
+  module Nodes
+    class Version < Scalar
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Travis::Yaml
+  module Nodes
+    class VersionList < Sequence
+      type Version
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Travis::Yaml
+  module Nodes
+    class VirtualEnv < Mapping
+      map :system_site_packages, to: Scalar[:bool]
+    end
+  end
+end

data/lib/travis/yaml/parser.rb

@@ -0,0 +1,31 @@
+module Travis::Yaml
+  module Parser
+    require 'travis/yaml/parser/dummy'
+    require 'travis/yaml/parser/psych'
+    require 'travis/yaml/parser/ruby'
+
+    extend self, Enumerable
+
+    def parses?(value)
+      !!parser_for(value)
+    end
+
+    def parse(value)
+      raise ArgumentError, "cannot parse %p" % value unless parser = parser_for(value)
+      parser.parse(value)
+    end
+
+    def parser_for(value)
+      detect { |p| p.parses? value if p.respond_to? :parses? }
+    end
+
+    def each(&block)
+      parsers.each(&block)
+    end
+
+    def parsers
+      constants.map { |name| const_get(name) }.
+        select { |c| c.respond_to? :parse }
+    end
+  end
+end

data/lib/travis/yaml/parser/dummy.rb

@@ -0,0 +1,13 @@
+module Travis::Yaml
+  module Parser
+    module Dummy
+      def self.parses?(value)
+        value.is_a? Travis::Yaml::Nodes::Node
+      end
+
+      def self.parse(value)
+        value
+      end
+    end
+  end
+end

data/lib/travis/yaml/parser/psych.rb

@@ -0,0 +1,217 @@
+require 'psych'
+require 'delegate'
+
+module Travis::Yaml
+  module Parser
+    class Psych
+      class SetNode < DelegateClass(::Psych::Nodes::Mapping)
+        def children
+          super.select.with_index { |_,i| i.even? }
+        end
+      end
+
+      class ScalarSequence < DelegateClass(::Psych::Nodes::Mapping)
+        def children
+          [__getobj__]
+        end
+      end
+
+      MAP       = /\A(?:tag:yaml\.org,2002:|!!?)map\z/
+      OMAP      = /\A(?:tag:yaml\.org,2002:|!!?)omap\z/
+      PAIRS     = /\A(?:tag:yaml\.org,2002:|!!?)pairs\z/
+      SET       = /\A(?:tag:yaml\.org,2002:|!!?)set\z/
+      SEQ       = /\A(?:tag:yaml\.org,2002:|!!?)seq\z/
+      BINARY    = /\A(?:tag:yaml\.org,2002:|!!?)binary\z/
+      BOOL      = /\A(?:tag:yaml\.org,2002:|!!?)bool\z/
+      FLOAT     = /\A(?:tag:yaml\.org,2002:|!!?)float\z/
+      INT       = /\A(?:tag:yaml\.org,2002:|!!?)int\z/
+      MERGE     = /\A(?:tag:yaml\.org,2002:|!!?)merge\z/
+      NULL      = /\A(?:tag:yaml\.org,2002:|!!?)null\z/
+      STR       = /\A(?:tag:yaml\.org,2002:|!!?)str\z/
+      TIMESTAMP = /\A(?:tag:yaml\.org,2002:|!!?)timestamp\z/
+      VALUE     = /\A(?:tag:yaml\.org,2002:|!!?)value\z/
+      YAML      = /\A(?:tag:yaml\.org,2002:|!!?)yaml\z/
+      SECURE    = /\A!(?:encrypted|secure|decrypted)\z/
+      TRUE      = /\A(?:y|Y|yes|Yes|YES|true|True|TRUE|on|On|ON)\z/
+      FALSE     = /\A(?:n|N|no|No|NO|false|False|FALSE|off|Off|OFF)\z/
+      REGEXP    = /\A!(?:ruby\/)?regexp\z/
+      REG_FLAGS = { 'i' => Regexp::IGNORECASE, 'm' => Regexp::MULTILINE, 'x' => Regexp::EXTENDED }
+      FORMATS   = {
+        '!bool'      => Regexp.union(TRUE, FALSE),
+        '!float'     => ::Psych::ScalarScanner::FLOAT,
+        '!null'      => /\A(:?~|null|Null|NULL|)\z/,
+        '!timestamp' => ::Psych::ScalarScanner::TIME,
+        '!int'       => ::Psych::ScalarScanner::INTEGER,
+        '!regexp'    => /\A\/(.*)\/([imx]*)\z/
+      }
+
+      if defined? ::Psych::ClassLoader
+        CLASS_LOADER = ::Psych::ClassLoader.new
+        class ScalarScanner < ::Psych::ScalarScanner
+          def initialize
+            super(CLASS_LOADER)
+          end
+        end
+      else
+        ScalarScanner = ::Psych::ScalarScanner
+      end
+
+      def self.parses?(value)
+        return true if value.is_a?(::Psych::Nodes::Node)
+        return true if value.is_a?(String) or value.is_a?(IO)
+        return true if defined?(StringIO) and value.is_a?(StringIO)
+        value.respond_to?(:to_str) or value.respond_to?(:to_io)
+      end
+
+      def self.parse(value)
+        new(value).parse
+      end
+
+      def initialize(value)
+        value    = value.to_str if value.respond_to? :to_str
+        value    = value.to_io  if value.respond_to? :to_io
+        @value   = value
+        @scanner = ScalarScanner.new
+      end
+
+      def parse(root = nil)
+        root   ||= Travis::Yaml::Nodes::Root.new
+        parsed   = @value if @value.is_a? ::Psych::Nodes::Node
+        parsed ||= ::Psych.parse(@value)
+        accept(root, parsed)
+        root
+      rescue ::Psych::SyntaxError => error
+        root.verify
+        root.warnings.clear
+        root.error("syntax error: %s", error.message)
+        root
+      end
+
+      def accept(node, value)
+        case value
+        when ::Psych::Nodes::Scalar   then accept_scalar   node, value
+        when ::Psych::Nodes::Mapping  then accept_mapping  node, value
+        when ::Psych::Nodes::Sequence then accept_sequence node, value
+        when ::Psych::Nodes::Alias    then accept_alias    node, value
+        when ::Psych::Nodes::Document then accept          node, value.root
+        when ::Psych::Nodes::Stream   then accept_sequence node, value
+        else node.visit_unexpected(self, value) if value
+        end
+        node.verify
+      end
+
+      def accept_sequence(node, value)
+        case value.tag
+        when SET, SEQ
+          node.visit_sequence self, value
+        when nil
+          value = ScalarSequence.new(value) unless value.is_a? ::Psych::Nodes::Sequence
+          node.visit_sequence self, value
+        else
+          node.visit_sequence self, ScalarSequence.new(value)
+        end
+      end
+
+      def accept_mapping(node, value)
+        case value.tag
+        when MAP, OMAP, PAIRS then node.visit_mapping  self, value
+        when SET              then node.visit_sequence self, SetNode.new(value)
+        when SEQ              then node.visit_sequence self, value
+        when nil
+          if value.children.size == 2 and value.children.first.value == 'secure'
+            node.visit_scalar(self, :secure, value.children.last)
+          else
+            node.visit_mapping(self, value)
+          end
+        else
+          node.visit_unexpected self, value, "unexpected tag %p for mapping" % value.tag
+        end
+      end
+
+      def accept_scalar(node, value)
+        case tag = scalar_tag(value)
+        when BINARY    then node.visit_scalar self, :binary, value, value.tag.nil?
+        when BOOL      then node.visit_scalar self, :bool,   value, value.tag.nil?
+        when FLOAT     then node.visit_scalar self, :float,  value, value.tag.nil?
+        when INT       then node.visit_scalar self, :int,    value, value.tag.nil?
+        when NULL      then node.visit_scalar self, :null,   value, value.tag.nil?
+        when STR       then node.visit_scalar self, :str,    value, value.tag.nil?
+        when TIMESTAMP then node.visit_scalar self, :time,   value, value.tag.nil?
+        when SECURE    then node.visit_scalar self, :secure, value, value.tag.nil?
+        when NULL      then node.visit_scalar self, :null,   value, value.tag.nil?
+        when REGEXP    then node.visit_scalar self, :regexp, value, value.tag.nil?
+        else node.visit_unexpected self, value, "unexpected tag %p for scalar %p" % [tag, simple(value)]
+        end
+      end
+
+      def simple(value)
+        case value
+        when ::Psych::Nodes::Scalar   then value.value
+        when ::Psych::Nodes::Mapping  then simple_mapping(value)
+        when ::Psych::Nodes::Sequence then value.children.map { |c| simple(c) }
+        when ::Psych::Nodes::Document then simple(value.root)
+        when ::Psych::Nodes::Stream   then value.children.map { |c| simple(c) }
+        else value
+        end
+      end
+
+      def simple_mapping(value)
+        children     = {}
+        keys, values = value.children.group_by.with_index { |_,i| i.even? }.values_at(true, false)
+        keys.zip(values) { |key, value| children[simple(key)] = simple(value) } if keys and values
+        children
+      end
+
+      def scalar_tag(value)
+        return value.tag if value.tag
+        return '!str' if value.quoted
+        FORMATS.each do |tag, format|
+          return tag if value.value =~ format
+        end
+        '!str'
+      end
+
+      def regexp(pattern)
+        return pattern if pattern.is_a? Regexp
+        return Regexp.new(pattern) unless pattern =~ FORMATS['!regexp']
+        flag = $2.chars.inject(0) { |f,c| f | REG_FLAGS.fetch(c, 0) }
+        Regexp.new($1, flag)
+      rescue RegexpError => error
+        raise ArgumentError, "broken regular expression - #{error.message}"
+      end
+
+      def cast(type, value)
+        case type
+        when :str    then value.value
+        when :binary then value.value.unpack('m').first
+        when :bool   then value.value !~ FALSE
+        when :float  then Float   @scanner.tokenize(value.value)
+        when :int    then Integer @scanner.tokenize(value.value)
+        when :time   then @scanner.parse_time(value.value)
+        when :secure then SecureString.new(value.value, value.tag != '!decrypted')
+        when :regexp then regexp(value.value)
+        when :null   then nil
+        else raise ArgumentError, 'unknown scalar type %p' % type
+        end
+      end
+
+      def apply_mapping(node, value)
+        keys, values = value.children.group_by.with_index { |_,i| i.even? }.values_at(true, false)
+        keys.zip(values) { |key, value| node.visit_pair(self, key, value) } if keys and values
+      end
+
+      def apply_sequence(node, value)
+        value.children.each { |child| node.visit_child(self, child) }
+      end
+
+      def generate_key(node, value)
+        unless value.respond_to? :value and (value.tag.nil? || value.tag == STR)
+          node.visit_unexpected(self, value, "expected string as key")
+        end
+
+        value = value.value.to_s
+        value.start_with?(?:) ? value[1..-1] : value
+      end
+    end
+  end
+end