ef-config 1.4.1

data/config.gemspec

@@ -0,0 +1,51 @@
+$:.push File.expand_path('../lib', __FILE__)
+
+# Maintain your gem's version:
+require 'config/version'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name             = 'ef-config'
+  s.version          = Config::VERSION
+  s.date             = Time.now.strftime '%F'
+  s.authors          = ['Hadley', 'Piotr Kuczynski', 'Fred Wu', 'Jacques Crocker']
+  s.email            = %w(hadley@everfest.com)
+  s.summary          = 'Effortless multi-environment settings in Rails, Sinatra, Pandrino and others'
+  s.description      = 'Everfest fork of config gem'
+  s.homepage         = 'https://bitbucket.org/everfest/config'
+  s.license          = 'MIT'
+  s.extra_rdoc_files = %w(README.md CHANGELOG.md LICENSE.md)
+  s.rdoc_options     = ['--charset=UTF-8']
+
+  s.files = `git ls-files`.split($/)
+  s.files.select! { |file| /(^lib\/|\.md$|\.gemspec$)/ =~ file }
+  s.files += Dir.glob('doc/**/*')
+
+  s.require_paths         = ['lib']
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_dependency 'activesupport',           '>= 3.0'
+  s.add_dependency 'deep_merge',              '~> 1.1.1'
+  s.add_dependency 'dry-validation',          '~> 0.10.4' if RUBY_VERSION >= '2.1'
+
+  s.add_development_dependency 'bundler',     '~> 1.13',  '>= 1.13.6'
+  s.add_development_dependency 'rake',        '~> 12.0',  '>= 12.0.0'
+
+  # Testing
+  s.add_development_dependency 'appraisal',   '~> 2.1',   '>= 2.1.0'
+  s.add_development_dependency 'rails',       '~> 5.0',   '>= 5.0.1'
+  s.add_development_dependency 'rspec',       '~> 3.5',   '>= 3.5.0'
+  s.add_development_dependency 'rspec-rails', '~> 3.5',   '>= 3.5.2'
+  s.add_development_dependency 'test-unit',   '~> 3.2',   '>= 3.2.1'
+  s.add_development_dependency 'sqlite3',     '~> 1.3',   '>= 1.3.11'
+  s.add_development_dependency 'pry'
+
+  # Static code analysis
+  s.add_development_dependency 'mdl',         '~> 0.4',   '>= 0.4.0'
+  s.add_development_dependency 'rubocop',     '~> 0.46',  '>= 0.46.0'
+
+  if ENV['TRAVIS']
+    s.add_development_dependency 'simplecov', '~> 0.12.0'
+    s.add_development_dependency 'codeclimate-test-reporter', '~> 1.0.3'
+  end
+end

data/lib/config.rb

@@ -0,0 +1,107 @@
+require 'active_support/core_ext/module/attribute_accessors'
+
+require 'config/compatibility'
+require 'config/options'
+require 'config/version'
+require 'config/integrations/rails/engine' if defined?(::Rails)
+require 'config/sources/yaml_source'
+require 'config/sources/hash_source'
+require 'config/validation/schema' if RUBY_VERSION >= '2.1'
+require 'deep_merge'
+
+module Config
+  extend Config::Validation::Schema if RUBY_VERSION >= '2.1'
+
+  # Ensures the setup only gets run once
+  @@_ran_once = false
+
+  mattr_accessor :const_name, :use_env, :env_prefix, :env_separator, :env_converter, :env_parse_values
+  @@const_name = 'Settings'
+  @@use_env    = false
+  @@env_prefix = @@const_name
+  @@env_separator = '.'
+  @@env_converter = :downcase
+  @@env_parse_values = true
+
+  # deep_merge options
+  mattr_accessor :knockout_prefix, :overwrite_arrays
+  @@knockout_prefix = nil
+  @@overwrite_arrays = true
+
+  def self.setup
+    yield self if @@_ran_once == false
+    @@_ran_once = true
+  end
+
+  # Create a populated Options instance from a settings file. If a second file is given, then the sections of that
+  # file will overwrite existing sections of the first file.
+  def self.load_files(*files)
+    config = Options.new
+
+    # add settings sources
+    [files].flatten.compact.uniq.each do |file|
+      config.add_source!(file.to_s)
+    end
+
+    config.load!
+    config.load_env! if @@use_env
+    config
+  end
+
+  # Loads and sets the settings constant!
+  def self.load_and_set_settings(*files)
+    Kernel.send(:remove_const, Config.const_name) if Kernel.const_defined?(Config.const_name)
+    Kernel.const_set(Config.const_name, Config.load_files(files))
+  end
+
+  def self.load_and_set_nested_settings(base_path, default_file_name)
+    Kernel.send(:remove_const, Config.const_name) if Kernel.const_defined?(Config.const_name)
+
+    config = Options.new
+    config.add_source!(File.join(base_path, default_file_name).to_s)
+    #config.add_source!(File.join(base_path, priority_file_name).to_s)
+
+    folder_names = Dir.glob("#{base_path}/**/**").select {|f| File.directory? f}
+
+    folder_names.each do |folder_name|
+      namespace_path = folder_name.to_s.sub("#{base_path.to_s}/", "")
+      namespaces = namespace_path.split("/")
+
+      namespaces.each_with_index do |namespace, i|
+        path = namespaces.first(i + 1).join("/")
+        namespaced_default_file = File.join(base_path, path, default_file_name).to_s
+        #priority_default_file = File.join(base_path, path, priority_file_name).to_s
+
+        config.add_source!(namespaced_default_file.to_s, path)
+        #config.add_source!(priority_default_file.to_s, path)
+      end
+    end
+
+    config.load!
+    config.load_env! if @@use_env
+
+    Kernel.const_set(Config.const_name, config)
+  end
+
+  def self.setting_files(config_root, env)
+    [
+      File.join(config_root, "settings.yml").to_s,
+      File.join(config_root, "settings", "#{env}.yml").to_s,
+      File.join(config_root, "environments", "#{env}.yml").to_s,
+
+      File.join(config_root, "settings.local.yml").to_s,
+      File.join(config_root, "settings", "#{env}.local.yml").to_s,
+      File.join(config_root, "environments", "#{env}.local.yml").to_s
+    ].freeze
+  end
+
+  def self.reload!
+    Kernel.const_get(Config.const_name).reload!
+  end
+end
+
+# Rails integration
+require('config/integrations/rails/railtie') if defined?(::Rails)
+
+# Sinatra integration
+require('config/integrations/sinatra') if defined?(::Sinatra)

