rails-settings-cached 0.5.6 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b57a0a5ecf132300eb30437cecef1d72ac4a6850
-  data.tar.gz: 0819f21de6cb043141b20ff39ddd4c212aabd758
+  metadata.gz: fa6d7bd1e608d80ee9995d8f1393e9fce6a19d2f
+  data.tar.gz: d47dd443d8e1afe1ea8dde4e7e10acbff1aafd3c
 SHA512:
-  metadata.gz: b26625a6a49cc7413f18201e454374a6de07523705efd6eedd7d889aa464f2f07a057a541a277eba1fcfc1ad6cc791c4221ce6e84b35c2004cb37d86fdb661ad
-  data.tar.gz: d2c7146010da954ef4b8010b5a3fe7bd92a9c6c100c389a8db3c834fd90429c64a648387f6d5885c414f13b407f4cde974b382d13c6a089cc5dc0373780ef7d2
+  metadata.gz: 0101c4f85fec7b475e5306bc94882c39ce7711f66b3cdc5c5175aedc333a138503388ba56d4dee0d956bb8ce2af396c030e04fcee89ef8d75749fc932e8259dd
+  data.tar.gz: 892a9665b231016b4c2ea079afdd94a01895169795ca1637cc23e7a2bf007823b5400d37fef0d400a2ca40204618d5dbe2c2a6b391fa7f4b53dee59db91b7373

data/README.md

