travis-yaml 0.1.0 → 0.2.0

data/lib/travis/yaml.rb

@@ -7,17 +7,20 @@ module Travis
     require 'travis/yaml/nodes'
     require 'travis/yaml/matrix'
     require 'travis/yaml/parser'
+    require 'travis/yaml/serializer'
 
     extend self
 
     def parse(value)
-      Parser.parse(value)
+      result = Parser.parse(value)
+      yield result if block_given?
+      result
     end
 
     alias_method :load, :parse
 
-    def parse!(value, file_name = '.travis.yml')
-      result = parse(value)
+    def parse!(value, file_name = '.travis.yml', &block)
+      result = parse(value, &block)
       result.nested_warnings.each do |key, message|
         warn key.empty? ? "#{file_name}: #{message}" :
           "#{file_name}: #{key.join(?.)} section - #{message}"

data/lib/travis/yaml/matrix.rb

@@ -10,23 +10,18 @@ module Travis::Yaml
     KEYS = EXPAND_KEYS + [:env]
 
     class Entry < DelegateClass(Nodes::Root)
-      attr_reader :env, :matrix_attributes
-
+      attr_reader :matrix_attributes
       def initialize(root, matrix_attributes)
-        super(root)
-
-        @matrix_attributes = matrix_attributes
-        @env               = Nodes::Env.new(self)
-        inherited_env      = root.env.global if root.env
-        @env.global        = [matrix_attributes[:env], *inherited_env].compact
-      end
-
-      EXPAND_KEYS.each do |key|
-        define_method(key) { @matrix_attributes.fetch(key, super()) }
-      end
-
-      def inspect
-        "#<#{self.class}: #{matrix_attributes}>"
+        @matrix_attributes   = matrix_attributes
+        normal_attributes    = matrix_attributes.select { |key| key != :env }
+        generated_root       = root.with_value(normal_attributes)
+        if matrix_attributes[:env]
+          generated_root.env.global = Travis::Yaml::Nodes::Env::List.new(generated_root.env)
+          generated_root.env.global.add_value! root.env.global if root.env.global
+          generated_root.env.global.add_value! matrix_attributes[:env]
+          generated_root.env.mapping.delete "matrix"
+        end
+        super(generated_root)
       end
     end
 
@@ -53,7 +48,7 @@ module Travis::Yaml
           m.include.each { |i| entries << Hash[axes.map { |k| [k, i[k]] }] } if m.include
         end
         entries.map! { |attributes| Entry.new(root, attributes) }
-        entries.any? ? entries : [root]
+        entries.any? ? entries : [Entry.new(root, {})]
       end
     end
 

data/lib/travis/yaml/nodes.rb

@@ -35,6 +35,10 @@ module Travis::Yaml
     require 'travis/yaml/nodes/notifications'
     require 'travis/yaml/nodes/branches'
     require 'travis/yaml/nodes/cache'
+    require 'travis/yaml/nodes/addons'
+    require 'travis/yaml/nodes/android'
+    require 'travis/yaml/nodes/dist'
+    require 'travis/yaml/nodes/group'
     require 'travis/yaml/nodes/root'
   end
 end

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

@@ -0,0 +1,44 @@
+module Travis::Yaml
+  module Nodes
+    class Addons < Mapping
+      class Addon < Mapping
+        def self.[](*keys)
+          Class.new(self) { map(*keys, to: Scalar[:str, :secure])}
+        end
+
+        def visit_scalar(visitor, type, value, implicit = true)
+          return super unless type == :bool
+        end
+      end
+
+      class CoverityScan < Addon
+        class Project < Mapping
+          map :name, to: Scalar[:str, :secure], required: true
+        end
+
+        map :project, to: Project
+        map :build_script_url, :branch_pattern, :notification_email, :build_command,
+          :build_command_prepend, to: Scalar[:str, :secure]
+      end
+
+      class Artifacts < Addon
+        map :bucket,       to: Scalar[:str, :secure], required: true
+        map :key,          to: Scalar[:str, :secure], required: true
+        map :paths,        to: Sequence
+        map :secret,       to: Scalar[:str, :secure], required: true
+
+        map :branch, :log_format, :target_paths, to: Scalar[:str, :secure]
+        map :debug, :concurrency, :max_size, to: Scalar[:str, :int, :secure]
+      end
+
+      map :artifacts,       to: Artifacts, drop_empty: false
+      map :code_climate,    to: Addon[:repo_token], drop_empty: false
+      map :coverity_scan,   to: CoverityScan
+      map :firefox,         to: Version
+      map :hosts,           to: Sequence
+      map :postgresql,      to: Version
+      map :sauce_connect,   to: Addon[:username, :access_key], drop_empty: false
+      map :ssh_known_hosts, to: Sequence
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Travis::Yaml
+  module Nodes
+    class Android < Mapping
+      map :components, :licenses, to: VersionList
+    end
+  end
+end

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

