travis-yaml 0.1.0 → 0.2.0

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

@@ -11,7 +11,7 @@ module Travis::Yaml
       end
 
       def accept_key?(key)
-        true
+        key != 'secure'
       end
     end
   end

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

@@ -5,7 +5,7 @@ module Travis::Yaml
 
       def verify_language(language)
         children.delete_if do |os|
-          next false if os.supports_language? language
+          next false if os.supports_language? language.to_s
           warning "dropping %p, does not support %p", os, language
           true
         end

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

@@ -1,7 +1,11 @@
 module Travis::Yaml
   module Nodes
     class OSEntry < FixedValue
-      OSX = %w[objective-c ruby c cpp]
+      MISSING = {
+        # see https://github.com/travis-ci/travis-ci/issues/2320
+        'osx'   => %w[node_js python php perl erlang groovy clojure scala go haskell],
+        'linux' => ['objective-c']
+      }
 
       ignore_case
       default :linux
@@ -9,10 +13,8 @@ module Travis::Yaml
       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
+        return false unless missing = MISSING[value]
+        !missing.include?(language)
       end
     end
   end

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

@@ -4,9 +4,12 @@ module Travis::Yaml
       include LanguageSpecific
 
       map :language, required: true
+      map :sudo, to: Scalar[:bool], required: false
       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 :deploy, :ruby, :os, :compiler, :git, :jdk, :virtualenv, :matrix, :env, :notifications, :branches, :cache, :addons, :android
+      map :lein, :otp_release, :go, :ghc, :xcode_sdk, :xcode_scheme, :perl, :php, :python, :services, :gemfile, to: VersionList
+      map :podfile, to: Version
+      map :node_js, to: VersionList[/^\d+\.\d+(\.\d+)?$/]
       map :rvm, to: :ruby
       map :otp, to: :otp_release
       map :node, to: :node_js
@@ -14,9 +17,12 @@ module Travis::Yaml
       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
+      map :dist, to: Dist
+      map :group, to: Group
+
+      FEATURE_KEYS = [:dist, :group]
 
       def initialize
         super(nil)
@@ -26,10 +32,24 @@ module Travis::Yaml
         super
         verify_os
         verify_language(language)
+        FEATURE_KEYS.each {|feature| warn_on_feature feature}
       end
 
       def verify_os
         self.os = language.default_os unless include? :os
+        warning 'your repository must be feature flagged for the "os" setting to be used' if os and os != language.default_os
+
+        if os.include? 'osx' and jdk
+          # https://github.com/travis-ci/travis-ci/issues/2317
+          warning 'dropping "jdk" section: currently not supported on "osx"'
+          @mapping.delete('jdk')
+        end
+      end
+
+      def warn_on_feature(feature)
+        if include? feature
+          warning 'your repository must be feature flagged for the "%s" setting to be used', feature
+        end
       end
 
       def nested_warnings(*)
@@ -39,6 +59,10 @@ module Travis::Yaml
       def inspect
         "#<Travis::Yaml:#{super}>"
       end
+
+      def to_matrix
+        Travis::Yaml.matrix(self)
+      end
     end
   end
-end
+end

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

@@ -82,7 +82,7 @@ module Travis::Yaml
       def cast(visitor, type, value)
         visitor.cast(type, value)
       rescue ArgumentError => error
-        error "failed to parse %p - %s", type.to_s, error.message
+        error "failed to parse %p - %s", type.to_s, error.message.sub("():", ":")
       end
 
       def cast?(type)
@@ -92,6 +92,21 @@ module Travis::Yaml
       def !@
         !value
       end
+
+      def with_value(value)
+        return value.dup if value.is_a? self.class
+        value = value.value while value.is_a? Scalar
+        super(value)
+      end
+
+      def with_value!(value)
+        self.value = value
+      end
+
+      def each_scalar(type = nil, &block)
+        return enum_for(:each_scalar, type) unless block
+        yield value if type.nil? or type === value
+      end
     end
   end
 end

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

@@ -4,6 +4,11 @@ module Travis::Yaml
       attr_reader :children
       alias_method :__getobj__, :children
 
+      def self.[](node_type)
+        node_type = Scalar[node_type] unless node_type.is_a? Node
+        Class.new(self) { type(node_type) }
+      end
+
       def self.type(identifier = nil)
         @type = Nodes[identifier] if identifier
         @type ||= superclass.respond_to?(:type) ? superclass.type : Scalar
@@ -79,6 +84,39 @@ module Travis::Yaml
         @children.each(&:deep_verify)
         super
       end
+
+      def each_scalar(type = nil, &block)
+        return enum_for(:each_scalar, type) unless block
+        @children.each { |c| c.each_scalar(type, &block) }
+      end
+
+      def with_value(value)
+        return value.dup if value.is_a? self.class
+        value = value.children if value.is_a? Sequence
+        value = value.value while value.is_a? Scalar
+        Parser::Ruby.new(Array(value)).parse self.class.new(parent)
+      end
+
+      def with_value!(value)
+        children.replace with_value(value).children
+      end
+
+      def add_value(value)
+        added = with_value(self)
+        added.add_value!(value)
+        added
+      end
+
+      def add_value!(value)
+        children.concat(with_value(value).children)
+      end
+
+      protected
+
+        def dup_values
+          @children = @children.map { |child| child.dup }
+          self
+        end
     end
   end
 end

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

