pokeedex 0.1.0

data/lib/pokeedex/database.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'sequel'
+
+Sequel.extension :migration
+
+module Pokeedex # :nodoc:
+  ##
+  # Class that holds the database connection and methods to connect to the database and run the migrations if needed and clean the database for testing purposes
+  class Database
+    ##
+    # The database connection to use for the gem (default: /path/to/pokeedex/db/pokeedex_local.sqlite3)
+    attr_accessor :db_connection
+
+    ##
+    # Connect to the database with the configuration provided and set the database connection to the connection object
+    def self.connect(config)
+      @db_connection = config.db_connection
+    end
+
+    ##
+    # Return the database connection to use for the gem (default: /path/to/pokeedex/db/pokeedex_local.sqlite3)
+    def self.connection
+      @db_connection
+    end
+
+    ##
+    # Run the migrations for the database connection to the database file to use for the gem (default: /path/to/pokeedex/db/pokeedex_local.sqlite3) using the migrations in the migrations folder
+    # The migrations are run in the order of the timestamp in the filename of the migration file (e.g. 001_create_pokemon_table.rb)
+    def self.run_migrations!
+      Sequel::Migrator.run(connection, File.join(Pokeedex.root_path, 'lib', 'pokeedex', 'db', 'migrations'))
+    end
+
+    ##
+    # Clean the database by deleting all the rows in all the tables in the database for testing purposes (e.g. before running the tests)
+    def self.clean!
+      connection.tables.each do |table|
+        connection.from(table).delete
+      end
+    end
+  end
+end

data/lib/pokeedex/db/migrations/001_create_pokemons.rb

@@ -0,0 +1,26 @@
+require 'sequel'
+
+Sequel.migration do
+  change do
+    unless table_exists?(:pokemons)
+      create_table :pokemons do
+        primary_key :id
+        Integer :number
+        index :number, unique: true
+        String :name
+        index :name
+        String :description
+        Float :hight
+        Float :weight
+        String :category
+        Text :abilities
+        Text :gender
+        Text :types
+        Text :weakness
+        Text :stats
+        Time :created_at
+        Time :updated_at
+      end
+    end
+  end
+end

data/lib/pokeedex/exceptions.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pokeedex # :nodoc:
+  ##
+  # Class that holds the exceptions for the gem
+  module Exceptions
+    ##
+    # Error that is raised when an error occurs while trying to get the information from the scrapper class
+    class ScrapperError < StandardError
+      def initialize(msg = 'An error occurred while trying to get the information. Please try again later.')
+        super
+      end
+    end
+  end
+end

data/lib/pokeedex/pokemon/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pokeedex # :nodoc:
+  module Pokemon # :nodoc:
+    ##
+    # The base class for the Pokemon module. It holds the methods to search for a Pokemon by number or name
+    class Base
+      ##
+      # Search for a Pokemon by number or name
+      # @param query [String] the number or name of the Pokemon to search
+      def self.search(query)
+        Searcher::Base.new(query)
+      end
+    end
+  end
+end

data/lib/pokeedex/pokemon/decorators/base.rb

