matrixeval-ruby 0.3.1 → 0.4.0

data/lib/matrixeval/ruby/context/find_by_command_options.rb

@@ -1,67 +0,0 @@
-module Matrixeval
-  module Ruby
-    class Context
-      class FindByCommandOptions
-        class << self
-          def call(options)
-            new(options).call
-          end
-        end
-
-        attr_reader :options
-
-        def initialize(options)
-          @options = options
-        end
-
-        def call
-          context = Context.all.find do |context|
-            context.main_variant == main_variant &&
-             context.rest_variants == rest_variants
-          end
-
-          raise Error.new("Can't find a corresponding matrix") if context.nil?
-
-          context
-        end
-
-        private
-
-        def main_variant
-          dig_variant Config.main_vector
-        end
-
-        def rest_variants
-          Config.rest_vectors.map do |vector|
-            dig_variant vector
-          end.sort do |v1, v2|
-            v1.id <=> v2.id
-          end
-        end
-
-        def dig_variant(vector)
-          if option_key?(vector.key)
-            find_variant(vector)
-          else
-            vector.default_variant
-          end
-        end
-
-        def find_variant(vector)
-          vector.variants.find do |variant|
-            option(vector.key) == variant.key
-          end
-        end
-
-        def option(key)
-          options[key.to_sym] || options[key.to_s]
-        end
-
-        def option_key?(key)
-          options.key?(key.to_sym) || options.key?(key.to_s)
-        end
-
-      end
-    end
-  end
-end

data/lib/matrixeval/ruby/context.rb

@@ -1,86 +0,0 @@
-require_relative "./context/find_by_command_options"
-require_relative "./context/build_docker_compose_extend"
-
-module Matrixeval
-  module Ruby
-    class Context
-
-      class << self
-
-        def find_by_command_options!(options)
-          FindByCommandOptions.call(options)
-        end
-
-        def all
-          Config.variant_combinations.map do |variants|
-            Context.new(
-              main_variant:  variants.find { |v| v.vector.main? },
-              rest_variants: variants.reject { |v| v.vector.main? }
-            )
-          end.select do |context|
-            Config.exclusions.none? do |exclusion|
-              context.match_exclusion?(exclusion)
-            end
-          end
-        end
-
-      end
-
-      attr_reader :main_variant, :rest_variants
-
-      def initialize(main_variant:, rest_variants:)
-        @main_variant = main_variant
-        @rest_variants = (rest_variants || []).sort do |v1, v2|
-          v1.id <=> v2.id
-        end
-      end
-
-      def name
-        variants.map(&:name).join(", ")
-      end
-
-      def id
-        [[main_variant.id] + rest_variants.map(&:id)].join("_")
-      end
-
-      def env
-        rest_variants.map(&:env).reduce({}, &:merge)
-          .merge(main_variant.env)
-      end
-
-      def docker_compose_service_name
-        main_variant.id
-      end
-
-      def gemfile_lock_path
-        Matrixeval.working_dir.join(".matrixeval/gemfile_locks/#{id}")
-      end
-
-      def docker_compose_file_path
-        Matrixeval.working_dir.join(".matrixeval/docker-compose/#{id}.yml")
-      end
-
-      def variants
-        [main_variant] + rest_variants
-      end
-
-      def match_exclusion?(exclusion)
-        return false if exclusion.empty?
-
-        variants.all? do |variant|
-          vector_key = variant.vector.key
-          if exclusion.key?(vector_key)
-            exclusion[vector_key].to_s == variant.key
-          else
-            true
-          end
-        end
-      end
-
-      def docker_compose_extend
-        BuildDockerComposeExtend.call(self)
-      end
-
-    end
-  end
-end

data/lib/matrixeval/ruby/docker_compose/extend.rb

@@ -1,21 +0,0 @@
-module Matrixeval
-  module Ruby
-    class DockerCompose
-      class Extend
-
-        def initialize(config)
-          @config = config || {}
-        end
-
-        def volumes
-          @config["volumes"] || {}
-        end
-
-        def services
-          @config["services"] || {}
-        end
-
-      end
-    end
-  end
-end

data/lib/matrixeval/ruby/docker_compose/extend_raw.rb

@@ -1,19 +0,0 @@
-require 'json'
-
-module Matrixeval
-  module Ruby
-    class DockerCompose
-      class ExtendRaw
-
-        def initialize(config)
-          @config = config || {}
-        end
-
-        def content
-          @config.to_json
-        end
-
-      end
-    end
-  end
-end

