kuby-core 0.17.0 → 0.18.0

data/lib/kuby/docker/debian.rb

@@ -3,39 +3,39 @@
 module Kuby
   module Docker
     class Debian < Distro
-      SHELL_EXE = T.let('/bin/bash'.freeze, String)
+      SHELL_EXE = '/bin/bash'.freeze
 
-      DEFAULT_PACKAGES = T.let([
+      DEFAULT_PACKAGES = [
         [:ca_certificates, nil],
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1']
-      ].freeze, T::Array[[Symbol, T.nilable(String)]])
+      ].freeze
 
-      sig { returns(Layer) }
+      # T::Sig::WithoutRuntime.sig { returns(Layer) }
       attr_reader :phase
 
-      sig { override.params(packages: T::Array[Distro::PackageImpl], into: Dockerfile).void }
+      # T::Sig::WithoutRuntime.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)]]) }
+      # T::Sig::WithoutRuntime.sig { override.returns(T::Array[[Symbol, T.nilable(String)]]) }
       def default_packages
         DEFAULT_PACKAGES
       end
 
-      sig { override.returns(String) }
+      # T::Sig::WithoutRuntime.sig { override.returns(String) }
       def shell_exe
         SHELL_EXE
       end
 
       private
 
-      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_managed(packages, dockerfile)
-        pkgs = T.cast(packages.select(&:managed?), T::Array[Distro::ManagedPackageImpl])
+        pkgs = packages.select(&:managed?)
 
         pkg_cmd = <<~CMD.strip
           apt-get update -qq && \\
@@ -52,7 +52,7 @@ module Kuby
         dockerfile.run(pkg_cmd)
       end
 
-      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_unmanaged(packages, dockerfile)
         packages
           .reject(&:managed?)

data/lib/kuby/docker/distro.rb

@@ -3,37 +3,37 @@
 module Kuby
   module Docker
     class Distro
-      extend T::Sig
-      extend T::Helpers
+      # extend T::Sig
+      # extend T::Helpers
 
-      abstract!
+      # abstract!
 
-      PackageImpl = T.type_alias {
-        T.any(Packages::Package, Packages::ManagedPackage, Packages::SimpleManagedPackage)
-      }
+      # PackageImpl = T.type_alias {
+      #   T.any(Packages::Package, Packages::ManagedPackage, Packages::SimpleManagedPackage)
+      # }
 
-      ManagedPackageImpl = T.type_alias {
-        T.any(Packages::ManagedPackage, Packages::SimpleManagedPackage)
-      }
+      # ManagedPackageImpl = T.type_alias {
+      #   T.any(Packages::ManagedPackage, Packages::SimpleManagedPackage)
+      # }
 
-      sig { params(phase: Layer).void }
+      # T::Sig::WithoutRuntime.sig { params(phase: Layer).void }
       def initialize(phase)
         @phase = phase
       end
 
-      sig { params(packages: T::Array[PackageImpl], into: Dockerfile).void }
+      # T::Sig::WithoutRuntime.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)]]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[[Symbol, T.nilable(String)]]) }
       def default_packages
         raise NotImplementedError,
           "#{__method__} must be defined in derived classes"
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def shell_exe
         raise NotImplementedError,
           "#{__method__} must be defined in derived classes"

data/lib/kuby/docker/docker_uri.rb

@@ -3,13 +3,13 @@
 module Kuby
   module Docker
     class DockerURI
-      extend T::Sig
+      # extend T::Sig
 
-      DEFAULT_REGISTRY_HOST = T.let('docker.io'.freeze, String)
-      DEFAULT_REGISTRY_INDEX_HOST = T.let('index.docker.io'.freeze, String)
-      DEFAULT_PORT = T.let(443, Integer)
+      DEFAULT_REGISTRY_HOST = 'docker.io'.freeze
+      DEFAULT_REGISTRY_INDEX_HOST = 'index.docker.io'.freeze
+      DEFAULT_PORT = 443
 
-      sig { params(url: String).returns(DockerURI) }
+      # T::Sig::WithoutRuntime.sig { params(url: String).returns(DockerURI) }
       def self.parse_uri(url)
         parse(
           url,
@@ -18,7 +18,7 @@ module Kuby
         )
       end
 
-      sig { params(url: String).returns(DockerURI) }
+      # T::Sig::WithoutRuntime.sig { params(url: String).returns(DockerURI) }
       def self.parse_index_uri(url)
         parse(
           url,
@@ -27,13 +27,13 @@ module Kuby
         )
       end
 