@@ -1,6 +1,19 @@
 module Travis::Yaml
   module Nodes
     class Version < Scalar
+      def self.[](expression)
+        Class.new(self) { format(expression) }
+      end
+
+      def self.format(expression = nil)
+        @format = expression if expression
+        @format ||= superclass.respond_to?(:format) ? superclass.format : //
+      end
+
+      def value=(value)
+        return super unless value and value.to_s !~ self.class.format
+        error "value %p is not a valid version", value.to_s
+      end
     end
   end
 end

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

@@ -1,6 +1,10 @@
 module Travis::Yaml
   module Nodes
     class VersionList < Sequence
+      def self.[](expression)
+        Class.new(self) { type Version[expression] }
+      end
+
       type Version
     end
   end

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

@@ -119,7 +119,13 @@ module Travis::Yaml
         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)
+            secret_value = value.children.last
+            if secret_value.is_a? ::Psych::Nodes::Scalar
+              secret_value.tag ||= '!secure'
+              node.visit_scalar(self, :secure, secret_value, false)
+            else
+              node.visit_unexpected(self, value, "secret value needs to be a string")
+            end
           else
             node.visit_mapping(self, value)
           end
@@ -205,12 +211,12 @@ module Travis::Yaml
       end
 
       def generate_key(node, value)
-        unless value.respond_to? :value and (value.tag.nil? || value.tag == STR)
+        if value.respond_to? :value and (value.tag.nil? || value.tag == STR)
+          value = value.value.to_s
+          value.start_with?(?:) ? value[1..-1] : value
+        else
           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

data/lib/travis/yaml/secure_string.rb

@@ -2,11 +2,44 @@ module Travis::Yaml
   class SecureString
     attr_accessor :encrypted_string, :decrypted_string
     def initialize(string, encrypted = true)
+      unless string.respond_to? :to_str
+        raise ArgumentError, "secure string needs to be a string, not a %p" % string.class.name.downcase
+      end
       if encrypted
-        @encryped_string = string
+        @encrypted_string = string.to_str
       else
-        @decrypted_string = string
+        @decrypted_string = string.to_str
       end
     end
+
+    def encrypted?
+      !!encrypted_string
+    end
+
+    def decrypted?
+      !!decrypted_string
+    end
+
+    def decrypt
+      return unless encrypted?
+      @decrypted_string = yield(encrypted_string)
+    end
+
+    def encrypt
+      return unless decrypted?
+      @encrypted_string = yield(decrypted_string)
+    end
+
+    def inspect
+      "[SECURE]".freeze
+    end
+
+    def ==(other)
+      other.encrypted_string == encrypted_string and other.decrypted_string == decrypted_string if other.is_a? SecureString
+    end
+
+    def hash
+      encrypted_string.hash | decrypted_string.hash
+    end
   end
 end

data/lib/travis/yaml/serializer.rb

@@ -0,0 +1,17 @@
+module Travis::Yaml
+  module Serializer
+    NotSupportedError ||= Class.new(ArgumentError)
+    require 'travis/yaml/serializer/generic'
+    require 'travis/yaml/serializer/ruby'
+    require 'travis/yaml/serializer/legacy'
+    require 'travis/yaml/serializer/json'
+    require 'travis/yaml/serializer/yaml'
+
+    def self.[](key)
+      return key if key.respond_to? :serialize
+      name = constants.detect { |c| c.downcase == key }
+      raise ArgumentError, "unknown serializer %p" % key unless name
+      const_get(name)
+    end
+  end
+end

data/lib/travis/yaml/serializer/generic.rb