data/lib/matrixeval/ruby/docker_compose/file.rb

@@ -1,135 +0,0 @@
-require "erb"
-
-module Matrixeval
-  module Ruby
-    class DockerCompose
-      class File
-        class << self
-
-          def create_all
-            FileUtils.mkdir_p folder
-
-            Context.all.each do |context|
-              new(context).create
-            end
-          end
-
-          private
-
-          def folder
-            Matrixeval.working_dir.join(".matrixeval/docker-compose")
-          end
-        end
-
-        attr_reader :context
-
-        def initialize(context)
-          @context = context
-        end
-
-        def create
-          ::File.open(docker_compose_file_path, 'w+') do |file|
-            file.puts build_content
-          end
-        end
-
-        private
-
-        def docker_compose_file_path
-          context.docker_compose_file_path
-        end
-
-        def build_content
-          {
-            "version" => "3",
-            "services" => services_json,
-            "volumes" => volumes_json
-          }.to_yaml.sub(/---\n/, "")
-        end
-
-        def services_json
-          services = {}
-
-          services[main_variant.docker_compose_service_name] = {
-            "image" => main_variant.container.image,
-            "volumes" => mounts(main_variant),
-            "environment" => {
-              "BUNDLE_PATH" => "/bundle",
-              "GEM_HOME" => "/bundle",
-              "BUNDLE_APP_CONFIG" => "/bundle",
-              "BUNDLE_BIN" => "/bundle/bin",
-              "PATH" => "/app/bin:/bundle/bin:$PATH"
-            }.merge(extra_env),
-            "working_dir" => "/app"
-          }.merge(depends_on)
-
-          services.merge(docker_compose_extend.services)
-        end
-
-        def volumes_json
-          {
-            bundle_volume => {
-              "name" => bundle_volume
-            }
-          }.merge(docker_compose_extend.volumes)
-        end
-
-        def depends_on
-          if docker_compose_extend.services.keys.empty?
-            {}
-          else
-            { "depends_on" => docker_compose_extend.services.keys }
-          end
-        end
-
-        def extra_env
-          Config.env.merge(context.env)
-                    .merge(main_variant.container.env)
-        end
-
-        def main_variant
-          context.main_variant
-        end
-
-        def bundle_volume
-          main_variant.bundle_volume_name
-        end
-
-        def mounts(variant)
-          [
-            "../..:/app:cached",
-            "#{variant.bundle_volume_name}:/bundle",
-            "../gemfile_locks/#{context.id}:/app/Gemfile.lock"
-          ] + extra_mounts
-        end
-
-        def extra_mounts
-          mounts = Config.mounts + context.variants.map(&:mounts).flatten
-          mounts.map do |mount|
-            local_path, in_docker_path = mount.split(':')
-            next mount if Pathname.new(local_path).absolute?
-
-            local_path = Matrixeval.working_dir.join(local_path)
-            docker_compose_folder_path = Matrixeval.working_dir.join(".matrixeval/docker-compose")
-            local_path = local_path.relative_path_from docker_compose_folder_path
-
-            "#{local_path}:#{in_docker_path}"
-          end
-        end
-
-        def docker_compose_extend
-          @docker_compose_extend ||= context.docker_compose_extend
-        end
-
-        def working_dir_name
-          Matrixeval.working_dir.basename
-        end
-
-        def project_name
-          Config.project_name.gsub(/[^A-Za-z0-9-]/,'_').downcase
-        end
-
-      end
-    end
-  end
-end

data/lib/matrixeval/ruby/docker_compose.rb

@@ -1,68 +0,0 @@
-
-require_relative "./docker_compose/file"
-
-module Matrixeval
-  module Ruby
-    class DockerCompose
-
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
-      end
-
-      def run(arguments)
-        forward_arguments = arguments.map do |arg|
-          arg.match(/\s/) ? "\"#{arg}\"" : arg
-        end.join(" ")
-
-        no_tty = %w[bash sh zsh dash].include?(arguments[0]) ? '' : '--no-TTY' 
-
-        system(
-          <<~DOCKER_COMPOSE_COMMAND
-          #{docker_compose} \
-          run --rm \
-          #{no_tty} \
-          #{context.docker_compose_service_name} \
-          #{forward_arguments}
-          DOCKER_COMPOSE_COMMAND
-        )
-      ensure
-        stop_containers
-        clean_containers_and_anonymous_volumes
-        turn_on_stty_opost
-      end
-
-      private
-
-      def stop_containers
-        system("#{docker_compose} stop >> /dev/null 2>&1")
-      end
-
-      def clean_containers_and_anonymous_volumes
-        system("#{docker_compose} rm -v -f >> /dev/null 2>&1")
-      end
-
-      def docker_compose
-        <<~DOCKER_COMPOSE_COMMAND.strip
-        docker --log-level error compose \
-        -f #{yaml_file} \
-        -p matrixeval-#{project_name}-#{context.id}
-        DOCKER_COMPOSE_COMMAND
-      end
-
-      def yaml_file
-        ".matrixeval/docker-compose/#{context.id}.yml"
-      end
-
-      def turn_on_stty_opost
-        system("stty opost")
-      end
-
-      def project_name
-        Config.project_name.gsub(/[^A-Za-z0-9-]/,'_').downcase
-      end
-
-    end
-  end
-end

