travis-yaml 0.1.0 → 0.2.0

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

@@ -0,0 +1,32 @@
+module Travis::Yaml
+  module Serializer
+    class Legacy < Ruby
+      def serialize_root(node)
+        return serialize_error(node) if node.errors?
+        super.merge(serialize_warnings(node))
+      end
+
+      def serialize_error(node)
+        {
+          serialize_key('.result')         => 'parse_error',
+          serialize_key('.result_message') => node.errors.join("\n")
+        }
+      end
+
+      def serialize_warnings(node)
+        {
+          serialize_key('.result')          => 'configured',
+          serialize_key('.result_warnings') => node.nested_warnings
+        }
+      end
+
+      def serialize_encrypted(value)
+        { serialize_key('secure') => value.encrypted_string }
+      end
+
+      def serialize_decrypted(value)
+        value.decrypted_string
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Travis::Yaml
+  module Serializer
+    class Ruby < Generic
+      def serialize_value(value)
+        value
+      end
+
+      def serialize_mapping(node)
+        Hash[super]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Travis::Yaml
+  module Serializer
+    class Yaml < Ruby
+      PSYCH_OPTIONS = [ :indentation, :line_width, :canonical ]
+
+      class Tagged
+        attr_accessor :tag, :value
+        def initialize(tag, value)
+          @tag, @value = tag, value
+        end
+
+        def encode_with(coder)
+          coder.represent_scalar(tag, value)
+        end
+      end
+
+      def self.serialize(node, options = nil)
+        psych_options = options.select { |key, _| PSYCH_OPTIONS.include? key } if options
+        ::Psych.dump(super, psych_options || {})
+      end
+
+      def avoid_tags?
+        !!options[:avoid_tags]
+      end
+
+      def serialize_encrypted(value)
+        value = value.encrypted_string
+        avoid_tags? ? { "secure" => value } : Tagged.new('!encrypted', value)
+      end
+
+      def serialize_decrypted(value)
+        value = value.decrypted_string
+        avoid_tags? ? value : Tagged.new('!decrypted', value)
+      end
+
+      def serialize_binary(value)
+        Tagged.new('!binary', [value].pack('m0'))
+      end
+    end
+  end
+end

data/lib/travis/yaml/version.rb

@@ -1,5 +1,5 @@
 module Travis
   module Yaml
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/play/spec.rb

@@ -34,7 +34,7 @@ module Travis::Yaml
         description
       end
 
-      def self.spec_format
+      def self.spec_format(*)
       end
 
       def self.spec(*prefix, **options)
@@ -45,7 +45,7 @@ module Travis::Yaml
     end
 
     class Scalar
-      def self.spec_format(append = "")
+      def self.spec_format(append = "", *)
         formats = cast.any? ? cast : [default_type]
         formats.map { |f| TYPES[f] ? TYPES[f]+append : f.to_s }.join(', ').gsub(/, ([^,]+)$/, ' or \1')
       end
@@ -77,24 +77,24 @@ module Travis::Yaml
     end
 
     class Notifications::Notification
-      def self.spec_notification_format
-        "list of strings or encrypted strings"
-      end
-
-      def self.spec_format
-        super + ", or #{spec_notification_format}, or boolean value"
-      end
+       def self.spec_format_prefix(input, append = "")
+         super(input)
+         input << ", or boolean value#{append}"
+       end
     end
 
-    class Notifications::Flowdoc
-      def self.spec_notification_format
-        "string, encrypted string"
-      end
+    class Notifications::Flowdock
+       def self.spec_format_prefix(input, append = "")
+         input << ", or string#{append}, encrypted string#{append}, or boolean value#{append}"
+       end
     end
 
     class Sequence
-      def self.spec_format
-        "list of " << type.spec_format("s") << "; or a single " << type.spec_format if type.spec_format
+      def self.spec_format(append = "", children = true, *)
+        return unless type.spec_format
+        format = "list of " << type.spec_format("s")
+        format << "; or a single " << type.spec_format if children
+        format
       end
 
       def self.spec(*prefix, **options)
@@ -117,8 +117,15 @@ module Travis::Yaml
     end
 
     class Mapping
-      def self.spec_format(append = "")
-        "key value mapping#{append}"
+      def self.spec_format(append = "", *)
+        format = "key value mapping#{append}"
+        spec_format_prefix(format, append)
+        format
+      end
+
+      def self.spec_format_prefix(input, append = "")
+        input << ", or #{subnode_for(prefix_sequence).spec_format('s', prefix_sequence != prefix_scalar)}" if prefix_sequence
+        input << ", or #{subnode_for(prefix_scalar).spec_format(append)}" if prefix_scalar and prefix_scalar != prefix_sequence
       end
 
       def self.default_spec_description

