jamesearl-rails-settings 1.0.2

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+gemfile:
+  - ci/Gemfile.rails-2.3.x
+#  - ci/Gemfile.rails-3.0.x
+  - ci/Gemfile.rails-3.1.x
+  - ci/Gemfile.rails-3.2.x

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rails-settings.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Alex Wayne
+Some additional features added 2009-2012 by Georg Ledermann
+
+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 PURPOa AND
+NONINFRINGEMENT. IN NO EVENT SaALL 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.

data/README.md

@@ -0,0 +1,151 @@
+# Changes from upstream
+
+Will attempt to use a corresponding ENV value if a setting key is not found in the database or defaults.
+
+Example:
+    If you look for Setting.foo, the gem well try
+    Settings.all["foo"]
+    defaults["foo"]
+    ENV["FOO"]
+
+Note the upcase.
+
+
+# Settings Gem/Plugin for Rails
+
+Settings is a gem/plugin that makes managing a table of key/value pairs easy. Think of it like a Hash stored in you database, that uses simple ActiveRecord like methods for manipulation. Keep track of any setting that you don't want to hard code into your rails app. You can store any kind of object: Strings, numbers, arrays, or any object which can be noted as YAML.
+
+
+## Requirements
+
+Rails 2.3.x, 3.1.x or 3.2.x (due to an [issue with Rails caching](https://github.com/rails/rails/pull/2010) it does not work properly with Rails 3.0.x)
+
+Tested with Ruby 1.8.7 and 1.9.3
+
+
+## Installation
+
+Include the gem in your Gemfile
+
+    gem 'jamesearl-rails-settings', :require => 'rails-settings'
+
+or install as a plugin:
+
+    ./script/plugin install git://github.com/jamesearl/rails-settings.git
+
+
+You have to create the table used by the Settings model by using this migration:
+
+    class CreateSettingsTable < ActiveRecord::Migration
+      def self.up
+        create_table :settings, :force => true do |t|
+          t.string  :var,         :null => false
+          t.text    :value
+          t.integer :target_id
+          t.string  :target_type, :limit => 30
+          t.timestamps
+        end
+
+        add_index :settings, [ :target_type, :target_id, :var ], :unique => true
+      end
+
+      def self.down
+        drop_table :settings
+      end
+    end
+    
+Now update your database with:
+
+    rake db:migrate
+
+## Usage
+
+The syntax is easy. First, lets create some settings to keep track of:
+
+    Settings.admin_password = 'supersecret'
+    Settings.date_format    = '%m %d, %Y'
+    Settings.cocktails      = ['Martini', 'Screwdriver', 'White Russian']
+    Settings.foo            = 123
+    Settings.credentials    = { :username => 'tom', :password => 'secret' }
+
+Now lets read them back:
+
+    Settings.foo
+    # => 123
+
+Changing an existing setting is the same as creating a new setting:
+
+    Settings.foo = 'super duper bar'
+
+For changing an existing setting which is a Hash, you can merge new values with existing ones:
+
+    Settings.merge! :credentials, :password => 'topsecret'
+    Settings.credentials
+    # => { :username => 'tom', :password => 'topsecret' }
+
+Decide you dont want to track a particular setting anymore?
+
+    Settings.destroy :foo
+    Settings.foo
+    # => nil
+
+Want a list of all the settings?
+
+    Settings.all
+    # => { 'admin_password' => 'super_secret', 'date_format' => '%m %d, %Y' }
+
+You need name spaces and want a list of settings for a give name space? Just choose your prefered named space delimiter and use Settings.all like this:
+
+    Settings['preferences.color'] = :blue
+    Settings['preferences.size'] = :large
+    Settings['license.key'] = 'ABC-DEF'
+    Settings.all('preferences.')
+    # => { 'preferences.color' => :blue, 'preferences.size' => :large }
+
+Set defaults for certain settings of your app.  This will cause the defined settings to return with the
+Specified value even if they are not in the database.  Make a new file in config/initializers/settings.rb
+with the following:
+
+    Settings.defaults[:some_setting] = 'footastic'
+  
+Now even if the database is completely empty, you app will have some intelligent defaults:
+
+    Settings.some_setting
+    # => 'footastic'
+
+Settings may be bound to any existing ActiveRecord object. Define this association like this:
+
+    class User < ActiveRecord::Base
+      has_settings
+    end
+
+Then you can set/get a setting for a given user instance just by doing this:
+
+    user = User.find(123)
+    user.settings.color = :red
+    user.settings.color
+    # => :red
+    
+    user.settings.all
+    # => { "color" => :red }
+
+I you want to find users having or not having some settings, there are named scopes for this:
+
+    User.with_settings
+    # returns a scope of users having any setting
+    
+    User.with_settings_for('color')
+    # returns a scope of users having a 'color' setting
+  
+    User.without_settings
+    # returns a scope of users having no setting at all (means user.settings.all == {})
+    
+    User.without_settings('color')
+    # returns a scope of users having no 'color' setting (means user.settings.color == nil)
+
+For better performance, you can enable caching, e.g.:
+
+    Settings.cache = ActiveSupport::Cache::MemoryStore.new
+    Settings.cache_options = { :expires_in => 5.minutes }
+
+That's all there is to it! Enjoy!

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = Dir.glob("test/**/*_test.rb")
+  t.verbose = true
+end
+
+task :default => :test
+
+require 'bundler/gem_tasks'

data/ci/Gemfile.rails-2.3.x

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'activerecord', '~> 2.3.14'
+gem 'sqlite3'
+gem 'rake'

data/ci/Gemfile.rails-3.0.x

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'activerecord', '~> 3.0.12'
+gem 'sqlite3'
+gem 'rake'

data/ci/Gemfile.rails-3.1.x

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'activerecord', '~> 3.1.4'
+gem 'sqlite3'
+gem 'rake'

data/ci/Gemfile.rails-3.2.x

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'activerecord', '~> 3.2.2'
+gem 'sqlite3'
+gem 'rake'

data/init.rb

@@ -0,0 +1 @@
+require 'rails-settings'

data/lib/rails-settings.rb

@@ -0,0 +1,5 @@
+require 'rails-settings/version'
+require 'rails-settings/null_store'
+require 'rails-settings/active_record'
+require 'rails-settings/settings'
+require 'rails-settings/scoped_settings'

data/lib/rails-settings/active_record.rb

@@ -0,0 +1,30 @@
+ActiveRecord::Base.class_eval do
+  def self.has_settings
+    class_eval do
+      def settings
+        ScopedSettings.for_target(self)
+      end
+      
+      after_destroy { |user| user.settings.target_scoped.delete_all }
+
+      scope_method = ActiveRecord::VERSION::MAJOR < 3 ? :named_scope : :scope
+      
+      send scope_method, :with_settings, :joins => "JOIN settings ON (settings.target_id = #{self.table_name}.#{self.primary_key} AND
+                                                                      settings.target_type = '#{self.base_class.name}')",
+                                         :select => "DISTINCT #{self.table_name}.*" 
+
+      send scope_method, :with_settings_for, lambda { |var| { :joins => "JOIN settings ON (settings.target_id = #{self.table_name}.#{self.primary_key} AND
+                                                                              settings.target_type = '#{self.base_class.name}') AND
+                                                                              settings.var = '#{var}'" } }
+                                                               
+      send scope_method, :without_settings, :joins => "LEFT JOIN settings ON (settings.target_id = #{self.table_name}.#{self.primary_key} AND
+                                                                 settings.target_type = '#{self.base_class.name}')",
+                                            :conditions => 'settings.id IS NULL'
+                                     
+      send scope_method, :without_settings_for, lambda { |var| { :joins => "LEFT JOIN settings ON (settings.target_id = #{self.table_name}.#{self.primary_key} AND
+                                                                                      settings.target_type = '#{self.base_class.name}') AND
+                                                                                      settings.var = '#{var}'",
+                                                                 :conditions => 'settings.id IS NULL' } }
+    end
+  end
+end

