vx-builder 0.0.2

data/lib/vx/builder/source/matrix.rb

@@ -0,0 +1,113 @@
+module Vx
+  module Builder
+    class Source
+      class Matrix
+
+        KEYS = (Source::LANGS + %w{ matrix_env:env }).freeze
+        NOT_MATRIX_KEYS = %w{ script before_script services }
+
+        attr_reader :source
+
+        def initialize(build_configuration)
+          @source = build_configuration
+        end
+
+        def keys
+          extract_pair_of_key_and_values.map(&:first).sort
+        end
+
+        def configurations
+          attributes_for_new_configurations_with_merged_env.map do |attrs|
+            attrs = attrs.merge(
+              NOT_MATRIX_KEYS.inject({}) do |a,v|
+                a[v] = source.public_send(v)
+                a
+              end
+            )
+            Source.new attrs
+          end
+        end
+
+        def attributes_for_new_configurations_with_merged_env
+          attrs = attributes_for_new_configurations
+          attrs = [{}] if attrs.empty?
+          attrs.map do |a|
+            e = a["env"]
+            a["env"] = {
+              "global" => Array(e) + source.global_env,
+              "matrix" => e
+            }
+            a
+          end
+          attrs
+        end
+
+        def attributes_for_new_configurations
+          permutate_and_build_values.inject([]) do |ac, values|
+            ac << values.inject({}) do |a,val|
+              a[val.key] = val.value
+              a
+            end
+            ac
+          end
+        end
+
+        def permutate_and_build_values
+          values = extract_pair_of_key_and_values.map do |key, vals|
+            vals.map{|it| Value.new(key, it) }
+          end
+          if matrix_values?(values)
+            array_permutations(values).map do |it|
+              if it.is_a?(Array)
+                it.flatten
+              else
+                [it]
+              end
+            end
+          else
+            [values.flatten]
+          end.sort_by(&:to_s)
+        end
+
+        def extract_pair_of_key_and_values
+          KEYS.map.inject([]) do |a, k|
+            k_method, k_name = k.split(":")
+            k_name ||= k_method
+
+            if (val = source[k_method]) && !val.empty?
+              a << [k_name, val]
+            end
+            a
+          end
+        end
+
+        private
+
+          def matrix_values?(values)
+            !values.all?{|i| i.size == 1 }
+          end
+
+          def array_permutations array, index=0
+            # index is 0 by default : start at the beginning, more elegant.
+            return array[-1] if index == array.size - 1 # Return last element if at end.
+
+            result = []
+
+            array[index].each do |element| # For each array
+              array_permutations(array, index + 1).each do |x| # Permute permute permute
+                result << [element, x]
+              end
+            end
+            result
+          end
+
+          Value = Struct.new(:key, :value) do
+            def to_s
+              [key, value].join(":")
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/vx/builder/source/serializable.rb

@@ -0,0 +1,43 @@
+require 'yaml'
+require 'json'
+
+module Vx
+  module Builder
+    class Source
+
+      module Serializable
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        def to_yaml
+          YAML.dump(attributes)
+        end
+
+        def to_hash
+          attributes
+        end
+
+        module ClassMethods
+
+          def from_file(file)
+            if File.readable? file
+              from_yaml File.read(file)
+            end
+          end
+
+          def from_yaml(yaml)
+            from_attributes YAML.load(yaml)
+          end
+
+          def from_attributes(attrs)
+            Source.new attrs
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/vx/builder/source.rb

