simpleconfig 1.2.0 → 2.0.0

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Changelog
 
-## master
+## 2.0.0
+
+- Remove deprecated SimpleConfig::Utilities.
+- Remove deprecated SimpleConfig::ControllerMixin.
+- Remove pre-Rails 3 init.rb file.
+- Add Rails 3 support using Railtie.
+
+## 1.2.0
 
 - Updated Rakefile.
 - Added support for Bundler.
@@ -9,7 +16,7 @@
 - Deprecated SimpleConfig::Utilities.
 - Deprecated SimpleConfig::ControllerMixin.
 
-## 1.1
+## 1.1.0
 
 - Added #to_hash method (via markschmidt)
 

data/{MIT-LICENSE → LICENSE}

@@ -1,4 +1,6 @@
-Copyright (c) 2010 Luke Redpath
+The MIT License
+
+Copyright (c) 2010-2012 Luke Redpath
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,32 +1,41 @@
 Simple Config is a plugin designed to make application-wide configuration settings easy to set and access in an
  object-oriented fashion.
 
-Rails already provides a way of configuring the framework on a per-environment basis but other than global variables/constants set in each environment file or environment.rb, there isn't a built-in way of providing application-specific settings.
+This library was originally designed to be a Rails plugin, but it's now a standard Ruby library with no dependency on Rails. You can use it in any Ruby application or project.
 
-One simple solution is to simply put all of your app configuration into a YAML file and load this somewhere in your environment, but I wanted something a little bit more flexible that we could use across all of our applications and Simple Config is what we came up with.
 
-SimpleConfig was originally written against Rails 1.x and may still work but as of version 1.1.1 the minimum required Rails version is 2.3.5. You may be able to use it with older versions of Rails but YMMV.
+## Rails Configuration vs SimpleConfig
 
-WARNING: SimpleConfig 1.x is not fully compatible with Rails 3. It works, but the rake tasks are not automatically loaded. Please upgrade to SimpleConfig 2.0 if you are using Rails 3.
+Rails already provides a way of configuring the framework on a per-environment or application basis, but the more the application becomes complex, the more the feature shows its limit.
+
+One common solution is to put your app configuration into YAML files and load them somewhere in your environment, but when you have many developers and dynamic configurations this is not always the best choice.
+
+Compared to the default Rails configuration system, SimpleConfig provides the following additional features:
+
+- Ability to define per developer settings using the `local.rb` file
+- Ability to nest configurations in groups
+- Ability to clone configs
+- Ability to load unlimited configuration scripts
 
 
 ## Getting started
 
 The plugin comes with a rake task to get you up and running quickly, so start by running that.
 
-  $ rake simple_config:setup
+  $ rake simpleconfig:setup
 
-This will create a config/settings folder and a blank settings file for each of the main Rails environments. It will also create a copy of the SimpleConfig initializer  in config/initializers/configuration.rb.
+This will create a `config/settings` folder and a blank settings file for each of the main Rails environments. It will also create a copy of the SimpleConfig initializer in `config/initializers/configuration.rb`.
 
-Now, if you open up the configuration.rb initializer, you will see something like this:
+Now, if you open up the `configuration.rb` initializer, you will see something like this:
 
 ```ruby
 SimpleConfig.for :application do
 
   # your app configuration here
   
-  load File.join(Rails.root, 'config', "settings", "#{RAILS_ENV}.rb"), :if_exists? => true
-  load File.join(Rails.root, 'config', "settings", "local.rb"),        :if_exists? => true
+  load File.join(Rails.root, "config", "settings", "application.rb"),   :if_exists? => true
+  load File.join(Rails.root, "config", "settings", "#{RAILS_ENV}.rb"),  :if_exists? => true
+  load File.join(Rails.root, "config", "settings", "local.rb"),         :if_exists? => true
   
 end
 ```
@@ -37,6 +46,7 @@ Variables can be overwritten, and are defined in the order that they are loaded,
 
 As well as loading a settings file for your current Rails environment, a file called "local.rb" is loaded which is designed as a place for you to override variables specific to your own development environment -- you can just keep a copy of this locally without having to check it into your version control system[1].
 