-      sig {
-        params(
-          url: String,
-          default_host: T.nilable(String),
-          default_port: T.nilable(Integer)
-        ).returns(DockerURI)
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     url: String,
+      #     default_host: T.nilable(String),
+      #     default_port: T.nilable(Integer)
+      #   ).returns(DockerURI)
+      # }
       def self.parse(url, default_host:, default_port:)
         if idx = url.index('://')
           url = url[(idx + 3)..-1] || ''
@@ -41,8 +41,8 @@ module Kuby
 
         host_port, *path = url.split('/')
         host, port, *path = if host_port =~ /[.:]/
-          hst, prt = T.must(host_port).split(':')
-          [T.must(hst), prt || default_port, *path]
+          hst, prt = host_port.split(':')
+          [hst, prt || default_port, *path]
         else
           [default_host, default_port, host_port, *path]
         end
@@ -50,23 +50,23 @@ module Kuby
         new(host.to_s, port.to_i, (path || []).join('/'))
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       attr_reader :host
 
-      sig { returns(Integer) }
+      # T::Sig::WithoutRuntime.sig { returns(Integer) }
       attr_reader :port
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       attr_reader :path
 
-      sig { params(host: String, port: Integer, path: String).void }
+      # T::Sig::WithoutRuntime.sig { params(host: String, port: Integer, path: String).void }
       def initialize(host, port, path)
         @host = host
         @port = port
         @path = path
       end
 
-      sig { returns(T::Boolean) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Boolean) }
       def has_default_port?
         port == DEFAULT_PORT
       end

data/lib/kuby/docker/dockerfile.rb

@@ -5,39 +5,39 @@ require 'digest'
 module Kuby
   module Docker
     class Dockerfile
-      extend T::Sig
+      # extend T::Sig
 
       class Command
-        extend T::Sig
+        # extend T::Sig
 
-        sig { returns(T::Array[T.any(String, Integer)]) }
+        # T::Sig::WithoutRuntime.sig { returns(T::Array[T.any(String, Integer)]) }
         attr_reader :args
 
-        sig { params(args: T::Array[T.any(String, Integer)]).void }
+        # T::Sig::WithoutRuntime.sig { params(args: T::Array[T.any(String, Integer)]).void }
         def initialize(args)
           @args = args
         end
 
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s
           args.join(' ')
         end
       end
 
       class From < Command
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         attr_reader :image_url
 
-        sig { returns(T.nilable(String)) }
+        # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
         attr_reader :as
 
-        sig { params(image_url: String, as: T.nilable(String)).void }
+        # T::Sig::WithoutRuntime.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) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s
           str = "FROM #{image_url}"
           str << " AS #{as}" if as
@@ -46,38 +46,38 @@ module Kuby
       end
 
       class Workdir < Command
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s; "WORKDIR #{super}"; end
       end
 
       class Env < Command
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s; "ENV #{super}"; end
       end
 
       class Run < Command
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s; "RUN #{super}"; end
       end
 
       class Copy < Command
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         attr_reader :source
 
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         attr_reader :dest
 
-        sig { returns(T.nilable(String)) }
+        # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
         attr_reader :from
 
-        sig { params(source: String, dest: String, from: T.nilable(String)).void }
+        # T::Sig::WithoutRuntime.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) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s
           cmd = ['COPY']
           cmd << "--from=#{from}" if from
@@ -87,91 +87,100 @@ module Kuby
       end
 
       class Expose < Command
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s; "EXPOSE #{super}"; end
       end
 
       class Cmd < Command
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s; "CMD #{super}"; end
       end
 
       class Arg < Command
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def to_s; "ARG #{super}"; end
       end
 
-      sig { returns(T::Array[Command]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[Command]) }
       attr_reader :commands
 
-      sig { returns(Integer) }
+      # T::Sig::WithoutRuntime.sig { returns(Integer) }
       attr_reader :cursor
 
-      sig { void }
+      # T::Sig::WithoutRuntime.sig { void }
       def initialize
-        @commands = T.let([], T::Array[Command])
-        @cursor = T.let(0, Integer)
+        @commands = []
+        @cursor = 0
       end
 
-      sig { params(image_url: String, as: T.nilable(String)).void }
+      # T::Sig::WithoutRuntime.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 }
+      # T::Sig::WithoutRuntime.sig { params(args: String).void }
       def workdir(*args)
         add Workdir.new(args)
       end
 
-      sig { params(args: String).void }
+      # T::Sig::WithoutRuntime.sig { params(args: String).void }
       def env(*args)
         add Env.new(args)
       end
 