data/lib/rails-settings/null_store.rb

@@ -0,0 +1,48 @@
+unless defined?(ActiveSupport::Cache::NullStore)
+  # Copied from Rails 3
+  # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/cache/null_store.rb
+  module ActiveSupport
+    module Cache
+      # A cache store implementation which doesn't actually store anything. Useful in
+      # development and test environments where you don't want caching turned on but
+      # need to go through the caching interface.
+      #
+      # This cache does implement the local cache strategy, so values will actually
+      # be cached inside blocks that utilize this strategy. See
+      # ActiveSupport::Cache::Strategy::LocalCache for more details.
+      class NullStore < Store
+        def initialize(options = nil)
+          super()
+          extend Strategy::LocalCache
+        end
+
+        def clear(options = nil)
+        end
+
+        def cleanup(options = nil)
+        end
+
+        def increment(name, amount = 1, options = nil)
+        end
+
+        def decrement(name, amount = 1, options = nil)
+        end
+
+        def delete_matched(matcher, options = nil)
+        end
+
+        protected
+          def read_entry(key, options) # :nodoc:
+          end
+
+          def write_entry(key, entry, options) # :nodoc:
+            true
+          end
+
+          def delete_entry(key, options) # :nodoc:
+            false
+          end
+      end
+    end
+  end
+end

