ruby_raider 3.13.0 → 4.0.0

data/lib/generators/templates/helpers/wait_helper.tt

@@ -1,611 +0,0 @@
-# frozen_string_literal: true
-
-require 'selenium-webdriver'
-require 'yaml'
-require_relative 'raider_element'
-
-<%- if mobile? -%>
-# Waits before it acts. Each method takes a locator ({ accessibility_id: 'name' },
-# with or without braces, or { ios: {...}, android: {...} }), a RaiderElement or a
-# raw element, polls every 0.1s until the element is ready, then acts on it:
-#   tap({ accessibility_id: 'login' })
-#   send_keys({ accessibility_id: 'user' }, 'admin')
-#   swipe('left', { accessibility_id: 'card' })
-#   scroll_to({ accessibility_id: 'footer' })
-#   eventually { expect(text(accessibility_id: 'welcome')).to eq('Hi') }
-<%- else -%>
-# Waits before it acts. Each method takes a locator ({ id: 'name' }, with or
-# without braces), a RaiderElement or a raw element, polls every 0.1s until the
-# element is ready, then calls the Selenium method of the same name:
-#   click({ id: 'login' })
-#   send_keys({ id: 'user' }, 'admin')
-#   eventually { expect(text(css: '.welcome')).to eq('Hi') }
-<%- end -%>
-# The wait is config/config.yml `timeout` seconds, or `timeout:` for one call.
-module WaitHelper
-  class TimeoutError < Selenium::WebDriver::Error::TimeoutError; end
-
-  CONFIG_FILE = 'config/config.yml'
-  DEFAULT_TIMEOUT = 10
-
-  class << self
-    # Follows every action and eventually when set (the trace helper does). Optional:
-    # nothing is called on it while nil, and one that raises is dropped.
-    attr_accessor :observer
-
-    # Calls the observer's hook, or returns nil without one. A broken observer must
-    # never fail a test: it is warned about once and removed.
-    # A block builds the details, so computing them is covered by the same rescue.
-    # $stderr.puts, not Kernel#warn: warn is silenced under -W0.
-    # rubocop:disable Style/StderrPuts
-    def report(hook, *args, **details)
-      current = observer
-      return unless current
-
-      details = yield if block_given?
-      current.public_send(hook, *args, **details)
-    rescue StandardError => e
-      $stderr.puts("[trace] observer stopped: #{e.class}: #{e.message}")
-      self.observer = nil
-    end
-    # rubocop:enable Style/StderrPuts
-  end
-
-  def self.default_timeout
-    @default_timeout ||= begin
-      config = File.exist?(CONFIG_FILE) ? YAML.load_file(CONFIG_FILE) : nil
-      (config.is_a?(Hash) && config['timeout']) || DEFAULT_TIMEOUT
-    end
-  end
-
-  def self.element(driver, locator, by = {})
-    RaiderElement.new(driver, Lookup.for(driver, locator, by))
-  end
-
-<%- if mobile? -%>
-  # Swipes or scrolls the element, or the whole screen without a locator.
-  def self.gesture(driver, kind, direction, locator, timeout)
-    return element(driver, locator).public_send(kind, direction, timeout: timeout) if locator
-
-    gesture = Gesture.new(driver, kind, direction)
-    Waiter.new(driver, timeout: timeout).perform_action(kind, Lookup.screen(driver), Waiter::PRESENT) do
-      gesture.perform(nil)
-    end
-    nil
-  end
-
-<%- end -%>
-  def find_element(locator = nil, visible: true, timeout: nil, **by)
-    Waiter.new(driver, timeout: timeout).find_element(Lookup.for(driver, locator, by), visible)
-  end
-
-  def find_elements(locator = nil, timeout: nil, **by)
-    Waiter.new(driver, timeout: timeout).find_elements(Lookup.for(driver, locator, by))
-  end
-
-<%- if mobile? -%>
-  %i[click clear text displayed? enabled? selected?].each do |action|
-<%- else -%>
-  %i[click clear submit hover scroll_into_view text displayed? enabled? selected?].each do |action|
-<%- end -%>
-    define_method(action) do |locator = nil, timeout: nil, **by|
-      WaitHelper.element(driver, locator, by).public_send(action, timeout: timeout)
-    end
-  end
-
-<%- if mobile? -%>
-  # tap is Appium's word for click and waits the same way. With a block and no
-  # locator it stays Ruby's Object#tap.
-  def tap(locator = nil, timeout: nil, **by, &block)
-    return super(&block) if block && locator.nil? && by.empty?
-
-    WaitHelper.element(driver, locator, by).tap(timeout: timeout)
-  end
-
-<%- end -%>
-  def send_keys(locator, *keys, timeout: nil)
-    WaitHelper.element(driver, locator).send_keys(*keys, timeout: timeout)
-  end
-
-<%- unless mobile? -%>
-  def select_by(locator, how, what, timeout: nil)
-    WaitHelper.element(driver, locator).select_by(how, what, timeout: timeout)
-  end
-
-<%- end -%>
-  def attribute(locator, name, timeout: nil)
-    WaitHelper.element(driver, locator).attribute(name, timeout: timeout)
-  end
-
-<%- if mobile? -%>
-  # direction: 'up', 'down', 'left' or 'right'.
-  def swipe(direction, locator = nil, timeout: nil)
-    WaitHelper.gesture(driver, :swipe, direction, locator, timeout)
-  end
-
-  def scroll(direction, locator = nil, timeout: nil)
-    WaitHelper.gesture(driver, :scroll, direction, locator, timeout)
-  end
-
-  # Scrolls the screen until the element is visible, then returns its RaiderElement.
-  def scroll_to(locator, direction: 'down', max_scrolls: 10, timeout: nil)
-    WaitHelper.element(driver, locator).scroll_to(direction: direction, max_scrolls: max_scrolls, timeout: timeout)
-  end
-<%- else -%>
-  def drag_and_drop(source, target, timeout: nil)
-    WaitHelper.element(driver, source).drag_and_drop(target, timeout: timeout)
-  end
-<%- end -%>
-
-  def eventually(timeout: nil, &block)
-    Waiter.new(nil, timeout: timeout).eventually(&block)
-  end
-
-  # How an element is found: a locator in a scope (the driver or a parent
-  # Lookup), or an element given as is. The found element is cached until reset.
-  class Lookup
-    OS_KEYS = %i[android ios].freeze
-    PASSED_HINT = 'it was passed in as an element, so it cannot be found again; ' \
-                  "pass its locator (for example { id: 'name' }) instead"
-    MEMBER_HINT = 'it came from find_elements, which keeps no locator per element; call find_elements again to re-query'
-
-    attr_reader :hint
-
-    # Selenium's aliases for the locator strategies, as the trace names them.
-    STRATEGIES = { css_selector: 'css', class: 'class_name', link: 'link_text', partial_link: 'partial_link_text' }.freeze
-
-    def self.for(driver, locator, by, scope: driver)
-      raise ArgumentError, 'pass the locator in braces or as keywords, not both' if locator && !by.empty?
-
-      given = locator || by
-      # A wrapper keeps how it was found, so it can still re-find itself.
-      return given.__send__(:lookup) if given.is_a?(RaiderElement)
-      return new(scope, element: given, hint: PASSED_HINT) if !given.is_a?(Hash) && given.respond_to?(:displayed?)
-
-      new(scope, locator: normalize(driver, given))
-    end
-<%- if mobile? -%>
-
-    # No locator and no element: a whole-screen gesture, which locates nothing.
-    def self.screen(driver)
-      new(driver)
-    end
-<%- end -%>
-
-    def self.normalize(driver, given)
-      locator = symbolize(given)
-      per_os = !locator.empty? && (locator.keys - OS_KEYS).empty?
-      locator = symbolize(locator.fetch(driver.appium_device.to_s.downcase.to_sym, nil), given) if per_os
-      return locator if locator.size == 1
-
-      raise ArgumentError, "a locator is a Hash with one key, such as { id: 'name' }; got #{given.inspect}"
-    end
-
-    def self.symbolize(hash, given = hash)
-      return hash.transform_keys(&:to_sym) if hash.is_a?(Hash)
-
-      raise ArgumentError, "a locator is a Hash with one key, such as { id: 'name' }; got #{given.inspect}"
-    end
-
-    def initialize(scope, locator: nil, element: nil, hint: nil, many: false)
-      @scope = scope
-      @locator = locator
-      @element = element
-      @last_found = element
-      @hint = hint
-      @many = many
-      @scope_stale = false
-    end
-
-    # The last element found. A reset only drops the re-find cache, so a wrapper
-    # keeps its element (and its == and hash) after a timed-out wait.
-    def element
-      @element || @last_found
-    end
-
-    def many
-      Lookup.new(@scope, locator: @locator, element: @element, many: true)
-    end
-
-    def locate
-      return find_all if @many
-
-      return @element if @element || !@locator
-
-      @element = @last_found = in_scope { |context| context.find_element(**@locator) }
-    end
-
-    # A stale element may mean its parent was re-rendered too, so stale resets the chain.
-    def reset(stale: false)
-      @element = nil if @locator
-      @scope_stale = false
-      @scope.reset(stale: true) if stale && @scope.is_a?(Lookup)
-    end
-
-    # After a stale error: the Lookup up the chain whose element went stale and cannot be
-    # found again (passed in, or from find_elements), or nil when re-finding can heal it.
-    def lost
-      return self unless @locator
-
-      @scope.lost if @scope_stale
-    end
-
-    # { strategy:, selector: } for the observer, or nil when this locates nothing.
-    def trace_locator
-      return unless @locator
-
-      strategy, selector = @locator.first
-      { strategy: STRATEGIES.fetch(strategy) { strategy.to_s }, selector: selector }
-    end
-
-    # The locators this one is searched inside, outermost first.
-    def trace_within
-      return [] unless @scope.is_a?(Lookup)
-
-      [*@scope.trace_within, @scope.trace_locator].compact
-    end
-
-    def describe
-      return 'the element' unless @locator
-
-      "{#{@locator.map { |key, value| "#{key}: #{value.inspect}" }.join(', ')}}"
-    end
-
-    private
-
-    # A stale error while searching inside the parent means the parent, or one above it, went stale.
-    def in_scope
-      return yield(@scope) unless @scope.is_a?(Lookup)
-
-      begin
-        yield(@scope.locate)
-      rescue Selenium::WebDriver::Error::StaleElementReferenceError
-        @scope_stale = true
-        raise
-      end
-    end
-
-    def find_all
-      return [@element] unless @locator
-
-      found = in_scope { |context| context.find_elements(**@locator) }
-      raise Selenium::WebDriver::Error::NoSuchElementError, 'no match' if found.empty?
-
-      found
-    end
-  end
-
-  # Polls until a Lookup is ready, then yields the raw element. perform_action
-  # is the one choke point every public method (bar eventually) goes through.
-  class Waiter
-    POLL_INTERVAL = 0.1
-    DEADLINE_KEY = :raider_wait_deadline
-    VISIBLE_ENABLED = %i[visible enabled].freeze
-    PRESENT = [].freeze
-<%- if mobile? -%>
-    CLICK = %i[visible enabled stable].freeze
-    VISIBLE = %i[visible].freeze
-    CHECKS = {
-      click: CLICK, tap: CLICK,
-      send_keys: VISIBLE_ENABLED, clear: VISIBLE_ENABLED,
-      swipe: VISIBLE, scroll: VISIBLE, scroll_to: VISIBLE,
-      text: PRESENT, attribute: PRESENT, displayed?: PRESENT, enabled?: PRESENT, selected?: PRESENT
-    }.freeze
-<%- else -%>
-    CHECKS = {
-      click: %i[visible enabled stable].freeze,
-      send_keys: VISIBLE_ENABLED, clear: VISIBLE_ENABLED, submit: VISIBLE_ENABLED, select_by: VISIBLE_ENABLED,
-      hover: %i[visible stable].freeze,
-      drag_and_drop: %i[visible enabled stable].freeze,
-      scroll_into_view: PRESENT, text: PRESENT, attribute: PRESENT,
-      displayed?: PRESENT, enabled?: PRESENT, selected?: PRESENT
-    }.freeze
-<%- end -%>
-    TARGET_CHECKS = %i[visible].freeze
-    STALE = 'stale element'
-    RETRIED = [Selenium::WebDriver::Error::StaleElementReferenceError,
-               Selenium::WebDriver::Error::ElementClickInterceptedError,
-               Selenium::WebDriver::Error::ElementNotInteractableError].freeze
-    HELPER_FILES = [__FILE__, File.expand_path('raider_element.rb', __dir__)].freeze
-
-    def initialize(driver, timeout: nil)
-      @driver = driver
-      @timeout = timeout
-      @last_rect = nil
-    end
-
-    def find_element(lookup, visible)
-      perform_action(:find_element, lookup, visible ? TARGET_CHECKS : PRESENT) { RaiderElement.new(@driver, lookup) }
-    end
-
-    def find_elements(lookup)
-      perform_action(:find_elements, lookup.many, PRESENT) do |elements|
-        elements.map { |found| RaiderElement.new(@driver, Lookup.new(@driver, element: found, hint: Lookup::MEMBER_HINT)) }
-      end
-    rescue TimeoutError
-      []
-    end
-
-    # checks: a subset of %i[visible enabled stable]; present is always checked.
-    # target: a second Lookup (the drop target) that must be visible in the same poll.
-    # between: called after each poll that was not ready (scroll_to scrolls there); once it
-    # returns false the wait stops, and the timeout message ends with its to_s.
-    # args: what the action acts with (send_keys' keys, select_by's how and what), for the observer.
-    def perform_action(action, locator, checks, target: nil, between: nil, args: nil, &block)
-      lookup = locator.is_a?(Lookup) ? locator : Lookup.for(@driver, locator, {})
-      return poll(action, lookup, checks, target, between, nil, &block) unless WaitHelper.observer
-
-      observed(action, lookup, args) { |run| poll(action, lookup, checks, target, between, run, &block) }
-    end
-
-    # Retries the block until it passes. Calls inside it share its deadline (see deadline_and_wait).
-    def eventually(&block)
-      return retry_block(nil, &block) unless WaitHelper.observer
-
-      token = WaitHelper.report(:group_started) { { action: :eventually, source: Observation.source } }
-      run = { retries: 0, token: token }
-      begin
-        result = retry_block(run, &block)
-        WaitHelper.report(:group_finished, token, status: :passed, retries: run[:retries], error: nil) if token
-        result
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        WaitHelper.report(:group_finished, token, status: :failed, retries: run[:retries], error: e) if token
-        raise
-      end
-    end
-
-    private
-
-    # Tells the observer an action started, when its element is ready and how it ended. The
-    # block gets a run hash that poll fills with the retries it took and the ready element.
-    def observed(action, lookup, args)
-      run = { retries: 0, element: nil, token: nil }
-      token = run[:token] = WaitHelper.report(:action_started) do
-        { action: action, locator: lookup.trace_locator, within: lookup.trace_within,
-          source: Observation.source, args: args }
-      end
-      started = now
-      begin
-        result = yield(run)
-        finished(token, :passed, started, run, nil)
-        result
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        finished(token, :failed, started, run, e)
-        raise
-      end
-    end
-
-    def finished(token, status, started, run, error)
-      return unless token
-
-      WaitHelper.report(:action_finished, token, status: status, waited_ms: ((now - started) * 1000).round,
-                                                 retries: run[:retries], error: error, element: run[:element])
-    end
-
-    # run: where to count retries and keep the ready element, or nil when nobody observes.
-    def poll(action, lookup, checks, target, between, run)
-      deadline, waited = deadline_and_wait
-      loop do
-        seen = catch(:not_ready) do
-          elements = [ready(lookup, checks)]
-          elements << ready(target, TARGET_CHECKS, 'drop target ') if target
-          ready_to_act(run, elements.first) if run
-          return yield(*elements)
-        rescue *RETRIED => e
-          retry_reason(lookup, e, action)
-        end
-        lookup.reset(stale: seen == STALE)
-        target&.reset
-        if now >= deadline || (between && !between.call)
-          seen = [seen, between].compact.join(' ')
-          raise TimeoutError, timeout_message(lookup, checks, seen, [waited, waited + now - deadline].min), backtrace
-        end
-
-        run[:retries] += 1 if run
-        pause(deadline)
-      end
-    end
-
-    # Keeps the ready element and tells the observer, just before the action runs on it.
-    def ready_to_act(run, element)
-      run[:element] = element
-      token = run[:token]
-      WaitHelper.report(:action_ready, token, element: element) if token
-    end
-
-    def retry_block(run)
-      enclosing = Thread.current[DEADLINE_KEY]
-      require 'rspec/expectations'
-      retried = [RSpec::Expectations::ExpectationNotMetError, Selenium::WebDriver::Error::NoSuchElementError,
-                 Selenium::WebDriver::Error::StaleElementReferenceError, TimeoutError]
-      deadline, waited = deadline_and_wait
-      Thread.current[DEADLINE_KEY] = deadline
-      loop do
-        return yield
-      rescue *retried => e
-        raise e.exception("(still failing after #{seconds(waited)}s)\n#{e.message}") if now >= deadline
-
-        retried(run, e)
-        pause(deadline)
-      end
-    ensure
-      Thread.current[DEADLINE_KEY] = enclosing
-    end
-
-    # Counts a failed pass of eventually, and tells the observer a new pass starts.
-    def retried(run, error)
-      return unless run
-
-      run[:retries] += 1
-      token = run[:token]
-      WaitHelper.report(:group_retried, token, error: error) if token
-    end
-
-    # Inside eventually, a call without timeout: waits for what is left of eventually's
-    # deadline; one with timeout: waits that long per attempt, never past eventually's deadline.
-    def deadline_and_wait
-      started = now
-      enclosing = Thread.current[DEADLINE_KEY]
-      own = started + (@timeout || WaitHelper.default_timeout) if @timeout || !enclosing
-      deadline = [own, enclosing].compact.min
-      [deadline, deadline - started]
-    end
-
-    def ready(lookup, checks, prefix = '')
-      element = lookup.locate
-      reason = unready(element, checks)
-      throw :not_ready, "#{prefix}#{reason}" if reason
-
-      element
-    rescue Selenium::WebDriver::Error::NoSuchElementError
-      throw :not_ready, "#{prefix}not found"
-    end
-
-    def unready(element, checks)
-      return 'present but not visible' if checks.include?(:visible) && !element.displayed?
-      return 'visible but disabled' if checks.include?(:enabled) && !element.enabled?
-
-      'still moving' if checks.include?(:stable) && !stable?(element)
-    end
-
-    # Stable: the same rect on two consecutive polls.
-    def stable?(element)
-      rect = element.rect
-      steady = rect == @last_rect
-      @last_rect = rect
-      steady
-    end
-
-    def retry_reason(lookup, error, action)
-      detail = error.message.lines.first.to_s.strip
-      case error
-      when Selenium::WebDriver::Error::StaleElementReferenceError
-        lost = lookup.lost
-        raise error.class, "#{detail} (during #{action}): #{lost.hint}", backtrace if lost
-
-        STALE
-      when Selenium::WebDriver::Error::ElementClickInterceptedError then "click intercepted: #{detail}"
-      else "not interactable: #{detail}"
-      end
-    end
-
-    def timeout_message(lookup, checks, seen, waited)
-      names = checks.map(&:to_s)
-      wanted = names.empty? ? 'present' : [names[0..-2].join(', '), names.last].reject(&:empty?).join(' and ')
-      "Waited #{seconds(waited)}s for #{lookup.describe} to be #{wanted}; last seen: #{seen}"
-    end
-
-    def seconds(value)
-      rounded = value.round(2)
-      rounded == rounded.to_i ? rounded.to_i : rounded
-    end
-
-    # Drops this helper's frames so the error points at the page object or spec line.
-    def backtrace
-      caller.reject { |line| HELPER_FILES.any? { |file| line.start_with?(file) } }
-            .drop_while { |line| line.start_with?('<internal:') }
-    end
-
-    def pause(deadline)
-      sleep([[POLL_INTERVAL, deadline - now].min, 0].max)
-    end
-
-    def now
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-  end
-
-  # Where an action was called from, for the observer.
-  module Observation
-    # helpers/ by its given and its real path (__dir__ is the real one): the wait, trace and
-    # driver helpers are never the line that called an action or a navigation.
-    HELPER_DIRS = [File.dirname(__FILE__), __dir__].uniq.map { |dir| File.join(dir, '') }.freeze
-
-    # The first frame outside helpers/, Ruby and gems, as { file:, line: } (file relative
-    # to the working directory when inside it), or nil.
-    def self.source
-      frame = caller_locations.find { |location| project?(location.absolute_path || location.path) }
-      return unless frame
-
-      { file: relative(frame.absolute_path || frame.path), line: frame.lineno }
-    end
-
-    def self.project?(path)
-      return false if path.start_with?('<internal:') || HELPER_DIRS.any? { |dir| path.start_with?(dir) }
-
-      library_paths.none? { |root| path.start_with?(root) }
-    end
-
-    def self.library_paths
-      @library_paths ||= [*RbConfig::CONFIG.values_at('rubylibdir', 'rubyarchdir'), *Gem.path]
-                         .compact.map { |dir| File.join(dir, '') }
-    end
-
-    def self.relative(path)
-      root = File.join(Dir.pwd, '')
-      path.start_with?(root) ? path.delete_prefix(root) : path
-    end
-  end
-<%- if mobile? -%>
-
-  # A swipe or scroll through the platform's own mobile: command, as appium_lib issues them.
-  class Gesture
-    DIRECTIONS = %w[up down left right].freeze
-    COMMANDS = {
-      ios: { swipe: 'mobile: swipe', scroll: 'mobile: scroll' }.freeze,
-      android: { swipe: 'mobile: swipeGesture', scroll: 'mobile: scrollGesture' }.freeze
-    }.freeze
-    PERCENT = 0.75
-
-    def initialize(driver, kind, direction)
-      @driver = driver
-      @device = driver.appium_device.to_s.downcase.to_sym
-      @command = COMMANDS.dig(@device, kind)
-      raise NotImplementedError, "#{kind} has no gesture for #{driver.appium_device.inspect}; only :ios and :android" unless @command
-
-      @direction = direction.to_s
-      raise ArgumentError, "direction must be up, down, left or right; got #{direction.inspect}" unless DIRECTIONS.include?(@direction)
-    end
-
-    # element: the raw element to act on, or nil for the whole screen.
-    def perform(element)
-      @driver.execute_script(@command, arguments(element))
-    end
-
-    private
-
-    def arguments(element)
-      return { direction: @direction, element: element&.id }.compact if @device == :ios
-
-      area = element ? { elementId: element.id } : screen
-      area.merge(direction: @direction, percent: PERCENT)
-    end
-
-    def screen
-      rect = @driver.window_rect
-      { left: rect.x, top: rect.y, width: rect.width, height: rect.height }
-    end
-  end
-
-  # Scrolls the screen once per call, between scroll_to's polls, up to max_scrolls times.
-  class Scroller
-    def initialize(gesture, max_scrolls)
-      @gesture = gesture
-      @max_scrolls = max_scrolls
-      @scrolls = 0
-    end
-
-    # False once every scroll is used up.
-    def call
-      return false if @scrolls >= @max_scrolls
-
-      @gesture.perform(nil)
-      @scrolls += 1
-    end
-
-    def to_s
-      "after #{@scrolls} scrolls"
-    end
-  end
-<%- end -%>
-end