-      sig { params(args: String).void }
+      # T::Sig::WithoutRuntime.sig { params(args: String).void }
       def arg(*args)
         add Arg.new(args)
       end
 
-      sig { params(args: String).void }
+      # T::Sig::WithoutRuntime.sig { params(args: String).void }
       def run(*args)
         add Run.new(args)
       end
 
-      sig { params(source: String, dest: String, from: T.nilable(String)).void }
+      # T::Sig::WithoutRuntime.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
 
-      sig { params(port: Integer).void }
+      # T::Sig::WithoutRuntime.sig { params(port: Integer).void }
       def expose(port)
         add Expose.new([port])
       end
 
-      sig { params(args: String).void }
+      # T::Sig::WithoutRuntime.sig { params(args: String).void }
       def cmd(*args)
         add Cmd.new(args)
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def to_s
         # ensure trailing newline
         "#{commands.map(&:to_s).join("\n")}\n"
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def checksum
         Digest::SHA256.hexdigest(to_s)
       end
 
-      sig { returns(T::Array[Integer]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[Integer]) }
       def exposed_ports
         commands
           .select { |c| c.is_a?(Expose) }
-          .map { |c| T.cast(c.args.first, Integer) }
+          .map { |c| c.args.first }
       end
 
-      sig { params(pos: Integer, block: T.proc.void).void }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
+      def current_workdir
+        found = commands.reverse_each.find do |command|
+          command.is_a?(Kuby::Docker::Dockerfile::Workdir)
+        end
+
+        found.args.first if found
+      end
+
+      # T::Sig::WithoutRuntime.sig { params(pos: Integer, block: T.proc.void).void }
       def insert_at(pos, &block)
         @cursor = pos
         yield
@@ -181,7 +190,7 @@ module Kuby
 
       private
 
-      sig { params(cmd: Command).void }
+      # T::Sig::WithoutRuntime.sig { params(cmd: Command).void }
       def add(cmd)
         commands.insert(cursor, cmd)
         @cursor += 1

data/lib/kuby/docker/image.rb

@@ -3,137 +3,149 @@
 module Kuby
   module Docker
     class Image
-      extend T::Sig
+      # extend T::Sig
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :identifier
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       attr_reader :image_url
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :registry_index_url
 
-      sig { returns(Credentials) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Credentials) }
       attr_reader :credentials
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :main_tag
 
-      sig { returns T::Array[String] }
+      # T::Sig::WithoutRuntime.sig { returns T::Array[String] }
       attr_reader :alias_tags
 
-      sig {
-        params(
-          dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
-          image_url: String,
-          credentials: Credentials,
-          registry_index_url: T.nilable(String),
-          main_tag: T.nilable(String),
-          alias_tags: T::Array[String]
-        ).void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     dockerfile: T.any(Dockerfile, T.proc.returns(Kuby::Docker::Dockerfile)),
+      #     image_url: String,
+      #     credentials: Kuby::Docker::Credentials,
+      #     registry_index_url: T.nilable(String),
+      #     main_tag: T.nilable(String),
+      #     alias_tags: T::Array[String]
+      #   ).void
+      # }
       def initialize(dockerfile, image_url, credentials, registry_index_url = nil, main_tag = nil, alias_tags = [])
-        @dockerfile = T.let(dockerfile, T.any(Dockerfile, T.proc.returns(Dockerfile)))
-        @image_url = T.let(image_url, String)
-        @registry_index_url = T.let(registry_index_url, T.nilable(String))
-        @credentials = T.let(credentials, Credentials)
-        @main_tag = T.let(main_tag, T.nilable(String))
-        @alias_tags = T.let(alias_tags, T::Array[String])
-        @identifier = T.let(@identifier, T.nilable(String))
-
-        @image_host = T.let(@image_host, T.nilable(String))
-        @image_hostname = T.let(@image_hostname, T.nilable(String))
-        @registry_index_host = T.let(@registry_index_host, T.nilable(String))
-        @registry_index_hostname = T.let(@registry_index_hostname, T.nilable(String))
-        @registry_index_uri = T.let(@registry_index_uri, T.nilable(DockerURI))
-        @image_repo = T.let(@image_repo, T.nilable(String))
-        @full_image_uri = T.let(@full_image_uri, T.nilable(DockerURI))
-        @docker_cli = T.let(@docker_cli, T.nilable(Docker::CLI))
-      end
-
-      sig { returns(Image) }
+        @dockerfile = dockerfile
+        @image_url = image_url
+        @registry_index_url = registry_index_url
+        @credentials = credentials
+        @main_tag = main_tag
+        @alias_tags = alias_tags
+        # @identifier = T.let(@identifier, T.nilable(String))
+
+        # @image_host = T.let(@image_host, T.nilable(String))
+        # @image_hostname = T.let(@image_hostname, T.nilable(String))
+        # @registry_index_host = T.let(@registry_index_host, T.nilable(String))
+        # @registry_index_hostname = T.let(@registry_index_hostname, T.nilable(String))
+        # @registry_index_uri = T.let(@registry_index_uri, T.nilable(DockerURI))
+        # @image_repo = T.let(@image_repo, T.nilable(String))
+        # @full_image_uri = T.let(@full_image_uri, T.nilable(DockerURI))
+        # @docker_cli = T.let(@docker_cli, T.nilable(Docker::CLI))
+      end
+
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Image) }
       def new_version
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { returns(Image) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Image) }
       def current_version
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { params(current_tag: T.nilable(String)).returns(Image) }
+      # T::Sig::WithoutRuntime.sig { params(current_tag: T.nilable(String)).returns(Image) }
       def previous_version(current_tag = nil)
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { returns(Dockerfile) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Dockerfile) }
       def dockerfile
         if @dockerfile.respond_to?(:call)
