anyway_config 1.4.4 → 2.0.0.pre

data/lib/anyway/dynamic_config.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Adds ability to generate anonymous (class-less) config dynamicly
+  # (like Rails.application.config_for but using more data sources).
+  module DynamicConfig
+    module ClassMethods
+      # Load config as Hash by any name
+      #
+      # Example:
+      #
+      #   my_config = Anyway::Config.for(:my_app)
+      #   # will load data from config/my_app.yml, secrets.my_app, ENV["MY_APP_*"]
+      #
+      def for(name, **options)
+        config = allocate
+        options[:env_prefix] ||= name.to_s.upcase
+        options[:config_path] ||= config.resolve_config_path(name, options[:env_prefix])
+        config.load_from_sources(name: name, **options)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/anyway/env.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'anyway/ext/deep_dup'
-require 'anyway/ext/string_serialize'
-
 module Anyway
   # Parses environment variables and provides
   # method-like access
@@ -19,7 +16,7 @@ module Anyway
     end
 
     def fetch(prefix)
-      @data[prefix] ||= parse_env(prefix.to_s.upcase)
+      @data[prefix] ||= parse_env(prefix)
       @data[prefix].deep_dup
     end
 
@@ -29,7 +26,7 @@ module Anyway
       ENV.each_pair.with_object({}) do |(key, val), data|
         next unless key.start_with?(prefix)
 
