class_formatter.rb

module Pokecli::EntityFormatters
  class Pokemon
    Unslugify = ->name { name.tr('-', ' ').capitalize }
    StatFormatter = ->stat { "#{stat[0].capitalize}: #{stat[1]}" }

    def self.render(response)
      new(response).render
    end

    def initialize(response)
      learned_abilities = response[:abilities].map { |ability| ability.dig(:ability, :name) }
      pokedex_number = response[:id]
      base_stats = response[:stats].map { |stat| [stat.dig(:stat, :name), stat[:base_stat]] }
      types = response[:types].map { |type| type.dig(:type, :name) }

      @params = {
        learned_abilities: learned_abilities,
        pokedex_number: pokedex_number,
        base_stats: base_stats,
        types: types
      }
    end

    def render
      <<~POKEMON
        Pokemon: #{Unslugify.call(@params[:name])} (N° #{@params[:pokedex_number]})
        Types: #{@params[:types].map(&:capitalize).join('/')}
        Abilities: #{@params[:learned_abilities].map(&Unslugify).join(', ')}

        Base stats:
        #{@params[:base_stats].map(&StatFormatter).join("\n")}
      POKEMON
    end
  end
end

lambda_formatter.rb

module Pokecli::EntityFormatters
  Pokemon = ->response do
    params = GetPokemonParams[response]

    <<~POKEMON
      Pokemon: #{Unslugify.call(params[:name])} (N° #{params[:pokedex_number]})
      Types: #{params[:types].map(&:capitalize).join('/')}
      Abilities: #{params[:learned_abilities].map(&Unslugify).join(', ')}

      Base stats:
      #{params[:base_stats].map(&StatFormatter).join("\n")}
    POKEMON
  end

  GetPokemonParams = ->response do
    learned_abilities = response[:abilities].map { |ability| ability.dig(:ability, :name) }
    pokedex_number = response[:id]
    base_stats = response[:stats].map { |stat| [stat.dig(:stat, :name), stat[:base_stat]] }
    types = response[:types].map { |type| type.dig(:type, :name) }

    {
      learned_abilities: learned_abilities,
      pokedex_number: pokedex_number,
      base_stats: base_stats,
      types: types
    }
  end

  Unslugify = ->name { name.tr('-', ' ').capitalize }
  StatFormatter = ->stat { "#{stat[0].capitalize}: #{stat[1]}" }

  private_constant :GetPokemonParams, :Unslugify, :StatFormatter
end

module Pokecli
  module EntityFormatters
  end
end

module Pokecli::EntityFormatters::Pokemon
  Unslugify = ->name { name.tr('-', ' ').capitalize }
  
  FormatStat = ->stat { "#{stat[0].capitalize}: #{stat[1]}" }

  GetParams = ->(id:, abilities:, stats:, types:, name:) do
    type_names = types.map { |type| type.dig(:type, :name) }.map(&:capitalize).join('/')
    base_stats = stats.map { |stat| [stat.dig(:stat, :name), stat[:base_stat]] }.map(&FormatStat).join("\n")
    learned_abilities = abilities.map { |ability| ability.dig(:ability, :name) }.map(&Unslugify).join(', ')

    {
      name: Unslugify.(name),
      types: type_names,
      base_stats: base_stats,
      pokedex_number: id,
      learned_abilities: learned_abilities,
    }
  end

  TEMPLATE = <<~POKEMON
    Pokemon: %{name} (N° %{pokedex_number})
    Types: %{types}
    Abilities: %{learned_abilities}
    Base stats:
    %{base_stats}
  POKEMON

  def self.call(response)
    TEMPLATE % GetParams.(**response)
  end

  private_constant :GetParams, :Unslugify, :FormatStat
end

puts Pokecli::EntityFormatters::Pokemon.call(
  id: '123',
  name: 'Pikachu',
  types: [{type: { name: 'eletrico' }}],
  stats: [{stat: { name: 'name' }, base_stat: 'foo'}],
  abilities: [{ability: { name: 'bar'}}]
)

module Pokecli
  module EntityFormatters
    Unslugify = ->name { name.tr('-', ' ').capitalize }
  
    FormatStat = ->stat { "#{stat[0].capitalize}: #{stat[1]}" }

    private_constant :Unslugify, :FormatStat
  end
end

module Pokecli::EntityFormatters
  module Pokemon
    GetParams = ->(id:, abilities:, stats:, types:, name:) do
      type_names = types.map { |type| type.dig(:type, :name) }.map(&:capitalize).join('/')
      base_stats = stats.map { |stat| [stat.dig(:stat, :name), stat[:base_stat]] }.map(&FormatStat).join("\n")
      learned_abilities = abilities.map { |ability| ability.dig(:ability, :name) }.map(&Unslugify).join(', ')

      {
        name: Unslugify.(name),
        types: type_names,
        base_stats: base_stats,
        pokedex_number: id,
        learned_abilities: learned_abilities,
      }
    end

    TEMPLATE = <<~POKEMON
      Pokemon: %{name} (N° %{pokedex_number})
      Types: %{types}
      Abilities: %{learned_abilities}
      Base stats:
      %{base_stats}
    POKEMON

    def self.call(response)
      TEMPLATE % GetParams.(**response)
    end

    private_constant :GetParams
  end
end

puts Pokecli::EntityFormatters::Pokemon.call(
  id: '123',
  name: 'Pikachu',
  types: [{type: { name: 'eletrico' }}],
  stats: [{stat: { name: 'name' }, base_stat: 'foo'}],
  abilities: [{ability: { name: 'bar'}}]
)

module Pokecli::EntityFormatters
  class Pokemon

    def self.call(response)
      return unless response.is_a?(Hash)

      new.call(response)
    end

    def call(response)
      render(
        name: extract_name(**response),
        pokedex_number: extract_pokedex_number(**response),
        types: extract_types(**response),
        learned_abilities: extract_learned_abilities(**response),
        base_stats: extract_base_stats(**response)
      )
    end

    private

    Unslugify = ->(name) { name.tr('-', ' ').capitalize }
    private_constant :Unslugify

    def render(name:, pokedex_number:, types:, learned_abilities:, base_stats:)
      <<~POKEMON
        Pokemon: #{name} (#{pokedex_number})
        Types: #{types}
        Abilities: #{learned_abilities}
        Base stats: #{base_stats}
      POKEMON
    end

    def extract_name(:name, **)
      Unslugify[name]
    end

    def extract_pokedex_number(id:, **)
      "N° #{id}"
    end

    def extract_types(types:, **)
      types
        .map { |type| type.dig(:type, :name).capitalize }
        .join('/')
    end

    def extract_learned_abilities(abilities:, **)
      abilities
        .map { |ability| Unslugify[ability.dig(:ability, :name)] }
        .join(', ')
    end

    def extract_base_stats(stats:, **)
      stats
        .map { |stat| "#{stat.dig(:stat, :name).capitalize}: #{stat[:base_stat]}" }
        .join("\n")
    end

  end
end