kuby-core 0.10.0 → 0.11.3

data/lib/kuby/definition.rb

@@ -1,11 +1,24 @@
+# typed: strict
+
 module Kuby
   class Definition
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :app_name
 
+    sig { params(app_name: String, block: T.nilable(T.proc.void)).void }
     def initialize(app_name, &block)
       @app_name = app_name
+      @environments = T.let(@environments, T.nilable(T::Hash[Symbol, Environment]))
     end
 
+    sig {
+      params(
+        name: Symbol,
+        block: T.nilable(T.proc.void)
+      ).returns(Environment)
+    }
     def environment(name = Kuby.env, &block)
       name = name.to_s
 
@@ -15,9 +28,10 @@ module Kuby
         environments[name].instance_eval(&block)
       end
 
-      environments[name]
+      T.must(environments[name])
     end
 
+    sig { returns(T::Hash[Symbol, Environment]) }
     def environments
       @environments ||= {}
     end

data/lib/kuby/dev_setup.rb

@@ -1,18 +1,34 @@
+# typed: strict
+
 module Kuby
   class Spinner
-    PIECES = %w(- \\ | /).freeze
-    INTERVAL = 0.2  # seconds
-
-    def self.spin(message)
+    extend T::Sig
+
+    PIECES = T.let(%w(- \\ | /).freeze, T::Array[String])
+    INTERVAL = T.let(0.2, Float)  # seconds
+
+    sig {
+      params(
+        message: String,
+        block: T.proc.params(spinner: Spinner).void
+      )
+      .void
+    }
+    def self.spin(message, &block)
       yield new(message)
     end
 
-    attr_reader :message, :status
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { returns(Symbol) }
+    attr_reader :status
 
+    sig { params(message: String).void }
     def initialize(message)
-      @message = message
-      @status = :running
-      @thread = Thread.new do
+      @message = T.let(message, String)
+      @status = T.let(:running, Symbol)
+      @thread = T.let(Thread.new do
         counter = 0
 
         while true
@@ -32,14 +48,16 @@ module Kuby
         end
 
         puts
-      end
+      end, Thread)
     end
 
+    sig { void }
     def success
       @status = :success
       @thread.join
     end
 
+    sig { void }
     def failure
       @status = :failure
       @thread.join
@@ -47,66 +65,116 @@ module Kuby
   end
 
   class SetupTask
-    attr_reader :message, :callable
+    extend T::Sig
 
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { returns(T.proc.void) }
+    attr_reader :callable
+
+    sig { params(message: String, callable: T.proc.void).void }
     def initialize(message, callable)
       @message = message
       @callable = callable
     end
 
+    sig { void }
     def run
       callable.call
     end
   end
 
   class Pipe
-    attr_reader :name, :cli, :out, :err
+    extend T::Sig
+
+    sig { returns(Symbol) }
+    attr_reader :name
+
+    sig { returns(T.untyped) }
+    attr_reader :cli
 
+    sig { returns(StringIO) }
+    attr_reader :out
+
+    sig { returns(StringIO) }
+    attr_reader :err
+
+    sig { params(name: Symbol, cli: T.untyped).void }
     def initialize(name, cli)
-      @name = name
-      @cli = cli
-      @out = StringIO.new
-      @err = StringIO.new
+      @name = T.let(name, Symbol)
+      @cli = T.let(cli, T.untyped)
+      @out = T.let(StringIO.new, StringIO)
+      @err = T.let(StringIO.new, StringIO)
     end
 
+    sig { params(block: T.proc.void).void }
     def wrap(&block)
       cli.with_pipes(out, err) do
         block.call
       end
     end
 
+    sig { returns(T::Boolean) }
     def success?
       cli.last_status.nil? || cli.last_status.success?
     end
   end
 
   class Pipes
+    extend T::Sig
+    extend T::Generic
+
     include Enumerable
 
-    attr_reader :pipes, :ex
+    Elem = type_member(fixed: Pipe)
+
+    sig { returns(T::Array[Pipe]) }
+    attr_reader :pipes
 