data/lib/rails-settings/scoped_settings.rb

@@ -0,0 +1,14 @@
+class ScopedSettings < Settings
+  def self.for_target(target)
+    @target = target
+    self
+  end
+  
+  def self.target_id
+    @target.id
+  end
+  
+  def self.target_type
+    @target.class.base_class.to_s
+  end
+end

data/lib/rails-settings/settings.rb

@@ -0,0 +1,136 @@
+class Settings < ActiveRecord::Base
+  class SettingNotFound < RuntimeError; end
+  
+  cattr_accessor :defaults
+  self.defaults = {}.with_indifferent_access
+
+  # cache must follow the contract of ActiveSupport::Cache. Defaults to no-op.
+  cattr_accessor :cache
+  self.cache = ActiveSupport::Cache::NullStore.new
+
+  # options passed to cache.fetch() and cache.write(). example: {:expires_in => 5.minutes}
+  cattr_accessor :cache_options
+  self.cache_options = {}
+
+  def self.cache_key(var_name)
+    [target_id, target_type, var_name].compact.join("::")
+  end
+
+  # Support old plugin
+  if defined?(SettingsDefaults::DEFAULTS)
+    self.defaults = SettingsDefaults::DEFAULTS.with_indifferent_access
+  end
+  
+  #get or set a variable with the variable as the called method
+  def self.method_missing(method, *args)
+    if self.respond_to?(method)
+      super
+    else
+      method_name = method.to_s
+    
+      #set a value for a variable
+      if method_name =~ /=$/
+        var_name = method_name.gsub('=', '')
+        value = args.first
+        self[var_name] = value
+    
+      #retrieve a value
+      else
+        self[method_name]
+      
+      end
+    end
+  end
+  
+  #destroy the specified settings record
+  def self.destroy(var_name)
+    var_name = var_name.to_s
+    begin
+      target(var_name).destroy
+      cache.delete(cache_key(var_name))
+      true
+    rescue NoMethodError
+      raise SettingNotFound, "Setting variable \"#{var_name}\" not found"
+    end
+  end
+
+  def self.delete_all(conditions = nil)
+    cache.clear
+    super
+  end
+
+  #retrieve all settings as a hash (optionally starting with a given namespace)
+  def self.all(starting_with=nil)
+    options = starting_with ? { :conditions => "var LIKE '#{starting_with}%'"} : {}
+    vars = target_scoped.find(:all, {:select => 'var, value'}.merge(options))
+    
+    result = {}
+    vars.each do |record|
+      result[record.var] = record.value
+    end
+    result.with_indifferent_access
+  end
+  
+  #get a setting value by [] notation
+  def self.[](var_name)
+    cache.fetch(cache_key(var_name), cache_options) do
+      if (var = target(var_name)).present?
+        var.value
+      else
+        ENV[var_name.to_s.upcase] || defaults[var_name.to_s]
+      end
+    end
+  end
+  
+  #set a setting value by [] notation
+  def self.[]=(var_name, value)
+    record = target_scoped.find_or_initialize_by_var(var_name.to_s)
+    record.value = value
+    record.save!
+    cache.write(cache_key(var_name), value, cache_options)
+    value
+  end
+  
+  def self.merge!(var_name, hash_value)
+    raise ArgumentError unless hash_value.is_a?(Hash)
+    
+    old_value = self[var_name] || {}
+    raise TypeError, "Existing value is not a hash, can't merge!" unless old_value.is_a?(Hash)
+    
+    new_value = old_value.merge(hash_value)
+    self[var_name] = new_value if new_value != old_value
+    
+    new_value
+  end
+
+  def self.target(var_name)
+    target_scoped.find_by_var(var_name.to_s)
+  end
+  
+  #get the value field, YAML decoded
+  def value
+    YAML::load(self[:value])
+  end
+  
+  #set the value field, YAML encoded
+  def value=(new_value)
+    self[:value] = new_value.to_yaml
+  end
+  
+  def self.target_scoped
+    Settings.scoped_by_target_type_and_target_id(target_type, target_id)
+  end
+  
+  #Deprecated!
+  def self.reload # :nodoc:
+    self
+  end
+  
+  def self.target_id
+    nil
+  end
+
+  def self.target_type
+    nil
+  end
+end

data/lib/rails-settings/version.rb

@@ -0,0 +1,3 @@
+module RailsSettings
+  VERSION = '1.0.2'
+end