@@ -1,14 +1,16 @@
 module Travis::Yaml
   module Nodes
     class Cache < Mapping
-      map :apt, :bundler, to: Scalar[:bool]
+      map :apt, :bundler, :cocoapods, to: Scalar[:bool]
+      map :edge, to: Scalar[:bool], experimental: true
       map :directories, to: Sequence
 
       def visit_scalar(visitor, type, value, implicit = true)
         case type
         when :bool
-          visit_key_value(visitor, :bundler, value)
-          visit_key_value(visitor, :apt,     value)
+          visit_key_value(visitor, :bundler,   value)
+          visit_key_value(visitor, :apt,       value)
+          visit_key_value(visitor, :cocoapods, value)
         when :str
           key = visitor.generate_key(self, value)
           self[key] = true

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

@@ -4,7 +4,8 @@ module Travis::Yaml
       include LanguageSpecific
       map :jdk, :node, :perl, :php, :python, :ruby, :scala, :node, to: Version
       map :rvm, to: :ruby
-      map :repo, :branch, :condition, to: Scalar[:str]
+      map :repo, to: Scalar[:str]
+      map :branch, :condition, to: Sequence[:str]
       map :all_branches, :tags, to: Scalar[:bool]
       prefix_scalar :branch
     end

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

@@ -1,10 +1,56 @@
 module Travis::Yaml
   module Nodes
     class DeployEntry < OpenMapping
+      class Setting < OpenMapping
+        KEY = ''
+        prefix_scalar KEY
+        default_type Scalar[:str, :secure]
+
+        def ==(other)
+          return true if super
+          return false unless branch_specific?
+          generic == other
+        end
+
+        def __getobj__
+          branch_specific? ? generic : super
+        end
+
+        def inspect
+          branch_specific? ? generic.inspect : super
+        end
+
+        def branch_specific?
+          @mapping.size == 1 and @mapping.include? KEY
+        end
+
+        def branches
+          @mapping.keys - [KEY]
+        end
+
+        def generic
+          @mapping[KEY]
+        end
+
+        def verify_branch(name)
+          branches.each do |branch|
+            next if branch.to_s == name.to_s
+            warning "branch %p not permitted by deploy condition, dropping", branch
+            @mapping.delete(branch)
+          end
+        end
+      end
+
+      default_type Setting
       prefix_scalar :provider
       map :provider, to: Scalar, required: true
       map :edge, to: Scalar[:bool], experimental: true
       map :on, to: DeployConditions
+
+      def verify
+        @mapping.each_value { |v| v.verify_branch(on.branch) if v.respond_to? :verify_branch } if on and on.branch
+        super
+      end
     end
   end
 end

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

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

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

@@ -11,7 +11,7 @@ module Travis::Yaml
           visitor.apply_mapping(self, value)
         end
 
-        def visit_mapping(visitor, key, value)
+        def visit_key_value(visitor, key, value)
           key  = visitor.generate_key(self, key)
           node = Scalar.new
           visitor.accept(node, value)

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

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

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

@@ -9,10 +9,11 @@ module Travis::Yaml
       value jvm: :java, javascript: :node_js, node: :node_js, nodejs: :node_js, golang: :go,
             objective_c: :"objective-c", obj_c: :"objective-c", objc: :"objective-c"
       value "c++" => :cpp, "node.js" => :node_js, "obj-c" => :"objective-c"
+      value :generic, bash: :generic, sh: :generic, shell: :generic
 
       def default_os
-        value == "objective-c" ? :osx : OSEntry.default
+        value == "objective-c" ? "osx" : OSEntry.default
       end
     end
   end
-end
+end

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

@@ -24,12 +24,12 @@ module Travis::Yaml
         gemfile:          %w[ruby objective-c],
         composer_args:    %w[php],
         npm_args:         %w[node_js],
-        sdk_components:   %w[android]
+        android:          %w[android]
       }
 
       def verify_language(language)
         LANGUAGE_SPECIFIC.each do |key, languages|
-          next unless include? key and not languages.include? language
+          next unless include? key and not languages.include? language.value
           mapping.delete mapped_key(key)
           warning "specified %p, but setting is not relevant for %p", key.to_s, language
         end

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

@@ -42,17 +42,27 @@ module Travis::Yaml
         prefix_scalar(key)
       end
 
-      def self.prefix_sequence(key)
-        define_method(:visit_sequence) do |visitor, value|
-          visit_key_value(visitor, key, value)
+      def self.prefix_sequence(key = nil)
+        @prefix_sequence ||= superclass.respond_to?(:prefix_sequence) ? superclass.prefix_sequence : nil
+        if key
+          @prefix_sequence = key.to_s
+          define_method(:visit_sequence) do |visitor, value|
+            visit_key_value(visitor, key, value)
+          end
         end
+        @prefix_sequence
       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)
