<commit_before>require "fog/core/deprecated_connection_accessors"

module Fog
  class Collection < Array
    extend Fog::Attributes::ClassMethods
    include Fog::Attributes::InstanceMethods
    include Fog::Core::DeprecatedConnectionAccessors

    attr_reader :service

    Array.public_instance_methods(false).each do |method|
      next if [:reject, :select, :slice, :clear, :inspect].include?(method.to_sym)
      class_eval <<-EOS, __FILE__, __LINE__
        def #{method}(*args)
          unless @loaded
            lazy_load
          end
          super
        end
      EOS
    end

    %w(reject select slice).each do |method|
      class_eval <<-EOS, __FILE__, __LINE__
        def #{method}(*args)
          unless @loaded
            lazy_load
          end
          data = super
          self.clone.clear.concat(data)
        end
      EOS
    end

    def self.model(new_model = nil)
      if new_model.nil?
        @model
      else
        @model = new_model
      end
    end

    def clear
      @loaded = true
      super
    end

    def create(attributes = {})
      object = new(attributes)
      object.save
      object
    end

    def destroy(identity)
      object = new(:identity => identity)
      object.destroy
    end

    # Creates a new Fog::Collection based around the passed service
    #
    # @param [Hash] attributes
    # @option attributes [Fog::Service] service Instance of a service
    #
    # @return [Fog::Collection]
    #
    def initialize(attributes = {})
      @service = attributes.delete(:service)
      @loaded = false
      merge_attributes(attributes)
    end

    def inspect
      Thread.current[:formatador] ||= Formatador.new
      data = "#{Thread.current[:formatador].indentation}<#{self.class.name}\n"
      Thread.current[:formatador].indent do
        unless self.class.attributes.empty?
          data << "#{Thread.current[:formatador].indentation}"
          data << self.class.attributes.map { |attribute| "#{attribute}=#{send(attribute).inspect}" }.join(",\n#{Thread.current[:formatador].indentation}")
          data << "\n"
        end
        data << "#{Thread.current[:formatador].indentation}["
        unless self.empty?
          data << "\n"
          Thread.current[:formatador].indent do
            data << map(&:inspect).join(", \n")
            data << "\n"
          end
          data << Thread.current[:formatador].indentation
        end
        data << "]\n"
      end
      data << "#{Thread.current[:formatador].indentation}>"
      data
    end

    def load(objects)
      clear
      objects.each do |object|
        self << new(object)
      end
      self
    end

    def model
      self.class.instance_variable_get("@model")
    end

    def new(attributes = {})
      unless attributes.is_a?(::Hash)
        raise ArgumentError, "Initialization parameters must be an attributes hash, got #{attributes.class} #{attributes.inspect}"
      end
      model.new(
        {
          :collection => self,
          :service => service
        }.merge(attributes)
      )
    end

    def reload
      clear
      lazy_load
      self
    end

    def table(attributes = nil)
      Formatador.display_table(map(&:attributes), attributes)
    end

    def to_json(_options = {})
      Fog::JSON.encode(map(&:attributes))
    end

    private

    def lazy_load
      all
    end
  end

  # Base class for collection classes whose 'all' method returns only a single
  # page of results and passes the 'Marker' option along as
  # self.filters[:marker]
  class PagedCollection < Collection
    def each(collection_filters = filters)
      if block_given?
        Kernel.loop do
          break unless filters[:marker]
          page = all(collection_filters)
          # We need to explicitly use the base 'each' method here on the page,
          #  otherwise we get infinite recursion
          base_each = Fog::Collection.instance_method(:each)
          base_each.bind(page).call { |item| yield item }
        end
      end
      self
    end
  end
end<commit_msg>Refactor inspect method into composed method residing in Fog::Collection::Data. This reduces ABCs in inspect, keeps class definition below 100 lines, and makes rubocop happy<commit_after>require "fog/core/deprecated_connection_accessors"

