anyway_config 0.4.0 → 0.5.1.rc1

data/config/cool.yml

@@ -0,0 +1,5 @@
+host: "test.host"
+user:
+  name: "root"
+  password: "root"
+port: <%= ENV['ANYWAY_COOL_PORT'] || 9292 %>

data/gemfiles/rails42.gemfile

@@ -1,7 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'sqlite3', platform: :mri
-gem 'activerecord-jdbcsqlite3-adapter', platform: :jruby
+gem 'sqlite3'
 gem 'rails', '~> 4.2.0'
 
 gemspec path: '..'

data/gemfiles/rails5.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'sqlite3'
+gem 'rails', '~> 5.0'
+
+gemspec path: '..'

data/gemfiles/railsmaster.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'arel', github: 'rails/arel'
+gem 'rails', github: 'rails/rails'
+
+gemspec path: '..'

data/lib/anyway.rb

@@ -1,9 +1,7 @@
-require 'active_support/core_ext/hash'
-require 'active_support/core_ext/string'
-require 'active_support/core_ext/object'
+# frozen_string_literal: true
 
-require "anyway/version"
-module Anyway
+module Anyway # :nodoc:
+  require "anyway/version"
   require "anyway/config"
   require "anyway/rails/config" if defined?(Rails)
   require "anyway/env"

data/lib/anyway/config.rb

@@ -1,36 +1,48 @@
-module Anyway
+# frozen_string_literal: true
+
+require 'anyway/ext/class'
+require 'anyway/ext/deep_dup'
+require 'anyway/ext/hash'
+
+module Anyway # :nodoc:
+  using Anyway::Ext::Class
+  using Anyway::Ext::DeepDup
+  using Anyway::Ext::Hash
+
+  # Base config class
+  # Provides `attr_config` method to describe
+  # configuration parameters and set defaults
   class Config
     class << self
       attr_reader :defaults, :config_attributes
 
-      def attr_config(*args,hargs)
-        @defaults = hargs.dup.with_indifferent_access
-        @config_attributes = args+hargs.keys
-        attr_accessor *@config_attributes
+      def attr_config(*args, **hargs)
+        @defaults = hargs.deep_dup
+        defaults.stringify_keys!
+        @config_attributes = args + defaults.keys
+        attr_accessor(*@config_attributes)
       end
 
       def config_name(val = nil)
         return (@config_name = val.to_s) unless val.nil?
-        @config_name ||= extract_name
+        @config_name = underscore_name unless defined?(@config_name)
+        @config_name
       end
 
       # 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_*"] 
+      #
+      #   my_config = Anyway::Config.for(:my_app)
+      #   # will load data from config/my_app.yml, secrets.my_app, ENV["MY_APP_*"]
       def for(name)
-        self.new(name,false).load_from_sources
+        new(name, false).load_from_sources
       end
-
-      private
-        def extract_name
-          name[/^(\w+)/].underscore
-        end
     end
 
-    def initialize(config_name=nil, do_load=true)
+    attr_reader :config_name
+
+    def initialize(config_name = nil, do_load = true)
       @config_name = config_name || self.class.config_name
       load if do_load
     end
@@ -39,7 +51,7 @@ module Anyway
       clear
       load
       self
-    end 
+    end
 
     def clear
       self.class.config_attributes.each do |attr|
@@ -49,37 +61,46 @@ module Anyway
     end
 
     def load
-      config = load_from_sources self.class.defaults.deep_dup
-      config.each do |key, val| 
+      config = load_from_sources((self.class.defaults || {}).deep_dup)
+      config.each do |key, val|
         set_value(key, val)
       end
     end
 
-    def load_from_sources(config={}.with_indifferent_access)        
+    def load_from_sources(config = {})
+      # Handle anonymous configs
+      return config unless config_name
       load_from_file(config)
       load_from_env(config)
     end
 
     def load_from_file(config)
