rails-settings-cached 0.7.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eba484df56932a47956229096367746c7ffdeb979c61e2f9bcadbad09c0fd0a6
-  data.tar.gz: 73ce168eead5d2627323f5944d2c7ee8629c85df602e3b432afdcb05ee29247a
+  metadata.gz: e89d0b87824703140e5d9182ade7936b22045bde791ba86d805dfbde9614f7b7
+  data.tar.gz: 2a3643dd2c6b3b837c3a4b1361651ca0a5b468336e038a38d1aaaa3bc659e151
 SHA512:
-  metadata.gz: 26f409db40e28e6febeba959cc27a127d6caa531d66974792efc7f1e4cf7ee8d0ca1e21130d6c874937ed645b24929e44094fd351add876f5471c0f37bf4a28d
-  data.tar.gz: 02d122fcc7346aac33f12cf470462bb283602d277cd2fc09c1cba40c4d597ccd4e65527572e7ebd523535c7fe92bcf948a99ead45f1f3f6dd7420ba95703d2b0
+  metadata.gz: e6b9209c170d1b5d34b62496533936c4e8598bc963fb5bd1fbb3a8c5b86424e6c7986fb300eb4aebc89ce7e13f86d083588bef06e93c5c6927b18ccf2465e5e6
+  data.tar.gz: 7b7b05d0794663008292b3630c99c160f8fc54cc0b9e8b958d46052cb63ce94f9eff4d012d06b2676551cfc805502d890e5313a887d3611bfb6fdbd0ffb2d3d9

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Alex Wayne
+Some additional features added 2009 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

@@ -1,12 +1,15 @@
 # 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
+This 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.
 