+
 ## Variables
 
 ### Setting Variables
@@ -117,38 +127,56 @@ config.awesome_stuff.my_variable # => "hello world"
 
 ## Using your configuration in your Rails app
 
-The plugin provides a convenient mixin for your `ApplicationController` to make configuration access as simple as possible. Assuming a configuration called "application" (as in the above examples), it defines a `config` method which can be used in any of your controllers. It also defines this as a method as a view helper using the Rails `helper_method` macro so you can access configuration data in your views. 
+When the application is initalized, by default the configurations are stored in the `:application` stack. You can access them anywhere using
 
-Note - there is no direct way of accessing your configuration variables in your models other than making a direct call to `SimpleConfig.for`. I'd recommend designing your models in such a way that configuration data can be passed into them at runtime as method arguments by your controller to avoid coupling your model to SimpleConfig.
+```ruby
+SimpleConfig.for(:application)
+```
 
-To use the mixin, simply include it in your `ApplicationController`:
+It's a common habit to define a `config` method in your Rails application or Rails libraries to have quick access to the configuration object. You can also use a mixin.
 
 ```ruby
+class Configurable
+  def config
+    SimpleConfig.for(:application)
+  end
+end
+
 class ApplicationController < ActionController::Base
-  include SimpleConfig::ControllerMixin
+  extend  Configurable
+  include Configurable
+
+  def do_something
+    # here you can use config
+    if config.my_variable 
+      render :foo
+    end
+      render :bar
+    else
+  end
+
 end
 ```
 
-Then in your controllers:
+An other very common pattern is to assing your configuration object to a constant so that it becomes globally available in your Rails project.
 
 ```ruby
-class MyController < ApplicationController
-  def index
-    render :text => config.my_config_variable
-  end
-end
+# config/initializers/configuration.rb
+# after the initialization block
+CONFIG = SimpleConfig.for :app
 ```
 
-The mixin provides also a class-level `config` method to access the configuration when you don't have a controller instance available.
+Then anywhere in your app
 
 ```ruby
-class MyController < ApplicationController
-  protect_from_forgery :secret => config.secret_token
-
-  def index
-    render :text => config.my_config_variable
+def do_something
+  if CONFIG.my_variable 
+    render :foo
   end
+    render :bar
+  else
 end
 ```
 
-fn1(footnote). In fact, I recommend you make sure your version control system ignores this file otherwise you risk checking in a file that will override values in production! If you are using Subversion, simply add local.rb to the svn:ignore property for the config/settings folder.
+
+fn1(footnote). In fact, I recommend you make sure your version control system ignores this file otherwise you risk checking in a file that will override values in production!

data/Rakefile

@@ -2,6 +2,9 @@ require 'rubygems'
 require 'rubygems/package_task'
 require 'bundler'
 
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'simple_config/version'
+
 
 # Run test by default.
 task :default => :test
@@ -14,12 +17,12 @@ task :default => :test
 #
 spec = Gem::Specification.new do |s|
   s.name     = "simpleconfig"
-  s.version  = "1.2.0"
+  s.version  = SimpleConfig::VERSION
   s.summary  = "Simple object-oriented application settings for Ruby applications"
   s.description = "SimpleConfig is a plugin designed to make application-wide configuration settings (e.g. in a Rails app) easy to set and access in an object-oriented fashion."
 
-  s.authors  = ["Luke Redpath"]
-  s.email    = "luke@lukeredpath.co.uk"
+  s.authors  = ["Luke Redpath", "Simone Carletti"]
+  s.email    = ["luke@lukeredpath.co.uk", "weppos@weppos.net"]
   s.homepage = "http://github.com/lukeredpath/simpleconfig"
 
   s.files             = `git ls-files`.split("\n")

data/lib/simple_config.rb

@@ -1,3 +1,6 @@
+require 'simple_config/version'
+require 'simple_config/railtie' if defined?(Rails)
+
 module SimpleConfig
 
   class << self

data/lib/simple_config/railtie.rb