@@ -0,0 +1,112 @@
+module Pokeedex # :nodoc:
+  module Pokemon # :nodoc:
+    module Decorators # :nodoc:
+      ##
+      # Base class for the Pokemon decorators
+      # This class is used to decorate the Pokemon object with additional information and format it for display to the user in the CLI or other interfaces.
+      # The class is initialized with a Pokemon object and has a method to return the decorated Pokemon object as a string for display to the user in the CLI or other interfaces with the following information:
+      # ==== For example
+      #   Número: 1
+      #   Nombre: Bulbasaur
+      #   Descripción: Tras nacer, crece alimentándose durante un tiempo de los nutrientes que contiene el bulbo de su lomo.
+      #   Altura: 0.7 m
+      #   Peso: 6.9 kg
+      #   Categoría:
+      #   Habilidades: Espesura
+      #   Genero: Macho, Hembra
+      #   Tipo: Planta, Veneno
+      #   Habilidades: Fuego, Hielo, Volador, Psíquico
+      #
+      #   Puntos de base
+      #   %%%------------ PS
+      #   %%%------------ Ataque
+      #   %%%------------ Defensa
+      #   %%%%----------- Ataque Especial
+      #   %%%%----------- Defensa Especial
+      #   %%%------------ Velocidad
+      #
+      class Base
+        ##
+        # The Pokemon object to decorate. Receive a Pokemon object to decorate of Pokeedex::Pokemon::Model::Base class
+        attr_reader :pokemon
+
+        GENDER = {
+          'male' => 'Macho',
+          'female' => 'Hembra'
+        }.freeze
+
+        MAXIMUM_STAT_VALUE = 15
+
+        def initialize(pokemon)
+          @pokemon = pokemon
+        end
+
+        ##
+        # Return the decorated Pokemon object as a string for display to the user in the CLI or other interfaces
+        def to_s
+          decorate
+        end
+
+        private
+
+        def decorate
+          return "Pokemon's not found" unless pokemon
+
+          <<~DECORATOR
+            Número: #{number}
+            Nombre: #{name}
+            Descripción: #{description}
+            Altura: #{hight} m
+            Peso: #{weight} kg
+            Categoría: #{category}
+            Habilidades: #{abilities}
+            Genero: #{gender}
+            Tipo: #{types}
+            Habilidades: #{weakness}
+
+            Puntos de base
+            #{stats}
+          DECORATOR
+        end
+
+        def number = pokemon.number
+
+        def name = pokemon.name
+
+        def description = pokemon.description
+
+        def hight = pokemon.hight
+
+        def weight = pokemon.weight
+
+        def category = pokemon.category
+
+        def abilities = pokemon.abilities.join(', ')
+
+        def gender
+          pokemon.gender.map { |g| GENDER[g] }.join(', ')
+        end
+
+        def types = pokemon.types.join(', ')
+
+        def weakness = pokemon.weakness.join(', ')
+
+        def stats
+          pokemon.stats.each_with_object('').each do |(key, value), stats_decorate|
+            stats_decorate << "#{display_graph(value, MAXIMUM_STAT_VALUE)} #{key}\n"
+          end
+        end
+
+        def display_graph(value, max_value)
+          value = [[value, 1].max, max_value].min
+
+          total_chars = max_value
+          filled_chars = (value.to_f / max_value * total_chars).round
+          empty_chars = total_chars - filled_chars
+
+          '#' * filled_chars + '-' * empty_chars
+        end
+      end
+    end
+  end
+end

data/lib/pokeedex/pokemon/model/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'json'
+
+require_relative '../../database'
+
+module Pokeedex # :nodoc:
+  module Pokemon # :nodoc:
+    module Model # :nodoc:
+      ##
+      # Base class for the Pokemon model. It holds the database connection and the methods to interact with the database table for the Pokemon model
+      class Base < Sequel::Model(Database.connection[:pokemons])
+        CACHE_TTL = 3600
+
+        plugin :timestamps, update_on_create: true
+        plugin :validation_helpers
+        plugin :serialization, :json, :abilities, :gender, :types, :weakness, :stats
+        plugin :caching, CACHE_TTL
+
+        ##
+        # Search for a Pokemon by number or name
+        def self.search(query)
+          where(Sequel.|({ number: query }, Sequel.ilike(:name, query)))
+        end
+
+        ##
+        # Validate the Pokemon model attributes
+        def validate
+          super
+          validates_presence %i[number name]
+          validates_unique :number
+        end
+
+        ##
+        # Return true when the Pokemon model is persisted in the database
+        def persisted?
+          !id.nil?
+        end
+      end
+    end
+  end
+end