+> 🚨 BREAK CHANGES WARNING:
+> rails-settings-cached 2.x has redesign the API, the new version will compatible with the stored setting values by older version.
+> When you wants to upgrade 2.x, you must read the README again, and follow guides to change your Setting model.
+
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/rails-settings-cached.svg)](https://rubygems.org/gems/rails-settings-cached) [![CI Status](https://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)
@@ -41,11 +44,23 @@ You will get `app/models/setting.rb`
 
 ```rb
 class Setting < RailsSettings::Base
-  source Rails.root.join("config/app.yml")
   # cache_prefix { "v1" }
+
+  field :host, default: "http://example.com"
+  field :readonly_item, type: :integer, default: 100, readonly: true
+  field :user_limits, type: :integer, default: 20
+  field :admin_emails, type: :array, default: %w[admin@rubyonrails.org]
+  field :captcha_enable, type: :boolean, default: 1
+  field :notification_options, type: :hash, default: {
+    send_all: true,
+    logging: true,
+    sender_email: "foo@bar.com"
+  }
 end
 ```
 
+You must use `field` method to statement the setting keys, otherwice you can't use it.
+
 Now just put that migration in the database with:
 
 ```bash
@@ -57,154 +72,92 @@ rake db:migrate
 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' }
+irb > Setting.host
+"http://example.com"
+irb > Setting.host = "https://your-host.com"
+irb > Setting.host
+"https://your-host.com"
+
+irb > Setting.user_limits
+20
+irb > Setting.user_limits = "30"
+irb > Setting.user_limits
+30
+irb > Setting.user_limits = 45
+irb > Setting.user_limits
+45
+
+irb > Setting.captcha_enable
+1
+irb > Setting.captcha_enable?
+true
+irb > Setting.captcha_enable = "0"
+irb > Setting.captcha_enable
+false
+irb > Setting.captcha_enable = "1"
+irb > Setting.captcha_enable
+true
+irb > Setting.captcha_enable = "false"
+irb > Setting.captcha_enable
+false
+irb > Setting.captcha_enable = "true"
+irb > Setting.captcha_enable
+true
+irb > Setting.captcha_enable?
+true
+
+irb > Setting.admin_emails
+["admin@rubyonrails.org"]
+irb > Setting.admin_emails = %w[foo@bar.com bar@dar.com]
+irb > Setting.admin_emails
+["foo@bar.com", "bar@dar.com"]
+irb > Setting.admin_emails = "huacnlee@gmail.com,admin@admin.com\nadmin@rubyonrails.org"
+irb > Setting.admin_emails
+["huacnlee@gmail.com", "admin@admin.com", "admin@rubyonrails.org"]
+
+irb > Setting.notification_options
+{
+  send_all: true,
+  logging: true,
+  sender_email: "foo@bar.com"
+}
+irb > Setting.notification_options = {
+  sender_email: "notice@rubyonrails.org"
+}
+irb > Setting.notification_options
+{
+  sender_email: "notice@rubyonrails.org"
+}
 ```
 
-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
+Setting.host -> Check Cache -> Exist - Get value of key for cache -> Return
                    |
-               Check Default -> Exist -> Write Cache -> Return
+                Fetch all key and values from DB -> Write Cache -> Get value of key for cache -> return
                    |
-               Return nil
+                Return default value or nil
 ```
 
+In each Setting keys call, we will load the cache/db and save in Thread.current for avoid hit cache/db.
+
+Each key update will expires the cache, so do not add some frequent update key.
+
 ## Change cache key
 
-When `config/app.yml` has changed, you may need change the cache prefix to expires caches.
+Some times you may need to force update cache, now you can use `cache_prefix`
 
 ```ruby
 class Setting < RailsSettings::Base
-  cache_prefix { 'you-prefix' }
+  cache_prefix { "you-prefix" }
   ...
 end
 ```
 
 -----
 
-## How to create a list, form to manage Settings?
+## How to manage Settings in admin interface?
 
 If you want create an admin interface to editing the Settings, you can try methods in follow:
 
@@ -224,61 +177,57 @@ module Admin
   class SettingsController < ApplicationController
     before_action :get_setting, only: [:edit, :update]
 
-    def index
-      @settings = Setting.get_all
-    end
-
-    def edit
+    def show
     end
 
-    def update
-      if @setting.value != params[:setting][:value]
-        @setting.value = params[:setting][:value]
-        @setting.save
-        redirect_to admin_settings_path, notice: 'Setting has updated.'
-      else
-        redirect_to admin_settings_path
+    def create
+      setting_params.keys.each do |key|
+        next if key.to_s == "site_logo"
+        Setting.send("#{key}=", setting_params[key].strip) unless setting_params[key].nil?
       end
+      redirect_to admin_settings_path(notice: "Setting was successfully updated.")
     end
 
-    def get_setting
-      @setting = Setting.find_by(var: params[:id]) || Setting.new(var: params[:id])
-    end
+
+    private
+      def setting_params
+        params.require(:setting).permit(:host, :user_limits, :admin_emails,
+          :captcha_enable, :notification_options)
+      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
+app/views/admin/settings/show.html.erb
 
 ```erb
-<%= form_for(@setting, url: admin_setting_path(@setting.var), method: 'patch') do |f| %>
-  <label><%= @setting.var %></label>
-  <%= f.text_area :value, rows: 10 %>
-  <%= f.submit %>
+<%= form_for(Setting.new, url: admin_settings_path) do |f| %>
+  <div class="form-group">
+    <label class="control-label">Host</label>
+    <%= f.text_field :host, value: Setting.host, class: "form-control", placeholder: "http://localhost"  %>
+  </div>
+
+  <div class="form-group form-checkbox">
+    <label>
+      <%= f.check_box :captcha_enable, checked: Setting.captcha_enable? %>
+      Enable/Disable Captcha
+    </label>
+  </div>
+
+  <div class="form-group">
+    <label class="control-label">Admin Emails</label>
+    <%= f.text_area :admin_emails, value: Setting.admin_emails.join("\n"), class: "form-control" %>
+  </div>
+
+  <div class="form-group">
+    <label class="control-label">Notification options</label>
+    <%= f.text_area :notification_options, value: YAML.dump(Setting.notification_options), class: "form-control", style: "height: 180px;"  %>
+    <div class="form-text">
+      Use YAML format to config the SMTP_html
+    </details>
 <% end %>
 ```
 
-Also you may use [rails-settings-ui](https://github.com/accessd/rails-settings-ui) gem
-for building ready to using interface with validations,
-or [activeadmin_settings_cached](https://github.com/artofhuman/activeadmin_settings_cached) gem if you use [activeadmin](https://github.com/activeadmin/activeadmin).
-
 ## Use case:
 
 - [ruby-china/ruby-china](https://github.com/ruby-china/ruby-china)

data/Rakefile

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Rails Settings Cached"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+  t.warning = false
+end
+
+task default: :test

data/lib/generators/settings/install_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators"
 require "rails/generators/migration"
 
@@ -27,7 +29,6 @@ module Settings
 
     def install_setting
       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", migration_version: migration_version
     end
 

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

@@ -3,12 +3,10 @@ class CreateSettings < ActiveRecord::Migration<%= migration_version %>
     create_table :settings do |t|
       t.string  :var,        null: false
       t.text    :value,      null: true
-      t.integer :thing_id,   null: true
-      t.string  :thing_type, null: true, limit: 30
       t.timestamps
     end
 
-    add_index :settings, %i(thing_type thing_id var), unique: true
+    add_index :settings, %i(var), unique: true
   end
 
   def self.down

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

@@ -1,7 +1,10 @@
 # RailsSettings Model
 class <%= class_name %> < RailsSettings::Base
-  source Rails.root.join("config/app.yml")
+  cache_prefix { "v1" }
 
-  # When config/app.yml has changed, you need change this prefix to v2, v3 ... to expires caches
-  # cache_prefix { "v1" }
+  # Define your fields
+  # field :host, type: :string, default: "http://localhost:3000"
+  # field :default_locale, default: "en", type: :string
+  # field :confirmable_enable, default: "0", type: :boolean
+  # field :admin_emails, default: "admin@rubyonrails.org", type: :array
 end

data/lib/rails-settings/base.rb

@@ -1,44 +1,121 @@
+# frozen_string_literal: true
+
 module RailsSettings
-  class Base < Settings
-    def rewrite_cache
-      Rails.cache.write(cache_key, value)
+  class Base < ActiveRecord::Base
+    class SettingNotFound < RuntimeError; end
+
+    SEPARATOR_REGEXP = /[\s,]/
+    self.table_name = table_name_prefix + "settings"
+
+    # get the value field, YAML decoded
+    def value
+      YAML.load(self[:value]) if self[:value].present?
     end
 
-    def expire_cache
-      Rails.cache.delete(cache_key)
+    # set the value field, YAML encoded
+    def value=(new_value)
+      self[:value] = new_value.to_yaml
     end
 
-    def cache_key
-      self.class.cache_key(var, thing)
+    def expire_cache
+      Thread.current[:rails_settings_all_settings] = nil
+      Rails.cache.delete(self.class.cache_key)
     end
 
     class << self
+      def field(key, **opts)
+        _define_field(key, default: opts[:default], type: opts[:type], readonly: opts[:readonly])
+      end
+
       def cache_prefix(&block)
         @cache_prefix = block
       end
 
-      def cache_key(var_name, scope_object)
-        scope = ["rails_settings_cached"]
+      def cache_key
+        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.to_s
         scope.join("/")
       end
 
-      def [](key)
-        return super(key) unless rails_initialized?
-        val = Rails.cache.fetch(cache_key(key, @object)) do
-          super(key)
+      private
+        def _define_field(key, default: nil, type: :string, readonly: false)
+          self.class.define_method(key) do
+            val = self.send(:_value_of, key)
+            result = nil
+            if !val.nil?
+              result = val
+            else
+              result = default
+              result = default.call if default.is_a?(Proc)
+            end
+
+            result = self.send(:_covert_string_to_typeof_value, type, result)
+
+            result
+          end
+
+          unless readonly
+            self.class.define_method("#{key}=") do |value|
+              var_name = key.to_s
+
+              record = find_by(var: var_name) || new(var: var_name)
+              value = self.send(:_covert_string_to_typeof_value, type, value)
+
+              record.value = value
+              record.save!
+
+              value
+            end
+          end
+
+          if type == :boolean
+            self.class.define_method("#{key}?") do
+              val = self.send(:_value_of, key)
+              val == "true" || val == "1"
+            end
+          end
         end
-        val
-      end
 
-      # set a setting value by [] notation
-      def []=(var_name, value)
-        super
-        Rails.cache.write(cache_key(var_name, @object), value)
-        value
-      end
+        def _covert_string_to_typeof_value(type, value)
+          return value unless value.is_a?(String) || value.is_a?(Integer)
+
+          case type
+          when :boolean
+            return value == "true" || value == "1" || value == 1 || value == true
+          when :array
+            return value.split(SEPARATOR_REGEXP).reject { |str| str.empty? }
+          when :hash
+            value = YAML.load(value).to_hash rescue {}
+            value.deep_stringify_keys!
+            return value
+          when :integer
+            return value.to_i
+          else
+            value
+          end
+        end
+
+        def _value_of(var_name)
+          raise "#{self.table_name} does not exist." unless table_exists?
+
+          _all_settings[var_name.to_s]
+        end
+
+        def rails_initialized?
+          Rails.application && Rails.application.initialized?
+        end
+
+        def _all_settings
+          raise "You can use settings before Rails initialize." unless rails_initialized?
+          Thread.current[:rails_settings_all_settings] ||= begin
+            Rails.cache.fetch(self.cache_key, expires_in: 1.week) do
+              vars = unscoped.select("var, value")
+              result = {}
+              vars.each { |record| result[record.var] = record.value }
+              result.with_indifferent_access
+            end
+          end
+        end
     end
   end
 end

data/lib/rails-settings/railtie.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module RailsSettings
   class Railtie < Rails::Railtie
     initializer "rails_settings.active_record.initialization" do
-      RailsSettings::Base.after_commit :rewrite_cache, on: %i(create update)
-      RailsSettings::Base.after_commit :expire_cache, on: %i(destroy)
+      RailsSettings::Base.after_commit :expire_cache, on: %i(create update destroy)
     end
   end
 end

data/lib/rails-settings/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module RailsSettings
   class << self
     def version
-      "0.7.2"
+      "2.0.0"
     end
   end
 end

data/lib/rails-settings-cached.rb

@@ -1,8 +1,6 @@
-require_relative "rails-settings/settings"
+# frozen_string_literal: true
+
 require_relative "rails-settings/base"
-require_relative "rails-settings/scoped_settings"
-require_relative "rails-settings/default"
-require_relative "rails-settings/extend"
 require_relative "rails-settings/railtie"
 require_relative "rails-settings/version"
 

metadata

@@ -1,17 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-settings-cached
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Jason Lee
-- Squeegy
-- Georg Ledermann
-- 100hz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-08 00:00:00.000000000 Z
+date: 2019-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -45,16 +42,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.46.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.46.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -70,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -108,18 +105,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
 - README.md
+- Rakefile
 - 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/default.rb
-- lib/rails-settings/extend.rb
 - lib/rails-settings/railtie.rb
-- lib/rails-settings/scoped_settings.rb
-- lib/rails-settings/settings.rb
 - lib/rails-settings/version.rb
 homepage: https://github.com/huacnlee/rails-settings-cached
 licenses: []
@@ -132,15 +126,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Settings plugin for Rails that makes managing a table of global keys.

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

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

data/lib/rails-settings/default.rb

@@ -1,40 +0,0 @@
-require "digest/md5"
-
-module RailsSettings
-  class Default < ::Hash
-    class MissingKey < StandardError; end
-
-    class << self
-      def enabled?
-        source_path && File.exist?(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
-        return instance[key] if instance.key?(key)
-        keys = key.to_s.split(".")
-        instance.dig(*keys)
-      end
-
-      def instance
-        return @instance if defined? @instance
-        @instance = new
-      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] || {}
-      replace hash
-    end
-  end
-end

data/lib/rails-settings/extend.rb

@@ -1,34 +0,0 @@
-module RailsSettings
-  module Extend
-    extend ActiveSupport::Concern
-
-    included do
-      scope :with_settings, lambda {
-        joins("JOIN settings ON (settings.thing_id = #{table_name}.#{primary_key} AND
-                                 settings.thing_type = '#{base_class.name}')")
-          .select("DISTINCT #{table_name}.*")
-      }
-
-      scope :with_settings_for, lambda { |var|
-        joins("JOIN settings ON (settings.thing_id = #{table_name}.#{primary_key} AND
-                                 settings.thing_type = '#{base_class.name}') AND settings.var = '#{var}'")
-      }
-
-      scope :without_settings, lambda {
-        joins("LEFT JOIN settings ON (settings.thing_id = #{table_name}.#{primary_key} AND
-                                      settings.thing_type = '#{base_class.name}')")
-          .where("settings.id IS NULL")
-      }
-
-      scope :without_settings_for, lambda { |var|
-        where("settings.id IS NULL")
-          .joins("LEFT JOIN settings ON (settings.thing_id = #{table_name}.#{primary_key} AND
-                                       settings.thing_type = '#{base_class.name}') AND settings.var = '#{var}'")
-      }
-    end
-
-    def settings
-      ScopedSettings.for_thing(self)
-    end
-  end
-end

data/lib/rails-settings/scoped_settings.rb

@@ -1,12 +0,0 @@
-module RailsSettings
-  class ScopedSettings < Base
-    def self.for_thing(object)
-      @object = object
-      self
-    end
-
-    def self.thing_scoped
-      unscoped.where(thing_type: @object.class.base_class.to_s, thing_id: @object.id)
-    end
-  end
-end

data/lib/rails-settings/settings.rb

@@ -1,120 +0,0 @@
-module RailsSettings
-  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
-      # rubocop:disable Style/MethodMissing
-      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 { |record| result[record.var] = record.value }
-        result.reverse_merge!(default_settings(starting_with))
-        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)
-        return Default[var_name] unless rails_initialized?
-
-        val = object(var_name)
-        return val.value if val
-        return Default[var_name] if Default.enabled?
-      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)
-        return nil unless table_exists?
-        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
-
-      def rails_initialized?
-        Rails.application && Rails.application.initialized?
-      end
-
-      private
-
-      def default_settings(starting_with = nil)
-        return {} unless Default.enabled?
-        return Default.instance if starting_with.nil?
-        Default.instance.select { |key, _| key.to_s.start_with?(starting_with) }
-      end
-    end
-  end
-end