@@ -0,0 +1,29 @@
+require 'simple_config'
+require 'rails'
+
+module Airbrake
+  class Railtie < ::Rails::Railtie
+
+    rake_tasks do
+      namespace :simpleconfig do
+        desc "Initialize SimpleConfig configurations."
+        task :setup do
+          abort("Already found config/settings. Have you already run this task?.") if File.exist?("config/settings")
+
+          mkdir("config/settings")
+          mkdir("config/initializers") unless File.exist?("config/initializers")
+
+          environments = Dir["config/environments/*.rb"].map { |f| File.basename(f, ".rb") }
+          environments << "application"
+          environments.each { |env| touch("config/settings/#{env}.rb") }
+
+          cp(
+              File.expand_path("../../../templates/configuration.rb", __FILE__), 
+              "config/initializers/configuration.rb"
+          )
+        end
+      end
+    end
+
+  end
+end

data/lib/simple_config/version.rb

@@ -0,0 +1,14 @@
+module SimpleConfig
+
+  module Version
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 0
+    BUILD = nil
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join(".")
+  end
+
+  VERSION = Version::STRING
+
+end

data/simpleconfig.gemspec

@@ -2,19 +2,19 @@
 
 Gem::Specification.new do |s|
   s.name = "simpleconfig"
-  s.version = "1.2.0"
+  s.version = "2.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Luke Redpath"]
+  s.authors = ["Luke Redpath", "Simone Carletti"]
   s.date = "2012-06-27"
   s.description = "SimpleConfig is a plugin designed to make application-wide configuration settings (e.g. in a Rails app) easy to set and access in an object-oriented fashion."
-  s.email = "luke@lukeredpath.co.uk"
-  s.files = [".gitignore", "CHANGELOG.md", "Gemfile", "MIT-LICENSE", "README.md", "Rakefile", "init.rb", "lib/simple_config.rb", "lib/simple_config/controller_mixin.rb", "lib/simple_config/utilities.rb", "lib/simpleconfig.rb", "lib/tasks/simple_config.rake", "simpleconfig.gemspec", "templates/configuration.rb", "test/controller_mixin_test.rb", "test/network_host_test.rb", "test/simple_config_functional_test.rb", "test/simple_config_test.rb", "test/test_helper.rb", "test/yaml_parser_test.rb"]
+  s.email = ["luke@lukeredpath.co.uk", "weppos@weppos.net"]
+  s.files = [".gitignore", "CHANGELOG.md", "Gemfile", "LICENSE", "README.md", "Rakefile", "lib/simple_config.rb", "lib/simple_config/railtie.rb", "lib/simple_config/version.rb", "lib/simpleconfig.rb", "simpleconfig.gemspec", "templates/configuration.rb", "test/simple_config_functional_test.rb", "test/simple_config_test.rb", "test/test_helper.rb", "test/yaml_parser_test.rb"]
   s.homepage = "http://github.com/lukeredpath/simpleconfig"
   s.require_paths = ["lib"]
   s.rubygems_version = "1.8.24"
   s.summary = "Simple object-oriented application settings for Ruby applications"
-  s.test_files = ["test/controller_mixin_test.rb", "test/network_host_test.rb", "test/simple_config_functional_test.rb", "test/simple_config_test.rb", "test/test_helper.rb", "test/yaml_parser_test.rb"]
+  s.test_files = ["test/simple_config_functional_test.rb", "test/simple_config_test.rb", "test/test_helper.rb", "test/yaml_parser_test.rb"]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/templates/configuration.rb

@@ -2,17 +2,17 @@ SimpleConfig.for :application do
   
   # Set here your global configuration.
   # All settings can be overwritten later per-environment.
-  load File.join(Rails.root.to_s, 'config', "settings", "application.rb"),   :if_exists? => true
+  load File.join(Rails.root.to_s, "config", "settings", "application.rb"),   :if_exists? => true
   
   # Per Environment settings.
   # At startup only the file matching current environment will be loaded.
   # Settings stored here will overwrite settings with the same name stored in application.rb