@@ -0,0 +1,106 @@
+require File.expand_path("../source/constants",    __FILE__)
+require File.expand_path("../source/matrix",       __FILE__)
+require File.expand_path("../source/serializable", __FILE__)
+
+module Vx
+  module Builder
+    class Source
+
+      include Source::Serializable
+
+      attr_reader :attributes
+      alias_method :to_hash, :attributes
+
+      def initialize(attrs = {})
+        @attributes = normalize_attributes attrs
+      end
+
+      def [](val)
+        public_send(val)
+      end
+
+      def matrix_keys
+        @matrix_keys ||=
+          Matrix::KEYS.inject({}) do |a,k|
+          k_method, k_name = k.split(":")
+          k_name ||= k_method
+          val = send(k_method)
+          unless val.empty?
+            a[k_name] = val.first
+          end
+          a
+        end
+      end
+
+      def to_matrix_s
+        @to_matrix_s ||= matrix_keys.map{|k,v| "#{k}:#{v}" }.sort.join(", ")
+      end
+
+      def to_script_builder(build)
+        ScriptBuilder.new(build, self)
+      end
+
+      def env
+        attributes["env"]
+      end
+
+      def matrix_env
+        attributes["env"]["matrix"]
+      end
+
+      def global_env
+        attributes["env"]["global"]
+      end
+
+      AS_ARRAY.each do |m|
+        define_method m do
+          @attributes[m] || []
+        end
+      end
+
+      def merge(attrs = {})
+        self.class.from_attributes self.attributes.merge(attrs)
+      end
+
+      private
+
+        def normalize_attributes(attributes)
+          attributes = attributes.inject({}) do |a,row|
+            k,v = row
+            if AS_ARRAY.include?(k.to_s)
+              v = Array(v)
+            end
+            a[k.to_s] = v
+            a
+          end
+          normalize_env_attribute attributes
+        end
+
+        def normalize_env_attribute(attributes)
+          env = (attributes['env'] || {}) .dup
+          case env
+          when Hash
+            attributes["env"] = {
+              "matrix" => Array(env['matrix']),
+              "global" => Array(env['global'])
+            }
+          else
+            attributes['env'] = {
+              "matrix" => Array(env).map(&:to_s),
+              "global" => []
+            }
+          end
+          freeze_normalized_attributes attributes
+        end
+
+        def freeze_normalized_attributes(attributes)
+          attributes.freeze
+          attributes['env'].freeze
+          attributes['env']['global'].freeze
+          attributes['env']['matrix'].freeze
+          attributes
+        end
+
+    end
+  end
+end

data/lib/vx/builder/task.rb

@@ -0,0 +1,27 @@
+module Vx
+  module Builder
+    class Task
+
+      attr_reader :name, :src, :sha, :deploy_key, :branch, :pull_request_id
+
+      def initialize(name, src, sha, options = {})
+        @name            = name
+        @src             = src
+        @sha             = sha
+        @deploy_key      = options[:deploy_key]
+        @branch          = options[:branch]
+        @pull_request_id = options[:pull_request_id]
+
+        validate!
+      end
+
+      private
+
+        def validate!
+          (name && src && sha && deploy_key && branch) or
+            raise(MissingKeys)
+        end
+
+    end
+  end
+end

data/lib/vx/builder/version.rb

@@ -0,0 +1,5 @@
+module Vx
+  module Builder
+    VERSION = "0.0.2"
+  end
+end

data/lib/vx/builder.rb

@@ -0,0 +1,38 @@
+require File.expand_path("../builder/version", __FILE__)
+
+module Vx
+  module Builder
+    autoload :Source,        File.expand_path("../builder/source",        __FILE__)
+    autoload :Script,        File.expand_path("../builder/script",        __FILE__)
+    autoload :Task,          File.expand_path("../builder/task",          __FILE__)
+    autoload :Configuration, File.expand_path("../builder/configuration", __FILE__)
+
+    module Helper
+      autoload :Config, File.expand_path("../builder/helper/config", __FILE__)
+      autoload :Logger, File.expand_path("../builder/helper/logger", __FILE__)
+      autoload :TraceShCommand, File.expand_path("../builder/helper/trace_sh_command", __FILE__)
+    end
+
+    class MissingKeys < Exception ; end
+
+    extend self
+
+    def logger
+      config.logger
+    end
+
+    def configure
+      yield config if block_given?
+      config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def reset_config!
+      @config = nil
+    end
+
+  end
+end

data/spec/fixtures/travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 2.0.0
+before_script:
+  - "echo before_script"
+script: "RAILS_ENV=test ls -1 && echo DONE!"

data/spec/fixtures/travis_bug_1.yml

@@ -0,0 +1,13 @@
+rvm:
+  - "2.0.0"
+
+env:
+  - DB=postgresql
+
+before_script:
+  - cp config/samples/secret_token.rb config/initializers/secret_token.rb
+  - cp config/database.travis.yml config/database.yml
+  - bundle exec rake db:setup
+
+script:
+  - bundle exec rake

data/spec/fixtures/travis_bug_2.yml