data/lib/scaffolding/templates/feature.tt

@@ -1,6 +0,0 @@
-Feature: <%= class_name %>
-
-Scenario: Scenario name
-    Given I am on the <%= normalized_name.tr('_', ' ') %> page
-    When I perform an action
-    Then I see the expected result

data/lib/scaffolding/templates/steps.tt

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../page_objects/pages/<%= normalized_name %>'
-
-Given('I am on the <%= normalized_name.tr("_", " ") %> page') do
-<%- if selenium? -%>
-  @page = <%= page_class_name %>.new(driver)
-<%- elsif watir? -%>
-  @page = <%= page_class_name %>.new(browser)
-<%- end -%>
-end
-
-When('I perform an action') do
-  pending 'implement step'
-end
-
-Then('I see the expected result') do
-  pending 'implement step'
-end

data/sig/generators/cucumber/cucumber_generator.rbs

@@ -1,12 +0,0 @@
-# Type definitions for CucumberGenerator
-class CucumberGenerator < Generator
-  def generate_feature: () -> void
-  def generate_steps: () -> void
-  def generate_user_factory: () -> void
-  def generate_env_file: () -> void
-  def generate_world: () -> void
-  def generate_cucumber_file: () -> void
-  def generate_accessibility_feature: () -> void
-  def generate_accessibility_steps: () -> void
-  def template_name: () -> String
-end