kuby-core 0.9.0 → 0.11.1

data/lib/kuby/docker/cli.rb

@@ -1,3 +1,5 @@
+# typed: strict
+
 require 'json'
 require 'open3'
 require 'shellwords'
@@ -5,22 +7,29 @@ require 'shellwords'
 module Kuby
   module Docker
     class CLI < CLIBase
+      extend T::Sig
+
+      sig { returns(String) }
       attr_reader :executable
 
+      sig { params(executable: T.nilable(String)).void }
       def initialize(executable = nil)
-        @executable = executable || `which docker`.strip
+        @executable = T.let(executable || `which docker`.strip, String)
       end
 
+      sig { returns(T.nilable(String)) }
       def config_file
         if File.exist?(default_config_file)
           default_config_file
         end
       end
 
+      sig { returns(String) }
       def default_config_file
         File.join(Dir.home, '.docker', 'config.json')
       end
 
+      sig { params(url: String, username: String, password: String).void }
       def login(url:, username:, password:)
         cmd = [
           executable, 'login', url, '--username', username, '--password-stdin'
@@ -36,13 +45,23 @@ module Kuby
         end
       end
 
+      sig { returns(T::Array[String]) }
       def auths
         return [] unless config_file
 
-        config = JSON.parse(File.read(config_file))
+        config = JSON.parse(File.read(T.must(config_file)))
         config.fetch('auths', {}).keys
       end
 
+      sig {
+        params(
+          dockerfile: Dockerfile,
+          image_url: String,
+          tags: T::Array[String],
+          build_args: T::Hash[T.any(Symbol, String), String]
+        )
+        .void
+      }
       def build(dockerfile:, image_url:, tags:, build_args: {})
         cmd = [
           executable, 'build',
@@ -63,6 +82,15 @@ module Kuby
         end
       end
 
+      sig {
+        params(
+          image_url: String,
+          tag: String,
+          env: T::Hash[T.any(Symbol, String), String],
+          ports: T::Array[T.any(String, Integer)]
+        )
+        .void
+      }
       def run(image_url:, tag: 'latest', env: {}, ports: [])
         cmd = [
           executable, 'run',
@@ -76,6 +104,7 @@ module Kuby
         execc(cmd)
       end
 
+      sig { params(image_url: String).returns(T::Array[T::Hash[Symbol, String]]) }
       def images(image_url)
         cmd = [
           executable, 'images', image_url,
@@ -89,6 +118,7 @@ module Kuby
         end
       end
 
+      sig { params(image_url: String, tag: String).void }
       def push(image_url, tag)
         systemm([
           executable, 'push', "#{image_url}:#{tag}"
@@ -100,14 +130,29 @@ module Kuby
         end
       end
 
+      sig { params(image_url: String, tag: String).void }
+      def pull(image_url, tag)
+        systemm([
+          executable, 'pull', "#{image_url}:#{tag}"
+        ])
+
+        unless last_status.success?
+          raise PullError, 'pull failed: docker command exited with '\
+            "status code #{last_status.exitstatus}"
+        end
+      end
+
+      sig { returns(Symbol) }
       def status_key
         :kuby_docker_cli_last_status
       end
 
+      sig { returns(Symbol) }
       def stdout_key
         :kuby_docker_stdout
       end
 
+      sig { returns(Symbol) }
       def stderr_key
         :kuby_docker_stderr
       end

data/lib/kuby/docker/copy_phase.rb

@@ -1,19 +1,27 @@
+# typed: strict
+
 module Kuby
   module Docker
     class CopyPhase < Layer
-      DEFAULT_PATHS = ['./'].freeze
+      extend T::Sig
+
+      DEFAULT_PATHS = T.let(['./'].freeze, T::Array[String])
 
+      sig { returns(T::Array[String]) }
       attr_reader :paths
 
-      def initialize(*args)
+      sig { params(environment: Environment).void }
+      def initialize(environment)
         super
-        @paths = []
+        @paths = T.let([], T::Array[String])
       end
 
+      sig { params(path: String).void }
       def <<(path)
         paths << path
       end
 
+      sig { params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         to_copy = paths.empty? ? DEFAULT_PATHS : paths
         to_copy.each { |path| dockerfile.copy(path, '.') }

data/lib/kuby/docker/credentials.rb

@@ -1,3 +1,4 @@
+# typed: strict
 require 'kube-dsl'
 
 module Kuby

data/lib/kuby/docker/debian.rb

@@ -1,38 +1,41 @@
+# typed: strict
+
 module Kuby
   module Docker
-    class Debian
-      SHELL_EXE = '/bin/bash'
+    class Debian < Distro
+      SHELL_EXE = T.let('/bin/bash'.freeze, String)
 
-      DEFAULT_PACKAGES = [
-        [:ca_certificates],
+      DEFAULT_PACKAGES = T.let([
+        [:ca_certificates, nil],
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1']
-      ].freeze
+      ].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])
 
         pkg_cmd = <<~CMD.strip
           apt-get update -qq && \\
@@ -49,6 +52,7 @@ module Kuby
         dockerfile.run(pkg_cmd)
       end
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_unmanaged(packages, dockerfile)
         packages
           .reject(&:managed?)

data/lib/kuby/docker/dev_spec.rb

@@ -1,63 +1,121 @@
+# typed: strict
+
 module Kuby
   module Docker
     class WebserverDevPhase < Layer
-      DEFAULT_PORT = 3000
+      extend T::Sig
+
+      DEFAULT_PORT = T.let(3000, Integer)
+
+      sig { params(port: Integer).void }
+      attr_writer :port
 
-      attr_accessor :port
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        super
+
+        @port = T.let(@port, T.nilable(Integer))
+      end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         dockerfile.expose(port)
       end
 
+      sig { returns(Integer) }
       def port
         @port || DEFAULT_PORT
       end
     end
 
     class DevSpec
+      extend T::Sig
+
+      sig { returns(Environment) }
       attr_reader :environment
 
+      sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
+
+        @setup_phase = T.let(@setup_phase, T.nilable(SetupPhase))
+        @package_phase = T.let(@package_phase, T.nilable(PackagePhase))
+        @webserver_phase = T.let(@webserver_phase, T.nilable(WebserverDevPhase))
+        @metadata = T.let(@metadata, T.nilable(Metadata))
+        @distro_spec = T.let(@distro_spec, T.nilable(Distro))
+        @cli = T.let(@cli, T.nilable(CLI))
+        @tags = T.let(@tags, T.nilable(LocalTags))
+        @layer_stack = T.let(@layer_stack, T.nilable(Docker::LayerStack))
       end
 
+      sig { params(dir: String).void }
       def working_dir(dir)
         setup_phase.working_dir = dir
       end
 
+      sig { params(env: String).void }
       def rails_env(env)
         setup_phase.rails_env = env
       end
 
-      def package(*args)
-        package_phase.add(*args)
+      sig {
+        params(
+          package_name: Symbol,
+          version: T.nilable(String)
+        )
+        .void
+      }
+      def package(package_name, version = nil)
+        package_phase.add(package_name, version)
       end
 
+      sig { params(distro_name: Symbol).void }
       def distro(distro_name)
         metadata.distro = distro_name
         @distro_spec = nil
       end
 
+      sig { params(port: Integer).void }
       def port(port)
         webserver_phase.port = port
       end
 
-      def use(*args, &block)
-        layer_stack.use(*args, &block)
+      sig {
+        params(
+          name: Symbol,
+          layer: T.nilable(Layer),
+          block: T.nilable(T.proc.params(df: Dockerfile).void)
+        )
+        .void
+      }
+      def use(name, layer = nil, &block)
+        layer_stack.use(name, layer, &block)
       end
 
-      def insert(*args, &block)
-        layer_stack.insert(*args, &block)
+      sig {
+        params(
+          name: Symbol,
+          layer: T.nilable(T.any(Layer, T::Hash[Symbol, T.untyped])),
+          options: T::Hash[Symbol, T.untyped],
+          block: T.nilable(T.proc.params(df: Dockerfile).void)
+        )
+        .void
+      }
+      def insert(name, layer = nil, options = {}, &block)
+        layer_stack.insert(name, layer, options, &block)
       end
 
-      def delete(*args)
-        layer_stack.delete(*args)
+      sig { params(name: Symbol).void }
+      def delete(name)
+        layer_stack.delete(name)
       end
 
-      def exists?(*args)
-        layer_stack.includes?(*args)
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def exists?(name)
+        layer_stack.includes?(name)
       end
 
+      sig { returns(Dockerfile) }
       def to_dockerfile
         Dockerfile.new.tap do |df|
           layer_stack.each { |layer| layer.apply_to(df) }
@@ -65,26 +123,27 @@ module Kuby
         end
       end
 
+      sig { returns(SetupPhase) }
       def setup_phase
         @setup_phase ||= SetupPhase.new(environment)
       end
 
+      sig { returns(PackagePhase) }
       def package_phase
         @package_phase ||= PackagePhase.new(environment)
       end
 
+      sig { returns(WebserverDevPhase) }
       def webserver_phase
         @webserver_phase ||= WebserverDevPhase.new(environment)
       end
 
+      sig { returns(Metadata) }
       def metadata
         @metadata ||= Metadata.new(environment)
       end
 
-      def cli
-        @cli ||= Docker::CLI.new
-      end
-
+      sig { returns(Distro) }
       def distro_spec
         @distro_spec ||= if distro_klass = Kuby.distros[metadata.distro]
           distro_klass.new(self)
@@ -93,6 +152,7 @@ module Kuby
         end
       end
 
+      sig { returns(String) }
       def tag
         t = ENV.fetch('KUBY_DOCKER_TAG') do
           tags.latest_timestamp_tag
@@ -105,22 +165,26 @@ module Kuby
         t.to_s
       end
 
-      def previous_tag(*)
+      sig { params(current_tag: String).returns(String) }
+      def previous_tag(current_tag)
         raise MissingTagError, 'cannot roll back in the development environment'
       end
 
+      sig { returns(CLI) }
       def cli
         @cli ||= Docker::CLI.new
       end
 
       private
 
+      sig { returns(LocalTags) }
       def tags
         @tags ||= LocalTags.new(cli, metadata)
       end
 
+      sig { returns(Docker::LayerStack) }
       def layer_stack
-        @layer_stack ||= LayerStack.new.tap do |stack|
+        @layer_stack ||= Docker::LayerStack.new.tap do |stack|
           stack.use(:setup_phase, setup_phase)
           stack.use(:package_phase, package_phase)
           stack.use(:webserver_phase, webserver_phase)

data/lib/kuby/docker/distro.rb

@@ -0,0 +1,43 @@
+# typed: strict
+
+module Kuby
+  module Docker
+    class Distro
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      PackageImpl = T.type_alias {
+        T.any(Packages::Package, Packages::ManagedPackage, Packages::SimpleManagedPackage)
+      }
+
+      ManagedPackageImpl = T.type_alias {
+        T.any(Packages::ManagedPackage, Packages::SimpleManagedPackage)
+      }
+
+      sig { params(phase: Layer).void }
+      def initialize(phase)
+        @phase = phase
+      end
+
+      sig { params(packages: T::Array[PackageImpl], into: Dockerfile).void }
+      def install(packages, into:)
+        raise NotImplementedError,
+          "#{__method__} must be defined in derived classes"
+      end
+
+      sig { returns(T::Array[[Symbol, T.nilable(String)]]) }
+      def default_packages
+        raise NotImplementedError,
+          "#{__method__} must be defined in derived classes"
+      end
+
+      sig { returns(String) }
+      def shell_exe
+        raise NotImplementedError,
+          "#{__method__} must be defined in derived classes"
+      end
+    end
+  end
+end