kuby-core 0.9.0 → 0.11.1

data/lib/kuby/docker/package_list.rb

@@ -1,31 +1,50 @@
+# typed: strict
+
 module Kuby
   module Docker
     class PackageList
+      extend T::Sig
+      extend T::Generic
+
+      Elem = type_member(fixed: Distro::PackageImpl)
+
       include Enumerable
 
+      sig { returns(T::Array[Distro::PackageImpl]) }
       attr_reader :packages
 
+      sig { params(package_tuples: T::Array[[Symbol, T.nilable(String)]]).void }
       def initialize(package_tuples)
-        @packages = []
-        package_tuples.each { |pt| add(*pt) }
+        @packages = T.let([], T::Array[Distro::PackageImpl])
+        package_tuples.each { |name, version| add(name, version) }
       end
 
+      sig { params(name: Symbol).returns(T.nilable(Distro::PackageImpl)) }
       def [](name)
         packages.find { |pkg| pkg.name == name }
       end
 
+      sig { params(name: Symbol, version: T.nilable(String)).void }
       def add(name, version = nil)
-        packages << Package.new(name, version)
+        packages << Packages::Package.new(name, version)
       end
 
+      sig { params(name: String).void }
       def delete(name)
         packages.delete_if { |pkg| pkg.name == name }
       end
 
+      sig {
+        override.params(
+          block: T.proc.params(package: Distro::PackageImpl).void
+        )
+        .void
+      }
       def each(&block)
         packages.each(&block)
       end
 
+      sig { returns(T::Boolean) }
       def empty?
         packages.empty?
       end

data/lib/kuby/docker/package_phase.rb

@@ -1,22 +1,33 @@
+# typed: strict
+
 module Kuby
   module Docker
     class PackagePhase < Layer
+      extend T::Sig
+
+      Operation = T.type_alias { [Symbol, Symbol, T.nilable(String)] }
+
+      sig { returns(T::Array[Operation]) }
       attr_reader :operations
 
-      def initialize(*args)
+      sig { params(environment: Environment).void }
+      def initialize(environment)
         super
 
-        @operations = []
+        @operations = T.let([], T::Array[Operation])
       end
 
+      sig { params(package_name: Symbol, version: T.nilable(String)).void }
       def add(package_name, version = nil)
         operations << [:add, package_name, version]
       end
 
+      sig { params(package_name: Symbol).void }
       def remove(package_name)
-        operations << [:remove, package_name]
+        operations << [:remove, package_name, nil]
       end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         packages = distro_spec.default_packages.dup
 
@@ -30,19 +41,27 @@ module Kuby
           end
         end
 
-        packages.map! do |package_name, version|
+        package_impls = packages.map do |package_name, version|
           get_package(package_name, version)
         end
 
-        distro_spec.install(packages, into: dockerfile)
+        distro_spec.install(package_impls, into: dockerfile)
       end
 
       private
 
+      sig { returns(Distro) }
       def distro_spec
         environment.docker.distro_spec
       end
 
+      sig {
+        params(
+          package_name: Symbol,
+          version: T.nilable(String)
+        )
+        .returns(Distro::PackageImpl)
+      }
       def get_package(package_name, version)
         if package = Kuby.packages[package_name]
           package.with_version(version)
@@ -51,6 +70,7 @@ module Kuby
         end
       end
 
+      sig { returns(Metadata) }
       def metadata
         environment.docker.metadata
       end

data/lib/kuby/docker/packages.rb

@@ -1,3 +1,4 @@
+# typed: strict
 module Kuby
   module Docker
     module Packages

data/lib/kuby/docker/packages/managed_package.rb

@@ -1,14 +1,30 @@
+# typed: strict
+
 module Kuby
   module Docker
     module Packages
       class ManagedPackage
-        attr_reader :name, :names_per_distro
+        extend T::Sig
+
+        sig { returns(Symbol) }
+        attr_reader :name
+
+        sig { returns(T::Hash[Symbol, String]) }
+        attr_reader :names_per_distro
 