module Fog
  # Fog::Collection - FILL ME IN
  class Collection < Array
    extend Fog::Attributes::ClassMethods
    include Fog::Attributes::InstanceMethods
    include Fog::Core::DeprecatedConnectionAccessors
    extend Fog::Collection::Data

    attr_reader :service

    Array.public_instance_methods(false).each do |method|
      next if [:reject, :select, :slice, :clear, :inspect].include?(method.to_sym)
      class_eval <<-EOS, __FILE__, __LINE__
        def #{method}(*args)
          unless @loaded
            lazy_load
          end
          super
        end
      EOS
    end

    %w(reject select slice).each do |method|
      class_eval <<-EOS, __FILE__, __LINE__
        def #{method}(*args)
          unless @loaded
            lazy_load
          end
          data = super
          self.clone.clear.concat(data)
        end
      EOS
    end

    def self.model(new_model = nil)
      if new_model.nil?
        @model
      else
        @model = new_model
      end
    end

    def clear
      @loaded = true && super
    end

    def create(attributes = {})
      new(attributes).save
    end

    def destroy(identity)
      new(:identity => identity).destroy
    end

    # Creates a new Fog::Collection based around the passed service
    #
    # @param [Hash] attributes
    # @option attributes [Fog::Service] service Instance of a service
    #
    # @return [Fog::Collection]
    #
    def initialize(attributes = {})
      @service = attributes.delete(:service)
      @loaded = false
      merge_attributes(attributes)
    end

    def inspect
      Thread.current[:formatador] ||= Formatador.new
      Fog::Collection::Data.make_data(Thread.current)
    end

    def load(objects)
      clear && objects.each { |object| self << new(object) }
      self
    end

    def model
      self.class.instance_variable_get("@model")
    end

    def new(attributes = {})
      unless attributes.is_a?(::Hash)
        raise ArgumentError, "Initialization parameters must be an attributes hash, got #{attributes.class} #{attributes.inspect}"
      end
      model.new(
        {
          :collection => self,
          :service => service
        }.merge(attributes)
      )
    end

    def reload
      clear && lazy_load
      self
    end

    def table(attributes = nil)
      Formatador.display_table(map(&:attributes), attributes)
    end

    def to_json(_options = {})
      Fog::JSON.encode(map(&:attributes))
    end

    private

    def lazy_load
      all
    end
  end
  # Base class for collection classes whose 'all' method returns only a single
  # page of results and passes the 'Marker' option along as
  # self.filters[:marker]
  class PagedCollection < Collection
    def each(collection_filters = filters)
      if block_given?
        Kernel.loop do
          break unless filters[:marker]
          page = all(collection_filters)
          # We need to explicitly use the base 'each' method here on the page,
          #  otherwise we get infinite recursion
          base_each = Fog::Collection.instance_method(:each)
          base_each.bind(page).call { |item| yield item }
        end
      end
      self
    end
  end

  # Fog::Collection::Data module
  module Data
    def make_data(thread)
      data = "#{thread[:formatador].indentation}<#{self.class.name}\n"
      thread[:formatador].indent do
        append_data(thread, ->(val) { data << val })
      end
      data << "#{thread[:formatador].indentation}>"
      data
    end

    def append_data(thread, &data)
      add_attributes(thread, data) unless self.class.attributes.empty?
      data.call("#{thread[:formatador].indentation}[")
      add_stuff(thread, data) unless self.empty?
      data.call("]\n")
    end

    def add_params(thread, &data)
      data.call("#{thread[:formatador].indentation}")
      add_attributes(thread, data)
      data.call("\n")
    end

    def add_attributes(thread, &data)
      attrs = self.class.attributes.map do |attr|
        str = "#{attr}=#{send(attr).inspect}"
        str.join(",\n#{thread[:formatador].indentation}")
      end
      data.call(attrs)
    end

    def add_stuff(thread, &data)
      data.call("\n")
      thread[:formatador].indent do
        data.call map(&:inspect).join(", \n") << "\n"
      end
      data.call(thread[:formatador].indentation)
    end
  end
end
{'fraction_non_alphanumeric': 0.10626229887718486, 'fraction_numerical': 0.0003472624146313231, 'mean_word_length': 2.287671232876712, 'pattern_counts': {'":': 0, '<': 47, '<?xml version=': 0, '>': 12, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '2981396', 'n_tokens_mistral': 2475, 'n_tokens_neox': 2448, 'n_words': 639}