drtom_rails_config 0.5.0.beta1

data/gemfiles/rails_3.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "3.2.18"
+
+gemspec :path => "../"

data/gemfiles/rails_4.1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.1.0"
+
+gemspec :path => "../"

data/gemfiles/rails_4.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.0.0"
+
+gemspec :path => "../"

data/lib/generators/rails_config/install_generator.rb

@@ -0,0 +1,32 @@
+module RailsConfig
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc "Generates a custom Rails Config initializer file."
+
+      def self.source_root
+        @_rails_config_source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def copy_initializer
+        template "rails_config.rb", "config/initializers/rails_config.rb"
+      end
+
+      def copy_settings
+        template "settings.yml", "config/settings.yml"
+        template "settings.local.yml", "config/settings.local.yml"
+        directory "settings", "config/settings"
+      end
+
+      def modify_gitignore
+        create_file '.gitignore' unless File.exists? '.gitignore'
+
+        append_to_file '.gitignore' do
+          "\n"                                +
+          "config/settings.local.yml\n"       +
+          "config/settings/*.local.yml\n"     +
+          "config/environments/*.local.yml\n"
+        end
+      end
+    end
+  end
+end

data/lib/generators/rails_config/templates/rails_config.rb

@@ -0,0 +1,3 @@
+RailsConfig.setup do |config|
+  config.const_name = "Settings"
+end

data/lib/rails_config.rb

@@ -0,0 +1,64 @@
+require 'active_support/core_ext/module/attribute_accessors'
+
+require 'rails_config/options'
+require 'rails_config/version'
+require 'rails_config/engine' if defined?(::Rails)
+require 'rails_config/sources/yaml_source'
+require 'rails_config/deep_merge' unless defined?(DeepMerge)
+
+module RailsConfig
+  # ensures the setup only gets run once
+  @@_ran_once = false
+
+  mattr_accessor :const_name, :use_env
+  @@const_name = "Settings"
+  @@use_env = false
+
+  def self.setup
+    yield self if @@_ran_once == false
+    @@_ran_once = true
+  end
+
+  # Create a populated Options instance from a yaml file.  If a second yaml file is given, then the sections of that file will overwrite the sections
+  # if the first file if they exist in the first file.
+  def self.load_files(*files)
+    config = Options.new
+
+    # add yaml 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, RailsConfig.const_name) if Kernel.const_defined?(RailsConfig.const_name)
+    Kernel.const_set(RailsConfig.const_name, RailsConfig.load_files(files))
+  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(RailsConfig.const_name).reload!
+  end
+end
+
+# add rails integration
+require('rails_config/integration/rails') if defined?(::Rails)
+
+# add sinatra integration
+require('rails_config/integration/sinatra') if defined?(::Sinatra)

data/lib/rails_config/deep_merge.rb

@@ -0,0 +1,32 @@
+#  Copyright (C)  2014, 2015 Dr. Thomas Schank  (DrTom@schank.ch, Thomas.Schank@algocon.ch)
+#
+require 'set'
+module DeepMerge
+  class << self 
+    def deep_merge(obj1, obj2)
+      if obj1.is_a?(Hash) && obj2.is_a?(Hash)
+        deep_merge_hashes obj1, obj2
+      else
+        obj2
+      end
+    end
+
+    private 
+
+    def keys(h1, h2)
+      Set.new(h1.keys) + Set.new(h2.keys)
+    end
+
+    def deep_merge_hashes(h1, h2)
+      Hash[(keys(h1, h2)).map do |k|
+        [k, if h1.key?(k) && h2.key?(k) 
+         deep_merge(h1[k], h2[k])
+        elsif h2.key?(k)
+          h2[k]
+        else
+          h1[k]
+        end]
+      end]
+    end
+  end
+end

data/lib/rails_config/engine.rb

@@ -0,0 +1,5 @@
+module RailsConfig
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsConfig
+  end
+end

data/lib/rails_config/integration/rails.rb

