scrap_cbf_record 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1689f847640b2f8bcfd5e9362b785d4b703bddd402097082f0c8f6bace631afe
+  data.tar.gz: 0fca0b02a69c838721a5f60fc1228e059bb35a2dd95f383b4d5cec94ca13b0d3
+SHA512:
+  metadata.gz: 4600056001b3c311ee5a9ea08ec1a3e35b6a1aa3502002afa8fc54c693c00bbf7094126f8a835418ddbb6164ab4b50bcf82680f255d8adf850da84976006766d
+  data.tar.gz: 2857154aa9b4acff0221fa0ad6447d3d77eb685bbf61584ae795f15c85b55b1a24f5b0c677d49408163e928ae11bf8af8c3017eeae33ba41a1649c627cb21e20

data/lib/scrap_cbf_record.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'scrap_cbf_record/version'
+require_relative 'scrap_cbf_record/logger'
+require_relative 'scrap_cbf_record/errors'
+require_relative 'scrap_cbf_record/models/base'
+require_relative 'scrap_cbf_record/models/championship'
+require_relative 'scrap_cbf_record/models/match'
+require_relative 'scrap_cbf_record/models/ranking'
+require_relative 'scrap_cbf_record/models/round'
+require_relative 'scrap_cbf_record/models/team'
+require_relative 'scrap_cbf_record/models/concerns/active_record_relation'
+require_relative 'scrap_cbf_record/config'
+require_relative 'scrap_cbf_record/active_record'
+
+# This module saves on database the output from the gem ScrapCbf
+#
+# It has two modules to accomplish that:
+# - configs: holds the settings for how to save the data
+# - records: responsible for saving the data on database.
+#
+# There configs are:
+# - championship
+# - match
+# - ranking
+# - round
+# - team
+#
+# The records are:
+# - matches: saves the matches for a specific championship
+# - rankings: saves the rankings for a specific championship
+# - rounds: saves the rounds for a specific championship
+# - teams: saves the teams that participated on the specific champ.
+class ScrapCbfRecord
+  class << self
+    # Returns the global configurations for these module
+    #
+    # @return [ScrapCbfRecord::Config]
+    def config
+      @config ||= settings
+    end
+
+    # Sets the global configurations
+    # We can set the configurations in the following way:
+    #
+    #   ScrapCbfRecord.settings do |config|
+    #     config.championship = {
+    #       class_name: 'Championship'
+    #       rename_attrs: {},
+    #       exclude_attrs_on_create: %i[],
+    #       exclude_attrs_on_update: %i[],
+    #       associations: %i[]
+    #     }
+    #
+    #     config.match = { ... }
+    #     config.ranking = { ... }
+    #     config.round = { ... }
+    #     config.team = { ... }
+    #   end
+    # If a config or a config's attribute was not set,
+    # default setting will be used
+    #
+    # @return [ScrapCbfRecord::Config]
+    def settings
+      configuration = Config.instance
+
+      yield configuration if block_given?
+
+      @config = configuration
+    end
+  end
+end

data/lib/scrap_cbf_record/active_record.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/except'
+
+require_relative 'active_records/base'
+require_relative 'active_records/matches'
+require_relative 'active_records/rankings'
+require_relative 'active_records/rounds'
+require_relative 'active_records/teams'
+
+class ScrapCbfRecord
+  # This module uses Active Record module to save data on database.
+  class ActiveRecord
+    class << self
+      def save(records)
+        new(records).save
+
+        true
+      end
+    end
+
+    # The argument records is a hash (json or not) with the following look :
+    # - hash[:championship] the championship for a specific year and divison
+    # - hash[:matches] the matches for the specific championship
+    # - hash[:rankings] the rankings for the specific championship
+    # - hash[:rounds] the rounds for the specific championship
+    # - hash[:teams] the teams that participated on the specific championship
+    #
+    # @param [records] hash or json returned from ScrapCbf gem
+    # @return [nil]
+    def initialize(records)
+      records = parse_json!(records) if records.is_a?(String)
+
+      raise ::ArgumentError, invalid_type_message unless records.is_a?(Hash)
+
+      @records = records.with_indifferent_access
+
+      validate_record_key_presence!(@records)
+
+      @championship = @records[:championship]
+      @matches = @records[:matches]
+      @rankings = @records[:rankings]
+      @rounds = @records[:rounds]
+      @teams = @records[:teams]
+    end
+
+    # Save records to the database.
+    # Note: Because of database relationships and dependencies between records
+    #  there maybe exist a saving order.
+    # - Teams must be save before Rankings and Match.
+    # - Rounds must be save before Matches
+    #
+    # @raise [ActiveRecordValidationError] in case of failing while saving
+    #
+    # @return [Boolean] true in case of success
+    def save
+      save_teams(@teams)
+      save_rankings(@rankings, @championship)
+      save_rounds(@rounds, @championship)
+      save_matches(@matches, @championship)
+
+      true
+    end
+
+    private
+
+    def save_teams(teams)
+      Teams.new(teams).create_unless_found
+    end
+
+    def save_rankings(rankings, championship)
+      Rankings.new(rankings).create_or_update(championship)
+    end
+
+    def save_rounds(rounds, championship)
+      Rounds.new(rounds).create_unless_found(championship)
+    end
+
+    def save_matches(matches, championship)
+      Matches.new(matches).create_or_update(championship)
+    end
+
+    def invalid_type_message
+      'must be a Hash or Json of a Hash'
+    end
+
+    def parse_json!(records)
+      JSON.parse(records)
+    rescue JSON::ParserError => e
+      raise JsonDecodeError, e
+    end
+
+    def validate_record_key_presence!(records)
+      raise MissingKeyError, 'championship' unless records.key?(:championship)
+      raise MissingKeyError, 'matches' unless records.key?(:matches)
+      raise MissingKeyError, 'rankings' unless records.key?(:rankings)
+      raise MissingKeyError, 'rounds' unless records.key?(:rounds)
+      raise MissingKeyError, 'teams' unless records.key?(:teams)
+
+      true
+    end
+  end
+end