data/spec/matrix_spec.rb

@@ -0,0 +1,57 @@
+describe Travis::Yaml::Matrix do
+  let(:matrix) { config.to_matrix }
+  let(:entries) { matrix.entries }
+  let(:matrix_attributes) { entries.first.matrix_attributes }
+
+  context 'no matrix' do
+    let(:config) { Travis::Yaml.load(language: "ruby") }
+    specify { expect(matrix.size)           .to be == 1                                     }
+    specify { expect(entries.first.to_ruby) .to be == {"language"=>"ruby", "os"=>["linux"]} }
+    specify { expect(config.to_ruby)        .to be == {"language"=>"ruby", "os"=>["linux"]} }
+    specify { expect(entries.first)         .to be_a(Travis::Yaml::Matrix::Entry)           }
+    specify { expect(matrix_attributes)     .to be_empty                                    }
+    specify { expect(matrix.axes)           .to be_empty                                    }
+  end
+
+  context 'simple matrix' do
+    let(:config) { Travis::Yaml.load(ruby: ["ruby", "jruby"]) }
+    specify { expect(matrix.size)           .to be == 2                                                                }
+    specify { expect(entries.first.to_ruby) .to be == {"language"=>"ruby", "os"=>["linux"], "ruby"=>"ruby"}            }
+    specify { expect(config.to_ruby)        .to be == {"language"=>"ruby", "os"=>["linux"], "ruby"=>["ruby", "jruby"]} }
+    specify { expect(entries.first)         .to be_a(Travis::Yaml::Matrix::Entry)                                      }
+    specify { expect(matrix_attributes)     .to be == { ruby: "ruby"}                                                  }
+    specify { expect(matrix.axes)           .to be == [:ruby]                                                          }
+  end
+
+  context 'two dimensional matrix' do
+    let(:config) { Travis::Yaml.load(ruby: ["ruby", "jruby"], os: ["linux", "osx"]) }
+    specify { expect(matrix.size)           .to be == 4                                                                       }
+    specify { expect(entries.first.to_ruby) .to be == {"language"=>"ruby", "os"=>"linux",          "ruby"=>"ruby"}            }
+    specify { expect(config.to_ruby)        .to be == {"language"=>"ruby", "os"=>["linux", "osx"], "ruby"=>["ruby", "jruby"]} }
+    specify { expect(entries.first)         .to be_a(Travis::Yaml::Matrix::Entry)                                             }
+    specify { expect(matrix_attributes)     .to be == { ruby: "ruby", os: "linux" }                                           }
+    specify { expect(matrix.axes)           .to be == [:ruby, :os]                                                            }
+  end
+
+  context 'matrix env, no global env' do
+    let(:config) { Travis::Yaml.load(env: ['a', 'b']) }
+    specify { expect(matrix.size)           .to be == 2                                                                    }
+    specify { expect(entries.first.to_ruby) .to be == {"env"=>{"global"=>["a"]}, "language"=>"ruby", "os"=>["linux"]}      }
+    specify { expect(entries.last.to_ruby)  .to be == {"env"=>{"global"=>["b"]}, "language"=>"ruby", "os"=>["linux"]}      }
+    specify { expect(config.to_ruby)        .to be == {"env"=>{"matrix"=>["a", "b"]}, "language"=>"ruby", "os"=>["linux"]} }
+    specify { expect(entries.first)         .to be_a(Travis::Yaml::Matrix::Entry)                                          }
+    specify { expect(matrix_attributes)     .to be == { env: "a" }                                                         }
+    specify { expect(matrix.axes)           .to be == [:env]                                                               }
+  end
+
+  context 'matrix env, global env' do
+    let(:config) { Travis::Yaml.load(env: { matrix: ['a', 'b'], global: ['x'] }) }
+    specify { expect(matrix.size)           .to be == 2                                                                                     }
+    specify { expect(entries.first.to_ruby) .to be == {"env"=>{"global"=>["x", "a"]}, "language"=>"ruby", "os"=>["linux"]}                  }
+    specify { expect(entries.last.to_ruby)  .to be == {"env"=>{"global"=>["x", "b"]}, "language"=>"ruby", "os"=>["linux"]}                  }
+    specify { expect(config.to_ruby)        .to be == {"env"=>{"matrix"=>["a", "b"], "global"=>["x"]}, "language"=>"ruby", "os"=>["linux"]} }
+    specify { expect(entries.first)         .to be_a(Travis::Yaml::Matrix::Entry)                                                           }
+    specify { expect(matrix_attributes)     .to be == { env: "a" }                                                                          }
+    specify { expect(matrix.axes)           .to be == [:env]                                                                                }
+  end
+end

data/spec/nodes/addons_spec.rb