-          T.cast(@dockerfile, T.proc.returns(Dockerfile)).call
+          @dockerfile.call
         else
-          T.cast(@dockerfile, Dockerfile)
+          @dockerfile
         end
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def image_host
         @image_host ||= "#{image_uri.host}:#{image_uri.port}"
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def registry_index_host
         @registry_index_host ||= "#{registry_index_uri.host}:#{registry_index_uri.port}"
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def registry_index_hostname
         @registry_index_hostname ||= registry_index_uri.host
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def image_hostname
         @image_hostname ||= image_uri.host
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def image_repo
         @image_repo ||= image_uri.path
       end
 
-      sig { returns(DockerURI) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::DockerURI) }
       def image_uri
         @full_image_uri ||= DockerURI.parse_uri(image_url)
       end
 
-      sig { returns(DockerURI) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::DockerURI) }
       def registry_index_uri
         @registry_index_uri ||= DockerURI.parse_index_uri(registry_index_url || image_url)
       end
 
-      sig { returns(T::Array[String]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[String]) }
       def tags
         [main_tag, *alias_tags].compact
       end
 
-      sig { params(build_args: T::Hash[String, String], docker_args: T::Array[String], context: T.nilable(String)).void }
-      def build(build_args = {}, docker_args = [], context: nil)
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     build_args: T::Hash[String, String],
+      #     docker_args: T::Array[String],
+      #     context: T.nilable(String),
+      #     cache_from: T.nilable(String)
+      #   ).void
+      # }
+      def build(build_args = {}, docker_args = [], context: nil, cache_from: nil)
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { params(tag: String).void }
+      # T::Sig::WithoutRuntime.sig { params(tag: String).void }
       def push(tag)
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { returns(Docker::CLI) }
+      # T::Sig::WithoutRuntime.sig { params(tag: String).void }
+      def pull(tag)
+        raise NotImplementedError, 'please use a Docker::Image subclass'
+      end
+
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::CLI) }
       def docker_cli
         @docker_cli ||= Docker::CLI.new
       end
 
       private
 
-      sig { params(main_tag: String, alias_tags: T::Array[String]).returns(Image) }
+      # T::Sig::WithoutRuntime.sig { params(main_tag: String, alias_tags: T::Array[String]).returns(Image) }
       def duplicate_with_tags(main_tag, alias_tags)
         self.class.new(dockerfile, image_url, credentials, registry_index_url, main_tag, alias_tags)
       end

data/lib/kuby/docker/inline_layer.rb

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

data/lib/kuby/docker/layer.rb

@@ -3,20 +3,20 @@
 module Kuby
   module Docker
     class Layer
-      extend T::Sig
-      extend T::Helpers
+      # extend T::Sig
+      # extend T::Helpers
 
-      abstract!
+      # abstract!
 
-      sig { returns(Environment) }
+      # T::Sig::WithoutRuntime.sig { returns(Environment) }
       attr_reader :environment
 
-      sig { params(environment: Environment).void }
+      # T::Sig::WithoutRuntime.sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
       end
 
-      sig { params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         raise NotImplementedError,
           "#{__method__} must be defined in derived classes"