@@ -0,0 +1,18 @@
+# bug: ignore services
+rvm:
+  - "2.0.0"
+
+services:
+  - elasticsearch
+
+env:
+  - DB=postgresql
+
+before_script:
+  - cp config/samples/secret_token.rb config/initializers/secret_token.rb
+  - cp config/database.travis.yml config/database.yml
+  - bundle exec rake db:setup
+  - bundle exec rake db:test:prepare
+
+script:
+  - bundle exec rspec

data/spec/lib/builder/configuration_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Vx::Builder::Configuration do
+  its(:logger)           { should be }
+  its(:webdav_cache_url) { should be_nil }
+  its(:casher_ruby)      { should be }
+end

data/spec/lib/builder/script_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Vx::Builder::Script do
+  let(:task)   { create :task }
+  let(:source) { create :source }
+  let(:script) { described_class.new task, source }
+  subject { script }
+
+  context "just created" do
+    its(:source) { should eq source }
+    its(:task)   { should eq task  }
+  end
+
+  context "#to_before_script" do
+    subject { script.to_before_script }
+    it { should be }
+  end
+
+  context "#to_after_script" do
+    subject { script.to_after_script }
+    it { should be }
+  end
+
+  context "#to_script" do
+    subject { script.to_script }
+    it { should be }
+  end
+
+end