data/lib/pokeedex/pokemon/scrapper/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'fetchers/base'
+require_relative 'parsers/base'
+
+module Pokeedex # :nodoc:
+  module Pokemon # :nodoc:
+    module Scrapper # :nodoc:
+      ##
+      # Base class for the Pokemon scrapper. It holds the methods to crawl the Pokemon data from the Pokemon website
+      class Base
+        ##
+        # The base URI to crawl the Pokemon data
+        BASE_URI = 'https://www.pokemon.com/el/pokedex'
+
+        ##
+        # Crawl the Pokemon data from the Pokemon website
+        def crawl
+          raise NotImplementedError
+        end
+
+        private
+
+        def parser
+          raise NotImplementedError
+        end
+
+        def fetcher
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/pokeedex/pokemon/scrapper/fetchers/base.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'playwright'
+
+module Pokeedex # :nodoc:
+  module Pokemon # :nodoc:
+    module Scrapper # :nodoc:
+      module Fetchers # :nodoc:
+        ##
+        # It holds the Playwright instance and the methods to fetch the content of a URL
+        # and fake mouse movements and scroll the page to avoid detection, and to generate a random viewport size to avoid detection.
+        # This implementation is based on the Playwright gem (
+        class Base
+          ##
+          # The URL to fetch the content from
+          attr_reader :url
+
+          ##
+          # The Playwright executable instance to use
+          attr_reader :playwright_exec
+
+          ##
+          # The Playwright instance to use to interact with the browser and the page to fetch the content from the URL
+          attr_reader :playwright
+
+          def initialize(url:)
+            @url = url
+            @playwright_exec = Playwright.create(playwright_cli_executable_path: Pokeedex.configuration.playwright_cli_executable_path)
+            @playwright = playwright_exec.playwright
+          end
+
+          ##
+          # Fetch the content of the URL and return the content as a string (HTML) or raise an exception if the content could not be fetched
+          def content
+            browser do |context|
+              page = context.new_page(viewport: generate_random_viewport)
+              page.goto(url)
+              page.wait_for_load_state
+
+              fake_mouse_movements(page, steps: 6)
+              fake_scroll_page_down_and_up(page)
+
+              page.content
+            end
+          rescue Playwright::Error
+            raise Exceptions::ScrapperError
+          end
+
+          ##
+          # Open a browser instance and execute the block with the browser instance and close the browser instance after the block is executed
+          def browser(&block)
+            block.call(chromium)
+          ensure
+            chromium.close
+          end
+
+          private
+
+          def chromium
+            @chromium ||= begin
+              args = [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-blink-features=AutomationControlled'
+              ]
+
+              playwright.chromium.launch(headless: true, args: args)
+            end
+          end
+
+          def generate_random_viewport
+            min_width = 1024
+            max_width = 2560
+            min_height = 800
+            max_height = 1440
+
+            width = rand(min_width..max_width)
+            height = rand(min_height..max_height)
+
+            { width: width, height: height }
+          end
+
+          def fake_mouse_movements(page, steps: 5)
+            viewport = page.viewport_size
+
+            max_width = viewport[:width]
+            max_height = viewport[:height]
+
+            steps.times do
+              x = rand(0..max_width)
+              y = rand(0..max_height)
+
+              page.mouse.move(x, y)
+
+              sleep(rand(0.2..0.5))
+            end
+          end
+
+          def fake_scroll_page_down_and_up(page)
+            page_height = page.evaluate('document.body.scrollHeight')
+
+            current_scroll_position = 0
+            scroll_step = 100
+
+            while current_scroll_position < page_height
+              page.evaluate("window.scrollBy(0, #{scroll_step})")
+              current_scroll_position += scroll_step
+
+              sleep(0.01)
+            end
+
+            while current_scroll_position > 0
+              page.evaluate("window.scrollBy(0, -#{scroll_step})")
+              current_scroll_position -= scroll_step
+
+              sleep(0.01)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pokeedex/pokemon/scrapper/parsers/base.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Pokeedex # :nodoc:
+  module Pokemon # :nodoc:
+    module Scrapper # :nodoc:
+      module Parsers # :nodoc:
+        ##
+        # Base class for the Pokemon parser. It holds the response and the methods to parse the response and return
+        # the Pokemon attributes from a HTML response
+        class Base
+          ##
+          # Response from the Pokemon::Pokemon::Scrapper::Fetcher::Base website (HTML response) to parse
+          attr_reader :response
+
+          def initialize(response)
+            @response = response
+          end
+
+          ##
+          # Return the Pokemon attributes as a JSON object
+          # @return [Hash] the Pokemon attributes as a JSON object
+          def as_json(*)
+            {
+              number: number,
+              name: name,
+              description: description,
+              hight: hight,
+              weight: weight,
+              category: category,
+              abilities: abilities,
+              gender: gender,
+              types: types,
+              weakness: weakness,
+              stats: stats
+            }
+          end
+
+          private
+
+          def raw_body
+            @raw_body ||= Nokogiri::HTML(response)
+          end
+
+          def raw_number
+            raw_body.css('.pokedex-pokemon-pagination-title > div > .pokemon-number').children[0].text.strip
+          rescue StandardError
+            nil
+          end
+
+          def number
+            raw_number[-4..].to_i if raw_number
+          end
+
+          def raw_name
+            raw_body.css('.pokedex-pokemon-pagination-title > div').children[0].text
+          rescue StandardError
+            nil
+          end
+
+          def name
+            raw_name&.strip if raw_name
+          end
+
+          def raw_description
+            raw_body
+              .css('.pokedex-pokemon-details-right')
+              .css('.version-descriptions .active').children[0].text
+          rescue StandardError
+            nil
+          end
+
+          def description
+            raw_description.strip if raw_description
+          end
+
+          def raw_hight
+            raw_body
+              .css('.pokedex-pokemon-details-right')
+              .css('.pokemon-ability-info > .column-7 > .left-column > ul > li:nth-child(1) > span.attribute-value')
+              .text
+              .gsub(',', '.')
+          rescue StandardError
+            nil
+          end
+
+          def hight
+            raw_hight[0..2].to_f if raw_hight
+          end
+
+          def raw_weight
+            raw_body
+              .css('.pokedex-pokemon-details-right')
+              .css('.pokemon-ability-info > .column-7 > .left-column > ul > li:nth-child(2) > span.attribute-value')
+              .text
+              .gsub(',', '.')
+          rescue StandardError
+            nil
+          end
+
+          def weight
+            raw_weight[0..2].to_f if raw_weight
+          end
+
+          def raw_category
+            raw_body
+              .css('div.pokemon-ability-info.color-bg.color-lightblue.match.active > div.column-7.push-4 > div > ul > li:nth-child(1) > span.attribute-value')
+              .text
+          rescue StandardError
+            nil
+          end
+
+          def category
+            raw_category.strip if raw_category
+          end
+
+          def raw_abilities
+            raw_body
+              .css('.pokedex-pokemon-details-right')
+              .css('.pokemon-ability-info > .column-7 > .right-column > ul > li:nth-child(2) > ul.attribute-list > li > a > span')
+              .children
+              .uniq
+              .map(&:text)
+              .map(&:strip)
+          rescue StandardError
+            []
+          end
+
+          def abilities
+            raw_abilities if raw_abilities.any?
+          end
+
+          def raw_gender
+            raw_body
+              .css('.pokedex-pokemon-details-right')
+              .css('.pokemon-ability-info > .column-7 > .left-column > ul > li:nth-child(3) > span.attribute-value > i')
+              .map { |i| i.attribute('class').text }
+              .uniq
+          rescue StandardError
+            []
+          end
+
+          def gender
+            raw_gender.map { |g| g[/male|female/] } if raw_gender.any?
+          end
+
+          def raw_types
+            raw_body
+              .css('.pokedex-pokemon-attributes > .dtm-type > ul > li > a')
+              .children
+              .map(&:text)
+              .uniq
+              .map(&:strip)
+              .reject(&:empty?)
+          rescue StandardError
+            []
+          end
+
+          def types
+            raw_types if raw_types.any?
+          end
+
+          def raw_weakness
+            raw_body
+              .css('.dtm-weaknesses > ul > li > a > span')
+              .children
+              .map(&:text)
+              .uniq
+              .map(&:strip)
+              .reject(&:empty?)
+          rescue StandardError
+            []
+          end
+
+          def weakness
+            raw_weakness if raw_weakness.any?
+          end
+
+          def raw_stats_info
+            raw_body.css('.pokemon-stats-info > ul')
+          end
+
+          def raw_stat_names
+            raw_stats_info.css('li > span').map(&:text)
+          end
+
+          def raw_stat_index_value(index)
+            raw_stats_info.css('li > ul > li:nth-child(1)')[index].attribute('data-value').value.to_i
+          end
+
+          def raw_stats
+            raw_stat_names.each_with_object({}).with_index do |(stat, stats), index|
+              stats[stat] = raw_stat_index_value(index)
+            end
+          end
+
+          def stats
+            raw_stats
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pokeedex/pokemon/scrapper/pokedex.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Pokeedex # :nodoc:
+  module Pokemon # :nodoc:
+    module Scrapper # :nodoc:
+      ##
+      # The Pokedex scrapper. It holds the methods to crawl the Pokedex data from the Pokemon website
+      class Pokedex < Base
+        ##
+        # Find by number or name the Pokemon data from the Pokemon website
+        attr_reader :number_or_name
+
+        def initialize(number_or_name:)
+          @number_or_name = number_or_name
+        end
+
+        ##
+        # Return the URL to crawl the Pokemon data
+        # If you number_or_name is 'pikachu' then the URL will be 'https://www.pokemon.com/el/pokedex/pikachu'
+        # @return [String]
+        def url
+          "#{BASE_URI}/#{number_or_name}"
+        end
+
+        ##
+        # Crawl the Pokemon data from the Pokemon website
+        # @return [Hash]
+        def crawl
+          parser.as_json
+        end
+
+        private
+
+        def parser
+          Parsers::Base.new(remote_content)
+        end
+
+        def remote_content
+          fetcher.content
+        end
+
+        def fetcher
+          @fetcher ||= Fetchers::Base.new(url: url)
+        end
+      end
+    end
+  end
+end