@@ -1,202 +1,263 @@
-# Settings Gem
-
-This is improved from [rails-settings](https://github.com/ledermann/rails-settings),
-added caching for all settings. Settings is a plugin that makes managing a table of
-global key, value pairs easy. Think of it like a global Hash stored in your database,
-that uses simple ActiveRecord like methods for manipulation. Keep track of any global
-setting that you dont want to hard code into your rails app. You can store any kind
-of object. Strings, numbers, arrays, or any object.
-
-## Status
-
-[![Gem Version](https://badge.fury.io/rb/rails-settings-cached.svg)](https://rubygems.org/gems/rails-settings-cached) [![CI Status](https://api.travis-ci.org/huacnlee/rails-settings-cached.svg)](http://travis-ci.org/huacnlee/rails-settings-cached) [![Code Climate](https://codeclimate.com/github/huacnlee/rails-settings-cached/badges/gpa.svg)](https://codeclimate.com/github/huacnlee/rails-settings-cached) [![codecov.io](https://codecov.io/github/huacnlee/rails-settings-cached/coverage.svg?branch=master)](https://codecov.io/github/huacnlee/rails-settings-cached?branch=master)
-
-## Setup
-
-Edit your Gemfile:
-
-```ruby
-gem 'rails-settings-cached', "~> 0.5.6"
-```
-
-Older Rails versions:
-
-```rb
-# 4.1.x
-gem "rails-settings-cached", "~> 0.4.0"
-# 4.0.x
-gem "rails-settings-cached", "0.3.1"
-# 3.x
-gem "rails-settings-cached", "0.2.4"
-```
-
-Generate your settings:
-
-```bash
-$ rails g settings:install
-```
-
-If you want custom model name:
-
-```bash
-$ rails g settings:install MySetting
-```
-
-Now just put that migration in the database with:
-
-```bash
-rake db:migrate
-```
-
-## Usage
-
-The syntax is easy.  First, lets create some settings to keep track of:
-
-```ruby
-Setting.admin_password = 'supersecret'
-Setting.date_format    = '%m %d, %Y'
-Setting.cocktails      = ['Martini', 'Screwdriver', 'White Russian']
-Setting.foo            = 123
-Setting.credentials    = { :username => 'tom', :password => 'secret' }
-```
-
-Now lets read them back:
-
-```ruby
-Setting.foo            # returns 123
-```
-
-Changing an existing setting is the same as creating a new setting:
-
-```ruby
-Setting.foo = 'super duper bar'
-```
-
-For changing an existing setting which is a Hash, you can merge new values with existing ones:
-
-```ruby
-Setting.merge!(:credentials, :password => 'topsecret')
-Setting.credentials    # returns { :username => 'tom', :password => 'topsecret' }
-```
-
-Decide you dont want to track a particular setting anymore?
-
-```ruby
-Setting.destroy :foo
-Setting.foo            # returns nil
-```
-
-Want a list of all the settings?
-```ruby
-# Rails 4.1.x
-Setting.get_all
-# Rails 3.x and 4.0.x
-Setting.all
-# returns {'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 `Setting.get_all` (`Settings.all` for # Rails 3.x and 4.0.x) like this:
-
-```ruby
-Setting['preferences.color'] = :blue
-Setting['preferences.size'] = :large
-Setting['license.key'] = 'ABC-DEF'
-# Rails 4.1.x
-Setting.get_all('preferences.')
-# Rails 3.x and 4.0.x
-Setting.all('preferences.')
-# returns { '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/default_settings.rb`
-with the following:
-
-```ruby
-Setting.defaults[:some_setting] = 'footastic'
-Setting.where(:var => "some_setting").count
-=> 0
-Setting.some_setting
-=> "footastic"
-```
-
-Init default value in database, this has indifferent with `Setting.defaults[:some_setting]`, this will **save the value into database**:
-
-```ruby
-Setting.save_default(:some_key, "123")
-Setting.where(:var => "some_key").count
-=> 1
-Setting.some_key
-=> "123"
-```
-
-Settings may be bound to any existing ActiveRecord object. Define this association like this:
-Notice! is not do caching in this version.
-
-```ruby
-class User < ActiveRecord::Base
-  include RailsSettings::Extend
-end
-```
-
-Then you can set/get a setting for a given user instance just by doing this:
-
-```ruby
-user = User.find(123)
-user.settings.color = :red
-user.settings.color # returns :red
-# Rails 4.1.x
-user.settings.get_all
-# Rails 3.x and 4.0.x
-user.settings.all
-# { "color" => :red }
-```
-
-If you want to find users having or not having some settings, there are named scopes for this:
-
-```ruby
-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.get_all == {})
-
-User.without_settings('color')
-# returns a scope of users having no 'color' setting (means user.settings.color == nil)
-```
-
-Settings maybe dynamically scoped. For example, if you're using [apartment gem](https://github.com/influitive/apartment) for multitenancy, you may not want tenants to share settings:
-
-```ruby
-class Settings < RailsSettings::CachedSettings
-  cache_prefix { Apartment::Tenant.current }
-  ...
-end
-```
-
------
-
-## How to create a list, form to manage Settings?
-
-If you want create an admin interface to editing the Settings, you can try methods in follow:
-
-```ruby
-class SettingsController < ApplicationController
-  def index
-    # to get all items for render list
-    @settings = Setting.unscoped
-  end
-
-  def edit
-    @setting = Setting.unscoped.find(params[:id])
-  end
-end
-```
-
-
-Also you may use [rails-settings-ui](https://github.com/accessd/rails-settings-ui) gem
-for building ready to using interface with validations.
-
+# Rails Settings Cached
+
+This is improved from [rails-settings](https://github.com/ledermann/rails-settings),
+added caching for all settings. Settings is a plugin that makes managing a table of
+global key, value pairs easy. Think of it like a global Hash stored in your database,
+that uses simple ActiveRecord like methods for manipulation. Keep track of any global
+setting that you dont want to hard code into your rails app. You can store any kind
+of object. Strings, numbers, arrays, or any object.
+
+## Status
+
+[![Gem Version](https://badge.fury.io/rb/rails-settings-cached.svg)](https://rubygems.org/gems/rails-settings-cached) [![CI Status](https://api.travis-ci.org/huacnlee/rails-settings-cached.svg)](http://travis-ci.org/huacnlee/rails-settings-cached) [![Code Climate](https://codeclimate.com/github/huacnlee/rails-settings-cached/badges/gpa.svg)](https://codeclimate.com/github/huacnlee/rails-settings-cached) [![codecov.io](https://codecov.io/github/huacnlee/rails-settings-cached/coverage.svg?branch=master)](https://codecov.io/github/huacnlee/rails-settings-cached?branch=master)
+
+## Setup
+
+Edit your Gemfile:
+
+```ruby
+gem "rails-settings-cached"
+```
+
+Generate your settings:
+
+```bash
+$ rails g settings:install
+```
+
+If you want custom model name:
+
+```bash
+$ rails g settings:install SiteConfig
+```
+
+Now just put that migration in the database with:
+
+```bash
+rake db:migrate
+```
+
+## Usage
+
+The syntax is easy.  First, lets create some settings to keep track of:
+
+```ruby
+Setting.admin_password = 'supersecret'
+Setting.date_format    = '%m %d, %Y'
+Setting.cocktails      = ['Martini', 'Screwdriver', 'White Russian']
+Setting.foo            = 123
+Setting.credentials    = { :username => 'tom', :password => 'secret' }
+```
+
+Now lets read them back:
+
+```ruby
+Setting.foo            # returns 123
+```
+
+Changing an existing setting is the same as creating a new setting:
+
+```ruby
+Setting.foo = 'super duper bar'
+```
+
+Decide you dont want to track a particular setting anymore?
+
+```ruby
+Setting.destroy :foo
+Setting.foo            # returns nil
+```
+
+Want a list of all the settings?
+```ruby
+Setting.get_all
+```
+
+You need name spaces and want a list of settings for a give name space? Just choose your prefered named space delimiter and use `Setting.get_all` (`Settings.all` for # Rails 3.x and 4.0.x) like this:
+
+```ruby
+Setting['preferences.color'] = :blue
+Setting['preferences.size'] = :large
+Setting['license.key'] = 'ABC-DEF'
+# Rails 4.1.x
+Setting.get_all('preferences.')
+# Rails 3.x and 4.0.x
+Setting.all('preferences.')
+# returns { 'preferences.color' => :blue, 'preferences.size' => :large }
+```
+
+## Extend a model
+
+Settings may be bound to any existing ActiveRecord object. Define this association like this:
+Notice! is not do caching in this version.
+
+```ruby
+class User < ActiveRecord::Base
+  include RailsSettings::Extend
+end
+```
+
+Then you can set/get a setting for a given user instance just by doing this:
+
+```ruby
+user = User.find(123)
+user.settings.color = :red
+user.settings.color # returns :red
+user.settings.get_all
+# { "color" => :red }
+```
+
+If you want to find users having or not having some settings, there are named scopes for this:
+
+```ruby
+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.get_all == {})
+
+User.without_settings('color')
+# returns a scope of users having no 'color' setting (means user.settings.color == nil)
+```
+
+## Default settings
+
+Sometimes you may want define default settings.
+
+RailsSettings has generate a config YAML file in:
+
+```yml
+# config/app.yml
+defaults: &defaults
+  github_token: "123456"
+  twitter_token: "<%= ENV["TWITTER_TOKEN"] %>"
+  foo:
+    bar: "Foo bar"
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults
+```
+
+And you can use by `Setting` model:
+
+```
+Setting.github_token
+=> "123456"
+Setting.github_token = "654321"
+# Save into database.
+Setting.github_token
+# Read from databae / caching.
+=> "654321"
+Setting['foo.bar']
+=> 'Foo bar'
+```
+
+NOTE: YAML setting it also under the cache scope, when you restart Rails application, cache will expire,
+      so when you want change default config, you need restart Rails application server.
+
+### Caching flow:
+
+```
+Setting.foo -> Check Cache -> Exist - Write Cache -> Return
+                   |
+                Check DB -> Exist -> Write Cache -> Return
+                   |
+               Check Default -> Exist -> Write Cache -> Return
+                   |
+               Return nil
+```
+
+## Change cache key
+
+```ruby
+class Setting < RailsSettings::Base
+  cache_prefix { 'you-prefix' }
+  ...
+end
+```
+
+-----
+
+## How to create a list, form to manage Settings?
+
+If you want create an admin interface to editing the Settings, you can try methods in follow:
+
+config/routes.rb
+
+```rb
+namespace :admin do
+  resources :settings
+end
+```
+
+
+app/controllers/admin/settings_controller.rb
+
+```rb
+module Admin
+  class SettingsController < ApplicationController
+    before_action :get_setting, only: [:edit, :update]
+
+    def index
+      @settings = Setting.get_all
+    end
+
+    def edit
+    end
+
+    def update
+      if @setting.value != params[:setting][:value]
+        @setting.value = YAML.load(params[:setting][:value])
+        @setting.save
+        redirect_to admin_settings_path, notice: 'Setting has updated.'
+      else
+        redirect_to admin_settings_path
+      end
+    end
+
+    def get_setting
+      @setting = Setting.find_by(var: params[:id]) || Setting.new(var: params[:id])
+      @setting[:value] = Setting[params[:id]]
+    end
+  end
+end
+```
+
+app/views/admin/settings/index.html.erb
+
+```erb
+<table>
+  <tr>
+    <th>Key</th>
+    <th></th>
+  </tr>
+  <% @settings.each_key do |key| %>
+  <tr>
+    <td><%= key %></td>
+    <td><%= link_to 'edit', edit_admin_setting_path(key) %></td>
+  </tr>
+  <% end %>
+</table>
+```
+
+app/views/admin/settings/edit.html.erb
+
+```erb
+<%= form_for(@setting, url: admin_setting_path(@setting.var), method: 'patch') do |f| %>
+  <label><%= @setting.var %></label>
+  <%= f.textarea :value, rows: 10 %>
+  <%= f.submit %>
+<% end %>
+```
+
+Also you may use [rails-settings-ui](https://github.com/accessd/rails-settings-ui) gem
+for building ready to using interface with validations.

data/lib/generators/settings/install_generator.rb

@@ -26,7 +26,8 @@ module Settings
     end
 
     def install_setting
-      template 'model.rb', File.join('app/models', class_path, "#{file_name}.rb"), force: true
+      template 'model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+      template 'app.yml', File.join('config', "app.yml")
       migration_template 'migration.rb', 'db/migrate/create_settings.rb'
     end
   end

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

@@ -0,0 +1,13 @@
+# config/app.yml for rails-settings-cached
+defaults: &defaults
+  foo: "Foo"
+  bar: 123
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults

data/lib/generators/settings/templates/model.rb

@@ -1,3 +1,5 @@
 # RailsSettings Model
 class <%= class_name %> < RailsSettings::CachedSettings
+  source Rails.root.join("config/app.yml")
+  namespace Rails.env
 end

data/lib/rails-settings-cached.rb

@@ -1,15 +1,16 @@
-require_relative 'rails-settings/base'
 require_relative 'rails-settings/settings'
+require_relative 'rails-settings/base'
 require_relative 'rails-settings/cached_settings'
 require_relative 'rails-settings/scoped_settings'
+require_relative 'rails-settings/default'
 require_relative 'rails-settings/extend'
 require_relative 'rails-settings/version'
 
 module RailsSettings
   class Railtie < Rails::Railtie
     initializer "rails_settings.active_record.initialization" do
-      RailsSettings::CachedSettings.after_commit :rewrite_cache, on: %i(create update)
-      RailsSettings::CachedSettings.after_commit :expire_cache, on: %i(destroy)
+      RailsSettings::Base.after_commit :rewrite_cache, on: %i(create update)
+      RailsSettings::Base.after_commit :expire_cache, on: %i(destroy)
     end
   end
 end

data/lib/rails-settings/base.rb

@@ -1,111 +1,55 @@
 module RailsSettings
-  class Base < ActiveRecord::Base
-    self.table_name = table_name_prefix + 'settings'
-
-    class SettingNotFound < RuntimeError; end
-
-    cattr_accessor :defaults
-    @@defaults = {}.with_indifferent_access
-
-    belongs_to :thing, polymorphic: true
-
-    # Support old plugin
-    if defined?(SettingsDefaults::DEFAULTS)
-      @@defaults = SettingsDefaults::DEFAULTS.with_indifferent_access
+  class Base < Settings
+    def rewrite_cache
+      Rails.cache.write(cache_key, value)
     end
 
-    # get the value field, YAML decoded
-    def value
-      YAML.load(self[:value]) if self[:value].present?
+    def expire_cache
+      Rails.cache.delete(cache_key)
     end
 
-    # set the value field, YAML encoded
-    def value=(new_value)
-      self[:value] = new_value.to_yaml
+    def cache_key
+      self.class.cache_key(var, thing)
     end
 
     class << self
-      # get or set a variable with the variable as the called method
-      def method_missing(method, *args)
-        method_name = method.to_s
-        super(method, *args)
-      rescue NoMethodError
-        # set a value for a variable
-        if method_name[-1] == '='
-          var_name = method_name.sub('=', '')
-          value = args.first
-          self[var_name] = value
-        else
-          # retrieve a value
-          self[method_name]
-        end
+      def cache_prefix_by_startup
+        @cache_prefix_by_startup ||= Time.now.to_f.to_s
       end
 
-      # destroy the specified settings record
-      def destroy(var_name)
-        var_name = var_name.to_s
-        obj = object(var_name)
-        raise SettingNotFound, "Setting variable \"#{var_name}\" not found" if obj.nil?
-
-        obj.destroy
-        true
+      def cache_prefix(&block)
+        @cache_prefix = block
       end
 
-      # retrieve all settings as a hash (optionally starting with a given namespace)
-      def get_all(starting_with = nil)
-        vars = thing_scoped.select('var, value')
-        vars = vars.where("var LIKE '#{starting_with}%'") if starting_with
-
-        result = {}
-        vars.each do |record|
-          result[record.var] = record.value
-        end
-        default_keys = @@defaults.keys
-        default_keys = default_keys.select {|k| k.start_with? starting_with } if starting_with
-        result.merge! @@defaults.slice(*(default_keys - result.keys))
-
-        result.with_indifferent_access
+      def cache_key(var_name, scope_object)
+        scope = ["rails_settings_cached", cache_prefix_by_startup]
+        scope << @cache_prefix.call if @cache_prefix
+        scope << "#{scope_object.class.name}-#{scope_object.id}" if scope_object
+        scope << var_name.to_s
+        scope.join('/')
       end
 
-      def where(sql = nil)
-        vars = thing_scoped.where(sql) if sql
-        vars
-      end
-
-      # get a setting value by [] notation
-      def [](var_name)
-        object(var_name).try(:value) || @@defaults[var_name.to_s]
+      def [](key)
+        val = Rails.cache.fetch(cache_key(key, @object)) do
+          super(key)
+        end
+        val
       end
 
       # set a setting value by [] notation
       def []=(var_name, value)
-        var_name = var_name.to_s
+        super
 
-        record = object(var_name) || thing_scoped.new(var: var_name)
-        record.value = value
-        record.save!
+        Rails.cache.write(cache_key(var_name, @object),value)
 
         value
       end
 
-      def 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 object(var_name)
-        thing_scoped.where(var: var_name.to_s).first
-      end
-
-      def thing_scoped
-        unscoped.where('thing_type is NULL and thing_id is NULL')
+      def save_default(key, value)
+        Kernel.warn 'DEPRECATION WARNING: RailsSettings save_default is deprecated and it will removed in 0.7.0. ' <<
+                    'Please use YAML file for default setting.'
+        return false unless self[key].nil?
+        self[key] = value
       end
     end
   end

data/lib/rails-settings/cached_settings.rb

@@ -1,54 +1,9 @@
 module RailsSettings
   class CachedSettings < Base
-    def rewrite_cache
-      Rails.cache.write(cache_key, value)
-    end
-
-    def expire_cache
-      Rails.cache.delete(cache_key)
-    end
-
-    def cache_key
-      self.class.cache_key(var, thing)
-    end
-
-    class << self
-      def cache_prefix(&block)
-        @cache_prefix = block
-      end
-
-      def cache_key(var_name, scope_object)
-        scope = "rails_settings_cached:"
-        scope << "#{@cache_prefix.call}:" if @cache_prefix
-        scope << "#{scope_object.class.name}-#{scope_object.id}:" if scope_object
-        scope << "#{var_name}"
-      end
-
-      def [](var_name)
-        value = Rails.cache.fetch(cache_key(var_name, @object)) do
-          super(var_name)
-        end
-
-        if value.nil?
-          @@defaults[var_name.to_s] if value.nil?
-        else
-          value
-        end
-      end
-
-      # set a setting value by [] notation
-      def []=(var_name, value)
-        super
-
-        Rails.cache.write(cache_key(var_name, @object),value)
-
-        value
-      end
-
-      def save_default(key, value)
-        return false unless self[key].nil?
-        self[key] = value
-      end
+    def self.inherited(subclass)
+      Kernel.warn 'DEPRECATION WARNING: RailsSettings::CachedSettings is deprecated and it will removed in 0.7.0. ' <<
+                  'Please use RailsSettings::Base instead.'
+      super(subclass)
     end
   end
 end

data/lib/rails-settings/default.rb

@@ -0,0 +1,43 @@
+module RailsSettings
+  class Default < ::Hash
+    class MissingKey < StandardError; end
+
+    class << self
+      def enabled?
+        source_path && File.exists?(source_path)
+      end
+
+      def source(value = nil)
+        @source ||= value
+      end
+
+      def source_path
+        @source || Rails.root.join('config/app.yml')
+      end
+
+      def [](key)
+        # foo.bar.dar Nested fetch value
+        keys = key.to_s.split('.')
+        val = instance
+        keys.each do |k|
+          val = val.fetch(k.to_s, nil)
+          break if val.nil?
+        end
+        val
+      end
+
+      def instance
+        return @instance if defined? @instance
+        @instance = new
+        @instance
+      end
+    end
+
+    def initialize
+      content = open(self.class.source_path).read
+      hash = content.empty? ? {} : YAML.load(ERB.new(content).result).to_hash
+      hash = hash[Rails.env] || {}
+      self.replace hash
+    end
+  end
+end

data/lib/rails-settings/scoped_settings.rb

@@ -1,5 +1,5 @@
 module RailsSettings
-  class ScopedSettings < CachedSettings
+  class ScopedSettings < Base
     def self.for_thing(object)
       @object = object
       self

data/lib/rails-settings/settings.rb

@@ -1,9 +1,119 @@
 module RailsSettings
-  class Settings < Base
-    def self.inherited(subclass)
-      Kernel.warn 'DEPRECATION WARNING: RailsSettings::Settings is deprecated and it will removed in 0.6.0. ' <<
-                  'Please use RailsSettings::Base instead.'
-      super(subclass)
+  class Settings < ActiveRecord::Base
+    self.table_name = table_name_prefix + 'settings'
+
+    class SettingNotFound < RuntimeError; end
+
+    belongs_to :thing, polymorphic: true
+
+    # get the value field, YAML decoded
+    def value
+      YAML.load(self[:value]) if self[:value].present?
+    end
+
+    # set the value field, YAML encoded
+    def value=(new_value)
+      self[:value] = new_value.to_yaml
+    end
+
+    class << self
+      # get or set a variable with the variable as the called method
+      def method_missing(method, *args)
+        method_name = method.to_s
+        super(method, *args)
+      rescue NoMethodError
+        # set a value for a variable
+        if method_name[-1] == '='
+          var_name = method_name.sub('=', '')
+          value = args.first
+          self[var_name] = value
+        else
+          # retrieve a value
+          self[method_name]
+        end
+      end
+
+      # destroy the specified settings record
+      def destroy(var_name)
+        var_name = var_name.to_s
+        obj = object(var_name)
+        raise SettingNotFound, "Setting variable \"#{var_name}\" not found" if obj.nil?
+
+        obj.destroy
+        true
+      end
+
+      # retrieve all settings as a hash (optionally starting with a given namespace)
+      def get_all(starting_with = nil)
+        vars = thing_scoped.select('var, value')
+        vars = vars.where("var LIKE '#{starting_with}%'") if starting_with
+
+        result = {}
+        vars.each do |record|
+          result[record.var] = record.value
+        end
+
+        defaults = {}
+        if Default.enabled?
+          defaults = starting_with.nil? ? Default.instance : Default.instance.fetch(starting_with, {})
+        end
+
+        result.merge! defaults
+
+        result.with_indifferent_access
+      end
+
+      def where(sql = nil)
+        vars = thing_scoped.where(sql) if sql
+        vars
+      end
+
+      # get a setting value by [] notation
+      def [](var_name)
+        if var = object(var_name)
+          val = var.value
+        elsif Default.enabled?
+          val = Default[var_name]
+        else
+          val = nil
+        end
+        val
+      end
+
+      # set a setting value by [] notation
+      def []=(var_name, value)
+        var_name = var_name.to_s
+
+        record = object(var_name) || thing_scoped.new(var: var_name)
+        record.value = value
+        record.save!
+
+        value
+      end
+
+      def 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 object(var_name)
+        thing_scoped.where(var: var_name.to_s).first
+      end
+
+      def thing_scoped
+        unscoped.where('thing_type is NULL and thing_id is NULL')
+      end
+
+      def source(filename)
+        Default.source(filename)
+      end
     end
   end
 end

data/lib/rails-settings/version.rb

@@ -1,7 +1,7 @@
 module RailsSettings
   class << self
     def version
-      "0.5.6"
+      "0.6.0"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-settings-cached
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.6.0
 platform: ruby
 authors:
 - Jason Lee
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-11 00:00:00.000000000 Z
+date: 2016-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -40,11 +40,13 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/generators/settings/install_generator.rb
+- lib/generators/settings/templates/app.yml
 - lib/generators/settings/templates/migration.rb
 - lib/generators/settings/templates/model.rb
 - lib/rails-settings-cached.rb
 - lib/rails-settings/base.rb
 - lib/rails-settings/cached_settings.rb
+- lib/rails-settings/default.rb
 - lib/rails-settings/extend.rb
 - lib/rails-settings/scoped_settings.rb
 - lib/rails-settings/settings.rb