dapp 0.0.24 → 0.1.0

data/lib/dapp/git_repo/base.rb

@@ -2,22 +2,20 @@ module Dapp
   module GitRepo
     # Base class for any Git repo (remote, gitkeeper, etc)
     class Base
-      attr_reader :builder
+      attr_reader :application
       attr_reader :name
-      attr_reader :su
 
-      def initialize(builder, name, build_path: nil)
-        @builder = builder
+      def initialize(application, name)
+        @application = application
         @name = name
-        @build_path = build_path || []
       end
 
-      def build_path(*paths)
-        builder.build_path(*@build_path, *paths)
+      def container_build_dir_path
+        application.container_build_path "#{name}.git"
       end
 
       def dir_path
-        build_path "#{name}.git"
+        application.build_path "#{name}.git"
       end
 
       def git_bare(command, **kwargs)
@@ -28,7 +26,7 @@ module Dapp
         Time.at Integer git_bare("show -s --format=%ct #{commit}").stdout.strip
       end
 
-      def latest_commit(branch = 'master')
+      def latest_commit(branch)
         git_bare("rev-parse #{branch}").stdout.strip
       end
 
@@ -39,14 +37,14 @@ module Dapp
       def cleanup!
       end
 
-      def lock(**kwargs, &block)
-        builder.filelock(build_path("#{name}.lock"), error_message: "Repository #{name} in use! Try again later.", **kwargs, &block)
+      def branch
+        git_bare('rev-parse --abbrev-ref HEAD').stdout.strip
       end
 
       protected
 
       def git(command, **kwargs)
-        builder.shellout "git #{command}", **kwargs
+        application.shellout!("git #{command}", **kwargs)
       end
     end
   end

data/lib/dapp/git_repo/own.rb

@@ -2,12 +2,16 @@ module Dapp
   module GitRepo
     # Own Git repo
     class Own < Base
-      def initialize(builder, **kwargs)
-        super(builder, 'own', **kwargs)
+      def initialize(application)
+        super(application, 'own')
       end
 
       def dir_path
-        @dir_path ||= git("-C #{builder.home_path} rev-parse --git-dir").stdout.strip
+        @dir_path ||= Pathname(git("-C #{application.home_path} rev-parse --git-dir").stdout.strip).expand_path
+      end
+
+      def latest_commit(branch = nil)
+        super(branch || 'HEAD')
       end
     end
   end

data/lib/dapp/git_repo/remote.rb

@@ -2,37 +2,31 @@ module Dapp
   module GitRepo
     # Normal Git repo
     class Remote < Base
-      def initialize(builder, name, url:, ssh_key_path: nil, **kwargs)
-        super(builder, name, **kwargs)
+      def initialize(application, name, url:, ssh_key_path: nil)
+        super(application, name)
 
         @url = url
-        @ssh_key_path = File.expand_path(ssh_key_path, builder.home_path) if ssh_key_path
+        @ssh_key_path = File.expand_path(ssh_key_path, application.home_path) if ssh_key_path
 
         @use_ssh_key = false
-        File.chmod(0600, @ssh_key_path) if @ssh_key_path
+        File.chmod(0o600, @ssh_key_path) if @ssh_key_path
 
-        lock do
-          unless File.directory? dir_path
-            with_ssh_key do
-              git "clone --bare --depth 1 #{url} #{dir_path}", log_verbose: true
-            end
-          end
-        end
+        with_ssh_key do
+          git "clone --bare --depth 1 #{url} #{dir_path}"
+        end unless File.directory? dir_path
       end
 
       def fetch!(branch = 'master')
-        lock do
-          with_ssh_key do
-            git_bare "fetch origin #{branch}:#{branch}", log_verbose: true
+        with_ssh_key do
+          application.log_secondary_process(application.t(code: 'process.git_artifact_fetch', data: { name: name }), short: true) do
+            git_bare "fetch origin #{branch}:#{branch}"
           end
-        end
+        end unless application.ignore_git_fetch || application.dry_run?
       end
 
       def cleanup!
-        lock do
-          super
-          FileUtils.rm_rf dir_path
-        end
+        super
+        FileUtils.rm_rf dir_path
       end
 
       protected
@@ -56,7 +50,7 @@ module Dapp
 
       def git(command, **kwargs)
         if use_ssh_key && ssh_key_path
-          builder.shellout "ssh-agent bash -ec 'ssh-add #{ssh_key_path}; git #{command}'", **kwargs
+          application.shellout!("ssh-agent bash -ec 'ssh-add #{ssh_key_path}; git #{command}'", **kwargs)
         else
           super
         end

data/lib/dapp/helper/cli.rb

@@ -0,0 +1,66 @@
+module Dapp
+  module Helper
+    # Cli
+    module Cli
+      def parse_options(cli, argv)
+        cli.parse_options(argv)
+      rescue OptionParser::MissingArgument, OptionParser::InvalidOption, OptionParser::InvalidArgument => e
+        STDERR.puts "Error: #{e.message}"
+        puts cli.opt_parser
+        exit 1
+      end
+
+      def required_argument(cli)
+        unless (arg = cli.cli_arguments.pop)
+          puts cli.opt_parser
+          exit 1
+        end
+        arg
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def parse_subcommand(cli, args)
+        argv = args
+        divided_subcommand = []
+        subcommand_argv = []
+
+        cmd_arr = args.dup
+        loop do
+          if cli.class::SUBCOMMANDS.include? cmd_arr.join(' ')
+            argv = args[0...args.index(cmd_arr.first)]
+            divided_subcommand = cmd_arr
+            index = cmd_arr.one? ? args.index(cmd_arr.first).next : args.index(cmd_arr.last).next
+            subcommand_argv = args[index..-1]
+          elsif !cmd_arr.empty?
+            cmd_arr.pop
+            next
+          end
+          break
+        end
+
+        [argv, divided_subcommand, subcommand_argv]
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def run_subcommand(cli, divided_subcommand, subcommand_argv)
+        if !divided_subcommand.empty?
+          cli.class.const_get(prepare_subcommand(divided_subcommand)).new.run(subcommand_argv)
+        else
+          STDERR.puts 'Error: subcommand not passed'
+          puts
+          puts cli.opt_parser
+          exit 1
+        end
+      end
+
+      def prepare_subcommand(divided_subcommand)
+        Array(divided_subcommand).map(&:capitalize).join
+      end
+
+      def composite_options(opt)
+        @composite_options ||= {}
+        @composite_options[opt] ||= []
+      end
+    end
+  end # Helper
+end # Dapp