@@ -0,0 +1,114 @@
+module Travis::Yaml
+  module Serializer
+    class Generic
+      attr_reader :options
+
+      def self.serialize(node, options = nil)
+        new(options).serialize(node)
+      end
+
+      def initialize(options = nil)
+        @options = options || {}
+      end
+
+      def symbol_keys?
+        !!options[:symbol_keys]
+      end
+
+      def serialize(node)
+        case node 
+        when Nodes::Root     then serialize_root(node)
+        when Nodes::Scalar   then serialize_scalar(node)
+        when Nodes::Mapping  then serialize_mapping(node)
+        when Nodes::Sequence then serialize_sequence(node)
+        else raise NotSupportedError, 'do not know how to serialize %p' % node.class
+        end
+      end
+
+      def serialize_scalar(node)        
+        case value = node.value
+        when true, false  then serialize_bool(value)
+        when Float        then serialize_float(value)
+        when Integer      then serialize_integer(value)
+        when Time         then serialize_time(value)
+        when SecureString then serialize_secure(value)
+        when Regexp       then serialize_regexp(value)
+        when String
+          value.encoding == Encoding::BINARY ? serialize_binary(value) : serialize_str(value)
+        else
+          serialize_value(node)
+        end
+      end
+
+      def serialize_bool(value)
+        serialize_value(value)
+      end
+
+      def serialize_float(value)
+        serialize_value(value)
+      end
+
+      def serialize_time(value)
+        serialize_value(value)
+      end
+
+      def serialize_secure(value)
+        case options[:secure]
+        when :decrypted
+          raise ArgumentError, 'secure option is set decrypted, but a secure value is not decrypted' unless value.decrypted?
+          serialize_decrypted(value)
+        when :encrypted
+          raise ArgumentError, 'secure option is set encrypted, but a secure value is not encrypted' unless value.encrypted?
+          serialize_encrypted(value)
+        else
+          raise ArgumentError, 'unexpected value for secure option: %p' % options[:secure] if options[:secure]
+          value.encrypted? ? serialize_encrypted(value) : serialize_decrypted(value)
+        end
+      end
+
+      def serialize_encrypted(value)
+        serialize_value(value)
+      end
+
+      def serialize_decrypted(value)
+        serialize_value(value)
+      end
+
+      def serialize_regexp(value)
+        serialize_value(value)
+      end
+
+      def serialize_str(value)
+        serialize_value(value)
+      end
+
+      def serialize_binary(value)
+        serialize_str(value)
+      end
+
+      def serialize_bool(value)
+        serialize_value(value)
+      end
+
+      def serialize_value(value)
+        raise NotSupportedError, 'cannot serialize %p with %p' % [node.class, self.class]
+      end
+
+      def serialize_root(node)
+        serialize_mapping(node)
+      end
+
+      def serialize_mapping(node)
+        node.map { |key, value| [serialize_key(key), serialize(value)] }
+      end
+
+      def serialize_sequence(node)
+        node.map { |value| serialize(value) }
+      end
+
+      def serialize_key(value)
+        symbol_keys? ? value.to_sym : value.to_s
+      end
+    end
+  end
+end

data/lib/travis/yaml/serializer/json.rb

@@ -0,0 +1,72 @@
+module Travis::Yaml
+  module Serializer
+    class Json < Generic
+      MAP = { # mapping stolen from json gem
+        "\x0"  => '\u0000', "\x1"  => '\u0001', "\x2"  => '\u0002', "\x3"  => '\u0003', "\x4"  => '\u0004', "\x5"  => '\u0005',
+        "\x6"  => '\u0006', "\x7"  => '\u0007', "\b"   =>  '\b',    "\t"   =>  '\t',    "\n"   => '\n',     "\xb"  => '\u000b',
+        "\f"   => '\f',     "\r"   =>  '\r',    "\xe"  => '\u000e', "\xf"  => '\u000f', "\x10" => '\u0010', "\x11" => '\u0011',
+        "\x12" => '\u0012', "\x13" => '\u0013', "\x14" => '\u0014', "\x15" => '\u0015', "\x16" => '\u0016', "\x17" => '\u0017',
+        "\x18" => '\u0018', "\x19" => '\u0019', "\x1a" => '\u001a', "\x1b" => '\u001b', "\x1c" => '\u001c', "\x1d" => '\u001d',
+        "\x1e" => '\u001e', "\x1f" => '\u001f', '"'    =>  '\"',    '\\'   =>  '\\\\'
+      }
+
+      def pretty?
+        !!options[:pretty]
+      end
+
+      def serialize_float(value)
+        raise NotSupportedError, 'cannot serialize infinity as JSON' if value.infinite?
+        "#{value}"
+      end
+
+      def serialize_encrypted(value)
+        key_value("secure", serialize_str(value.encrypted_string), "{%s}")
+      end
+
+      def serialize_decrypted(value)
+        serialize_str(value.decrypted_string)
+      end
+
+      def serialize_str(value)
+        string = value.encode('utf-8')
+        string.force_encoding('binary')
+        string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
+        string.force_encoding('utf-8')
+        "\"#{string}\""
+      end
+
+      def serialize_binary(value)
+        raise NotSupportedError, 'cannot serialize binary data as JSON'
+      end
+
+      def serialize_bool(value)
+        value ? "true" : "false"
+      end
+
+      def serialize_mapping(node)
+        lines('{%s}', super.map { |key, value| key_value(key, value) })
+      end
+
+      def serialize_sequence(node)
+        lines('[%s]', super)
+      end
+
+      def key_value(key, value, wrapper = "%s")
+        space = pretty? ? " " : ""
+        wrapper % "#{serialize_str(key)}:#{space}#{value}"
+      end
+
+      def lines(wrapper, lines)
+        return wrapper % lines.join(',') unless pretty?
+        return wrapper % "" if lines.empty?
+        return wrapper % " #{lines.first} " unless lines.size > 1 or  lines.first.include?("\n") or lines.first.size > 50
+        lines = "\n  " + lines.join(",\n").strip.gsub("\n", "\n  ") + "\n"
+        wrapper % lines
+      end
+
+      def serialize_key(value)
+        value.to_s
+      end
+    end
+  end
+end