-      config_path = (Anyway.env.send(@config_name)||{}).delete(:conf)
-      if config_path and File.file?(config_path)
-        require 'yaml'
-        config.deep_merge! (YAML.load_file(config_path) || {})
+      config_path = Anyway.env.fetch(config_name).delete('conf') ||
+                    "./config/#{config_name}.yml"
+      if config_path && File.file?(config_path)
+        config.deep_merge!(parse_yml(config_path) || {})
       end
       config
     end
-    
+
     def load_from_env(config)
-      config.deep_merge! (Anyway.env.send(@config_name) || {})
+      config.deep_merge!(Anyway.env.fetch(config_name))
       config
     end
 
     private
 
-    # safe way to assing config value
-    # checks that key exists in config
     def set_value(key, val)
-      send("#{key}=", val) if self.class.config_attributes.include?(key.to_sym)
-    end    
+      send("#{key}=", val) if respond_to?(key)
+    end
+
+    def parse_yml(path)
+      require 'yaml'
+      if defined?(ERB)
+        YAML.safe_load(ERB.new(File.read(path)).result)
+      else
+        YAML.load_file(path)
+      end
+    end
   end
-end
+end

data/lib/anyway/env.rb

@@ -1,87 +1,86 @@
+# frozen_string_literal: true
+
 module Anyway
+  # Parses environment variables and provides
+  # method-like access
   class Env
-
     # Regexp to detect array values
     # Array value is a values that contains at least one comma