data/spec/lib/builder/source_matrix_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+require 'yaml'
+
+describe Vx::Builder::Source::Matrix do
+  let(:attributes) { {
+    env:   %w{ FOO=1 BAR=2 },
+    rvm:   %w{ 1.8.7 1.9.3 2.0.0 },
+    scala: %w{ 2.9.2 2.10.1 },
+    before_script: "echo before_script",
+    script: "echo script"
+  } }
+  let(:config) { Vx::Builder::Source.from_attributes attributes }
+  let(:matrix) { described_class.new config }
+
+  subject { matrix }
+
+  context "just created" do
+    its(:source) { should eq config }
+  end
+
+  context "keys" do
+    subject { matrix.keys }
+    it { should eq %w{ env rvm scala } }
+    context "without matrix" do
+      let(:attributes) { {} }
+
+      it { should eq [] }
+    end
+  end
+
+  context 'configurations' do
+    subject { matrix.configurations }
+
+    it "should copy script from source" do
+      expect(subject.map(&:script).uniq).to eq [["echo script"]]
+    end
+
+    it "should copy before_script from source" do
+      expect(subject.map(&:before_script).uniq).to eq [["echo before_script"]]
+    end
+
+    context "without any matrix keys" do
+      let(:attributes) { {
+        script: %w{ /bin/true },
+      } }
+
+      it { should have(1).item }
+      its("first.attributes") { should eq(
+        "env" => {
+          "matrix" => [],
+          "global" => []
+        },
+        "script"        =>["/bin/true"],
+        "before_script" =>[],
+        "services"      => []
+      )}
+    end
+
+    context "with one env and one rvm key" do
+      let(:config) { Vx::Builder::Source.from_file fixture_path("travis_bug_1.yml") }
+
+      it{ should have(1).item }
+
+      context "attributes" do
+        subject { matrix.configurations.map(&:to_matrix_s) }
+
+        it { should eq ["env:DB=postgresql, rvm:2.0.0"] }
+      end
+    end
+
+    context "with services key" do
+      let(:config) { Vx::Builder::Source.from_file fixture_path("travis_bug_2.yml") }
+      it { should have(1).item }
+
+      it "should have services" do
+        expect(matrix.configurations.first.services).to eq %w{ elasticsearch }
+      end
+
+    end
+
+    context "values" do
+
+      it { should have(12).items }
+
+      context "attributes" do
+        subject { matrix.configurations.map(&:to_matrix_s) }
+
+        it do
+          should eq [
+            "env:BAR=2, rvm:1.8.7, scala:2.10.1",
+            "env:FOO=1, rvm:1.8.7, scala:2.10.1",
+            "env:BAR=2, rvm:1.8.7, scala:2.9.2",
+            "env:FOO=1, rvm:1.8.7, scala:2.9.2",
+            "env:BAR=2, rvm:1.9.3, scala:2.10.1",
+            "env:FOO=1, rvm:1.9.3, scala:2.10.1",
+            "env:BAR=2, rvm:1.9.3, scala:2.9.2",
+            "env:FOO=1, rvm:1.9.3, scala:2.9.2",
+            "env:BAR=2, rvm:2.0.0, scala:2.10.1",
+            "env:FOO=1, rvm:2.0.0, scala:2.10.1",
+            "env:BAR=2, rvm:2.0.0, scala:2.9.2",
+            "env:FOO=1, rvm:2.0.0, scala:2.9.2"
+          ]
+        end
+
+        context "without matrix" do
+          let(:attributes) { {
+            rvm: %w{ 2.0.0 },
+          } }
+
+          it { should eq ['rvm:2.0.0'] }
+        end
+
+      end
+    end
+  end
+
+  context "attributes_for_new_confgurations_with_merged_env" do
+    subject { matrix.attributes_for_new_configurations_with_merged_env }
+
+    before do
+      attributes.merge!(
+        env: {
+          "global" => "FOO=1",
+          "matrix" => %w{ BAR=1 BAR=2 }
+        }
+      )
+    end
+
+    it { should have(12).items }
+
+    it "should merge matrix env to global env" do
+      expect(subject.map{|i| i["env"]["global"] }.uniq.sort).to eq([["BAR=1", "FOO=1"], ["BAR=2", "FOO=1"]])
+    end
+  end
+
+  context 'attributes_for_new_configurations' do
+    subject { matrix.attributes_for_new_configurations }
+
+    it { should have(12).items }
+
+    its(:first) { should eq("rvm"   => "1.8.7",
+                            "scala" => "2.10.1",
+                            "env"   => "BAR=2") }
+    its(:last)  { should eq("rvm"   => "2.0.0",
+                            "scala" => "2.9.2",
+                            "env"   => "FOO=1") }
+  end
+
+  context 'extract_pair_of_key_and_values' do
+    subject { matrix.extract_pair_of_key_and_values }
+    it {
+      should eq [
+        ["rvm",   %w{ 1.8.7 1.9.3 2.0.0 }],
+        ["scala", %w{ 2.9.2 2.10.1 }],
+        ["env",   %w{ FOO=1 BAR=2 }]
+      ]
+    }
+  end
+
+  context "permutate_and_build_values" do
+    subject { format_values matrix.permutate_and_build_values }
+    let(:expected) { [
+      %w{env:BAR=2 rvm:1.8.7 scala:2.10.1},
+      %w{env:BAR=2 rvm:1.8.7 scala:2.9.2},
+      %w{env:BAR=2 rvm:1.9.3 scala:2.10.1},
+      %w{env:BAR=2 rvm:1.9.3 scala:2.9.2},
+      %w{env:BAR=2 rvm:2.0.0 scala:2.10.1},
+      %w{env:BAR=2 rvm:2.0.0 scala:2.9.2},
+      %w{env:FOO=1 rvm:1.8.7 scala:2.10.1},
+      %w{env:FOO=1 rvm:1.8.7 scala:2.9.2},
+      %w{env:FOO=1 rvm:1.9.3 scala:2.10.1},
+      %w{env:FOO=1 rvm:1.9.3 scala:2.9.2},
+      %w{env:FOO=1 rvm:2.0.0 scala:2.10.1},
+      %w{env:FOO=1 rvm:2.0.0 scala:2.9.2},
+    ] }
+
+    it { should eq expected }
+
+    context "with empty keys" do
+      let(:attributes) { {
+        env:   %w{ FOO=1 BAR=2 },
+        rvm:   %w{ 1.8.7 1.9.3 2.0.0 },
+        scala: %w{ 2.9.2 2.10.1 },
+        java: [],
+        go: nil
+      } }
+      it { should eq expected }
+    end
+
+    context "with one key" do
+      let(:attributes) { {
+        rvm:   %w{ 1.9.3 2.0.0 },
+      } }
+      let(:expected) {[
+        %w{ rvm:1.9.3 },
+        %w{ rvm:2.0.0 }
+      ]}
+      it { should eq expected }
+    end
+
+    context "without matrix" do
+      let(:attributes) { {
+        rvm:   %w{ 2.0.0 },
+      } }
+      let(:expected) {[
+        %w{ rvm:2.0.0 }
+      ]}
+      it { should eq expected }
+    end
+
+    def format_values(values)
+      values.map{|i| i.map(&:to_s).sort }.sort
+    end
+  end
+end