@@ -0,0 +1,63 @@
+describe Travis::Yaml::Nodes::Addons do
+  context 'from Ruby' do
+    def addons(input)
+      Travis::Yaml.parse!(language: 'ruby', addons: input).addons
+    end
+
+    context 'artifacts' do
+      let :config do
+        addons(artifacts: {
+          bucket:       'whatever',
+          branch:       'borken',
+          concurrency:  40,
+          debug:        1,
+          key:          'foo',
+          max_size:     1024 * 1024 * 10,
+          paths:        '$(git ls-files -o | tr "\n" ":")',
+          secret:       'bar',
+          target_paths: 'somewhere/in/teh/clood',
+          log_format:   'special',
+        })
+      end
+
+      example { expect(config.artifacts.key).to be == 'foo' }
+      example { expect(config.artifacts.secret).to be == 'bar' }
+      example { expect(config.artifacts.bucket).to be == 'whatever' }
+    end
+
+    context 'code_climate' do
+      example { expect(addons(code_climate: true).code_climate).to be == {} }
+      example { expect(addons(code_climate: { repo_token: "foo" }).code_climate.repo_token).to be == "foo" }
+    end
+
+    context 'coverity_scan' do
+      example do
+        config = addons(coverity_scan: { project: { name: :foo } })
+        expect(config.coverity_scan.project.name).to be == "foo"
+      end
+    end
+
+    context 'firefox' do
+      example { expect(addons(firefox: '15').firefox).to be == '15' }
+    end
+
+    context 'hosts' do
+      example { expect(addons(hosts: 'foo.dev').hosts).to be == ['foo.dev'] }
+      example { expect(addons(hosts: ['foo.dev', 'bar.dev']).hosts).to be == ['foo.dev', 'bar.dev'] }
+    end
+
+    context 'postgresql' do
+      example { expect(addons(postgresql: '9.1').postgresql).to be == '9.1' }
+    end
+
+    context 'sauce_connect' do
+      example { expect(addons(sauce_connect: true).sauce_connect).to be == {} }
+      example { expect(addons(sauce_connect: { username: "foo" }).sauce_connect.username).to be == "foo" }
+    end
+
+    context 'ssh_known_hosts' do
+      example { expect(addons(ssh_known_hosts: 'git.example.org').ssh_known_hosts).to be == ['git.example.org'] }
+      example { expect(addons(ssh_known_hosts: ['git.example.org', 'git.example.com']).ssh_known_hosts).to be == ['git.example.org', 'git.example.com'] }
+    end
+  end
+end

data/spec/nodes/cache_spec.rb

@@ -2,12 +2,12 @@ describe Travis::Yaml::Nodes::Cache do
   context 'from Ruby' do
     specify 'with true' do
       config = Travis::Yaml.parse(cache: true)
-      expect(config.cache).to be == { 'apt' => true, 'bundler' => true }
+      expect(config.cache).to be == { 'apt' => true, 'bundler' => true, 'cocoapods' => true }
     end
 
     specify 'with false' do
       config = Travis::Yaml.parse(cache: false)
-      expect(config.cache).to be == { 'apt' => false, 'bundler' => false }
+      expect(config.cache).to be == { 'apt' => false, 'bundler' => false, 'cocoapods' => false }
     end
 
     specify 'with string' do
@@ -29,12 +29,12 @@ describe Travis::Yaml::Nodes::Cache do
   context 'from YAML' do
     specify 'with true' do
       config = Travis::Yaml.parse('cache: on')
-      expect(config.cache).to be == { 'apt' => true, 'bundler' => true }
+      expect(config.cache).to be == { 'apt' => true, 'bundler' => true, 'cocoapods' => true }
     end
 
     specify 'with false' do
       config = Travis::Yaml.parse('cache: off')
-      expect(config.cache).to be == { 'apt' => false, 'bundler' => false }
+      expect(config.cache).to be == { 'apt' => false, 'bundler' => false, 'cocoapods' => false }
     end
 
     specify 'with string' do

data/spec/nodes/deploy_spec.rb

@@ -46,6 +46,18 @@ describe Travis::Yaml::Nodes::Deploy do
       config = Travis::Yaml.parse(deploy: { provider: :heroku, on: { rvm: "2.0.0", repo: 'foo/bar', tags: true } })
       expect(config.deploy.first.on).to be == { 'ruby' => '2.0.0', 'repo' => 'foo/bar', 'tags' => true }
     end
