kuby-core 0.9.0 → 0.11.1

data/lib/kuby/docker/dockerfile.rb

@@ -1,28 +1,43 @@
+# typed: strict
+
 require 'digest'
 
 module Kuby
   module Docker
     class Dockerfile
+      extend T::Sig
+
       class Command
+        extend T::Sig
+
+        sig { returns(T::Array[T.any(String, Integer)]) }
         attr_reader :args
 
-        def initialize(*args)
+        sig { params(args: T::Array[T.any(String, Integer)]).void }
+        def initialize(args)
           @args = args
         end
 
+        sig { returns(String) }
         def to_s
           args.join(' ')
         end
       end
 
       class From < Command
-        attr_reader :image_url, :as
+        sig { returns(String) }
+        attr_reader :image_url
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :as
 
+        sig { params(image_url: String, as: T.nilable(String)).void }
         def initialize(image_url, as: nil)
           @image_url = image_url
           @as = as
         end
 
+        sig { returns(String) }
         def to_s
           str = "FROM #{image_url}"
           str << " AS #{as}" if as
@@ -31,26 +46,38 @@ module Kuby
       end
 
       class Workdir < Command
+        sig { returns(String) }
         def to_s; "WORKDIR #{super}"; end
       end
 
       class Env < Command
+        sig { returns(String) }
         def to_s; "ENV #{super}"; end
       end
 
       class Run < Command
+        sig { returns(String) }
         def to_s; "RUN #{super}"; end
       end
 
       class Copy < Command
-        attr_reader :source, :dest, :from
+        sig { returns(String) }
+        attr_reader :source
 
+        sig { returns(String) }
+        attr_reader :dest
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :from
+
+        sig { params(source: String, dest: String, from: T.nilable(String)).void }
         def initialize(source, dest, from: nil)
           @source = source
           @dest = dest
           @from = from
         end
 
+        sig { returns(String) }
         def to_s
           cmd = ['COPY']
           cmd << "--from=#{from}" if from
@@ -60,72 +87,92 @@ module Kuby
       end
 
       class Expose < Command
+        sig { returns(String) }
         def to_s; "EXPOSE #{super}"; end
       end
 
       class Cmd < Command
+        sig { returns(String) }
         def to_s; "CMD #{super}"; end
       end
 
       class Arg < Command
+        sig { returns(String) }
         def to_s; "ARG #{super}"; end
       end
 
-      attr_reader :commands, :cursor
+      sig { returns(T::Array[Command]) }
+      attr_reader :commands
+
+      sig { returns(Integer) }
+      attr_reader :cursor
 
+      sig { void }
       def initialize
-        @commands = []
-        @cursor = 0
+        @commands = T.let([], T::Array[Command])
+        @cursor = T.let(0, Integer)
       end
 
-      def from(*args, **kwargs)
-        add From.new(*args, **kwargs)
+      sig { params(image_url: String, as: T.nilable(String)).void }
+      def from(image_url, as: nil)
+        add From.new(image_url, as: as)
       end
 
+      sig { params(args: String).void }
       def workdir(*args)
-        add Workdir.new(*args)
+        add Workdir.new(args)
       end
 
+      sig { params(args: String).void }
       def env(*args)
-        add Env.new(*args)
+        add Env.new(args)
       end
 
+      sig { params(args: String).void }
       def arg(*args)
-        add Arg.new(*args)
+        add Arg.new(args)
       end
 
+      sig { params(args: String).void }
       def run(*args)
-        add Run.new(*args)
+        add Run.new(args)
       end
 
-      def copy(*args, **kwargs)
-        add Copy.new(*args, **kwargs)
+      sig { params(source: String, dest: String, from: T.nilable(String)).void }
+      def copy(source, dest, from: nil)
+        add Copy.new(source, dest, from: from)
       end
 
-      def expose(*args)
-        add Expose.new(*args)
+      sig { params(port: Integer).void }
+      def expose(port)
+        add Expose.new([port])
       end
 
+      sig { params(args: String).void }
       def cmd(*args)
-        add Cmd.new(*args)
+        add Cmd.new(args)
       end
 
+      sig { returns(String) }
       def to_s
         # ensure trailing newline
         "#{commands.map(&:to_s).join("\n")}\n"
       end
 
+      sig { returns(String) }
       def checksum
         Digest::SHA256.hexdigest(to_s)
       end
 