-    # and doesn't start/end with quote 
-
+    # and doesn't start/end with quote
     ARRAY_RXP = /\A[^'"].*\s*,\s*.*[^'"]\z/
 
     def initialize
       @data = {}
-      load
-    end
-
-    def reload
-      clear
-      load
-      self
     end
 
     def clear
       @data.clear
-      self
     end
 
-    def method_missing(meth, *args, &block)
-      meth = meth.to_s.gsub(/\_/,'')
-      if args.empty? and @data.key?(meth)
-        @data[meth]
-      end
+    def fetch(config_name)
+      @data[config_name] ||= parse_env(config_name)
     end
 
     private
-      def load
-        ENV.each_pair do |key, val|
-          if config_key?(key)
-            mod, path = extract_module_path(key)
-            set_by_path(get_hash(@data, mod), path, serialize_val(val))
-          end
+
+    def parse_env(config_name)
+      config_env_name = config_name.to_s.delete("_")
+      config_env_name.upcase!
+      data = {}
+      ENV.each_pair do |key, val|
+        if key.start_with?(config_env_name)
+          _mod, path = extract_module_path(key)
+          set_by_path(data, path, serialize_val(val))
         end
       end
-    
-      def config_key?(key)
-        key =~ /^[A-Z\d]+\_[A-Z\d\_]+/
-      end
+      data
+    end
 
-      def extract_module_path(key)
-        _, mod, path = key.split(/^([^\_]+)/)
-        path.sub!(/^[\_]+/,'')
-        [mod.downcase, path.downcase]
-      end
+    def config_key?(key)
+      key =~ /^[A-Z\d]+\_[A-Z\d\_]+/
+    end
 
-      def set_by_path(to, path, val)
-        parts = path.split("__")
+    def extract_module_path(key)
+      _, mod, path = key.split(/^([^\_]+)/)
+      path.sub!(/^[\_]+/, '')
+      [mod.downcase, path.downcase]
+    end
 
-        while parts.length > 1
-          to = get_hash(to, parts.shift)
-        end
-        to[parts.first] = val        
-      end
+    def set_by_path(to, path, val)
+      parts = path.split("__")
 
-      def get_hash(from, name)
-        (from[name] ||= {}.with_indifferent_access)
-      end
+      to = get_hash(to, parts.shift) while parts.length > 1
 
-      def serialize_val(value)
-        case value
-        when ARRAY_RXP
-          value.split(/\s*,\s*/).map(&method(:serialize_val))
-        when /\A(true|t|yes|y)\z/i
-          true
-        when /\A(false|f|no|n)\z/i
-          false
-        when /\A(nil|null)\z/i
-          nil
-        when /\A\d+\z/
-          value.to_i
-        when /\A\d*\.\d+\z/
-          value.to_f
-        when /\A['"].*['"]\z/
-          value.gsub(/(\A['"]|['"]\z)/,'')
-        else
-          value
-        end
+      to[parts.first] = val
+    end
+
+    def get_hash(from, name)
+      (from[name] ||= {})
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def serialize_val(value)
+      case value
+      when ARRAY_RXP
+        value.split(/\s*,\s*/).map(&method(:serialize_val))
+      when /\A(true|t|yes|y)\z/i
+        true
+      when /\A(false|f|no|n)\z/i
+        false
+      when /\A(nil|null)\z/i
+        nil
+      when /\A\d+\z/
+        value.to_i
+      when /\A\d*\.\d+\z/
+        value.to_f
+      when /\A['"].*['"]\z/
+        value.gsub(/(\A['"]|['"]\z)/, '')
+      else
+        value
       end
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity
   end
-end
+end

data/lib/anyway/ext/class.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Ext
+    # Extend String through refinements
+    module Class
+      refine ::Class do
+        def underscore_name
+          return unless name
+          word = name[/^(\w+)/]
+          word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+          word.downcase!
+          word
+        end
+      end
+    end
+  end
+end

data/lib/anyway/ext/deep_dup.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Ext
+    # Extend Object through refinements
+    module DeepDup
+      refine ::Hash do
+        # Based on ActiveSupport http://api.rubyonrails.org/classes/Hash.html#method-i-deep_dup
+        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
+          end
+        end
+      end
+
+      refine ::Array do
+        # From ActiveSupport http://api.rubyonrails.org/classes/Array.html#method-i-deep_dup
+        def deep_dup
+          map do |value|
+            if value.is_a?(::Hash) || value.is_a?(::Array)
+              value.deep_dup
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anyway/ext/hash.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Ext
+    # Extend Hash through refinements
+    module Hash
+      refine ::Hash do
+        # From ActiveSupport http://api.rubyonrails.org/classes/Hash.html#method-i-deep_merge
+        def deep_merge!(other_hash)
+          other_hash.each_pair do |current_key, other_value|
+            this_value = self[current_key]
+
+            if this_value.is_a?(::Hash) && other_value.is_a?(::Hash)
+              this_value.deep_merge!(other_value)
+              this_value
+            else
+              self[current_key] = other_value
+            end
+          end
+
+          self
+        end
+
+        def stringify_keys!
+          keys.each do |key|
+            value = delete(key)
+            value.stringify_keys! if value.is_a?(::Hash)
+            self[key.to_s] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anyway/rails/config.rb

@@ -1,25 +1,34 @@
+# frozen_string_literal: true
+
 module Anyway
-  class Config
-    def load_from_sources(config={}.with_indifferent_access)        
+  class Config # :nodoc:
+    class << self
+      def defaults
+        return unless @defaults
+        @defaults_wia ||= @defaults.with_indifferent_access
+      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_file(config)
-      config_path = Rails.root.join("config","#{@config_name}.yml")
+      config_path = Rails.root.join("config", "#{@config_name}.yml")
       if File.file? config_path
-        require 'yaml'
-        config.deep_merge! (YAML.load_file(config_path)[Rails.env] || {})
+        config.deep_merge!(parse_yml(config_path)[Rails.env] || {})
       end
       config
     end
 
     def load_from_secrets(config)
       if Rails.application.respond_to?(:secrets)
-        config.deep_merge! (Rails.application.secrets.send(@config_name)||{})
+        config.deep_merge!(Rails.application.secrets.send(@config_name) || {})
       end
       config
     end
   end
-end
+end