-  load File.join(Rails.root.to_s, 'config', "settings", "#{RAILS_ENV}.rb"),  :if_exists? => true
+  load File.join(Rails.root.to_s, "config", "settings", "#{Rails.env}.rb"),  :if_exists? => true
   
   # Local settings. It is designed as a place for you to override variables 
   # specific to your own development environment.
   # Make sure your version control system ignores this file otherwise 
   # you risk checking in a file that will override values in production
-  load File.join(Rails.root.to_s, 'config', "settings", "local.rb"),         :if_exists? => true
+  load File.join(Rails.root.to_s, "config", "settings", "local.rb"),         :if_exists? => true
   
 end

data/test/simple_config_functional_test.rb

@@ -1,3 +1,4 @@
+require 'test_helper'
 require 'fileutils'
 
 class SimpleConfigFunctionalTest < Test::Unit::TestCase

metadata

@@ -1,11 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: simpleconfig
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
 - Luke Redpath
+- Simone Carletti
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -61,7 +62,9 @@ dependencies:
         version: '0'
 description: SimpleConfig is a plugin designed to make application-wide configuration
   settings (e.g. in a Rails app) easy to set and access in an object-oriented fashion.
-email: luke@lukeredpath.co.uk
+email:
+- luke@lukeredpath.co.uk
+- weppos@weppos.net
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -69,19 +72,15 @@ files:
 - .gitignore
 - CHANGELOG.md
 - Gemfile
-- MIT-LICENSE
+- LICENSE
 - README.md
 - Rakefile
-- init.rb
 - lib/simple_config.rb
-- lib/simple_config/controller_mixin.rb
-- lib/simple_config/utilities.rb
+- lib/simple_config/railtie.rb
+- lib/simple_config/version.rb
 - lib/simpleconfig.rb
-- lib/tasks/simple_config.rake
 - simpleconfig.gemspec
 - templates/configuration.rb
-- test/controller_mixin_test.rb
-- test/network_host_test.rb
 - test/simple_config_functional_test.rb
 - test/simple_config_test.rb
 - test/test_helper.rb
@@ -100,7 +99,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -580664195664011592
+      hash: 1619246843325472384
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -114,8 +113,6 @@ signing_key:
 specification_version: 3
 summary: Simple object-oriented application settings for Ruby applications
 test_files:
-- test/controller_mixin_test.rb
-- test/network_host_test.rb
 - test/simple_config_functional_test.rb
 - test/simple_config_test.rb
 - test/test_helper.rb

data/init.rb

@@ -1,4 +0,0 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
-
-require 'simple_config'
-require 'simple_config/controller_mixin'

data/lib/simple_config/controller_mixin.rb

@@ -1,37 +0,0 @@
-warn <<-EOS
-DEPRECATION WARNING: SimpleConfig::ControllerMixin is deprecated and will be removed in SimpleConfig 2.0. If you really need this functionality, add the code to your app or consider creating a MicroGem.
-See http://jeffkreeftmeijer.com/2011/microgems-five-minute-rubygems/
-EOS
-
-
-module SimpleConfig
-  module ControllerMixin
-    
-    def self.included(base)
-      base.extend     ClassMethods
-      base.class_eval do
-        include       InstanceMethods
-        helper_method :config
-      end
-    end
-    
-    module ClassMethods
-      
-      # Returns the application config.
-      def config
-        SimpleConfig.for(:application)
-      end
-      
-    end
-    
-    module InstanceMethods
-      
-      # Instance-level proxy to class-level +config+ method.
-      def config
-        self.class.config
-      end
-      
-    end
-    
-  end
-end

data/lib/simple_config/utilities.rb