+      sig { returns(T::Array[Integer]) }
       def exposed_ports
         commands
           .select { |c| c.is_a?(Expose) }
-          .map { |c| c.args.first }
+          .map { |c| T.cast(c.args.first, Integer) }
       end
 
-      def insert_at(pos)
+      sig { params(pos: Integer, block: T.proc.void).void }
+      def insert_at(pos, &block)
         @cursor = pos
         yield
       ensure
@@ -134,6 +181,7 @@ module Kuby
 
       private
 
+      sig { params(cmd: Command).void }
       def add(cmd)
         commands.insert(cursor, cmd)
         @cursor += 1

data/lib/kuby/docker/errors.rb

@@ -1,16 +1,25 @@
+# typed: strict
+
 module Kuby
   module Docker
     class BuildError < StandardError; end
     class PushError < StandardError; end
+    class PullError < StandardError; end
     class LoginError < StandardError; end
 
     class MissingTagError < StandardError
+      extend T::Sig
+
+      sig { returns(String) }
       attr_reader :tag
 
+      sig { params(tag: String).void }
       def initialize(tag)
         @tag = tag
+        @message = T.let(@message, T.nilable(String))
       end
 
+      sig { returns(String) }
       def message
         @message ||= "Could not find tag '#{tag}'."
       end

data/lib/kuby/docker/inline_layer.rb

@@ -1,12 +1,19 @@
+# typed: strict
+
 module Kuby
   module Docker
     class InlineLayer < Layer
+      extend T::Sig
+
+      sig { returns(T.proc.params(df: Dockerfile).void) }
       attr_reader :block
 
+      sig { params(block: T.proc.params(df: Dockerfile).void).void }
       def initialize(block)
         @block = block
       end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         block.call(dockerfile)
       end

data/lib/kuby/docker/layer.rb

@@ -1,12 +1,22 @@
+# typed: strict
+
 module Kuby
   module Docker
     class Layer
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(Environment) }
       attr_reader :environment
 
+      sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
       end
 
+      sig { params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         raise NotImplementedError,
           "#{__method__} must be defined in derived classes"
@@ -14,6 +24,7 @@ module Kuby
 
       private
 
+      sig { returns(Metadata) }
       def metadata
         environment.docker.metadata
       end

data/lib/kuby/docker/layer_stack.rb

@@ -1,20 +1,46 @@
+# typed: strict
+
 module Kuby
   module Docker
     class LayerStack
+      extend T::Sig
+      extend T::Generic
+
+      Elem = type_member(fixed: Layer)
+
       include Enumerable
 
-      attr_reader :stack, :layers
+      sig { returns(T::Array[Symbol]) }
+      attr_reader :stack
+
+      sig { returns(T::Hash[Symbol, Layer]) }
+      attr_reader :layers
 
+      sig { void }
       def initialize
-        @stack = []
-        @layers = {}
+        @stack = T.let([], T::Array[Symbol])
+        @layers = T.let({}, T::Hash[Symbol, Layer])
       end
 
-      def each
-        return to_enum(__method__) unless block_given?
-        @stack.each { |name| yield layers[name] }
+      sig {
+        override.params(
+          block: T.nilable(T.proc.params(layer: Layer).void)
+        )
+        .void
+      }
+      def each(&block)
+        return to_enum(T.must(__method__)) unless block_given?
+        @stack.each { |name| yield T.must(layers[name]) }
       end
 
+      sig {
+        params(
+          name: Symbol,
+          layer: T.nilable(Layer),
+          block: T.nilable(T.proc.params(df: Dockerfile).void)
+        )
+        .void
+      }
       def use(name, layer = nil, &block)
         stack << name
 
@@ -27,6 +53,15 @@ module Kuby
         end
       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)
         # this is truly gross but it's the only way I can think of to be able
         # to call insert these two ways:
@@ -59,11 +94,13 @@ module Kuby
         end
       end
 
+      sig { params(name: Symbol).void }
       def delete(name)
         stack.delete(name)
         layers.delete(name)
       end
 
+      sig { params(name: Symbol).returns(T::Boolean) }
       def includes?(name)
         layers.include?(name)
       end

data/lib/kuby/docker/local_tags.rb

@@ -1,18 +1,37 @@
+# typed: strict
+
 module Kuby
   module Docker
     class LocalTags
-      attr_reader :cli, :metadata
+      extend T::Sig
+
+      sig { returns CLI }
+      attr_reader :cli
 
