scrap_cbf_record 0.1.0

data/lib/scrap_cbf_record/configs/team.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  class Config
+    # Team settings
+    class Team < Base
+      class << self
+        # Default settings
+        #
+        # @return [Hash]
+        def default
+          {
+            class_name: 'Team',
+            rename_attrs: {},
+            exclude_attrs_on_create: %i[],
+            exclude_attrs_on_update: %i[],
+            associations: {}
+
+          }
+        end
+
+        # Settings use by the system
+        # Not configurable
+        #
+        # @return [Hash]
+        def required
+          { must_exclude_attrs: %i[] }
+        end
+
+        # Record Attributes
+        # It must match with ScrapCbf
+        #
+        # @return [Array]
+        def record_attrs
+          %i[
+            name
+            state
+            avatar_url
+          ]
+        end
+      end
+
+      attr_reader :class_name,
+                  :rename_attrs,
+                  :exclude_attrs_on_create,
+                  :exclude_attrs_on_update,
+                  :associations
+
+      # Starts the settings with default
+      #
+      # @return [nil]
+      def initialize
+        @class_name = default_class_name
+        @rename_attrs = default_rename_attrs
+        @exclude_attrs_on_create = default_exclude_attrs_on_create
+        @exclude_attrs_on_update = default_exclude_attrs_on_update
+        @associations = default_associations
+
+        ScrapCbfRecord::Team.config = self
+
+        super(*configs)
+      end
+
+      # These method receives the users settings
+      # Missing settings are left as default
+      #
+      # @param [config] Hash contaning the settings
+      # @return [nil]
+      def config=(config)
+        raise ::ArgumentError, 'config must be a Hash' unless config.is_a?(Hash)
+
+        @class_name = config[:class_name] if config[:class_name]
+        @rename_attrs = config[:rename_attrs] if config[:rename_attrs]
+        if config[:exclude_attrs_on_create]
+          @exclude_attrs_on_create = config[:exclude_attrs_on_create]
+        end
+        if config[:exclude_attrs_on_update]
+          @exclude_attrs_on_update = config[:exclude_attrs_on_update]
+        end
+        @associations = config[:associations] if config[:associations]
+
+        super(*configs)
+      end
+
+      # Return the configurable settings
+      #
+      # @return [Array]
+      def configs
+        [
+          @class_name,
+          @rename_attrs,
+          @exclude_attrs_on_create,
+          @exclude_attrs_on_update,
+          @associations
+        ]
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/errors.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  # Base error for all ScrapCbf errors.
+  class BaseError < ::StandardError; end
+
+  # Raise when error occurs while decoding
+  class JsonDecodeError < BaseError
+    def initialize(argument)
+      super(argument)
+    end
+  end
+
+  # Raise when missing a Hash key
+  class MissingKeyError < BaseError
+    def initialize(arg)
+      message = "Hash missing required key: #{arg}"
+      super(message)
+    end
+  end
+
+  # Raise when a validation error is found
+  class ActiveRecordValidationError < BaseError
+    def initialize
+      message = 'An error raised while saving records.' \
+      ' Check the log for more details'
+      super(message)
+    end
+  end
+
+  # Raise when the championship instance is not found on database
+  class ChampionshipInstanceNotFoundError < BaseError
+    def initialize(year)
+      message = "The Championship instance for year #{year}" \
+      ' was not found on database. Check if the values are right' \
+      ' or the instance exist on database, before saving records'
+
+      super(message)
+    end
+  end
+
+  class RecordClassNotDefinedError < BaseError
+    def initialize(record)
+      message = "The record class #{record.class_name}" \
+      ' was not defined. Check if the class exist or is being loaded'
+
+      super(message)
+    end
+  end
+
+  class RecordAssociationAttributeNotDefinedError < BaseError
+    def initialize(record, attribute)
+      message = "The record class #{record.class_name}" \
+      " has not defined the attribute #{attribute}." \
+      " If you don't want define this attribute," \
+      ' remove it from the config associations.'
+
+      super(message)
+    end
+  end
+
+  class RecordAttributeNotDefinedError < BaseError
+    def initialize(record, attribute)
+      message = "The record class #{record.class}" \
+      " has not defined the attribute #{attribute}." \
+      " If you don't want define this attribute," \
+      ' add it to the config lists of excludes on create and update.'
+
+      super(message)
+    end
+  end
+
+  class RecordRenameAttributeNotDefinedError < BaseError
+    def initialize(record, attribute)
+      message = "The record class #{record.class}" \
+      " has not defined the renamed attribute #{attribute}." \
+      ' Check if you write the attribute name correct, or' \
+      ' if you don\'t want rename, remove it from the config list rename attrs.'
+
+      super(message)
+    end
+  end
+end