data/lib/matrixeval/ruby/extra_mount_files.rb

@@ -1,23 +0,0 @@
-module Matrixeval
-  module Ruby
-    class ExtraMountFiles
-      class << self
-
-        def create
-          Config.all_mounts.each do |mount|
-            local_path, _ = mount.split(':')
-            next mount if Pathname.new(local_path).absolute?
-
-            local_path = Matrixeval.working_dir.join(local_path)
-            next if local_path.extname.empty?
-            next if local_path.ascend.none? { |path| path == Matrixeval.working_dir }
-
-            FileUtils.mkdir_p local_path.dirname
-            FileUtils.touch local_path
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/matrixeval/ruby/gemfile_locks.rb

@@ -1,23 +0,0 @@
-module Matrixeval
-  module Ruby
-    class GemfileLocks
-      class << self
-
-        def create
-          FileUtils.mkdir_p gemfile_lock_folder
-
-          Context.all.each do |context|
-            FileUtils.touch context.gemfile_lock_path
-          end
-        end
-
-        private
-
-        def gemfile_lock_folder
-          Matrixeval.working_dir.join(".matrixeval/gemfile_locks")
-        end
-
-      end
-    end
-  end
-end

data/lib/matrixeval/ruby/gitignore.rb

@@ -1,54 +0,0 @@
-module Matrixeval
-  module Ruby
-    class Gitignore
-      class << self
-
-        def update
-          add_docker_compose
-          add_gemfile_locks
-        end
-
-        private
-
-        def add_docker_compose
-          return if docker_compose_included?
-
-          File.open(gitignore_path, 'a+') do |file|
-            file.puts docker_compose
-          end
-        end
-
-        def add_gemfile_locks
-          return if gemfile_locks_included?
-
-          File.open(gitignore_path, 'a+') do |file|
-            file.puts gemfile_locks
-          end
-        end
-
-        def docker_compose_included?
-          File.exist?(gitignore_path) &&
-            File.read(gitignore_path).include?(docker_compose)
-        end
-
-        def gemfile_locks_included?
-          File.exist?(gitignore_path) &&
-            File.read(gitignore_path).include?(gemfile_locks)
-        end
-
-        def docker_compose
-          ".matrixeval/docker-compose"
-        end
-
-        def gemfile_locks
-          ".matrixeval/gemfile_locks"
-        end
-
-        def gitignore_path
-          Matrixeval.working_dir.join(".gitignore")
-        end
-
-      end
-    end
-  end
-end

data/lib/matrixeval/ruby/runner.rb