+    sig { returns(T.nilable(StandardError)) }
+    attr_reader :ex
+
+    sig { params(clis: T::Hash[Symbol, T.untyped]).returns(Pipes) }
     def self.build(clis)
       new(clis.map { |name, cli| Pipe.new(name, cli) })
     end
 
+    sig { params(pipes: T::Array[Pipe]).void }
     def initialize(pipes)
-      @pipes = pipes
+      @ex = T.let(@ex, T.nilable(StandardError))
+      @pipes = T.let(pipes, T::Array[Pipe])
     end
 
+    sig {
+      override.params(
+        block: T.proc.params(package: Pipe).void
+      )
+      .void
+    }
     def each(&block)
       pipes.each(&block)
     end
 
+    sig { params(block: T.proc.void).void }
     def wrap(&block)
       do_wrap(pipes, &block)
     end
 
+    sig { returns(T::Boolean) }
     def success?
       pipes.all?(&:success?) && !ex
     end
 
     private
 
+    sig {
+      params(
+        remaining_pipes: T::Array[Pipe],
+        block: T.proc.void
+      )
+      .void
+    }
     def do_wrap(remaining_pipes, &block)
       if remaining_pipes.empty?
         begin
@@ -118,20 +186,28 @@ module Kuby
         return
       end
 
-      remaining_pipes[0].wrap do
-        do_wrap(remaining_pipes[1..-1], &block)
+      T.must(remaining_pipes[0]).wrap do
+        do_wrap(T.must(remaining_pipes[1..-1]), &block)
       end
     end
   end
 
   class SetupTaskList
-    attr_reader :tasks, :clis
+    extend T::Sig
+
+    sig { returns(T::Array[SetupTask]) }
+    attr_reader :tasks
 
+    sig { returns T::Hash[Symbol, T.untyped] }
+    attr_reader :clis
+
+    sig { params(tasks: T::Array[SetupTask], clis: T::Hash[Symbol, T.untyped]).void }
     def initialize(tasks, clis)
       @tasks = tasks
       @clis = clis
     end
 
+    sig { void }
     def run
       tasks.each do |task|
         pipes = Pipes.build(clis)
@@ -159,6 +235,7 @@ module Kuby
 
     private
 
+    sig { params(pipe: Pipe).void }
     def print_streams(pipe)
       unless pipe.out.string.strip.empty?
         puts("========= #{pipe.name.upcase} STDOUT ========")
@@ -171,27 +248,37 @@ module Kuby
       end
     end
 
+    sig { params(ex: T.nilable(StandardError)).void }
     def print_error(ex)
       return unless ex
       puts("========= RUBY ERROR ========")
       puts(ex.message)
-      puts(ex.backtrace.join("\n"))
+      puts(T.must(ex.backtrace).join("\n"))
     end
   end
 
   class DevSetup
+    extend T::Sig
+
+    sig { returns(Environment) }
     attr_reader :environment
 
+    sig { params(environment: Environment).void }
     def initialize(environment)
-      @environment = environment
+      @environment = T.let(environment, Environment)
+      @setup_tasks = T.let(@setup_tasks, T.nilable(T::Array[SetupTask]))
+      @clis = T.let(@clis, T.nilable(T::Hash[Symbol, T.untyped]))
+      @tasks = T.let(@tasks, T.nilable(Tasks))
     end
 
+    sig { void }
     def run
       SetupTaskList.new(setup_tasks, clis).run
     end
 
     private
 