data/lib/scrap_cbf_record/logger.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support/logger'
+require 'active_support/tagged_logging'
+
+class ScrapCbfRecord
+  class TagLogger
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+      end
+
+      def with_context(tags, message)
+        logger.tagged(*tags) { logger.info message }
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/models/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  # Base class for the models abstractions
+  class Base
+    class << self
+      # Create a instance for the real model, the one used by the user
+      #
+      # @param [args] arguments passed to new instance
+      # @return [Object] the instance model
+      def new(args)
+        @config.klass.new(args)
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/models/championship.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  # Abstraction for the class Championship
+  class Championship < Base
+    class << self
+      attr_accessor :config
+
+      def find_by!(attributes)
+        year         = attributes[:year]
+        associate    = attributes[:associate]
+
+        # if associate is nil, that means self is calling this method
+        instance = if associate.nil? || associate
+                     @config.klass.find_by(
+                       "#{@config.searchable_attr(:year)}": year
+                     )
+                   else
+                     year
+                   end
+
+        raise ChampionshipInstanceNotFoundError, year unless instance
+
+        instance
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/models/concerns/active_record_relation.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  # This class helps with the communication between models association
+  class ActiveRecordRelation
+    # @param [association_class] the class associated that will be searched
+    # @param [associate] boolean true if associate, false if it's not
+    # @return [ActiveRecordRelation]
+    def initialize(association_class, associate)
+      @association_class = association_class
+      @associate = associate
+    end
+
+    # Searchs on the association. Dependes on the associate value,
+    #  the search on db will be made if more or less arguments, or none.
+    #  be made on database level. If it's not, it may be using
+    #
+    # @param [attributes] hash contaning the attributes use to search
+    # @return [Object] return the obj found on db or their identifier
+    def find_by(attributes)
+      attributes[:associate] = @associate
+      @association_class.send __method__, attributes
+    end
+
+    # Searchs on the association. Dependes on the associate value,
+    #  the search on db will be made if more or less arguments, or none.
+    #  be made on database level. If it's not, it may be using
+    #
+    # @note Raises a exception if not found
+    # @param [attributes] hash contaning the attributes use to search
+    # @return [Object] return the obj found on db or their identifier
+    def find_by!(attributes)
+      attributes[:associate] = @associate
+      @association_class.send __method__, attributes
+    end
+  end
+end

data/lib/scrap_cbf_record/models/match.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  # Abstraction for the class Match
+  class Match < Base
+    class << self
+      attr_accessor :config
+
+      def championship
+        ActiveRecordRelation.new(
+          Championship,
+          @config.championship_associate?
+        )
+      end
+
+      def round
+        ActiveRecordRelation.new(
+          Round,
+          @config.round_associate?
+        )
+      end
+
+      def team
+        ActiveRecordRelation.new(
+          Team,
+          @config.team_associate?
+        )
+      end
+
+      def opponent
+        ActiveRecordRelation.new(
+          Team,
+          @config.opponent_associate?
+        )
+      end
+
+      # Find the current model on db. If current model is associate
+      #  to championship, the attribute serie is not need, as the
+      #  association can be used as a unique identifer for the model.
+      #
+      # @param attributes [Hash] the attrs used to find on db
+      # @return [Object, nil] returns Object if find, else nil
+      def find_by(attributes)
+        id_match     = attributes[:id_match]
+        championship = attributes[:championship]
+        serie        = attributes[:serie]
+
+        if @config.championship_associate?
+          find_match_associated(id_match, championship)
+        else
+          find_match(id_match, championship, serie)
+        end
+      end
+
+      def find_match(id_match, championship, serie)
+        @config.klass.find_by(
+          "#{@config.searchable_attr(:id_match)}": id_match,
+          "#{@config.searchable_attr(:championship)}": championship,
+          "#{@config.searchable_attr(:serie)}": serie
+        )
+      end
+
+      def find_match_associated(id_match, championship)
+        @config.klass.find_by(
+          "#{@config.searchable_attr(:id_match)}": id_match,
+          "#{@config.searchable_attr(:championship_id)}": championship.id
+        )
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/models/ranking.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  # Abstraction for the class Ranking
+  class Ranking < Base
+    class << self
+      attr_accessor :config
+
+      def championship
+        ActiveRecordRelation.new(
+          Championship,
+          @config.championship_associate?
+        )
+      end
+
+      def team
+        ActiveRecordRelation.new(
+          Team,
+          @config.team_associate?
+        )
+      end
+
+      def next_opponent
+        ActiveRecordRelation.new(
+          Team,
+          @config.next_opponent_associate?
+        )
+      end
+
+      def find_by(attributes)
+        position     = attributes[:position]
+        championship = attributes[:championship]
+        serie        = attributes[:serie]
+
+        if @config.championship_associate?
+          find_ranking_associated(position, championship)
+        else
+          find_ranking(position, championship, serie)
+        end
+      end
+
+      def find_ranking(position, championship, serie)
+        @config.klass.find_by(
+          "#{@config.searchable_attr(:position)}": position,
+          "#{@config.searchable_attr(:championship)}": championship,
+          "#{@config.searchable_attr(:serie)}": serie
+        )
+      end
+
+      def find_ranking_associated(position, championship)
+        @config.klass.find_by(
+          "#{@config.searchable_attr(:position)}": position,
+          "#{@config.searchable_attr(:championship_id)}": championship.id
+        )
+      end
+    end
+  end
+end

data/lib/scrap_cbf_record/models/round.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class ScrapCbfRecord
+  # Abstraction for the class Round
+  class Round < Base
+    class << self
+      attr_accessor :config
+
+      def championship
+        ActiveRecordRelation.new(
+          Championship,
+          @config.championship_associate?
+        )
+      end
+
+      def find_by(attributes)
+        number       = attributes[:number]
+        championship = attributes[:championship]
+        serie        = attributes[:serie]
+        associate    = attributes[:associate]
+
+        # if associate is nil, that means self is calling this method
+        if associate.nil? || associate
+          find_round_on_database(number, championship, serie)
+        else
+          number
+        end
+      end
+
+      def find_round_on_database(number, championship, serie)
+        if @config.championship_associate?
+          find_round_associated(number, championship)
+        else
+          find_round(number, championship, serie)
+        end
+      end
+
+      def find_round(number, championship, serie)
+        @config.klass.find_by(
+          "#{@config.searchable_attr(:number)}": number,
+          "#{@config.searchable_attr(:championship)}": championship,
+          "#{@config.searchable_attr(:serie)}": serie
+        )
+      end
+
+      def find_round_associated(number, championship)
+        @config.klass.find_by(
+          "#{@config.searchable_attr(:number)}": number,
+          "#{@config.searchable_attr(:championship_id)}": championship.id
+        )
+      end
+    end
+  end
+end