+      sig { returns(Metadata) }
+      attr_reader :metadata
+
+      sig {
+        params(
+          cli: CLI,
+          metadata: Metadata
+        )
+        .void
+      }
       def initialize(cli, metadata)
         @cli = cli
         @metadata = metadata
+
+        @latest_timestamp_tag = T.let(@latest_timestamp_tag, T.nilable(TimestampTag))
       end
 
+      sig { returns(T::Array[String]) }
       def tags
         images = cli.images(metadata.image_url)
-        images.map { |image| image[:tag] }
+        images.map { |image| T.must(image[:tag]) }
       end
 
+      sig { returns(T::Array[String]) }
       def latest_tags
         # find "latest" tag
         images = cli.images(metadata.image_url)
@@ -30,10 +49,12 @@ module Kuby
         end
       end
 
+      sig { returns(T::Array[TimestampTag]) }
       def timestamp_tags
         tags.map { |t| TimestampTag.try_parse(t) }.compact
       end
 
+      sig { returns(T.nilable(TimestampTag)) }
       def latest_timestamp_tag
         @latest_timestamp_tag ||= timestamp_tags.sort.last
       end

data/lib/kuby/docker/metadata.rb

@@ -1,51 +1,76 @@
+# typed: strict
+
 require 'uri'
 
 module Kuby
   module Docker
     class Metadata
+      extend T::Sig
+
       DEFAULT_DISTRO = :debian
-      DEFAULT_REGISTRY_HOST = 'https://www.docker.com'.freeze
-      DEFAULT_REGISTRY_SCHEME = 'https'
-      LATEST_TAG = 'latest'
+      DEFAULT_REGISTRY_HOST = T.let('https://www.docker.com'.freeze, String)
+      DEFAULT_REGISTRY_SCHEME = T.let('https', String)
+      LATEST_TAG = T.let('latest'.freeze, String)
+
+      sig { params(image_url: String).void }
+      attr_writer :image_url
 
-      attr_accessor :image_url
+      sig { returns(Environment) }
       attr_reader :environment
 
+      sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
-        @tags = []
+        @tags = T.let([], T::Array[String])
+
+        @image_url = T.let(@image_url, T.nilable(String))
+        @image_host = T.let(@image_host, T.nilable(String))
+        @image_hostname = T.let(@image_hostname, T.nilable(String))
+        @image_repo = T.let(@image_repo, T.nilable(String))
+        @distro = T.let(@distro, T.nilable(Symbol))
+        @full_image_uri = T.let(@full_image_uri, T.nilable(URI::Generic))
+        @default_image_url = T.let(@default_image_url, T.nilable(String))
+        @default_tags = T.let(@default_tags, T.nilable(T::Array[String]))
       end
 
+      sig { returns(String) }
       def image_url
         @image_url || default_image_url
       end
 
+      sig { returns(String) }
       def image_host
         @image_host ||= "#{full_image_uri.scheme}://#{full_image_uri.host}"
       end
 
+      sig { returns(String) }
       def image_hostname
-        @image_hostname ||= URI(image_host).host
+        @image_hostname ||= T.must(URI(image_host).host)
       end
 
+      sig { returns(String) }
       def image_repo
-        @image_repo ||= full_image_uri.path.sub(/\A[\/]+/, '')
+        @image_repo ||= T.must(full_image_uri.path).sub(/\A[\/]+/, '')
       end
 
+      sig { returns(T::Array[String]) }
       def tags
         @tags.empty? ? default_tags : @tags
       end
 
+      sig { returns(Symbol) }
       def distro
         @distro || DEFAULT_DISTRO
       end
 
+      sig { params(distro_name: Symbol).void }
       def distro=(distro_name)
         @distro = distro_name
       end
 
       private
 
+      sig { returns(URI::Generic) }
       def full_image_uri
         @full_image_uri ||= if image_url.include?('://')
           URI.parse(image_url)
@@ -56,17 +81,20 @@ module Kuby
         end
       end
 
+      sig { returns(String) }
       def default_image_url
         # assuming dockerhub by not specifying full url
         @default_image_url ||= environment.app_name.downcase
       end
 
+      sig { returns(T::Array[String]) }
       def default_tags
         @default_tags ||= [
           TimestampTag.new(Time.now).to_s, LATEST_TAG
         ]
       end
 
+      sig { params(url: String).returns(URI::Generic) }
       def parse_url(url)
         uri = URI.parse(url)
         return uri if uri.scheme