rails_config_i18n 0.3.1.1

data/.bundle/config

@@ -0,0 +1,2 @@
+--- {}
+

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+pkg/*.gem
+.rvmrc
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'i18n'
+  gem 'json',         :platforms => :mri_18
+  gem "ruby-debug",   :platforms => :mri_18
+  gem "ruby-debug19", :platforms => :mri_19
+end

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2010 Jacques Crocker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Deep Merge (deep_merge.rb) code Copyright (c) 2008 Steve Midgley, released under the MIT license

data/README.md

@@ -0,0 +1,243 @@
+# RailsConfig
+
+## Summary
+
+RailsConfig I18n helps you manage environment and locale specific Rails settings in an easy and usable manner
+
+<del>RailsConfig helps you easily manage environment specific Rails settings in an easy and usable manner</del>
+
+## Features
+
+* simple YAML config files
+* Support locales with I18n
+* config files support ERB
+* config files support inheritance
+* access config information via convenient object member notation
+
+## Compatibility
+
+* Rails 3.x
+* Padrino
+* Sinatra
+
+For older versions of Rails and other Ruby apps, use [AppConfig](http://github.com/fredwu/app_config).
+
+## Installing on Rails 3
+
+Add this to your `Gemfile`:
+
+```ruby
+gem "rails_config"
+```
+
+## Installing on Padrino
+
+Add this to your `Gemfile`:
+
+```ruby
+gem "rails_config"
+```
+
+in your app.rb, you'll also need to register RailsConfig
+
+```ruby
+register RailsConfig
+```
+
+## Installing on Sinatra
+
+Add this to your `Gemfile`:
+
+```ruby
+gem "rails_config"
+```
+
+in your app, you'll need to register RailsConfig. You'll also need to give it a root so it can find the config files.
+
+```ruby
+set :root, File.dirname(__FILE__)
+register RailsConfig
+```
+
+It's also possible to initialize it manually within your configure block if you want to just give it some yml paths to load from.
+
+```ruby
+RailsConfig.load_and_set_settings("/path/to/yaml1", "/path/to/yaml2", ...)
+```
+
+## Customizing RailsConfig
+
+You may customize the behavior of RailsConfig by generating an initializer file:
+
+    rails g rails_config:install
+
+This will generate `config/initializers/rails_config.rb` with a set of default settings as well as to generate a set of default settings files:
+
+    config/settings.yml
+    config/settings/development.yml
+    config/settings/production.yml
+    config/settings/test.yml
+
+## Accessing the Settings object
+
+After installing this plugin, the `Settings` object will be available globally. Entries are accessed via object member notation:
+
+```ruby
+Settings.my_config_entry
+```
+
+Nested entries are supported:
+
+```ruby
+Settings.my_section.some_entry
+```
+
+Alternatively, you can also use the `[]` operator if you don't know which exact setting you need to access ahead of time.
+
+```ruby
+# All the following are equivalent to Settings.my_section.some_entry
+Settings.my_section[:some_entry]
+Settings.my_section['some_entry]
+Settings[:my_section][:some_entry]
+```
+
+If you have set a different constant name for the object in the initializer file, use that instead.
+
+## Common config file
+
+Config entries are compiled from:
+
+    config/settings.yml
+    config/settings/#{environment}.yml
+    config/settings/#{locale}.yml
+    config/environments/#{environment}.yml
+
+    config/settings.local.yml
+    config/settings/#{environment}.local.yml
+    config/environments/#{environment}.local.yml
+
+Settings defined in files that are lower in the list override settings higher.
+
+### Reloading settings
+
+You can reload the Settings object at any time by running `Settings.reload!`.
+
+### Reloading settings and config files
+
+You can also reload the `Settings` object from different config files at runtime.
+
+For example, in your tests if you want to test the production settings, you can:
+
+```ruby
+Rails.env = "production"
+Settings.reload_from_files(
+  Rails.root.join("config", "settings.yml").to_s,
+  Rails.root.join("config", "settings", "#{Rails.env}.yml").to_s,
+  Rails.root.join("config", "environments", "#{Rails.env}.yml").to_s
+)
+```
+
+### Environment specific config files
+
+You can have environment specific config files. Environment specific config entries take precedence over common config entries.
+
+Example development environment config file:
+
+```ruby
+#{Rails.root}/config/environments/development.yml
+```
+
+Example production environment config file:
+
+```ruby
+#{Rails.root}/config/environments/production.yml
+```
+
+### Developer specific config files
+
+If you want to have local settings, specific to your machine or development environment,
+you can use the following files, which are automatically `.gitignored` :
+
+    Rails.root.join("config", "settings.local.yml").to_s,
+    Rails.root.join("config", "settings", "#{Rails.env}.local.yml").to_s,
+    Rails.root.join("config", "environments", "#{Rails.env}.local.yml").to_s
+
+
+### Adding sources at Runtime
+
+You can add new YAML config files at runtime. Just use:
+
+```ruby
+Settings.add_source!("/path/to/source.yml")
+Settings.reload!
+```
+
+This will use the given source.yml file and use its settings to overwrite any previous ones.
+
+One thing I like to do for my Rails projects is provide a local.yml config file that is .gitignored (so its independent per developer). Then I create a new initializer in `config/initializers/add_local_config.rb` with the contents
+
+```ruby
+Settings.add_source!("#{Rails.root}/config/settings/local.yml")
+Settings.reload!
+```
+
+> Note: this is an example usage, it is easier to just use the default local files `settings.local.yml, settings/#{Rails.env}.local.yml and environments/#{Rails.env}.local.yml`
+>       for your developer specific settings.
+
+## Embedded Ruby (ERB)
+
+Embedded Ruby is allowed in the configuration files. See examples below.
+
+## Accessing Configuration Settings
+
+Consider the two following config files.
+
+ #{Rails.root}/config/settings.yml:
+
+```yaml
+size: 1
+server: google.com
+```
+
+ #{Rails.root}/config/environments/development.yml:
+
+```yaml
+size: 2
+computed: <%= 1 + 2 + 3 %>
+section:
+  size: 3
+  servers: [ {name: yahoo.com}, {name: amazon.com} ]
+```
+
+Notice that the environment specific config entries overwrite the common entries.
+
+```ruby
+Settings.size   # => 2
+Settings.server # => google.com
+```
+
+Notice the embedded Ruby.
+
+```ruby
+Settings.computed # => 6
+```
+
+Notice that object member notation is maintained even in nested entries.
+
+```ruby
+Settings.section.size # => 3
+```
+
+Notice array notation and object member notation is maintained.
+
+```ruby
+Settings.section.servers[0].name # => yahoo.com
+Settings.section.servers[1].name # => amazon.com
+```
+
+## Authors
+
+* [Jacques Crocker](http://github.com/railsjedi)
+* [Fred Wu](http://github.com/fredwu)
+* [Cedric Fung](https://bitbucket.org/ABitNo)
+* Inherited from [AppConfig](http://github.com/cjbottaro/app_config) by [Christopher J. Bottaro](http://github.com/cjbottaro)

data/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require "bundler"
+  Bundler::GemHelper.install_tasks
+rescue Exception => e
+end
+
+require "rake"
+require "rspec"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new('spec:progress') do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+require "rdoc/task"
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "Rails Config #{RailsConfig::VERSION}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+task :default => :spec

data/autotest/discover.rb

@@ -0,0 +1,2 @@
+Autotest.add_discovery { "rspec2" }
+

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/lib/rails_config_i18n'

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
+        if 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
+end

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

@@ -0,0 +1,4 @@
+RailsConfig.setup do |config|
+  I18n.default_locale = :en
+  config.const_name = "Settings"
+end

data/lib/generators/rails_config/templates/settings/development.yml

@@ -0,0 +1 @@
+en:

data/lib/generators/rails_config/templates/settings/production.yml

@@ -0,0 +1 @@
+en:

data/lib/generators/rails_config/templates/settings/test.yml

@@ -0,0 +1 @@
+en:

data/lib/generators/rails_config/templates/settings.local.yml

@@ -0,0 +1 @@
+en:

data/lib/generators/rails_config/templates/settings.yml

@@ -0,0 +1 @@
+en:

data/lib/rails_config/integration/rails.rb

@@ -0,0 +1,38 @@
+module RailsConfig
+  module Integration
+    module Rails3
+      if defined?(Rails::Railtie)
+        class Railtie < Rails::Railtie
+
+          # manually load the custom initializer before everything else
+          initializer :load_custom_rails_config, :before => :load_environment_config do
+            initializer = Rails.root.join("config", "initializers", "rails_config.rb")
+            require initializer if File.exist?(initializer)
+          end
+
+          # Parse the settings before any of the initializers
+          initializer :load_rails_config_settings, :after => :load_custom_rails_config, :before => :load_environment_config do
+            RailsConfig.load_and_set_settings(
+              Rails.root.join("config", "settings.yml").to_s,
+              *Dir[Rails.root.join("config", "settings", "**", "*.yml")],
+              Rails.root.join("config", "environments", "#{Rails.env}.yml").to_s,
+
+              Rails.root.join("config", "settings.local.yml").to_s,
+              Rails.root.join("config", "settings", "#{Rails.env}.local.yml").to_s,
+              Rails.root.join("config", "environments", "#{Rails.env}.local.yml").to_s
+            )
+          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,31 @@
+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(
+        File.join(root.to_s, "config", "settings.yml").to_s,
+        File.join(root.to_s, "config", "settings", "#{env}.yml").to_s,
+        File.join(root.to_s, "config", "environments", "#{env}.yml").to_s
+      )
+
+      inner_app.use(::RailsConfig::Rack::Reloader) if inner_app.development?
+    end
+  end
+
+end

data/lib/rails_config/options.rb

@@ -0,0 +1,100 @@
+require 'ostruct'
+module RailsConfig
+  class Options < OpenStruct
+
+    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
+
+    # 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)
+        end
+      end
+
+      conf.each_pair { |locale, values|
+        unless locale == I18n.default_locale.to_s
+          conf[locale.to_s].merge!(conf[I18n.default_locale.to_s].merge(conf[locale.to_s])) if conf[I18n.default_locale.to_s].is_a?(Hash) && conf[locale.to_s].is_a?(Hash)
+        end
+      }
+
+      # swap out the contents of the OStruct with a hash (need to recursively convert)
+      marshal_load(__convert(conf).marshal_dump)
+
+      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 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)
+      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/rails_config.rb

@@ -0,0 +1,55 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'rails_config/options'
+
+require "rails_config/sources/yaml_source"
+
+require 'rails_config/vendor/deep_merge' unless defined?(DeepMerge)
+
+module RailsConfig
+  # ensures the setup only gets run once
+  @@_ran_once = false
+
+  @@options = nil
+
+  mattr_accessor :const_name
+  @@const_name = "Settings"
+
+  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)
+    @@options = Options.new
+
+    # add yaml sources
+    [files].flatten.compact.uniq.each do |file|
+      @@options.add_source!(file.to_s)
+    end
+
+    @@options.load!
+  end
+
+  # Loads and sets the settings constant!
+  def self.load_and_set_settings(*files)
+    Kernel.send(:remove_const, @@const_name) if Kernel.const_defined?(@@const_name)
+    load_files(files)
+    Kernel.const_set(@@const_name, self)
+  end
+
+  def self.reload!
+    @@options.reload!
+  end
+
+  def self.method_missing(method, *args, &block)
+    (@@options[I18n.locale] || @@options[I18n.default_locale] || {}).send(method, *args)
+  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/sources/yaml_source.rb

@@ -0,0 +1,24 @@
+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.exists?(@path.to_s)
+          result = YAML.load(ERB.new(IO.read(@path.to_s)).result)
+        end
+        result || {}
+      end
+
+    end
+  end
+end