giga-clean-tool 0.0.1

data/config-5.6.1/lib/config/configuration.rb

@@ -0,0 +1,36 @@
+module Config
+  # The main configuration backbone
+  class Configuration < Module
+    # Accepts configuration options,
+    # initializing a module that can be used to extend
+    # the necessary class with the provided config methods
+    def initialize(**attributes)
+      attributes.each do |name, default|
+        define_reader(name, default)
+        define_writer(name)
+      end
+    end
+
+    private
+
+    def define_reader(name, default)
+      variable = :"@#{name}"
+
+      define_method(name) do
+        if instance_variable_defined?(variable)
+          instance_variable_get(variable)
+        else
+          default
+        end
+      end
+    end
+
+    def define_writer(name)
+      variable = :"@#{name}"
+
+      define_method("#{name}=") do |value|
+        instance_variable_set(variable, value)
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/dry_validation_requirements.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Config
+  module DryValidationRequirements
+    VERSIONS = ['~> 1.0', '>= 1.0.0'].freeze
+
+    def self.load_dry_validation!
+      return if defined?(@load_dry_validation)
+
+      begin
+        require 'dry/validation/version'
+        version = Gem::Version.new(Dry::Validation::VERSION)
+        unless VERSIONS.all? { |req| Gem::Requirement.new(req).satisfied_by?(version) }
+          raise LoadError
+        end
+      rescue LoadError
+        raise ::Config::Error, "Could not find a dry-validation version matching requirements (#{VERSIONS.map(&:inspect) * ','})"
+      end
+
+      require 'dry/validation'
+      @load_dry_validation = true
+      nil
+    end
+  end
+end

data/config-5.6.1/lib/config/error.rb

@@ -0,0 +1,4 @@
+module Config
+  class Error < StandardError
+  end
+end

data/config-5.6.1/lib/config/integrations/heroku.rb