@@ -1,205 +0,0 @@
-require 'optparse'
-require 'pathname'
-require 'fileutils'
-require 'matrixeval/ruby/config'
-require 'matrixeval/ruby/command_line'
-require "concurrent/utility/processor_counter"
-require 'terminal-table'
-
-module Matrixeval
-  module Ruby
-    class Runner
-      class << self
-        def start(argv)
-          new(argv).start
-        end
-      end
-
-      attr_reader :argv, :command
-
-      def initialize(argv)
-        @argv = argv
-        @command = CommandLine.new(argv)
-        @threads ||= []
-        @matrixeval_results ||= []
-      end
-
-      def start
-        validates
-
-        if command.init?
-          init
-        elsif command.all?
-          run_all_contexts
-        else
-          run_a_specific_context
-        end
-      rescue OptionParser::InvalidOption => e
-        puts <<~ERROR
-          #{e.message}
-          See 'matrixeval --help'
-          ERROR
-        exit
-      rescue Config::YAML::MissingError
-        puts "Please run 'matrixeval init' first to generate matrixeval.yml"
-        exit
-      ensure
-        turn_on_stty_opost
-      end
-
-      private
-
-      def validates
-        return if command.valid?
-
-        puts <<~ERROR
-          matrixeval: '#{argv.join(' ')}' is not a MatrixEval command.
-          See 'matrixeval --help'
-          ERROR
-        exit
-      end
-
-      def init
-        Config::YAML.create
-        Gitignore.update
-      end
-
-      def run_all_contexts
-        Config::YAML.create
-        DockerCompose::File.create_all
-        GemfileLocks.create
-        Gitignore.update
-        ExtraMountFiles.create
-
-        pull_all_images
-
-        if workers_count == 1
-          run_all_contexts_sequentially
-        else
-          run_all_contexts_in_parallel
-        end
-      end
-
-      def run_all_contexts_sequentially
-        Context.all.each do |context|
-          puts Rainbow("[ MatrixEval ] ").blue.bright + Rainbow(" #{context.name} ").white.bright.bg(:blue)
-          puts Rainbow("[ MatrixEval ] Run \"#{command.rest_arguments.join(" ")}\"").blue.bright
-
-          docker_compose = DockerCompose.new(context)
-          success = docker_compose.run(command.rest_arguments)
-
-          @matrixeval_results << [context, !!success]
-        end
-
-        report
-      end
-
-      def run_all_contexts_in_parallel
-        parallel(contexts) do |sub_contexts|
-          Thread.current[:matrixeval_results] = []
-
-          sub_contexts.each do |context|
-            docker_compose = DockerCompose.new(context)
-            success = docker_compose.run(command.rest_arguments)
-
-            Thread.current[:matrixeval_results] << [context, !!success]
-          end
-        end
-
-        report
-      end
-
-      def run_a_specific_context
-        Config::YAML.create
-        DockerCompose::File.create_all
-        GemfileLocks.create
-        Gitignore.update
-        ExtraMountFiles.create
-
-        context = Context.find_by_command_options!(command.context_options)
-
-        puts Rainbow("[ MatrixEval ] ").blue.bright + Rainbow(" #{context.name} ").white.bright.bg(:blue)
-        puts Rainbow("[ MatrixEval ] Run \"#{command.rest_arguments.join(" ")}\"").blue.bright
-
-        docker_compose = DockerCompose.new(context)
-        docker_compose.run(command.rest_arguments)
-      end
-
-      def pull_all_images
-        parallel(Config.main_vector_variants) do |sub_variants|
-          sub_variants.each do |variant|
-            puts "Docker image check/pull #{variant.container.image}"
-            image_exists = system %Q{[ -n "$(docker images -q #{variant.container.image})" ]}
-            next if image_exists
-
-            system "docker pull #{variant.container.image}"
-          end
-        end
-      end
-
-      def report
-        turn_on_stty_opost
-
-        table = Terminal::Table.new(title: Rainbow("MatrixEval").blue.bright + " Summary", alignment: :center) do |table|
-
-          headers = Config.vectors.map(&:key) + ['result']
-          table.add_row headers.map { |value| { value: value, alignment: :center } }
-          table.add_separator 
-
-          @matrixeval_results.each do |context, success|
-            success_cell = [success ? Rainbow('Success').green : Rainbow('Failed').red]
-            row = (context.variants.map(&:key) + success_cell).map do |value|
-              { value: value, alignment: :center }
-            end
-
-            table.add_row row
-          end
-
-        end
-
-        puts table
-      end
-
-      def parallel(collection)
-        @threads = [] unless @threads.empty?
-        @matrixeval_results = [] unless @matrixeval_results.empty?
-
-        collection.each_slice(per_worker_contexts_count) do |sub_collection|
-          @threads << Thread.new do
-            yield sub_collection
-          end
-        end
-
-        @threads.each(&:join)
-
-        @threads.each do |thread|
-          @matrixeval_results += (thread[:matrixeval_results] || [])
-        end
-      end
-
-
-      def per_worker_contexts_count
-        [(contexts.count / workers_count), 1].max
-      end
-
-      def contexts
-        @contexts ||= Context.all
-      end
-
-      def workers_count
-        count = if Config.parallel_workers == "number_of_processors"
-          Concurrent.physical_processor_count
-        else
-          Integer(Config.parallel_workers)
-        end
-
-        [count, 1].max
-      end
-
-      def turn_on_stty_opost
-        system("stty opost")
-      end
-
-    end
-  end
-end