dapp 0.6.1 → 0.6.2

data/lib/dapp/config/shell.rb

@@ -1,64 +0,0 @@
-module Dapp
-  module Config
-    # Shell
-    class Shell
-      attr_reader :_before_install, :_before_setup, :_install, :_setup
-      attr_reader :_before_install_cache_version, :_before_setup_cache_version, :_install_cache_version, :_setup_cache_version
-
-      def initialize
-        @_before_install = []
-        @_before_setup   = []
-        @_install       = []
-        @_setup         = []
-      end
-
-      def before_install(*args, cache_version: nil)
-        @_before_install.concat(args)
-        @_before_install_cache_version = cache_version
-      end
-
-      def before_setup(*args, cache_version: nil)
-        @_before_setup.concat(args)
-        @_before_setup_cache_version = cache_version
-      end
-
-      def install(*args, cache_version: nil)
-        _install.concat(args)
-        @_install_cache_version = cache_version
-      end
-
-      def setup(*args, cache_version: nil)
-        _setup.concat(args)
-        @_setup_cache_version = cache_version
-      end
-
-      def reset_before_install
-        @_before_install = []
-      end
-
-      def reset_before_setup
-        @_before_setup = []
-      end
-
-      def reset_install
-        @_install = []
-      end
-
-      def reset_setup
-        @_setup = []
-      end
-
-      def reset_all
-        methods.tap { |arr| arr.delete(__method__) }.grep(/^reset_/).each(&method(:send))
-      end
-
-      def empty?
-        @_before_install.empty? && @_before_setup.empty? && @_install.empty? && @_setup.empty?
-      end
-
-      def clone
-        Marshal.load(Marshal.dump(self))
-      end
-    end
-  end
-end

data/lib/dapp/helper/i18n.rb

@@ -1,20 +0,0 @@
-module Dapp
-  module Helper
-    # I18n
-    module I18n
-      def self.initialize
-        ::I18n.load_path << Dir[File.join(Dapp.root, 'config', '**', '*')].select { |path| File.file?(path) }
-        ::I18n.reload!
-        ::I18n.locale = :en
-      end
-
-      def t(context: nil, **desc)
-        code = desc[:code]
-        data = desc[:data] || {}
-        ::I18n.t [:common, context, code].join('.'), [:common, code].join('.'), **data, raise: true
-      rescue ::I18n::MissingTranslationData => _e
-        raise ::NetStatus::Exception, code: :missing_translation, data: { code: code }
-      end
-    end
-  end # Helper
-end # Dapp

data/lib/dapp/helper/paint.rb

@@ -1,27 +0,0 @@
-module Dapp
-  module Helper
-    # Paint
-    module Paint
-      FORMAT = {
-        step: [:yellow, :bold],
-        info: [:blue],
-        success: [:green, :bold],
-        warning: [:red, :bold],
-        secondary: [:white, :bold],
-        default: [:white]
-      }.freeze
-
-      def paint_style(name)
-        FORMAT[name].tap do |format|
-          raise if format.nil?
-        end
-      end
-
-      def paint_string(object, style_name)
-        ::Paint[::Paint.unpaint(object.to_s), *paint_style(style_name)]
-      end
-    end # Paint
-  end # Helper
-end # Dapp
-
-Dapp::Helper::Paint.extend Dapp::Helper::Paint

data/lib/dapp/helper/shellout.rb

@@ -1,63 +0,0 @@
-module Dapp
-  module Helper
-    # Shellout
-    module Shellout
-      include Streaming
-
-      def shellout(*args, log_verbose: false, **kwargs)
-        log_verbose = (log_verbose && cli_options[:log_verbose]) if defined? cli_options
-        kwargs[:live_stream] ||= STDOUT if log_verbose
-
-        env = nil
-
-        Shellout.default_env_keys.each do |env_key|
-          env_key = env_key.to_s.upcase
-          env ||= {}
-          env[env_key] = ENV[env_key]
-        end
-
-        param_env = (kwargs.delete(:env) || kwargs.delete(:environment))
-        param_env = param_env.map { |key, value| [key.to_s.upcase, value.to_s] }.to_h if param_env
-
-        env = (env || {}).merge(param_env) if param_env
-        kwargs[:env] = env if env
-
-        do_shellout = -> { ::Mixlib::ShellOut.new(*args, timeout: 3600, **kwargs).run_command }
-        if defined? ::Bundler
-          ::Bundler.with_clean_env { do_shellout.call }
-        else
-          do_shellout.call
-        end
-      end
-
-      def shellout!(*args, log_verbose: false, log_time: false, **kwargs)
-        stream = Stream.new
-        log_time = defined?(cli_options) ? cli_options[:log_time] : log_time
-        if log_verbose
-          kwargs[:live_stream] = Proxy::Base.new(stream, STDOUT, with_time: log_time)
-        else
-          kwargs[:live_stdout] = Proxy::Base.new(stream, with_time: log_time)
-        end
-        kwargs[:live_stderr] = Proxy::Error.new(stream, with_time: log_time)
-        shellout(*args, **kwargs).tap(&:error!)
-      rescue ::Mixlib::ShellOut::ShellCommandFailed => e
-        raise Error::Shellout, code: Trivia.class_to_lowercase(e.class),
-                               data: { stream: stream.show }
-      end
-
-      def shellout_pack(command)
-        "eval $(echo #{Base64.strict_encode64(command)} | base64 --decode)"
-      end
-
-      class << self
-        def included(base)
-          base.extend(self)
-        end
-
-        def default_env_keys
-          @default_env_keys ||= []
-        end
-      end # << self
-    end
-  end # Helper
-end # Dapp