+        sig {
+          params(
+            name: Symbol,
+            names_per_distro: T::Hash[Symbol, String]
+          )
+          .void
+        }
         def initialize(name, names_per_distro)
           @name = name
           @names_per_distro = names_per_distro
         end
 
+        sig { params(distro: Symbol).returns(String) }
         def package_name_for(distro)
           names_per_distro.fetch(distro) do
             raise UnsupportedDistroError, "Couldn't install #{name} "\
@@ -16,10 +32,12 @@ module Kuby
           end
         end
 
-        def with_version(*)
+        sig { params(ver: String).returns(T.self_type) }
+        def with_version(ver)
           self
         end
 
+        sig { returns(T::Boolean) }
         def managed?
           true
         end

data/lib/kuby/docker/packages/nodejs.rb

@@ -1,21 +1,29 @@
+# typed: strict
+
 module Kuby
   module Docker
     module Packages
       class Nodejs < Package
+        extend T::Sig
+
+        sig { params(dockerfile: Dockerfile).void }
         def install_on_debian(dockerfile)
           install_from_image("node:#{version}", dockerfile)
         end
 
+        sig { params(dockerfile: Dockerfile).void }
         def install_on_alpine(dockerfile)
           install_from_image("node:#{version}-alpine", dockerfile)
         end
 
+        sig { returns(String) }
         def version
           @version || 'current'
         end
 
         private
 
+        sig { params(image: String, dockerfile: Dockerfile).void }
         def install_from_image(image, dockerfile)
           dockerfile.insert_at(0) do
             dockerfile.from(image, as: 'nodejs')

data/lib/kuby/docker/packages/package.rb

@@ -1,18 +1,32 @@
+# typed: strict
+
 module Kuby
   module Docker
     module Packages
       class Package
-        attr_reader :name, :version
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        sig { returns(Symbol) }
+        attr_reader :name
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :version
 
+        sig { params(name: Symbol, version: T.nilable(String)).void }
         def initialize(name, version = nil)
           @name = name
           @version = version
         end
 
+        sig { params(ver: String).returns(T.self_type) }
         def with_version(ver)
           self.class.new(name, ver)
         end
 
+        sig { returns(T::Boolean) }
         def managed?
           false
         end

data/lib/kuby/docker/packages/simple_managed_package.rb

@@ -1,21 +1,30 @@
+# typed: strict
+
 module Kuby
   module Docker
     module Packages
       class SimpleManagedPackage
+        extend T::Sig
+
+        sig { returns(String) }
         attr_reader :name
 
+        sig { params(name: String).void }
         def initialize(name)
           @name = name
         end
 
+        sig { params(distro: Symbol).returns(String) }
         def package_name_for(distro)
           name
         end
 
-        def with_version(*)
+        sig { params(ver: String).returns(T.self_type) }
+        def with_version(ver)
           self
         end
 
+        sig { returns(T::Boolean) }
         def managed?
           true
         end

data/lib/kuby/docker/packages/yarn.rb

@@ -1,7 +1,19 @@
+# typed: strict
+
 module Kuby
   module Docker
     module Packages
       class Yarn < Package
+        extend T::Sig
+
+        sig { params(name: Symbol, version: T.nilable(String)).void }
+        def initialize(name, version = nil)
+          super
+
+          @url = T.let(@url, T.nilable(String))
+        end
+
+        sig { params(dockerfile: Dockerfile).void }
         def install_on_debian(dockerfile)
           dockerfile.run(<<~CMD.strip)
             wget #{url} && \\
@@ -17,6 +29,7 @@ module Kuby
           dockerfile.env("PATH=$PATH:/opt/yarn/bin")
         end
 
+        sig { params(dockerfile: Dockerfile).void }
         def install_on_alpine(dockerfile)
           dockerfile.run(<<~CMD.strip)
             wget #{url} && \\
@@ -34,6 +47,7 @@ module Kuby
 
         private
 