+    sig { returns(T::Array[SetupTask]) }
     def setup_tasks
       @setup_tasks ||= [
         SetupTask.new(
@@ -230,14 +317,17 @@ module Kuby
       ]
     end
 
+    sig { returns(Kubernetes::Spec) }
     def kubernetes
       environment.kubernetes
     end
 
+    sig { returns(Docker::Spec) }
     def docker
       environment.docker
     end
 
+    sig { returns T::Hash[Symbol, T.untyped] }
     def clis
       @clis ||= {
         kubectl: kubernetes.provider.kubernetes_cli,
@@ -248,6 +338,7 @@ module Kuby
       }
     end
 
+    sig { returns(Tasks) }
     def tasks
       @tasks ||= Kuby::Tasks.new(environment)
     end

data/lib/kuby/docker.rb

@@ -1,3 +1,5 @@
+# typed: strict
+
 require 'kuby/docker/errors'
 
 module Kuby
@@ -10,6 +12,7 @@ module Kuby
     autoload :Credentials,    'kuby/docker/credentials'
     autoload :Debian,         'kuby/docker/debian'
     autoload :DevSpec,        'kuby/docker/dev_spec'
+    autoload :Distro,         'kuby/docker/distro'
     autoload :Dockerfile,     'kuby/docker/dockerfile'
     autoload :InlineLayer,    'kuby/docker/inline_layer'
     autoload :Layer,          'kuby/docker/layer'

data/lib/kuby/docker/alpine.rb

@@ -1,40 +1,43 @@
+# typed: strict
+
 module Kuby
   module Docker
-    class Alpine
-      SHELL_EXE = '/bin/sh'.freeze
+    class Alpine < Distro
+      SHELL_EXE = T.let('/bin/sh'.freeze, String)
 
-      DEFAULT_PACKAGES = [
-        [:ca_certificates],
+      DEFAULT_PACKAGES = T.let([
+        [:ca_certificates, nil],
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1'],
-        [:c_toolchain],
-        [:tzdata]
-      ].freeze
+        [:c_toolchain, nil],
+        [:tzdata, nil]
+      ].freeze, T::Array[[Symbol, T.nilable(String)]])
 
+      sig { returns(Layer) }
       attr_reader :phase
 
-      def initialize(phase)
-        @phase = phase
-      end
-
+      sig { override.params(packages: T::Array[Distro::PackageImpl], into: Dockerfile).void }
       def install(packages, into:)
         dockerfile = into
         install_managed(packages, dockerfile)
         install_unmanaged(packages, dockerfile)
       end
 
+      sig { override.returns(T::Array[[Symbol, T.nilable(String)]]) }
       def default_packages
         DEFAULT_PACKAGES
       end
 
+      sig { override.returns(String) }
       def shell_exe
         SHELL_EXE
       end
 
       private
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_managed(packages, dockerfile)
-        pkgs = packages.select(&:managed?)
+        pkgs = T.cast(packages.select(&:managed?), T::Array[Distro::ManagedPackageImpl])
 
         unless pkgs.empty?
           package_names = pkgs.map { |pkg| pkg.package_name_for(:alpine) }
@@ -44,6 +47,7 @@ module Kuby
         end
       end
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_unmanaged(packages, dockerfile)
         packages
           .reject(&:managed?)

data/lib/kuby/docker/assets_phase.rb

@@ -1,6 +1,11 @@
+# typed: strict
+
 module Kuby
   module Docker
     class AssetsPhase < Layer
+      extend T::Sig
+
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         dockerfile.run(
           'bundle', 'exec', 'rake', 'assets:precompile'

data/lib/kuby/docker/bundler_phase.rb

@@ -1,12 +1,44 @@
+# typed: strict
+
 require 'pathname'
 
 module Kuby
   module Docker
     class BundlerPhase < Layer
-      DEFAULT_WITHOUT = ['development', 'test', 'deploy'].freeze
+      extend T::Sig
+
+      DEFAULT_WITHOUT = T.let(
+        ['development', 'test', 'deploy'].freeze, T::Array[String]
+      )
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :version
+
+      sig { params(version: String).void }
+      attr_writer :version
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :gemfile
 
-      attr_accessor :version, :gemfile, :without
+      sig { params(gemfile: String).void }
+      attr_writer :gemfile
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :without
+
+      sig { params(without: T::Array[String]).void }
+      attr_writer :without
+
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        super
+
+        @version = T.let(@version, T.nilable(String))
+        @gemfile = T.let(@gemfile, T.nilable(String))
+        @without = T.let(@without, T.nilable(T::Array[String]))
+      end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         gf = gemfile || default_gemfile
         lf = "#{gf}.lock"
@@ -41,10 +73,12 @@ module Kuby
 
       private
 
+      sig { returns(String) }
       def default_version
         Bundler::VERSION
       end
 
+      sig { returns(String) }
       def default_gemfile
         Bundler
           .definition