scrap_cbf_record 0.1.0

data/lib/scrap_cbf_record/active_records/rankings.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  class ActiveRecord
+    # Class responsible for saving rankings to database
+    class Rankings < Base
+      #
+      # @param [rankings] hash contaning the rankings
+      # @return [nil]
+      def initialize(rankings)
+        raise_unless_respond_to_each(rankings, :rankings)
+
+        configurations = ScrapCbfRecord.config
+
+        super(configurations.ranking)
+
+        @rankings = rankings
+      end
+
+      # Creates/Updates the matches found on the instance variable rankings
+      # Update if ranking already exist, otherwise create it.
+      #
+      # @param [championship_hash] the championship associated with the rankings
+      # @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
+          @rankings.each do |hash|
+            ranking = find_ranking_by(hash, championship, serie)
+            team = Ranking.team.find_by(name: hash[:team])
+            next_opponent =
+              Ranking.next_opponent.find_by(name: hash[:next_opponent])
+
+            associations = {
+              championship: championship,
+              team: team,
+              next_opponent: next_opponent
+            }
+
+            ranking = normalize_before_save(ranking, hash, associations)
+
+            save_or_log_error(ranking)
+          end
+        end
+        true
+      end
+
+      private
+
+      def find_championship_by(championship_hash)
+        championship =
+          Ranking.championship.find_by!(year: championship_hash[:year])
+
+        serie = championship_hash[:serie]
+
+        [championship, serie]
+      end
+
+      def find_ranking_by(hash, championship, serie)
+        Ranking.find_by(
+          position: hash[:position],
+          championship: championship,
+          serie: serie
+        )
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/active_records/rounds.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  class ActiveRecord
+    # Class responsible for saving rounds to database
+    class Rounds < Base
+      #
+      # @param [rounds] hash contaning the rounds
+      # @return [nil]
+      def initialize(rounds)
+        raise_unless_respond_to_each(rounds, :rounds)
+
+        configurations = ScrapCbfRecord.config
+
+        super(configurations.round)
+
+        @rounds = rounds
+      end
+
+      # Creates the rounds found on the instance variable rounds
+      # Create only if doesn't exist, otherwise do nothing
+      #
+      # @param [championship_hash] the championship associated with the rounds
+      # @raise [ActiveRecordValidationError] if fail on saving
+      # @return [Boolean] true if not exception is raise
+      def create_unless_found(championship_hash)
+        championship, serie = find_championship_by(championship_hash)
+
+        ::ActiveRecord::Base.transaction do
+          @rounds.each do |hash|
+            round = Round.find_by(
+              number: hash[:number],
+              championship: championship,
+              serie: serie
+            )
+            next if round
+
+            hash = normalize_before_create(hash, { championship: championship })
+
+            round = Round.new(hash)
+
+            save_or_log_error(round)
+          end
+        end
+        true
+      end
+
+      private
+
+      def find_championship_by(championship_hash)
+        championship =
+          Round.championship.find_by!(year: championship_hash[:year])
+
+        serie = championship_hash[:serie]
+
+        [championship, serie]
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/active_records/teams.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  class ActiveRecord
+    # Class responsible for saving teams to database
+    class Teams < Base
+      #
+      # @param [teams] hash contaning the teams
+      # @return [nil]
+      def initialize(teams)
+        raise_unless_respond_to_each(teams, :teams)
+
+        configurations = ScrapCbfRecord.config
+
+        super(configurations.team)
+
+        @teams = teams
+      end
+
+      # Creates the teams found on the instance variable teams
+      # Create only if doesn't exist, otherwise do nothing
+      #
+      # @raise [ActiveRecordValidationError] if fail on saving
+      # @return [Boolean] true if not exception is raise
+      def create_unless_found
+        ::ActiveRecord::Base.transaction do
+          @teams.each do |hash|
+            team = Team.find_by(name: hash[:name])
+            next if team
+
+            hash = normalize_before_create(hash)
+
+            team = Team.new(hash)
+
+            save_or_log_error(team)
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/config.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+require_relative 'configs/base'
+require_relative 'configs/championship'
+require_relative 'configs/match'
+require_relative 'configs/ranking'
+require_relative 'configs/round'
+require_relative 'configs/team'
+
+class ScrapCbfRecord
+  # This class is responsible for holding the configs on how records
+  # must be save on database. That means:
+  # - which class to use to save the records
+  # - which record attributes to exclude on create and update
+  # - which record attributes to rename
+  # - which db associations the record has.
+  # Each of the configs are set for each record:
+  # - match record
+  # - ranking record
+  # - round record
+  # - team record
+  class Config
+    include Singleton
+
+    attr_reader :championship,
+                :match,
+                :ranking,
+                :round,
+                :team
+
+    def initialize
+      @championship = Championship.new
+      @match = Match.new
+      @ranking = Ranking.new
+      @round = Round.new
+      @team = Team.new
+    end
+
+    # Define the logger to be use by ActiveSupport::TaggedLogging
+    #
+    # @param [Logger] active support logger with params
+    # @return [::Logger]
+    def logger=(logger)
+      TagLogger.logger = ActiveSupport::TaggedLogging.new(logger)
+    end
+
+    # Return an array with all record classes
+    #
+    # @return [Array]
+    def record_classes
+      [
+        @championship.klass,
+        @match.klass,
+        @ranking.klass,
+        @round.klass,
+        @team.klass
+      ]
+    end
+
+    # Return an array with all config classes
+    #
+    # @return [Array]
+    def config_classes
+      [
+        @championship,
+        @match,
+        @ranking,
+        @round,
+        @team
+      ]
+    end
+
+    # Restaure configs to default
+    #
+    # @return [Boolean] true if works
+    def restore
+      @championship = Championship.new
+      @match = Match.new
+      @ranking = Ranking.new
+      @round = Round.new
+      @team = Team.new
+
+      true
+    end
+
+    private_class_method :new
+
+    # Validate users/default configuration
+    # - check if record classes were defined
+    # - check if attrs were defined on record classes
+    #
+    # @raise [RecordClassNotDefinedError] if record class is not defined
+    # @raise [RecordAssociationAttributeNotDefinedError]
+    #  if association undefined
+    # @raise [RecordRenameAttributeNotDefinedError] if renamed attr undefined
+    # @raise [RecordAttributeNotDefinedError] if attr is undefined
+    # @return [Boolean] true if pass
+    def validate!
+      config_classes.each do |config_record|
+        validate_record_presence!(config_record)
+
+        validate_attrs_presence!(config_record)
+
+        validate_associations_presence!(config_record)
+      end
+
+      true
+    end
+
+    # Validate if Record is defined
+    #
+    # @raise [RecordClassNotDefinedError] if record is not defined
+    # @return [Objct] true if works
+    def validate_record_presence!(config_record)
+      config_record.klass
+    rescue NameError
+      raise RecordClassNotDefinedError, config_record
+    end
+
+    # Validate if association attribute exist on Record class
+    #
+    # @raise [RecordAssociationAttributeNotDefinedError] if not found
+    # @return [Array] returns array of associations
+    def validate_associations_presence!(config_record)
+      record_instance = config_record.klass.new
+
+      # validte foreign key associations
+      config_record.associations.each do |_key, assoc|
+        begin
+          record_instance.send assoc[:foreign_key] if assoc.key?(:foreign_key)
+        rescue NameError
+          raise(
+            RecordAssociationAttributeNotDefinedError.new(
+              config_record,
+              assoc[:foreign_key]
+            )
+          )
+        end
+      end
+    end
+
+    # Validate the presence on the record class
+    #  for the attributes renamed and non-exclude.
+    #
+    # @raise [RecordRenameAttributeNotDefinedError] if renamed not found
+    # @raise [RecordAttributeNotDefinedError] if non-exclude not found
+    # @return [Boolean] returns true if valid
+    def validate_attrs_presence!(config_record)
+      record_instance = config_record.klass.new
+      exclude_attrs = config_record.exclude_attrs
+      rename_attrs = config_record.rename_attrs
+
+      config_record.record_attrs.each do |attribute|
+        # if is a renamed attr, its original form is exclude
+        # so we only have to check it here
+        if rename_attrs.key?(attribute)
+          validate_attr_presence_from_rename!(
+            record_instance,
+            attribute,
+            rename_attrs
+          )
+        else
+          # non-exclude are the ones: not renamed, associated or excluded
+          validate_attr_presence_from_exclude!(
+            record_instance,
+            attribute,
+            exclude_attrs
+          )
+        end
+      end
+
+      true
+    end
+
+    # Validate if renamed attribute exist on Record class
+    #
+    # @raise [RecordRenameAttributeNotDefinedError] if not found
+    # @return [Object] returns the attribute found
+    def validate_attr_presence_from_rename!(
+      record_instance,
+      attribute,
+      rename_attrs
+    )
+      if rename_attrs.key?(attribute)
+        record_instance.send rename_attrs[attribute]
+      end
+    rescue NameError
+      raise(
+        ScrapCbfRecord::RecordRenameAttributeNotDefinedError.new(
+          record_instance,
+          rename_attrs[attribute]
+        )
+      )
+    end
+
+    # Validate if non-exclude attribute exist on Record class
+    #
+    # @raise [RecordAttributeNotDefinedError] if not found
+    # @return [Object] returns the attribute found
+    def validate_attr_presence_from_exclude!(
+      record_instance,
+      attribute,
+      exclude_attrs
+    )
+      record_instance.send attribute unless exclude_attrs.include?(attribute)
+    rescue NameError
+      raise(
+        ScrapCbfRecord::RecordAttributeNotDefinedError.new(
+          record_instance,
+          attribute
+        )
+      )
+    end
+  end
+end