+
+    specify 'with branch specific settings' do
+      config = Travis::Yaml.parse(deploy: { provider: :heroku, foo: { master: :bar, staging: :baz } })
+      expect(config.deploy.first['foo'])    .to be == { 'master' => 'bar', 'staging' => 'baz' }
+      expect(config.deploy.nested_warnings) .to be_empty
+    end
+
+    specify 'branches in settings that are not in the condition' do
+      config = Travis::Yaml.parse(deploy: { provider: :heroku, foo: { master: :bar, staging: :baz }, on: :master })
+      expect(config.deploy.first['foo'])    .to be == { 'master' => 'bar' }
+      expect(config.deploy.nested_warnings) .to include([['foo'], 'branch "staging" not permitted by deploy condition, dropping'])
+    end
   end
 
   describe 'from yaml' do

data/spec/nodes/dist_spec.rb

@@ -0,0 +1,11 @@
+describe Travis::Yaml::Nodes::Dist do
+  it 'adds warnings about feature' do
+    expect(Travis::Yaml.parse(language: 'ruby', dist: 'precise').warnings).
+      to include('your repository must be feature flagged for the "dist" setting to be used')
+  end
+
+  specify 'set dist value' do
+    config = Travis::Yaml.parse(dist: 'trusty')
+    expect(config.dist).to eq 'trusty'
+  end
+end

data/spec/nodes/env_spec.rb

@@ -0,0 +1,48 @@
+describe Travis::Yaml::Nodes::Deploy do
+  context 'from Ruby' do
+    specify 'list of values' do
+      config = Travis::Yaml.parse <<-YAML.gsub(/^ {8}/, '')
+        ---
+        language: ruby
+        env:
+        - "FOO=BAR"
+        - "FOX=BAZ"
+      YAML
+
+      expect(config.nested_warnings).to be_empty
+      expect(config.env.matrix.length).to be == 2
+    end
+
+    specify 'global with secure' do
+      config = Travis::Yaml.parse <<-YAML.gsub(/^ {8}/, '')
+        ---
+        language: ruby
+        env:
+          global:
+          - secure: "..."
+          - secure: "..."
+      YAML
+
+      expect(config.nested_warnings).to be_empty
+      expect(config.env.global.length).to be == 2
+    end
+
+    specify 'global and matrix' do
+      config = Travis::Yaml.parse <<-YAML.gsub(/^ {8}/, '')
+        ---
+        language: ruby
+        env:
+          matrix:
+          - "FOO=BAR"
+          - "FOX=BAZ"
+          global:
+          - secure: "..."
+          - secure: "..."
+      YAML
+
+      expect(config.nested_warnings).to be_empty
+      expect(config.env.global.length).to be == 2
+      expect(config.env.matrix.length).to be == 2
+    end
+  end
+end

data/spec/nodes/git_spec.rb

@@ -48,7 +48,7 @@ describe Travis::Yaml::Nodes::Git do
         expect(Travis::Yaml.parse('git: { depth: !str foo }').nested_warnings).to \
           include([['git'], 'dropping "depth" section: "str" not supported, dropping "foo"'])
         expect(Travis::Yaml.parse('git: { depth: foo }').nested_warnings).to \
-          include([['git'], 'dropping "depth" section: failed to parse "int" - invalid value for Integer(): "foo"'])
+          include([['git'], 'dropping "depth" section: failed to parse "int" - invalid value for Integer: "foo"'])
       end
     end
   end

data/spec/nodes/group_spec.rb

@@ -0,0 +1,11 @@
+describe Travis::Yaml::Nodes::Group do
+  it 'adds warnings about feature' do
+    expect(Travis::Yaml.parse(group: 'dev').warnings).
+      to include('your repository must be feature flagged for the "group" setting to be used')
+  end
+
+  specify 'set group value' do
+    config = Travis::Yaml.parse(group: 'update')
+    expect(config.group).to eq 'update'
+  end
+end

data/spec/nodes/node_js_spec.rb

@@ -0,0 +1,14 @@
+describe Travis::Yaml do
+  context 'from ruby' do
+    specify 'valid versions' do
+      config = Travis::Yaml.parse(node_js: ['0.10', '0.8.0'], language: 'node.js')
+      expect(config.node_js).to be == ['0.10', '0.8.0']
+    end
+
+    specify 'invalid versions' do
+      config = Travis::Yaml.parse(node_js: ['0.10.x', '0.8.0'], language: 'node.js')
+      expect(config.node_js).to be == ['0.8.0']
+      expect(config.nested_warnings).to include([['node_js'], 'value "0.10.x" is not a valid version'])
+    end
+  end
+end

data/spec/nodes/notifications_spec.rb

@@ -42,4 +42,11 @@ describe Travis::Yaml::Nodes::Notifications do
       expect(config.notifications.email).to     be_enabled
     end
   end
+
+  context :flowdoc do
+    example "handles scalar value" do
+      config = Travis::Yaml.parse(notifications: { flowdock: "foo" })
+      expect(config.notifications.flowdock.api_token).to be == "foo"
+    end
+  end
 end