data/lib/scrap_cbf_record/active_records/base.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  class ActiveRecord
+    # Superclass for the classes lib/active_records/<record>.rb
+    class Base
+      def initialize(config)
+        # config is associated with the current record class
+        #
+        @config = config
+
+        # This reference the user class used to save on database
+        #
+        @model = config.klass
+
+        # current configs set by users
+        #
+        @associations = @config.associations
+        @exclude_attrs_on_create = @config.exclude_attrs_on_create
+        @exclude_attrs_on_update = @config.exclude_attrs_on_update
+        @rename_attrs = @config.rename_attrs
+
+        # current configs required by the system
+        #
+        @must_exclude_attrs = @config.must_exclude_attrs
+      end
+
+      # Normalize, for create and update, the new record with:
+      # Setting Associations
+      # Rename attributes
+      # Exclusion of attributes
+      #
+      # @param [Object, Nil] the record if exist
+      # @param [Hash] contaning the new record
+      # @param [Hash] contaning the existent record's associations
+      # @return [Object] normalized
+      def normalize_before_save(record, hash, associations = {})
+        if record
+          hash = normalize_before_update(hash, associations)
+
+          record.assign_attributes(hash)
+
+          record
+        else
+          hash = normalize_before_create(hash, associations)
+
+          @model.new(hash)
+        end
+      end
+
+      # Normalize, on create, the new record with:
+      # Setting Associations
+      # Rename attributes
+      # Exclusion of attributes
+      #
+      # @param [Hash] contaning the new record
+      # @param [Hash] contaning the existent record's associations
+      # @return [Hash] normalized
+      def normalize_before_create(hash, assocs = {})
+        hash = include_associations(
+          hash,
+          @associations,
+          assocs
+        )
+
+        hash = exclude_attrs(
+          hash,
+          @exclude_attrs_on_create,
+          @must_exclude_attrs,
+          @associations.keys
+        )
+
+        hash = rename_attrs(hash, @rename_attrs)
+
+        hash
+      end
+
+      # Normalize, on update, the new record with:
+      # Setting Associations
+      # Rename attributes
+      # Exclusion of attributes
+      #
+      # @param [Hash] contaning the new record
+      # @param [Hash] contaning the existent record's associations
+      # @return [Hash] normalized
+      def normalize_before_update(hash, assocs = {})
+        hash = include_associations(
+          hash,
+          @associations,
+          assocs
+        )
+
+        hash = exclude_attrs(
+          hash,
+          @exclude_attrs_on_update,
+          @must_exclude_attrs,
+          @associations.keys
+        )
+
+        hash = rename_attrs(hash, @rename_attrs)
+
+        hash
+      end
+
+      # Save record instance or log the errors found
+      #
+      # @raise [ActiveRecordValidationError]
+      # @param record [ActiveRecord] instance to be saved
+      # @return [ActiveRecord] the instance saved
+      def save_or_log_error(record)
+        if record.valid?
+          record.save
+        else
+          log_record_errors(record)
+          # It raises custom error to display message warning about the logs.
+          raise ActiveRecordValidationError
+        end
+        record
+      end
+
+      protected
+
+      # Includes associations <attribute_id> and its value to the record hash
+      #  only include if the associations was set by the user.
+      #
+      # @param hash [Hash] record hash to be modified
+      # @param associations [Hash] hash contaning associations details
+      # @param assocs [Hash] hash contaning the associations
+      #  values returned by find_by
+      # @return [Hash] record hash with associations included
+      def include_associations(hash, associations, assocs)
+        associations.each do |name, attrs|
+          instance = assocs[name.to_sym]
+
+          foreign_key = attrs[:foreign_key]
+
+          # for cases where instance is:
+          # - association is empty (nil)
+          # - association is present
+          #
+          # update hash with the foreign_key
+          hash[foreign_key.to_sym] = (instance.id if instance.present?)
+        end
+
+        hash
+      end
+
+      # Exclude some keys from the record hash
+      #
+      # @param hash [Hash] record hash to be modified
+      # @param attrs [Array] has the keys to be exclude.
+      #  These attrs are the union of exclude_attrs_on_create/update.
+      # @param must_exclude [Array] has the keys to be excluded.
+      #  The keys are set by the lib, and is used to remove unwanted attrs.
+      # @param associations [Array] has the names of the associations.
+      #  include_associations method does't remove the associations added.
+      #  e.g if championship association exist, then:
+      #   add championship_id to hash.
+      #   But, it doesn't remove the championship key from the hash.
+      #   It's remove here.
+      # @return [Hash] record hash modified
+      def exclude_attrs(hash, attrs, must_exclude, associations)
+        exclude = attrs + associations + must_exclude
+        hash.except(*exclude)
+      end
+
+      # Rename keys from the record hash
+      #
+      # @param hash [Hash] record hash to be modified
+      # @param renames [Hash] has the keys to be renamed by the key's value.
+      # @return [Hash] record hash modified
+      def rename_attrs(hash, renames)
+        # rename attrs
+        renames.each do |key, val|
+          hash[val.to_sym] = hash.delete(key) if hash.key?(key)
+        end
+
+        hash
+      end
+
+      def raise_unless_respond_to_each(records, records_type)
+        return if records.respond_to?(:each)
+
+        raise ::ArgumentError, "#{records_type} must respond to method :each"
+      end
+
+      def log_record_errors(record)
+        TagLogger.with_context([Time.current], 'Errors found while saving')
+        record.errors.each do |attribute, message|
+          TagLogger.with_context(:info, record.inspect.to_s)
+          TagLogger.with_context(:error, "#{attribute}: #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/active_records/matches.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  class ActiveRecord
+    # Class responsible for saving matches to database
+    class Matches < Base
+      #
+      # @param [matches] hash contaning the matches
+      # @return [nil]
+      def initialize(matches)
+        raise_unless_respond_to_each(matches, :matches)
+
+        configurations = ScrapCbfRecord.config
+
+        super(configurations.match)
+
+        @matches = matches
+      end
+
+      # Creates/Updates the matches found on the instance variable matches
+      # Update if match already exist, otherwise create it
+      #
+      # @param [championship_hash] the championship associated with the matches
+      # @raise [ActiveRecordValidationError] if fail on saving
+      # @return [Boolean] true if not exception is raise
+      def create_or_update(championship_hash)
+        championship, serie = find_championship_by(championship_hash)
+
+        ::ActiveRecord::Base.transaction do
+          @matches.each do |hash|
+            attrs = [hash, championship, serie]
+            match = find_match_by(*attrs)
+            round = find_round_by(*attrs)
+            team = Match.team.find_by(name: hash[:team])
+            opponent = Match.opponent.find_by(name: hash[:opponent])
+
+            associations = {
+              championship: championship,
+              round: round,
+              team: team,
+              opponent: opponent
+            }
+
+            match = normalize_before_save(match, hash, associations)
+
+            save_or_log_error(match)
+          end
+        end
+        true
+      end
+
+      private
+
+      def find_championship_by(championship_hash)
+        championship =
+          Match.championship.find_by!(year: championship_hash[:year])
+
+        serie = championship_hash[:serie]
+
+        [championship, serie]
+      end
+
+      def find_match_by(hash, championship, serie)
+        Match.find_by(
+          id_match: hash[:id_match],
+          championship: championship,
+          serie: serie
+        )
+      end
+
+      def find_round_by(hash, championship, serie)
+        Match.round.find_by(
+          number: hash[:round],
+          championship: championship,
+          serie: serie
+        )
+      end
+    end
+  end
+end