@@ -0,0 +1,59 @@
+require 'bundler'
+
+module Config
+  module Integrations
+    class Heroku < Struct.new(:app)
+      def invoke
+        puts 'Setting vars...'
+        heroku_command = "config:set #{vars}"
+        heroku(heroku_command)
+        puts 'Vars set:'
+        puts heroku_command
+      end
+
+      def vars
+        # Load only local options to Heroku
+        Config.load_and_set_settings(
+            Rails.root.join("config", "#{Config.file_name}.local.yml").to_s,
+            Rails.root.join("config", Config.dir_name, "#{environment}.local.yml").to_s,
+            Rails.root.join("config", "environments", "#{environment}.local.yml").to_s
+        )
+
+        out = ''
+        dotted_hash = to_dotted_hash Kernel.const_get(Config.const_name).to_hash, {}, Config.const_name
+        dotted_hash.each {|key, value| out += " #{key}=#{value} "}
+        out
+      end
+
+      def environment
+        heroku("run 'echo $RAILS_ENV'").chomp[/(\w+)\z/]
+      end
+
+      def heroku(command)
+        with_app = app ? " --app #{app}" : ""
+        `heroku #{command}#{with_app}`
+      end
+
+      def `(command)
+        Bundler.with_clean_env { super }
+      end
+
+      def to_dotted_hash(source, target = {}, namespace = nil)
+        prefix = "#{namespace}." if namespace
+        case source
+          when Hash
+            source.each do |key, value|
+              to_dotted_hash(value, target, "#{prefix}#{key}")
+            end
+          when Array
+            source.each_with_index do |value, index|
+              to_dotted_hash(value, target, "#{prefix}#{index}")
+            end
+          else
+            target[namespace] = source
+        end
+        target
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/integrations/rails/railtie.rb

@@ -0,0 +1,38 @@
+module Config
+  module Integrations
+    module Rails
+      class Railtie < ::Rails::Railtie
+        def preload
+          # Manually load the custom initializer before everything else
+          initializer = ::Rails.root.join('config', 'initializers', 'config.rb')
+          require initializer if File.exist?(initializer)
+
+          # Parse the settings before any of the initializers
+          Config.load_and_set_settings(
+            Config.setting_files(::Rails.root.join('config'), Config.environment.nil? ? ::Rails.env : Config.environment.to_sym)
+          )
+        end
+
+        # Load rake tasks (eg. Heroku)
+        rake_tasks do
+          Dir[File.join(File.dirname(__FILE__), '../tasks/*.rake')].each { |f| load f }
+        end
+
+        config.before_configuration { preload }
+
+        # Development environment should reload settings on every request
+        if ::Rails.env.development?
+          initializer :config_reload_on_development do
+            ActiveSupport.on_load :action_controller_base do
+              if ::Rails::VERSION::MAJOR >= 4
+                prepend_before_action { ::Config.reload! }
+              else
+                prepend_before_filter { ::Config.reload! }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/integrations/sinatra.rb

@@ -0,0 +1,26 @@
+require "config/rack/reloader"
+
+module Config
+  # provide helper to register within your Sinatra app
+  #
+  # set :root, File.dirname(__FILE__)
+  # register Config
+  #
+  def self.registered(app)
+    app.configure do |inner_app|
+
+      env = inner_app.environment || ENV["RACK_ENV"]
+      root = inner_app.root
+
+      # use Padrino settings if applicable
+      if defined?(Padrino)
+        env = Padrino.env if Padrino.respond_to?(:env)
+        root = Padrino.root if Padrino.respond_to?(:root)
+      end
+
+      Config.load_and_set_settings(Config.setting_files(File.join(root, 'config'), env))
+
+      inner_app.use(::Config::Rack::Reloader) if inner_app.development?
+    end
+  end
+end

data/config-5.6.1/lib/config/options.rb

@@ -0,0 +1,195 @@
+require 'ostruct'
+require 'config/validation/validate'
+
+module Config
+  class Options < OpenStruct
+    include Enumerable
+    include Validation::Validate
+
+    def keys
+      marshal_dump.keys
+    end
+
+    def empty?
+      marshal_dump.empty?
+    end
+
+    def add_source!(source)
+      # handle yaml file paths
+      source = (Sources::YAMLSource.new(source)) if source.is_a?(String) || source.is_a?(Pathname)
+      source = (Sources::HashSource.new(source)) if source.is_a?(Hash)
+
+      @config_sources ||= []
+      @config_sources << source
+    end
+
+    def prepend_source!(source)
+      source = (Sources::YAMLSource.new(source)) if source.is_a?(String) || source.is_a?(Pathname)
+      source = (Sources::HashSource.new(source)) if source.is_a?(Hash)
+
+      @config_sources ||= []
+      @config_sources.unshift(source)
+    end
+
+    # look through all our sources and rebuild the configuration
+    def reload!
+      conf = {}
+      @config_sources.each do |source|
+        source_conf = source.load
+
+        if conf.empty?
+          conf = source_conf
+        else
+          DeepMerge.deep_merge!(
+                                source_conf,
+                                conf,
+                                preserve_unmergeables: false,
+                                knockout_prefix:       Config.knockout_prefix,
+                                overwrite_arrays:      Config.overwrite_arrays,
+                                merge_nil_values:      Config.merge_nil_values,
+                                merge_hash_arrays:     Config.merge_hash_arrays
+                               )
+        end
+      end
+
+      # swap out the contents of the OStruct with a hash (need to recursively convert)
+      marshal_load(__convert(conf).marshal_dump)
+
+      validate!
+
+      self
+    end
+
+    alias :load! :reload!
+
+    def reload_from_files(*files)
+      Config.load_and_set_settings(files)
+      reload!
+    end
+
+    def to_hash
+      result = {}
+      marshal_dump.each do |k, v|
+        if v.instance_of? Config::Options
+          result[k] = v.to_hash
+        elsif v.instance_of? Array
+          result[k] = descend_array(v)
+        else
+          result[k] = v
+        end
+      end
+      result
+    end
+
+    alias :to_h :to_hash
+
+    def each(*args, &block)
+      marshal_dump.each(*args, &block)
+    end
+
+    def to_json(*args)
+      require "json" unless defined?(JSON)
+      to_hash.to_json(*args)
+    end
+
+    def as_json(options = nil)
+      to_hash.as_json(options)
+    end
+
+    def merge!(hash)
+      current = to_hash
+      DeepMerge.deep_merge!(
+                            hash.dup,
+                            current,
+                            preserve_unmergeables: false,
+                            knockout_prefix:       Config.knockout_prefix,
+                            overwrite_arrays:      Config.overwrite_arrays,
+                            merge_nil_values:      Config.merge_nil_values,
+                            merge_hash_arrays:     Config.merge_hash_arrays
+                           )
+      marshal_load(__convert(current).marshal_dump)
+      self
+    end
+
+    # Some keywords that don't play nicely with OpenStruct
+    SETTINGS_RESERVED_NAMES = %w[select collect test count zip min max exit! table].freeze
+
+    # Some keywords that don't play nicely with Rails 7.*
+    RAILS_RESERVED_NAMES = %w[maximum minimum].freeze
+
+    # An alternative mechanism for property access.
+    # This let's you do foo['bar'] along with foo.bar.
+    def [](param)
+      return super if SETTINGS_RESERVED_NAMES.include?(param)
+      return super if RAILS_RESERVED_NAMES.include?(param)
+      public_send("#{param}")
+    end
+
+    def []=(param, value)
+      send("#{param}=", value)
+    end
+
+    SETTINGS_RESERVED_NAMES.each do |name|
+      define_method name do
+        self[name]
+      end
+    end
+
+    RAILS_RESERVED_NAMES.each do |name|
+      define_method name do
+        self[name]
+      end
+    end
+
+    def key?(key)
+      @table.key?(key)
+    end
+
+    def has_key?(key)
+      @table.has_key?(key)
+    end
+
+    def method_missing(method_name, *args)
+      if Config.fail_on_missing && method_name !~ /.*(?==\z)/m
+        raise KeyError, "key not found: #{method_name.inspect}" unless key?(method_name)
+      end
+      super
+    end
+
+    def respond_to_missing?(*args)
+      super
+    end
+
+    protected
+
+    def descend_array(array)
+      array.map do |value|
+        if value.instance_of? Config::Options
+          value.to_hash
+        elsif value.instance_of? Array
+          descend_array(value)
+        else
+          value
+        end
+      end
+    end
+
+    # Recursively converts Hashes to Options (including Hashes inside Arrays)
+    def __convert(h) #:nodoc:
+      s = self.class.new
+
+      h.each do |k, v|
+        k = k.to_s if !k.respond_to?(:to_sym) && k.respond_to?(:to_s)
+
+        if v.is_a?(Hash)
+          v = v["type"] == "hash" ? v["contents"] : __convert(v)
+        elsif v.is_a?(Array)
+          v = v.collect { |e| e.instance_of?(Hash) ? __convert(e) : e }
+        end
+
+        s[k] = v
+      end
+      s
+    end
+  end
+end

data/config-5.6.1/lib/config/rack/reloader.rb

@@ -0,0 +1,15 @@
+module Config
+  module Rack
+    # Rack middleware the reloads Config on every request (only use in dev mode)
+    class Reloader
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Config.reload!
+        @app.call(env)
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/sources/env_source.rb

@@ -0,0 +1,94 @@
+module Config
+  module Sources
+    # Allows settings to be loaded from a "flat" hash with string keys, like ENV.
+    class EnvSource
+      attr_reader :prefix
+      attr_reader :separator
+      attr_reader :converter
+      attr_reader :parse_values
+      attr_reader :parse_arrays
+
+      def initialize(env,
+                     prefix: Config.env_prefix || Config.const_name,
+                     separator: Config.env_separator,
+                     converter: Config.env_converter,
+                     parse_values: Config.env_parse_values,
+                     parse_arrays: Config.env_parse_arrays)
+        @env = env
+        @prefix = prefix.to_s.split(separator)
+        @separator = separator
+        @converter = converter
+        @parse_values = parse_values
+        @parse_arrays = parse_arrays
+      end
+
+      def load
+        return {} if @env.nil? || @env.empty?
+
+        hash = Hash.new
+
+        @env.each do |variable, value|
+          keys = variable.to_s.split(separator)
+
+          next if keys.shift(prefix.size) != prefix
+
+          keys.map! { |key|
+            case converter
+              when :downcase then
+                key.downcase
+              when nil then
+                key
+              else
+                raise "Invalid ENV variables name converter: #{converter}"
+            end
+          }
+
+          leaf = keys[0...-1].inject(hash) { |h, key|
+            h[key] ||= {}
+          }
+
+          unless leaf.is_a?(Hash)
+            conflicting_key = (prefix + keys[0...-1]).join(separator)
+            raise "Environment variable #{variable} conflicts with variable #{conflicting_key}"
+          end
+
+          leaf[keys.last] = parse_values ? __value(value) : value
+        end
+
+        parse_arrays ? convert_hashes_to_arrays(hash) : hash
+      end
+
+      private
+      def convert_hashes_to_arrays(hash)
+        hash.each_with_object({}) do |(key, value), new_hash|
+          if value.is_a?(Hash)
+            value = convert_hashes_to_arrays(value)
+            if consecutive_numeric_keys?(value.keys)
+              new_hash[key] = value.keys.sort_by(&:to_i).map { |k| value[k] }
+            else
+              new_hash[key] = value
+            end
+          else
+            new_hash[key] = value
+          end
+        end
+      end
+
+      def consecutive_numeric_keys?(keys)
+        keys.map(&:to_i).sort == (0...keys.size).to_a && keys.all? { |k| k == k.to_i.to_s }
+      end
+
+      # Try to convert string to a correct type
+      def __value(v)
+        case v
+        when 'false'
+          false
+        when 'true'
+          true
+        else
+          Integer(v) rescue Float(v) rescue v
+        end
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/sources/hash_source.rb

@@ -0,0 +1,16 @@
+module Config
+  module Sources
+    class HashSource
+      attr_accessor :hash
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      # returns hash that was passed in to initialize
+      def load
+        hash.is_a?(Hash) ? hash : {}
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/sources/yaml_source.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+require 'erb'
+
+module Config
+  module Sources
+    class YAMLSource
+      attr_accessor :path
+      attr_reader :evaluate_erb
+
+      def initialize(path, evaluate_erb: Config.evaluate_erb_in_yaml)
+        @path = path.to_s
+        @evaluate_erb = !!evaluate_erb
+      end
+
+      # returns a config hash from the YML file
+      def load
+        if @path and File.exist?(@path)
+          file_contents = File.read(@path)
+          file_contents = ERB.new(file_contents).result if evaluate_erb
+          result = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(file_contents) : YAML.load(file_contents)
+        end
+
+        result || {}
+
+      rescue Psych::SyntaxError => e
+        raise "YAML syntax error occurred while parsing #{@path}. " \
+              "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
+              "Error: #{e.message}"
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/tasks/heroku.rake

@@ -0,0 +1,7 @@
+require 'config/integrations/heroku'
+
+namespace 'config' do
+  task :heroku, [:app] => :environment do |_, args|
+    Config::Integrations::Heroku.new(args[:app]).invoke
+  end
+end

data/config-5.6.1/lib/config/validation/error.rb

@@ -0,0 +1,15 @@
+require_relative "../error"
+
+module Config
+  module Validation
+    class Error < ::Config::Error
+
+      def self.format(v_res)
+        v_res.errors.group_by(&:path).map do |path, messages|
+          "#{' ' * 2}#{path.join('.')}: #{messages.map(&:text).join('; ')}"
+        end.join("\n")
+      end
+
+    end
+  end
+end

data/config-5.6.1/lib/config/validation/schema.rb

@@ -0,0 +1,23 @@
+require_relative '../dry_validation_requirements'
+require_relative '../error'
+
+module Config
+  module Validation
+    module Schema
+      # Assigns schema configuration option
+      def schema=(value)
+        @schema = value
+      end
+
+      def schema(&block)
+        if block_given?
+          # Delay require until optional schema validation is requested
+          Config::DryValidationRequirements.load_dry_validation!
+          @schema = Dry::Schema.define(&block)
+        else
+          @schema
+        end
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/validation/validate.rb

@@ -0,0 +1,29 @@
+require 'config/validation/error'
+
+module Config
+  module Validation
+    module Validate
+      def validate!
+        return unless Config.validation_contract || Config.schema
+
+        Config::DryValidationRequirements.load_dry_validation!
+
+        validate_using!(Config.validation_contract)
+        validate_using!(Config.schema)
+      end
+
+      private
+
+      def validate_using!(validator)
+        if validator
+          result = validator.call(to_hash)
+
+          return if result.success?
+
+          error = Config::Validation::Error.format(result)
+          raise Config::Validation::Error, "Config validation failed:\n\n#{error}"
+        end
+      end
+    end
+  end
+end

data/config-5.6.1/lib/config/version.rb

@@ -0,0 +1,3 @@
+module Config
+  VERSION = '5.6.1'.freeze
+end