+        sig { returns(String) }
         def url
           @url ||= if version
             "https://github.com/yarnpkg/yarn/releases/download/v#{version}/yarn-v#{version}.tar.gz"

data/lib/kuby/docker/remote_tags.rb

@@ -1,21 +1,40 @@
+# typed: strict
+
 module Kuby
   module Docker
     class RemoteTags
-      attr_reader :remote_client, :metadata
+      extend T::Sig
+
+      sig { returns(::Docker::Remote::Client) }
+      attr_reader :remote_client
+
+      sig { returns(Metadata) }
+      attr_reader :metadata
 
+      sig {
+        params(
+          remote_client: ::Docker::Remote::Client,
+          metadata: Metadata
+        )
+        .void
+      }
       def initialize(remote_client, metadata)
         @remote_client = remote_client
         @metadata = metadata
       end
 
+      sig { returns(T::Array[String]) }
       def tags
         remote_client.tags
       end
 
+      sig { returns(T::Array[String]) }
       def latest_tags
-        raise NotImplementedError, 'latest tags are not available for remote repos'
+        # not available for remote repos
+        []
       end
 
+      sig { returns(T::Array[TimestampTag]) }
       def timestamp_tags
         tags.map { |t| TimestampTag.try_parse(t) }.compact
       end

data/lib/kuby/docker/setup_phase.rb

@@ -1,10 +1,40 @@
+# typed: strict
+
 module Kuby
   module Docker
     class SetupPhase < Layer
-      DEFAULT_WORKING_DIR = '/usr/src/app'.freeze
+      extend T::Sig
+
+      DEFAULT_WORKING_DIR = T.let('/usr/src/app'.freeze, String)
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :base_image
+
+      sig { params(base_image: String).void }
+      attr_writer :base_image
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :working_dir
 
-      attr_accessor :base_image, :working_dir, :rails_env
+      sig { params(working_dir: String).void }
+      attr_writer :working_dir
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :rails_env
+
+      sig { params(rails_env: String).void }
+      attr_writer :rails_env
+
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        super
+
+        @base_image = T.let(@base_image, T.nilable(String))
+        @working_dir = T.let(@working_dir, T.nilable(String))
+        @rails_env = T.let(@rails_env, T.nilable(String))
+      end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         dockerfile.from(base_image || default_base_image)
         dockerfile.workdir(working_dir || DEFAULT_WORKING_DIR)
@@ -15,14 +45,15 @@ module Kuby
 
       private
 
+      sig { returns(String) }
       def default_base_image
-        @default_base_image ||= case metadata.distro
+        case metadata.distro
           when :debian
             "ruby:#{RUBY_VERSION}"
           when :alpine
             "ruby:#{RUBY_VERSION}-alpine"
           else
-            # ERROR
+            raise MissingDistroError, "distro '#{metadata.distro}' hasn't been registered"
         end
       end
     end

data/lib/kuby/docker/spec.rb

@@ -1,115 +1,185 @@
+# typed: strict
+
 require 'docker/remote'
 
 module Kuby
   module Docker
     class Spec
+      extend T::Sig
+
+      sig { returns(Environment) }
       attr_reader :environment
 
+      sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
+
+        @credentials = T.let(@credentials, T.nilable(Credentials))
+        @setup_phase = T.let(@setup_phase, T.nilable(SetupPhase))
+        @package_phase = T.let(@package_phase, T.nilable(PackagePhase))
+        @bundler_phase = T.let(@bundler_phase, T.nilable(BundlerPhase))
+        @yarn_phase = T.let(@yarn_phase, T.nilable(YarnPhase))
+        @copy_phase = T.let(@copy_phase, T.nilable(CopyPhase))
+        @assets_phase = T.let(@assets_phase, T.nilable(AssetsPhase))
+        @webserver_phase = T.let(@webserver_phase, T.nilable(WebserverPhase))
+        @metadata = T.let(@metadata, T.nilable(Metadata))
+
+        @distro_spec = T.let(@distro_spec, T.nilable(Distro))
+        @cli = T.let(@cli, T.nilable(CLI))
+        @remote_client = T.let(@remote_client, T.nilable(::Docker::Remote::Client))
+        @tags = T.let(@tags, T.nilable(Tags))
+        @layer_stack = T.let(@layer_stack, T.nilable(Kuby::Docker::LayerStack))
       end
 