data/lib/dapp/helper/streaming.rb

@@ -1,47 +0,0 @@
-module Dapp
-  module Helper
-    # Streaming
-    module Streaming
-      # Stream
-      class Stream
-        def buffer
-          @buffer ||= []
-        end
-
-        def <<(string)
-          buffer << string
-        end
-
-        def show
-          buffer.join.strip
-        end
-      end
-
-      # Proxy
-      module Proxy
-        # Base
-        class Base
-          def initialize(*streams, with_time: false)
-            @streams = streams
-            @with_time = with_time
-          end
-
-          def <<(str)
-            @streams.each { |s| s << format_string(str) }
-          end
-
-          def format_string(str)
-            str.lines.map { |l| "#{Project::Logging.log_time if @with_time}#{l.strip}\n" }.join
-          end
-        end
-
-        # Error
-        class Error < Base
-          def format_string(str)
-            "#{Paint.paint_string(super.strip, :warning)}\n"
-          end
-        end
-      end
-    end
-  end # Helper
-end # Dapp

data/lib/dapp/project/command/stages_cleanup.rb

@@ -1,72 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      # StagesCleanup
-      module StagesCleanup
-        def stages_cleanup(repo)
-          repo_applications = repo_applications(repo)
-          build_configs.map(&:_basename).uniq.each do |basename|
-            lock("#{basename}.images") do
-              log(basename)
-              containers_flush(basename)
-              apps, stages = project_images(basename).partition { |_, image_id| repo_applications.values.include?(image_id) }
-              apps, stages = apps.to_h, stages.to_h
-              apps.each { |_, aiid| stages = clear_stages(aiid, stages) }
-              run_command(%(docker rmi #{stages.keys.join(' ')})) unless stages.keys.empty?
-            end
-          end
-        end
-
-        def clear_stages(image_id, stages)
-          if image_exist?(image_id)
-            image_dapp_artifacts_label(image_id).each { |aiid| clear_stages(aiid, stages) }
-            iid = image_id
-            loop do
-              stages.delete_if { |_, siid| siid == iid }
-              break if (iid = image_parent(iid)).empty?
-            end
-          else
-            stages.delete_if { |_, siid| siid == image_id }
-          end
-          stages
-        end
-
-        protected
-
-        def registry(repo)
-          @registry ||= DockerRegistry.new(repo)
-        end
-
-        def repo_applications(repo)
-          @repo_apps ||= begin
-            registry = registry(repo)
-            registry.tags.select { |tag| !tag.start_with?('dappstage') }.map { |tag| [tag, registry.image_id_by_tag(tag)] }.to_h
-          end
-        end
-
-        def project_images(basename)
-          shellout!(%(docker images --format "{{.Repository}}:{{.Tag}};{{.ID}}" --no-trunc #{stage_cache(basename)})).stdout.lines.map do |line|
-            line.strip.split(';')
-          end.to_h
-        end
-
-        def image_parent(image_id)
-          shellout!(%(docker inspect -f {{.Parent}} #{image_id})).stdout.strip
-        end
-
-        def image_dapp_artifacts_label(image_id)
-          Image::Docker.image_config_option(image_id: image_id, option: 'labels').select { |k, _v| k.start_with?('dapp-artifact') }.values
-        end
-
-        def image_exist?(image_id)
-          shellout!(%(docker inspect #{image_id}))
-          true
-        rescue Error::Shellout
-          false
-        end
-      end
-    end
-  end # Project
-end # Dapp

data/lib/dapp/project/command/stages_flush.rb

@@ -1,20 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      # StagesFlush
-      module StagesFlush
-        def stages_flush
-          build_configs.map(&:_basename).uniq.each do |basename|
-            lock("#{basename}.images") do
-              log(basename)
-              containers_flush(basename)
-              remove_images(%(docker images --format="{{.Repository}}:{{.Tag}}" #{stage_cache(basename)}))
-            end
-          end
-        end
-      end
-    end
-  end # Project
-end # Dapp

data/lib/dapp/project/paint.rb

@@ -1,16 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Paint
-    module Paint
-      def paint_initialize
-        ::Paint.mode = case cli_options[:log_color]
-                       when 'auto' then STDOUT.tty? ? 8 : 0
-                       when 'on'   then 8
-                       when 'off'  then 0
-                       else raise
-                       end
-      end
-    end # Paint
-  end # Project
-end # Dapp