@@ -0,0 +1,34 @@
+module RailsConfig
+  module Integration
+    module Rails
+      if defined?(::Rails::Railtie)
+        class Railtie < ::Rails::Railtie
+          # Load rake tasks (eg. Heroku)
+          rake_tasks do
+            Dir[File.join(File.dirname(__FILE__),'../tasks/*.rake')].each { |f| load f }
+          end
+
+          ActiveSupport.on_load :before_configuration, :yield => true do
+            # Manually load the custom initializer before everything else
+            initializer = ::Rails.root.join("config", "initializers", "rails_config.rb")
+            require initializer if File.exist?(initializer)
+
+            # Parse the settings before any of the initializers
+            RailsConfig.load_and_set_settings(
+              RailsConfig.setting_files(::Rails.root.join("config"), ::Rails.env)
+            )
+          end
+
+          # Rails Dev environment should reload the Settings on every request
+          if ::Rails.env.development?
+            initializer :rails_config_reload_on_development do
+              ActionController::Base.class_eval do
+                prepend_before_filter { ::RailsConfig.reload! }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_config/integration/sinatra.rb

@@ -0,0 +1,26 @@
+require "rails_config/rack/reloader"
+
+module RailsConfig
+  # provide helper to register within your Sinatra app
+  #
+  # set :root, File.dirname(__FILE__)
+  # register RailsConfig
+  #
+  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
+
+      RailsConfig.load_and_set_settings(RailsConfig.setting_files(File.join(root, 'config'), env))
+
+      inner_app.use(::RailsConfig::Rack::Reloader) if inner_app.development?
+    end
+  end
+end

data/lib/rails_config/options.rb

@@ -0,0 +1,118 @@
+require 'ostruct'
+module RailsConfig
+
+  class Options < OpenStruct
+    include Enumerable
+
+    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)
+
+      @config_sources ||= []
+      @config_sources << source
+    end
+
+    def reload_env!
+      return self if ENV.nil? || ENV.empty?
+      conf = Hash.new
+      ENV.each do |key, value|
+        next unless key.to_s.index(RailsConfig.const_name) == 0
+        hash = value
+        key.to_s.split('.').reverse.each do |element|
+          hash = {element => hash}
+        end
+        conf= DeepMerge.deep_merge(conf,hash)
+      end
+
+      merge!(conf[RailsConfig.const_name] || {})
+    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
+          conf= DeepMerge.deep_merge(conf, source_conf)
+        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 RailsConfig.use_env
+
+      return self
+    end
+
+    alias :load! :reload!
+
+    def reload_from_files(*files)
+      RailsConfig.load_and_set_settings(files)
+      reload!
+    end
+
+    def to_hash
+      result = {}
+      marshal_dump.each do |k, v|
+        result[k] = v.instance_of?(RailsConfig::Options) ? v.to_hash : v
+      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
+      current = DeepMerge.deep_merge(current,hash)
+      marshal_load(__convert(current).marshal_dump)
+      self
+    end
+
+    # An alternative mechanism for property access.
+    # This let's you do foo['bar'] along with foo.bar.
+    def [](param)
+      send("#{param}")
+    end
+
+    def []=(param, value)
+      send("#{param}=", value)
+    end
+
+    protected
+
+    # 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
+  end
+end

data/lib/rails_config/rack/reloader.rb

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

data/lib/rails_config/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails'
+
+module RailsConfig
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__),'tasks/*.rake')].each { |f| load f }
+    end
+  end
+end

data/lib/rails_config/sources/yaml_source.rb

@@ -0,0 +1,26 @@
+require 'yaml'
+require 'erb'
+
+module RailsConfig
+  module Sources
+    class YAMLSource
+      attr_accessor :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      # returns a config hash from the YML file
+      def load
+        if @path and File.exist?(@path.to_s)
+          result = YAML.load(ERB.new(IO.read(@path.to_s)).result)
+        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/lib/rails_config/tasks.rb

@@ -0,0 +1,59 @@
+require "bundler"
+
+module RailsConfig
+  module Tasks
+    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
+        RailsConfig.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(RailsConfig.const_name).to_hash, {}, RailsConfig.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