data/lib/dapp/helper/i18n.rb

@@ -0,0 +1,20 @@
+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/log.rb

@@ -0,0 +1,72 @@
+module Dapp
+  module Helper
+    # Log
+    module Log
+      def log_info(message, *args)
+        log(message, *args, style: :info)
+      end
+
+      def log_step(message, *args)
+        log(message, *args, style: :step)
+      end
+
+      def log_secondary(message, *args)
+        log(message, *args, style: :secondary)
+      end
+
+      def log(message = '', desc: nil, inline: false, **kwargs)
+        return unless defined?(cli_options) && !cli_options[:log_quiet]
+        unless desc.nil?
+          (desc[:data] ||= {})[:msg] = message
+          message = t(desc: desc)
+        end
+        print "#{log_format_string(message, **kwargs)}#{"\n" unless inline}"
+      end
+
+      def log_time
+        "#{DateTime.now.strftime('%Y-%m-%dT%T%z')} "
+      end
+
+      def log_format_string(str, time: true, indent: true, style: nil)
+        str.to_s.lines.map do |line|
+          line = paint_string(line, style) if style
+          "#{log_time if time && cli_options[:log_time]}#{indent ? (log_indent + line) : line}"
+        end.join
+      end
+
+      def log_with_indent(message = '', **kvargs)
+        with_log_indent do
+          log(message, **kvargs)
+        end
+      end
+
+      def with_log_indent(with = true)
+        log_indent_next if with
+        yield
+        log_indent_prev if with
+      end
+
+      def log_indent
+        ' ' * 2 * cli_options[:log_indent].to_i
+      end
+
+      def log_indent_next
+        return unless defined? cli_options
+        cli_options[:log_indent] += 1
+      end
+
+      def log_indent_prev
+        return unless defined? cli_options
+        if cli_options[:log_indent] <= 0
+          cli_options[:log_indent] = 0
+        else
+          cli_options[:log_indent] -= 1
+        end
+      end
+
+      def self.included(base)
+        base.include(Paint)
+      end
+    end # Log
+  end # Helper
+end # Dapp

data/lib/dapp/helper/paint.rb

@@ -0,0 +1,27 @@
+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|
+          fail 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/sha256.rb

@@ -0,0 +1,14 @@
+module Dapp
+  module Helper
+    # Sha256
+    module Sha256
+      def hashsum(arg)
+        sha256(arg)
+      end
+
+      def sha256(arg)
+        Digest::SHA256.hexdigest Array(arg).compact.map(&:to_s).join(':::')
+      end
+    end
+  end # Helper
+end # Dapp

data/lib/dapp/helper/shellout.rb

@@ -0,0 +1,41 @@
+module Dapp
+  module Helper
+    # Shellout
+    module Shellout
+      include Streaming
+
+      def shellout(*args, log_verbose: false, **kwargs)
+        do_shellout = proc do
+          log_verbose = (log_verbose && cli_options[:log_verbose]) if defined? cli_options
+          kwargs[:live_stream] ||= STDOUT if log_verbose
+          ::Mixlib::ShellOut.new(*args, timeout: 3600, **kwargs).run_command
+        end
+
+        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.inspect }
+      end
+
+      def self.included(base)
+        base.extend(self)
+      end
+    end
+  end # Helper
+end # Dapp

data/lib/dapp/helper/streaming.rb

@@ -0,0 +1,49 @@
+module Dapp
+  module Helper
+    # Streaming
+    module Streaming
+      # Stream
+      class Stream
+        def buffer
+          @buffer ||= []
+        end
+
+        def <<(string)
+          buffer << string
+        end
+
+        def inspect
+          buffer.join
+        end
+      end
+
+      # Proxy
+      module Proxy
+        # Base
+        class Base
+          include Helper::Log
+
+          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| "#{log_time if @with_time}#{l.strip}\n" }.join
+          end
+        end
+
+        # Error
+        class Error < Base
+          def format_string(str)
+            Paint.paint_string(super, :warning)
+          end
+        end
+      end
+    end
+  end # Helper
+end # Dapp

data/lib/dapp/helper/trivia.rb

@@ -0,0 +1,27 @@
+module Dapp
+  module Helper
+    # Trivia
+    module Trivia
+      def kwargs(args)
+        args.last.is_a?(Hash) ? args.pop : {}
+      end
+
+      def class_to_lowercase(class_name = self.class)
+        Trivia.class_to_lowercase(class_name)
+      end
+
+      def delete_file(path)
+        path = Pathname(path)
+        path.delete if path.exist?
+      end
+
+      def to_mb(bytes)
+        (bytes / 1024.0 / 1024.0).round(2)
+      end
+
+      def self.class_to_lowercase(class_name = self.class)
+        class_name.to_s.split('::').last.split(/(?=[[:upper:]]|[0-9])/).join('_').downcase.to_s
+      end
+    end # Trivia
+  end # Helper
+end # Dapp