data/lib/config/compatibility.rb

@@ -0,0 +1,3 @@
+if defined?(RbConfig) && defined?(Config)
+  Object.send :remove_const, :Config
+end

data/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", "settings.local.yml").to_s,
+            Rails.root.join("config", "settings", "#{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/lib/config/integrations/rails/engine.rb

@@ -0,0 +1,9 @@
+module Config
+  module Integrations
+    module Rails
+      class Engine < ::Rails::Engine
+        isolate_namespace Config
+      end
+    end
+  end
+end

data/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'), ::Rails.env)
+          )
+        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
+            ActionController::Base.class_eval 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/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
+        root = Padrino.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/lib/config/options.rb

@@ -0,0 +1,191 @@
+require 'ostruct'
+require 'config/validation/validate' if RUBY_VERSION >= '2.1'
+
+module Config
+  class Options < OpenStruct
+    include Enumerable
+    include Validation::Validate if RUBY_VERSION >= '2.1'
+
+    def keys
+      marshal_dump.keys
+    end
+
+    def empty?
+      marshal_dump.empty?
+    end
+
+    def add_source!(source, namespace=nil)
+      # handle yaml file paths
+      source = (Sources::YAMLSource.new(source, namespace)) if source.is_a?(String)
+      source = (Sources::HashSource.new(source, namespace)) 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 = (Sources::HashSource.new(source)) if source.is_a?(Hash)
+
+      @config_sources ||= []
+      @config_sources.unshift(source)
+    end
+
+    def reload_env!
+      return self if ENV.nil? || ENV.empty?
+
+      hash = Hash.new
+
+      ENV.each do |variable, value|
+        keys = variable.to_s.split(Config.env_separator)
+
+        next if keys.shift != (Config.env_prefix || Config.const_name)
+
+        keys.map! { |key|
+          case Config.env_converter
+            when :downcase then
+              key.downcase.to_sym
+            when nil then
+              key.to_sym
+            else
+              raise "Invalid ENV variables name converter: #{Config.env_converter}"
+          end
+        }
+
+        leaf = keys[0...-1].inject(hash) { |h, key|
+          h[key] ||= {}
+        }
+
+        leaf[keys.last] = Config.env_parse_values ? __value(value) : value
+      end
+
+      merge!(hash)
+    end
+
+    alias :load_env! :reload_env!
+
+    # 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)
+        end
+      end
+
+      # swap out the contents of the OStruct with a hash (need to recursively convert)
+      marshal_load(__convert(conf).marshal_dump)
+
+      reload_env! if Config.use_env
+      validate! if RUBY_VERSION >= '2.1'
+
+      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
+
+    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 merge!(hash)
+      current = to_hash
+      DeepMerge.deep_merge!(hash.dup,
+                            current,
+                            preserve_unmergeables: false,
+                            overwrite_arrays:      Config.overwrite_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}
+
+    # 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)
+      send("#{param}")
+    end
+
+    def []=(param, value)
+      send("#{param}=", value)
+    end
+
+    SETTINGS_RESERVED_NAMES.each do |name|
+      define_method name do
+        self[name]
+      end
+    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)
+        s.new_ostruct_member(k)
+
+        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.send("#{k}=".to_sym, v)
+      end
+      s
+    end
+
+    # Try to convert string to a correct type
+    def __value(v)
+      Integer(v) rescue Float(v) rescue v
+    end
+  end
+end