@@ -1,45 +0,0 @@
-require 'uri'
-
-warn <<-EOS
-DEPRECATION WARNING: SimpleConfig::Utilities is deprecated and will be removed in SimpleConfig 2.0. Please package it as a Gem or MicroGem.
-See http://jeffkreeftmeijer.com/2011/microgems-five-minute-rubygems/
-EOS
-
-module SimpleConfig
-  module Utilities
-    class NetworkHost
-      attr_reader :name, :port
-
-      def initialize(name, port = nil, secure = false)
-        @name, @port = name, port
-        @secure = secure
-      end
-      
-      def secure?
-        @secure
-      end
-
-      def self.from_string(host_string)
-        host, port = host_string.split(':')
-        new(host, port.to_i)
-      end
-
-      def to_uri(uri_options = {})
-        [:host, :port].each { |opt| uri_options.delete(opt) }
-        URI::Generic.build({:host => name, :port => port, :scheme => default_uri_scheme}.merge(uri_options))
-      end
-
-      def url_for_path(path)
-        to_uri(:path => path).to_s
-      end
-
-      def to_s
-        [name, port].compact.join(':')
-      end
-      
-      def default_uri_scheme
-        secure? ? 'https' : 'http'
-      end
-    end
-  end
-end

data/lib/tasks/simple_config.rake

@@ -1,21 +0,0 @@
-require 'fileutils'
-
-namespace :simple_config do
-  include FileUtils
-  
-  task :setup do
-    raise "This task should be run from within a Rails application." unless File.exist?('config')
-    raise "Already found config/settings. Have you already run this task?." if File.exist?('config/settings')
-    
-    mkdir('config/settings')
-    mkdir("config/initializers") unless File.exist?("config/initializers")
-    
-    environments =  Dir["config/environments/*.rb"].map { |f| File.basename(f, ".rb") }
-    environments << 'application'
-    environments.each { |env| touch("config/settings/#{env}.rb") }
-    
-    cp(File.join(File.dirname(__FILE__), *%w[.. .. templates configuration.rb]), 
-        "config/initializers/configuration.rb")
-  end  
-  
-end

data/test/controller_mixin_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-require 'simple_config/controller_mixin'
-
-class RailsController
-  class << self
-    attr_reader :helper_methods
-    def helper_method(name)
-      (@helper_methods ||= []) << name
-    end
-  end
-end
-
-class ControllerMixinTest < Test::Unit::TestCase
-
-  def setup
-    @app_config = SimpleConfig.for(:application) do
-    end
-    
-    @controller_klass = Class.new(RailsController)
-  end
-  
-  def test_should_define_a_config_class_method_that_returns_the_application_config_when_included
-    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
-    assert_equal @app_config, @controller_klass.config
-  end
-  
-  def test_should_define_a_config_instance_method_that_returns_the_application_config_when_included
-    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
-    assert_equal @app_config, @controller_klass.new.config
-  end
-  
-  def test_should_define_the_config_method_as_helper_method_to_make_it_available_to_views_when_included
-    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
-    assert_equal [:config], @controller_klass.helper_methods
-  end
-end

data/test/network_host_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-require 'simple_config/utilities'
-
-class NetworkHostTest < Test::Unit::TestCase
-  include SimpleConfig::Utilities
-    
-  def test_should_default_to_no_port
-    host = NetworkHost.new('www.example.com')
-    assert_nil host.port
-  end
-  
-  def test_should_build_a_uri_object_with_the_specified_hostname_and_port_and_a_http_scheme
-    uri = NetworkHost.new('www.example.com', 9000).to_uri
-    assert_instance_of URI::Generic, uri
-    assert_equal 'http', uri.scheme
-  end
-  
-  def test_should_build_a_uri_object_with_an_https_scheme_if_secure
-    uri = NetworkHost.new('www.example.com', 443, secure = true).to_uri
-    assert_equal 'https', uri.scheme
-  end
-  
-  def test_should_return_a_url_for_a_given_path
-    host = NetworkHost.new('www.example.com')
-    assert_equal 'http://www.example.com/foo/bar', host.url_for_path('/foo/bar')
-  end
-  
-  def test_should_return_a_string_representation
-    assert_equal 'www.example.com:9000', NetworkHost.new('www.example.com', 9000).to_s
-  end
-  
-  def test_should_be_constructed_from_a_string_representation
-    host = NetworkHost.from_string('www.example.com:9000')
-    assert_equal 'www.example.com', host.name
-    assert_equal 9000, host.port
-  end
-end