+      sig { params(image_url: String).void }
       def base_image(image_url)
         setup_phase.base_image = image_url
       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
 
+      sig { params(version: String).void }
       def bundler_version(version)
         bundler_phase.version = version
       end
 
+      sig { params(path: String).void }
       def gemfile(path)
         bundler_phase.gemfile = path
       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(path: String).void }
       def files(path)
         copy_phase << path
       end
 
+      sig { params(port: Integer).void }
       def port(port)
         webserver_phase.port = port
       end
 
+      sig { params(url: String).void }
       def image_url(url)
         metadata.image_url = url
       end
 
-      def use(*args, &block)
-        layer_stack.use(*args, &block)
-      end
-
-      def insert(*args, &block)
-        layer_stack.insert(*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
+
+      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 {
+        params(block: T.nilable(T.proc.void)).returns(Credentials)
+      }
       def credentials(&block)
         @credentials ||= Credentials.new
         @credentials.instance_eval(&block) if block
         @credentials
       end
 
+      sig { returns(Dockerfile) }
       def to_dockerfile
         Dockerfile.new.tap do |df|
           layer_stack.each { |layer| layer.apply_to(df) }
         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(BundlerPhase) }
       def bundler_phase
         @bundler_phase ||= BundlerPhase.new(environment)
       end
 
+      sig { returns(YarnPhase) }
       def yarn_phase
         @yarn_phase ||= YarnPhase.new(environment)
       end
 
+      sig { returns(CopyPhase) }
       def copy_phase
         @copy_phase ||= CopyPhase.new(environment)
       end
 
+      sig { returns(AssetsPhase) }
       def assets_phase
         @assets_phase ||= AssetsPhase.new(environment)
       end
 
+      sig { returns(WebserverPhase) }
       def webserver_phase
         @webserver_phase ||= WebserverPhase.new(environment)
       end
 
+      sig { returns(Metadata) }
       def metadata
         @metadata ||= Metadata.new(environment)
       end
 
+      sig { returns(String) }
       def tag
         t = ENV.fetch('KUBY_DOCKER_TAG') do
           tags.latest_timestamp_tag
@@ -122,6 +192,7 @@ module Kuby
         t.to_s
       end
 
+      sig { params(current_tag: String).returns(String) }
       def previous_tag(current_tag)
         t = tags.previous_timestamp_tag(current_tag)
 
@@ -132,10 +203,12 @@ module Kuby
         t.to_s
       end
 
+      sig { returns(CLI) }
       def cli
         @cli ||= Docker::CLI.new
       end
 
+      sig { returns(::Docker::Remote::Client) }
       def remote_client
         @remote_client ||= ::Docker::Remote::Client.new(
           metadata.image_host, metadata.image_repo,
@@ -143,6 +216,7 @@ module Kuby
         )
       end
 
+      sig { returns(Distro) }
       def distro_spec
         @distro_spec ||= if distro_klass = Kuby.distros[metadata.distro]
           distro_klass.new(self)
@@ -151,14 +225,16 @@ module Kuby
         end
       end
 
+      sig { returns(Tags) }
       def tags
         @tags ||= Tags.new(cli, remote_client, metadata)
       end
 
       private
 
+      sig { returns(Kuby::Docker::LayerStack) }
       def layer_stack
-        @layer_stack ||= LayerStack.new.tap do |stack|
+        @layer_stack ||= Kuby::Docker::LayerStack.new.tap do |stack|
           stack.use(:setup_phase, setup_phase)
           stack.use(:package_phase, package_phase)
           stack.use(:bundler_phase, bundler_phase)