settable 1.1 → 3.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9fc35a6d3c9c14cc86b200c1340fd2237cfd033a
+  data.tar.gz: da581e63af6e9d0367f8f0f4a159d4ad7a0d2c7a
+SHA512:
+  metadata.gz: f29356b13085637dba0e53224a340ddfa8c6c6c7dd87aa857348b631b9de510b1233b605da2241306c5ad59a47d6fce100e960001a2cd40c219e65caa0b862b9
+  data.tar.gz: b1d84ac501e7997de743f1de902e181543813e8e814e2ba1dde907eb49313fe60c8af9f4d3fe90f464e55c78570659f079e502e9915191b851f6656c687d6bab

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=documentation

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+script: bundle exec rspec spec

data/Readme.md

@@ -1,74 +1,137 @@
-About
-===
+# Settable 3.0
 
-Simple library to make configuration files dead simple. It uses "set, enable, disable" just like capistrano and sinatra. It also has some rails helpers to change settings based off environments.
+[![Build Status](https://travis-ci.org/robhurring/settable.png?branch=master)](https://travis-ci.org/robhurring/settable)
 
-To create the configuration wrapper, its as simple as:
+An alternative to using rails' environment files or YAML for application config. Settable was created out of the frustration of
+missing a config setting in an environment file, or constantly duplicating YAML keys for different environments. Settable helps
+make your config "safe" by always having a default value, and its built using Ruby so it is highly customizable and powerful.
 
-    class Configuration
-      include Settable
+Check the Usage for some details on how it can be used.
 
-      def initialize(&block)
-        instance_eval(&block) if block_given?
-      end
-    end
+**Note:** This is a complete re-write from settable v2.0 and not backwards compatible. The old code was clunky and confusing, so
+it was refactored to be cleaner and a little more flexible.
 
-to use this in your initializer, script, etc. just open it up and use set/enable/etc    
+## Installation
 
-    # using it without the rails helpers
-    config = Configuration.new do
-      set :environment, 'development'
-      enable :debug
-      
-      set :api_token do
-        return 'PRODTOKEN' if environment == 'production'
-        'DEVTOKEN'
-      end
+Add this line to your application's Gemfile:
 
-      set :api_endpoint, "http://example.com/api/#{api_token}"
-    end
-    
-    puts config.debug?
-    puts config.api_endpoint
-    
-or if you wanted to use it with rails    
-    
-    class Configuration
-      include Settable
-      include Settable::Rails
-
-      def initialize(&block)
-        instance_eval(&block) if block_given?
-      end
+    gem 'settable', git: 'https://github.com/robhurring/settable'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+### Basic Usage
+
+```ruby
+$config = Settable.configure do
+  # basic set, similar to capistrano and sinatra
+  set :username, 'user'
+  set :password, 's3kr1t'
+
+  # namespace support to keep config clean
+  namespace :tracking do
+    set :enabled, true
+  end
+
+  set :block do
+    'blocks are allowed too!'
+  end
+end
+
+if params[:user] == $config.username && params[:password] == $config.password
+  ...
+end
+
+# all settings have a "presence" method, just add a "?" to check if it has been set
+if $config.tracking.enabled?
+  ...
+end
+```
+
+### Rails Integration
+
+```ruby
+# config/initializers/app_config.rb
+$config = Settable.configure do
+  # this enables the +environment+ helpers below, so we can set values in specific
+  # environments only. (environment testers can be swapped out - see the advanced example)
+  use_environment :rails
+
+  set :username do
+    # checks Rails.env and will return 'superadmin' when in production
+    environment :production, 'superadmin'
+
+    # defaults back to 'devuser' if environment doesn't match
+    'devuser'
+  end
+
+  set :password do
+    environment :production, 's3kr1t'
+
+    'defaultpassword'
+  end
+
+  set :tracking do
+    # check if we're in production _or_ staging
+    environment [:production, :staging], true
+    false
+  end
+end
+
+# some_controller.rb
+http_basic_authenticate_with name: $config.username, password: $config.password
+```
+
+### Advanced Integration
+
+To use a custom class/namespace for your configuration you can do the following:
+
+```ruby
+class MyApp
+  # include the Settable DSL
+  include Settable
+
+  # create a custom environment tester, any object that respond to #call(value) can be used
+  # as an environment tester. This is in the core code when using "use_environment :env"
+  module EnvironmentTester
+    def self.call(environment)
+      ::ENV.has_key?(environment.to_s.upcase)
     end
-      
-and use the environment helpers
-
-    config = Configuration.new do
-      # add some custom environments from our app
-      define_environments :blah, :qa
-
-      set :something, in_blah?
-      set :debug, in_environments?(:development, :test)
-  
-      if in_production?
-        enable :tracking, :caching
-      else
-        disable :tracking, :caching
-      end
-  
-      set :api_token do
-        in_production { return 'PRODTOKEN' }
-        in_development{ return 'DEVTOKEN' }
-        'OTHERTOKEN'
-      end
-  
-      set :api_endpoint do
-        in_environments(:development, :test){ return "http://sandbox.example.com/api/#{api_token}" }
-        "http://example.com/api/#{api_token}"
+  end
+
+  # creates a class and instance method +config+ that holds all settings
+  settable :config do
+    # use our custom env tester for all +environment+ calls
+    use_environment EnvironmentTester
+
+    set :redis_uri do
+      # check our ENV for the REDIS_TO_GO_URL key
+      environment :REDIS_TO_GO_URL do
+        ENV['REDIS_TO_GO_URL']
       end
+
+      # default to localhost if not found
+      'localhost:6379'
     end
-    
-    puts config.debug?
-    puts config.caching?
-    puts config.api_endpoint
+  end
+
+  def redis
+    Redis.new(config.redis_uri)
+  end
+end
+
+$app = MyApp.new
+$redis = $app.redis
+# you can also reach the redis_uri at MyApp.config.redis_uri
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/settable/environment/env.rb

@@ -0,0 +1,9 @@
+module Settable
+  module Environment
+    module Env
+      def self.call(environment)
+        ::ENV.has_key?(environment.to_s)
+      end
+    end
+  end
+end

data/lib/settable/environment/rails.rb

@@ -0,0 +1,10 @@
+module Settable
+  module Environment
+    module Rails
+      def self.call(environment)
+        return false unless defined?(::Rails)
+        ::Rails.env.to_s == environment.to_s
+      end
+    end
+  end
+end