data/lib/scrap_cbf_record/configs/base.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  class Config
+    # Superclass for the classes lib/config/<record>.rb
+    class Base
+      class << self
+        # Users may configure these settings
+        #
+        # @return [Hash] holding users or default settings
+        def default
+          raise NotImplementedError, 'default method must be implemented'
+        end
+
+        # These settings are not configurable by user
+        #
+        # @return [Hash] holding system settings
+        def required
+          raise NotImplementedError, 'required method must be implemented'
+        end
+
+        # Returns the key :class_name from the method default
+        # Class_name is used to find a specific record class
+        # The user may set a custom name for the specific record class
+        #
+        # @return [String, Symbol] holding class name
+        def default_class_name
+          default[:class_name]
+        end
+
+        # Returns the key :rename_attrs from the method default
+        #
+        # @return [Hash] with key been attrs name and value the renamed
+        def default_rename_attrs
+          default[:rename_attrs]
+        end
+
+        # Returns the key :exclude_attrs_on_create from the method default
+        #
+        # @return [Array] holding attrs to be exclude on create
+        def default_exclude_attrs_on_create
+          default[:exclude_attrs_on_create]
+        end
+
+        # Returns the key :exclude_attrs_on_update from the method default
+        # Rename_attrs is a array of strings contaning the attrs to be renamed
+        #
+        # @return [Array] holding attrs to be exclude on update
+        def default_exclude_attrs_on_update
+          default[:exclude_attrs_on_update]
+        end
+
+        # Returns the key :associations from the method default
+        # The associations are name of associations that a record has
+        #
+        # @return [Array] holding existent associations for the record
+        def default_associations
+          default[:associations]
+        end
+
+        # Returns the key :must_exclude_attrs from the method required
+        #
+        # @return [Array] holding attrs that must be excluded
+        def must_exclude_attrs
+          required[:must_exclude_attrs]
+        end
+      end
+
+      # @param [class_name] default[:class_name]
+      # @param [rename_attrs] default[:rename_attrs]
+      # @param [exclude_attrs_on_create] default[:exclude_attrs_on_create]
+      # @param [exclude_attrs_on_update] default[:exclude_attrs_on_update]
+      # @param [associations] default[:associations]
+      # @return [nil]
+      def initialize(
+        class_name,
+        rename_attrs,
+        exclude_attrs_on_create,
+        exclude_attrs_on_update,
+        associations
+      )
+        @class_name = class_name
+        @rename_attrs = rename_attrs
+        @exclude_attrs_on_create = exclude_attrs_on_create
+        @exclude_attrs_on_update = exclude_attrs_on_update
+        @associations = associations
+      end
+
+      # These method receives the users settings
+      #
+      # @param [class_name]
+      # @param [rename_attrs]
+      # @param [exclude_attrs_on_create]
+      # @param [exclude_attrs_on_update]
+      # @param [associations]
+      # @return [nil]
+      def config=(
+        class_name,
+        rename_attrs,
+        exclude_attrs_on_create,
+        exclude_attrs_on_update,
+        associations
+      )
+        @class_name = class_name
+        @rename_attrs = rename_attrs
+        @exclude_attrs_on_create = exclude_attrs_on_create
+        @exclude_attrs_on_update = exclude_attrs_on_update
+        @associations = associations
+      end
+
+      # Returns the class defined on class_name instance variable
+      # Class_name is a string or symbol and is set by user or default
+      #
+      # @raise [NameError] with class is not found
+      # @return [Object] class set by user
+      def klass
+        Object.const_get(@class_name)
+      end
+
+      # Check if argument matches with the subclasses name.
+      # This helps check if config correspond to the right active record config
+      #
+      # @param [record_type] symbol/string to be match with self subclasse name
+      # @return [Boolean]
+      def record_is_a?(record_type)
+        config_name = self.class.name.split('::').last
+
+        config_name.downcase == record_type.to_s
+      end
+
+      # Check if attribute was renamed.
+      # It will search on attrs and associations for the calling class.
+      # If not found returns the attribute.
+      #
+      # @param [attribute] the attribute to be searched on the calling class
+      # @return [Symbol]
+      def searchable_attr(attribute)
+        attribute = attribute.to_sym
+
+        foreign_key = fetch_association_foreign_key(attribute)
+
+        return foreign_key if foreign_key
+
+        return @rename_attrs[attribute] if @rename_attrs.key?(attribute)
+
+        attribute
+      end
+
+      # Returns the foreign key for the given association name.
+      # @note the association must be passed in the form <association-name>_id
+      #  to distinguish from the record hash attrs using the association name
+      #
+      # @param association [String, Symbol] <association-name>_id
+      # @return [Symbol, nil] Symbol if exist
+      def fetch_association_foreign_key(association_fk)
+        # associations are in the for of association-name_id
+        attr_name, attr_id = association_fk.to_s.split('_')
+
+        return unless attr_name && attr_id
+
+        association_name = attr_name.to_sym
+        return unless @associations.key?(association_name)
+
+        @associations[association_name][:foreign_key]
+      end
+
+      # Check if config has specific setting association.
+      #
+      # @return [Boolean]
+      def championship_associate?
+        return false unless associations?
+
+        @championship_associate ||= @associations.key?(:championship)
+      end
+
+      # Check if current config has specific setting association.
+      #
+      # @return [Boolean]
+      def round_associate?
+        return false unless associations?
+
+        @round_associate ||= @associations.key?(:round)
+      end
+
+      # Check if current config has specific setting association.
+      #
+      # @return [Boolean]
+      def team_associate?
+        return false unless associations?
+
+        @team_associate ||= @associations.key?(:team)
+      end
+
+      # Check if current config has any association.
+      #
+      # @return [Boolean]
+      def associations?
+        @associations && !@associations.empty?
+      end
+
+      # Return the excludes attributes by user and lib.
+      # @note: non-exclude are the ones: not renamed, associated or excluded.
+      # @note: Lib excludes must_exclude_attrs
+      # @note: Lib excludes renamed attrs
+      # @note: Lib excludes associations simple form
+      #  e.g championship is simple form from championship_id
+      #
+      # @return [Array]
+      def exclude_attrs
+        # This handle especial case: round and team doesn't have update action
+        user_exclusion = if record_is_a?(:round) || record_is_a?(:team)
+                           @exclude_attrs_on_create
+                         else
+                           (@exclude_attrs_on_create & @exclude_attrs_on_update)
+                         end
+
+        user_exclusion +
+          must_exclude_attrs +
+          @rename_attrs.keys +
+          @associations.keys
+      end
+
+      # Returns required must_exclude_attrs
+      #
+      # @return [Array]
+      def must_exclude_attrs
+        self.class.must_exclude_attrs
+      end
+
+      # Returns record_attrs
+      #
+      # @return [Array]
+      def record_attrs
+        self.class.record_attrs
+      end
+
+      def default_class_name
+        self.class.default_class_name
+      end
+
+      def default_rename_attrs
+        self.class.default_rename_attrs
+      end
+
+      def default_exclude_attrs_on_create
+        self.class.default_exclude_attrs_on_create
+      end
+
+      def default_exclude_attrs_on_update
+        self.class.default_exclude_attrs_on_update
+      end
+
+      def default_associations
+        self.class.default_associations
+      end
+    end
+  end
+end