+      def self.prefix_scalar(key = nil, *types)
+        @prefix_scalar ||= superclass.respond_to?(:prefix_scalar) ? superclass.prefix_scalar : nil
+        if key
+          @prefix_scalar = key.to_s
+          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
+        @prefix_scalar
       end
 
       def self.define_map_accessor(key)
@@ -84,6 +94,7 @@ module Travis::Yaml
 
       def visit_key_value(visitor, key, value)
         return warning("unexpected key %p, dropping", key) unless node = subnode_for(key)
+        warning("has multiple %p entries, keeping last entry", key) if self[key]
         self[key] = node
         visitor.accept(node, value)
       end
@@ -93,12 +104,12 @@ module Travis::Yaml
       end
 
       def []=(key, value)
-        if key = mapped_key(key)
+        if mapped_key = mapped_key(key)
           unless value.is_a? Node
-            node  = subnode_for(key)
+            node  = subnode_for(mapped_key)
             value = node if Parser::Ruby.new(value).parse(node)
           end
-          @mapping[key] = value
+          @mapping[mapped_key] = value
         else
           warning("unexpected key %p, dropping", key)
         end
@@ -199,6 +210,24 @@ module Travis::Yaml
           list = value.nested_warnings(*prefix, key) + list
         end
       end
+
+      def with_value!(value)
+        value = value.mapping while value.is_a? Mapping
+        value.each { |key, value| self[key] = value }
+      end
+
+      def each_scalar(type = nil, &block)
+        return enum_for(:each_scalar, type) unless block
+        @mapping.each_value { |v| v.each_scalar(type, &block) }
+      end
+
+      protected
+
+        def dup_values
+          duped_mapping = @mapping.map { |key, value| [key.dup, value.dup] }
+          @mapping      = Hash[duped_mapping]
+          self
+        end
     end
   end
 end

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

@@ -5,7 +5,7 @@ module Travis::Yaml
         false
       end
 
-      attr_accessor :partent
+      attr_accessor :parent
       def initialize(parent)
         @nested_warnings = []
         @parent          = parent
@@ -97,6 +97,63 @@ module Travis::Yaml
       def to_s
         __getobj__.to_s
       end
+
+      def decrypt(&block)
+        each_scalar(SecureString) { |v| v.decrypt(&block) }
+      end
+
+      def encrypt(&block)
+        each_scalar(SecureString) { |v| v.encrypt(&block) }
+      end
+
+      def decrypted?
+        each_scalar(SecureString).all? { |v| v.decrypted? }
+      end
+
+      def encrypted?
+        each_scalar(SecureString).all? { |v| v.encrypted? }
+      end
+
+      def serialize(serializer, options = nil)
+        Serializer[serializer].serialize(self, options)
+      end
+
+      def to_yaml(options = nil)
+        serialize(:yaml, options)
+      end
+
+      def to_json(options = nil)
+        serialize(:json, options)
+      end
+
+      def to_ruby(options = nil)
+        serialize(:ruby, options)
+      end
+
+      def to_legacy_ruby(options = nil)
+        serialize(:legacy, options)
+      end
+
+      def with_value(value)
+        node = dup
+        node.with_value!(value)
+        node
+      end
+
+      def dup
+        super.dup_values
+      end
+
+      protected
+
+        def dup_values
+          self
+        end
+
+        def dup_ivar(name)
+          instance_variable_set(name, instance_variable_get(name).dup)
+        rescue TypeError
+        end
     end
   end
 end

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

@@ -3,6 +3,10 @@ module Travis::Yaml
     class Notifications < Mapping
       Callbacks ||= FixedValue[:always, :never, :change]
 
+      class List < Sequence
+        type Scalar[:str, :secure]
+      end
+
       class Notification < Mapping
         map :enabled, :disabled, to: Scalar[:bool]
         map :on_success, :on_failure, :on_start, to: Callbacks
@@ -12,7 +16,7 @@ module Travis::Yaml
         end
 
         def self.list(name)
-          map name, to: Sequence
+          map name, to: List
           prefix_sequence name
           prefix_scalar name, :str, :secure
         end
@@ -32,7 +36,7 @@ module Travis::Yaml
       end
 
       class Template < Sequence
-        VARIABLES = %w[repository_slug repository_name repository build_number branch commit author message duration compare_url build_url]
+        VARIABLES = %w[repository_slug repository_name repository build_number branch commit author message duration compare_url build_url commit_message]
 
         def verify
           super
@@ -60,18 +64,18 @@ module Travis::Yaml
         list :rooms
       end
 
-      class Flowdoc < Notification
+      class Flowdock < Notification
         map :api_token, to: Scalar[:str, :secure]
-        prefix_scalar name, :str, :secure
+        prefix_scalar :api_token, :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 :flowdock,                    to: Flowdock
       map :hipchat,                     to: Hipchat
       map :irc,                         to: IRC
       map :webhook,                     to: :webhooks
     end
   end
-end
+end