-        path = key.sub(/^#{prefix}_/, '').downcase
+        path = key.sub(/^#{prefix}_/, "").downcase
         set_by_path(data, path, val.serialize)
       end
     end

data/lib/anyway/ext/deep_dup.rb

@@ -9,10 +9,10 @@ module Anyway
         def deep_dup
           each_with_object(dup) do |(key, value), hash|
             hash[key] = if value.is_a?(::Hash) || value.is_a?(::Array)
-                          value.deep_dup
-                        else
-                          value
-                        end
+              value.deep_dup
+            else
+              value
+            end
           end
         end
       end

data/lib/anyway/ext/deep_freeze.rb

@@ -22,6 +22,11 @@ module Anyway
         end
       end
 
+      begin
+        require "active_support/core_ext/hash/indifferent_access"
+      rescue LoadError
+      end
+
       if defined?(::ActiveSupport::HashWithIndifferentAccess)
         refine ::ActiveSupport::HashWithIndifferentAccess do
           def deep_freeze

data/lib/anyway/ext/jruby.rb

@@ -13,10 +13,10 @@ module Anyway
         def deep_dup
           each_with_object(dup) do |(key, value), hash|
             hash[key] = if value.is_a?(::Hash) || value.is_a?(::Array)
-                          value.deep_dup
-                        else
-                          value
-                        end
+              value.deep_dup
+            else
+              value
+            end
           end
         end
 
@@ -74,6 +74,11 @@ module Anyway
         end
       end
 
+      begin
+        require "active_support/core_ext/hash/indifferent_access"
+      rescue LoadError
+      end
+
       if defined?(::ActiveSupport::HashWithIndifferentAccess)
         refine ::ActiveSupport::HashWithIndifferentAccess do
           def deep_freeze

data/lib/anyway/ext/string_serialize.rb

@@ -10,14 +10,10 @@ module Anyway
       ARRAY_RXP = /\A[^'"].*\s*,\s*.*[^'"]\z/
 
       refine ::String do
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Metrics/CyclomaticComplexity
         def serialize
           case self
           when ARRAY_RXP
-            # rubocop:disable Style/SymbolProc
             split(/\s*,\s*/).map { |word| word.serialize }
-            # rubocop:enable Style/SymbolProc
           when /\A(true|t|yes|y)\z/i
             true
           when /\A(false|f|no|n)\z/i
@@ -29,13 +25,11 @@ module Anyway
           when /\A\d*\.\d+\z/
             to_f
           when /\A['"].*['"]\z/
-            gsub(/(\A['"]|['"]\z)/, '')
+            gsub(/(\A['"]|['"]\z)/, "")
           else
             self
           end
         end
-        # rubocop:enable Metrics/MethodLength
-        # rubocop:enable Metrics/CyclomaticComplexity
       end
 
       using self

data/lib/anyway/option_parser_builder.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'optparse'
+require "optparse"
 
 module Anyway # :nodoc:
   # Initializes the OptionParser instance using the given configuration
@@ -19,7 +19,7 @@ module Anyway # :nodoc:
       private
 
       def option_parser_on_args(key, flag: false, desc: nil)
-        on_args = ["--#{key.to_s.tr('_', '-')}#{flag ? '' : ' VALUE'}"]
+        on_args = ["--#{key.to_s.tr("_", "-")}#{flag ? "" : " VALUE"}"]
         on_args << desc unless desc.nil?
         on_args
       end

data/lib/anyway/optparse_config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "anyway/option_parser_builder"
+
+require "anyway/ext/deep_dup"
+require "anyway/ext/string_serialize"
+
+module Anyway
+  using Anyway::Ext::DeepDup
+  using Anyway::Ext::StringSerialize
+
+  # Adds ability to use script options as the source
+  # of configuration (via optparse)
+  module OptparseConfig
+    module ClassMethods
+      def ignore_options(*args)
+        args.each do |name|
+          option_parser_descriptors[name.to_s][:ignore] = true
+        end
+      end
+
+      def describe_options(**hargs)
+        hargs.each do |name, desc|
+          option_parser_descriptors[name.to_s][:desc] = desc
+        end
+      end
+
+      def flag_options(*args)
+        args.each do |name|
+          option_parser_descriptors[name.to_s][:flag] = true
+        end
+      end
+
+      def extend_options(&block)
+        option_parser_extensions << block
+      end
+
+      def option_parser_options
+        config_attributes.each_with_object({}) do |key, result|
+          descriptor = option_parser_descriptors[key.to_s]
+          next if descriptor[:ignore] == true
+
+          result[key] = descriptor
+        end
+      end
+
+      def option_parser_extensions
+        return @option_parser_extensions if instance_variable_defined?(:@option_parser_extensions)
+
+        @option_parser_extensions =
+          if superclass < Anyway::Config
+            superclass.option_parser_extensions.dup
+          else
+            []
+          end
+      end
+
+      def option_parser_descriptors
+        return @option_parser_descriptors if instance_variable_defined?(:@option_parser_descriptors)
+
+        @option_parser_descriptors =
+          if superclass < Anyway::Config
+            superclass.option_parser_descriptors.deep_dup
+          else
+            Hash.new { |h, k| h[k] = {} }
+          end
+      end
+    end
+
+    def option_parser
+      @option_parser ||= begin
+        OptionParserBuilder.call(self.class.option_parser_options) do |key, arg|
+          set_value(key, arg.is_a?(String) ? arg.serialize : arg)
+        end.tap do |parser|
+          self.class.option_parser_extensions.map do |extension|
+            extension.call(parser, self)
+          end
+        end
+      end
+    end
+
+    def parse_options!(options)
+      option_parser.parse!(options)
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/anyway/rails/config.rb

@@ -1,38 +1,90 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/hash/indifferent_access"
+
 module Anyway
-  class Config # :nodoc:
-    class << self
-      def defaults
-        return unless @defaults
+  module Rails
+    # Enhance config to be more Railsy-like:
+    # – accept hashes with indeferent access
+    # - load data from secrets
+    # - recognize Rails env when loading from YML
+    module Config
+      module ClassMethods
+        # Make defaults to be a Hash with indifferent access
+        def defaults
+          return @defaults if instance_variable_defined?(:@defaults)
 
-        @defaults_wia ||= @defaults.with_indifferent_access
+          @defaults = super.with_indifferent_access
+        end
       end
-    end
 
-    def load_from_sources(config = {})
-      config = config.with_indifferent_access
-      load_from_file(config)
-      load_from_secrets(config)
-      load_from_env(config)
-    end
+      def load_from_sources(**options)
+        base_config = {}.with_indifferent_access
+        each_source(options) do |config|
+          base_config.deep_merge!(config) if config
+        end
+        base_config
+      end
 
-    def load_from_file(config)
-      config.deep_merge!(parse_yml(config_path)[Rails.env] || {}) if File.file? config_path
-      config
-    end
+      def each_source(options)
+        yield load_from_file(options)
+        yield load_from_secrets(options)
+        yield load_from_credentials(options)
+        yield load_from_env(options)
+      end
 
-    def load_from_secrets(config)
-      if Rails.application.respond_to?(:secrets)
-        config.deep_merge!(Rails.application.secrets.send(@config_name) || {})
+      def load_from_file(name:, config_path:, env_prefix:, **_options)
+        file_config = load_from_yml(config_path)[::Rails.env] || {}
+
+        if Anyway::Settings.use_local_files
+          local_config_path = config_path.sub(/\.yml/, ".local.yml")
+          file_config.deep_merge!(load_from_yml(local_config_path) || {})
+        end
+
+        file_config
+      end
+
+      def load_from_secrets(name:, **_options)
+        return unless ::Rails.application.respond_to?(:secrets)
+
+        ::Rails.application.secrets.public_send(name)
       end
-      config
-    end
 
-    private
+      def load_from_credentials(name:, **_options)
+        # do not load from credentials if we're in the context
+        # of the `credentials:edit` command
+        return if defined?(::Rails::Command::CredentialsCommand)
 
-    def default_config_path
-      Rails.root.join("config", "#{config_name}.yml")
+        return unless ::Rails.application.respond_to?(:credentials)
+
+        # Create a new hash cause credentials are mutable!
+        creds_config = {}
+
+        creds_config.deep_merge!(::Rails.application.credentials.public_send(name) || {})
+
+        creds_config.deep_merge!(load_from_local_credentials(name: name)) if Anyway::Settings.use_local_files
+        creds_config
+      end
+
+      def load_from_local_credentials(name:)
+        local_creds_path = ::Rails.root.join("config/credentials/local.yml.enc").to_s
+
+        return unless File.file?(local_creds_path)
+
+        creds = ::Rails.application.encrypted(
+          local_creds_path,
+          key_path: ::Rails.root.join("config/credentials/local.key")
+        )
+
+        creds.public_send(name) || {}
+      end
+
+      def default_config_path(name)
+        ::Rails.root.join("config", "#{name}.yml")
+      end
     end
   end
 end
+
+Anyway::Config.prepend Anyway::Rails::Config
+Anyway::Config.singleton_class.prepend Anyway::Rails::Config::ClassMethods

data/lib/anyway/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Anyway # :nodoc:
+  class Railtie < ::Rails::Railtie # :nodoc:
+    # Add settings to Rails config
+    config.anyway_config = Anyway::Settings
+
+    # Allow autoloading of app/configs in configuration files
+    ActiveSupport::Dependencies.autoload_paths << "app/configs"
+  end
+end

data/lib/anyway/testing.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "anyway/testing/helpers"
+
+if defined?(RSpec)
+  RSpec.configure do |config|
+    config.include(
+      Anyway::Testing::Helpers,
+      type: :config,
+      file_path: %r{spec/configs}
+    )
+  end
+end

data/lib/anyway/testing/helpers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Testing
+    module Helpers
+      # Sets the ENV variables to the provided
+      # values and restore outside the block
+      #
+      # Also resets Anyway.env before and after calling the block
+      # to make sure that the values are not cached.
+      #
+      # NOTE: to remove the env value, pass `nil` as the value
+      def with_env(data)
+        was_values = []
+
+        data.each do |key, val|
+          was_values << [key, ENV[key]]
+          next ENV.delete(key) if val.nil?
+          ENV[key] = val
+        end
+
+        # clear cached env values
+        Anyway.env.clear
+        yield
+      ensure
+        was_values.each do |(key, val)|
+          next ENV.delete(key) if val.nil?
+          ENV[key] = val
+        end
+
+        # clear cache again
+        Anyway.env.clear
+      end
+    end
+  end
+end

data/lib/anyway/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Anyway # :nodoc:
-  VERSION = "1.4.4"
+  VERSION = "2.0.0.pre"
 end