data/rails-settings.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'rails-settings/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'jamesearl-rails-settings'
+  s.version     = RailsSettings::VERSION
+  s.authors     = ['James Cunningham']
+  s.email       = ['james@einherj.ar.com']
+  s.homepage    = 'https://github.com/jamesearl/rails-settings'
+  s.summary     = %q{Settings management for ActiveRecord objects}
+  s.description = %q{Ruby Gem that makes managing a table of key/value pairs easy. Think of it like a Hash stored in you database, that uses simple ActiveRecord like methods for manipulation.}
+
+  s.rubyforge_project = 'jamesearl-rails-settings'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.add_dependency 'activerecord', '>= 2.3'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'sqlite3'
+end

data/test/settings_test.rb

@@ -0,0 +1,213 @@
+require 'test_helper'
+
+class SettingsTest < Test::Unit::TestCase
+  setup_db
+  
+  def setup
+    Settings.create(:var => 'test',  :value => 'foo')
+    Settings.create(:var => 'test2', :value => 'bar')
+  end
+
+  def teardown
+    User.delete_all
+    Settings.delete_all
+  end
+  
+  def test_defaults
+    Settings.defaults[:foo] = 'default foo'
+    
+    assert_nil Settings.target(:foo)
+    assert_equal 'default foo', Settings.foo
+    
+    Settings.foo = 'bar'
+    assert_equal 'bar', Settings.foo
+    assert_not_nil Settings.target(:foo)
+  end
+  
+  def tests_defaults_true
+    Settings.defaults[:foo] = true
+    assert_equal true, Settings.foo
+  end
+
+  def tests_defaults_false
+    Settings.defaults[:foo] = false
+    assert_equal false, Settings.foo
+  end
+  
+  def test_get
+    assert_setting 'foo', :test
+    assert_setting 'bar', :test2
+  end
+
+  def test_update
+    assert_assign_setting '321', :test
+  end
+  
+  def test_create
+    assert_assign_setting '123', :onetwothree
+  end
+  
+  def test_complex_serialization
+    complex = [1, '2', {:three => true}]
+    Settings.complex = complex
+    assert_equal complex, Settings.complex
+  end
+  
+  def test_serialization_of_float
+    Settings.float = 0.01
+    Settings.reload
+    assert_equal 0.01, Settings.float
+    assert_equal 0.02, Settings.float * 2
+  end
+  
+  def test_target_scope
+    user1 = User.create :name => 'First user'
+    user2 = User.create :name => 'Second user'
+    
+    assert_assign_setting 1, :one, user1
+    assert_assign_setting 2, :two, user2
+    
+    assert_setting 1, :one, user1
+    assert_setting 2, :two, user2
+    
+    assert_setting nil, :one
+    assert_setting nil, :two
+    
+    assert_setting nil, :two, user1
+    assert_setting nil, :one, user2
+    
+    assert_equal({ "one" => 1}, user1.settings.all('one'))
+    assert_equal({ "two" => 2}, user2.settings.all('two'))
+    assert_equal({ "one" => 1}, user1.settings.all('o'))
+    assert_equal({}, user1.settings.all('non_existing_var'))
+  end
+  
+  def test_named_scope
+    user_without_settings = User.create :name => 'User without settings'
+    user_with_settings = User.create :name => 'User with settings'
+    user_with_settings.settings.one = '1'
+    user_with_settings.settings.two = '2'
+    
+    assert_equal [user_with_settings], User.with_settings
+    assert_equal [user_with_settings], User.with_settings_for('one')
+    assert_equal [user_with_settings], User.with_settings_for('two')
+    assert_equal [], User.with_settings_for('foo')
+    
+    assert_equal [user_without_settings], User.without_settings
+    assert_equal [user_without_settings], User.without_settings_for('one')
+    assert_equal [user_without_settings], User.without_settings_for('two')
+    assert_equal [user_without_settings, user_with_settings], User.without_settings_for('foo')
+  end
+  
+  def test_delete_settings_after_destroying_target
+    user1 = User.create :name => 'Mr. Foo'
+    user2 = User.create :name => 'Mr. Bar'
+    user1.settings.example = 42
+    user2.settings.example = 43
+    
+    before_count = Settings.count
+    user1.destroy
+    assert_equal before_count - 1, Settings.count
+    
+    before_count = Settings.count
+    user2.destroy
+    assert_equal before_count - 1, Settings.count
+  end
+  
+  def test_all
+    assert_equal({ "test2" => "bar", "test" => "foo" }, Settings.all)
+    assert_equal({ "test2" => "bar" }, Settings.all('test2'))
+    assert_equal({ "test2" => "bar", "test" => "foo" }, Settings.all('test'))
+    assert_equal({}, Settings.all('non_existing_var'))
+  end
+  
+  def test_merge
+    assert_raise(TypeError) do
+      Settings.merge! :test, { :a => 1 }
+    end
+
+    Settings[:hash] = { :one => 1 }
+    Settings.merge! :hash, { :two => 2 }
+    assert_equal({ :one => 1, :two => 2 }, Settings[:hash])
+    
+    assert_raise(ArgumentError) do
+      Settings.merge! :hash, 123
+    end
+    
+    Settings.merge! :empty_hash, { :two => 2 }
+    assert_equal({ :two => 2 }, Settings[:empty_hash])
+  end
+  
+  def test_destroy
+    Settings.destroy :test
+    assert_equal nil, Settings.test
+    
+    assert_raise(Settings::SettingNotFound) do
+      Settings.destroy :unknown
+    end
+  end
+  
+  def test_false
+    Settings.test3 = false
+    assert_setting(false, 'test3')
+    
+    Settings.destroy :test3
+    assert_setting(nil, 'test3')
+  end
+  
+  private
+    def assert_setting(value, key, scope_target=nil)
+      key = key.to_sym
+      
+      if scope_target
+        assert_equal value, scope_target.instance_eval("settings.#{key}")
+        assert_equal value, scope_target.settings[key.to_sym]
+        assert_equal value, scope_target.settings[key.to_s]
+      else
+        assert_equal value, eval("Settings.#{key}")
+        assert_equal value, Settings[key.to_sym]
+        assert_equal value, Settings[key.to_s]
+      end
+    end
+    
+    def assert_assign_setting(value, key, scope_target=nil)
+      key = key.to_sym
+      
+      if scope_target
+        assert_equal value, (scope_target.settings[key] = value)
+        assert_setting value, key, scope_target
+        scope_target.settings[key] = nil
+      
+        assert_equal value, (scope_target.settings[key.to_s] = value)
+        assert_setting value, key, scope_target
+      else
+        assert_equal value, (Settings[key] = value)
+        assert_setting value, key
+        Settings[key] = nil
+      
+        assert_equal value, (Settings[key.to_s] = value)
+        assert_setting value, key
+      end
+    end
+end
+
+class CachedSettingsTest < SettingsTest
+  def setup
+    Settings.cache = ActiveSupport::Cache::MemoryStore.new
+    Settings.cache_options = { :expires_in => 5.minutes }
+    super
+  end
+
+  def test_caching_is_in_place
+    Settings.progress = "boing"
+    Settings.connection.execute("delete from settings")
+    assert_equal "boing", Settings.progress
+    Settings.cache.clear
+    assert_nil Settings.progress
+  end
+
+  def teardown
+    Settings.cache.clear
+    super
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+
+require 'active_support'
+require 'active_support/test_case'
+require 'active_record'
+require 'test/unit'
+
+require "#{File.dirname(__FILE__)}/../init"
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Migration.verbose = false
+
+class User < ActiveRecord::Base
+  has_settings
+end
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :settings do |t|
+      t.string :var, :null => false
+      t.text   :value, :null => true
+      t.integer :target_id, :null => true
+      t.string :target_type, :limit => 30, :null => true
+      t.timestamps
+    end
+    add_index :settings, [ :target_type, :target_id, :var ], :unique => true
+    
+    create_table :users do |t|
+      t.string :name
+    end
+  end
+end
+
+puts "Testing with ActiveRecord #{ActiveRecord::VERSION::STRING}"

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: jamesearl-rails-settings
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+  prerelease: 
+platform: ruby
+authors:
+- James Cunningham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby Gem that makes managing a table of key/value pairs easy. Think of
+  it like a Hash stored in you database, that uses simple ActiveRecord like methods
+  for manipulation.
+email:
+- james@einherj.ar.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- ci/Gemfile.rails-2.3.x
+- ci/Gemfile.rails-3.0.x
+- ci/Gemfile.rails-3.1.x
+- ci/Gemfile.rails-3.2.x
+- init.rb
+- lib/rails-settings.rb
+- lib/rails-settings/active_record.rb
+- lib/rails-settings/null_store.rb
+- lib/rails-settings/scoped_settings.rb
+- lib/rails-settings/settings.rb
+- lib/rails-settings/version.rb
+- rails-settings.gemspec
+- test/settings_test.rb
+- test/test_helper.rb
+homepage: https://github.com/jamesearl/rails-settings
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: jamesearl-rails-settings
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: Settings management for ActiveRecord objects
+test_files:
+- test/settings_test.rb
+- test/test_helper.rb