jdx-rails-settings 0.7.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6389648edb553abe574732af98fcd81201a8aee7e7573c33de3d166b31004afe
+  data.tar.gz: 4ae03fec50a981e7c7fc981310a9d56f7185ab6128561c2cc7446f77299ad046
+SHA512:
+  metadata.gz: aa24fab669e47700f7d5a3b84bcf27eacc057a10353404e24cb28be077c663346cc827f9ba73c803ceda08251085e3ed2a4d6dcb360f9f356ac2a2c4571e71c2
+  data.tar.gz: 69137ecf802735e28c073f2844ba3cea2ca18ab0b971358b2428d2307661399255a9ebc82d65739c557fbfb693a76280999f612c0b85833e58de3a5fefa7869d

data/README.md

@@ -0,0 +1,284 @@
+# 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://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
+```
+
+Or use a custom name:
+
+```bash
+$ rails g settings:install SiteConfig
+```
+
+You will get `app/models/setting.rb`
+
+```rb
+class Setting < RailsSettings::Base
+  source Rails.root.join("config/app.yml")
+  # cache_prefix { "v1" }
+end
+```
+
+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
+
+When `config/app.yml` has changed, you may need change the cache prefix to expires caches.
+
+```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 = 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])
+    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.text_area :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,
+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/lib/generators/settings/install_generator.rb

@@ -0,0 +1,42 @@
+require "rails/generators"
+require "rails/generators/migration"
+
+module Settings
+  class InstallGenerator < Rails::Generators::NamedBase
+    desc "Generate RailsSettings files."
+    include Rails::Generators::Migration
+
+    argument :name, type: :string, default: "setting"
+
+    source_root File.expand_path("../templates", __FILE__)
+
+    @@migrations = false
+
+    def self.next_migration_number(dirname) #:nodoc:
+      if ActiveRecord::Base.timestamped_migrations
+        if @@migrations
+          (current_migration_number(dirname) + 1)
+        else
+          @@migrations = true
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        end
+      else
+        format "%.3d", current_migration_number(dirname) + 1
+      end
+    end
+
+    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
+
+    def rails5?
+      Rails.version.start_with? "5"
+    end
+
+    def migration_version
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]" if rails5?
+    end
+  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/migration.rb

@@ -0,0 +1,17 @@
+class CreateSettings < ActiveRecord::Migration<%= migration_version %>
+  def self.up
+    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
+  end
+
+  def self.down
+    drop_table :settings
+  end
+end

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

@@ -0,0 +1,7 @@
+# RailsSettings Model
+class <%= class_name %> < RailsSettings::Base
+  source Rails.root.join("config/app.yml")
+
+  # When config/app.yml has changed, you need change this prefix to v2, v3 ... to expires caches
+  # cache_prefix { "v1" }
+end

data/lib/rails-settings-cached.rb

@@ -0,0 +1,11 @@
+require "sinatra/activerecord"
+require_relative "rails-settings/settings"
+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"
+
+module RailsSettings
+end

data/lib/rails-settings/base.rb

@@ -0,0 +1,61 @@
+module RailsSettings
+  class Base < Settings
+    def rewrite_cache
+      self.class.configuration.cache_store.fetch(cache_key, value)
+    end
+
+    def expire_cache
+      self.class.configuration.cache_store.delete(cache_key)
+    end
+
+    def cache_key
+      self.class.cache_key(var, thing)
+    end
+
+    class << self
+
+      attr_accessor :configuration
+
+      def configure
+        self.configuration ||= Configuration.new
+        yield(configuration)
+      end
+
+      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.to_s
+        scope.join("/")
+      end
+
+      def [](key)
+        return super(key) unless rails_initialized?
+        val = cache_store.fetch(cache_key(key, @object)) do
+          super(key)
+        end
+        val
+      end
+
+      # set a setting value by [] notation
+      def []=(var_name, value)
+        super
+        cache_store.write(cache_key(var_name, @object), value)
+        value
+      end
+
+      def cache_store
+        @cache_store ||= RailsSettings::Base.configuration.cache_store
+      end
+
+      class Configuration
+        attr_accessor :cache_store
+      end
+
+    end
+  end
+end

data/lib/rails-settings/default.rb

@@ -0,0 +1,40 @@
+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 || "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[Sinatra::Application.environment.to_s] || {}
+      replace hash
+    end
+  end
+end

data/lib/rails-settings/extend.rb

@@ -0,0 +1,34 @@
+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/railtie.rb

@@ -0,0 +1,8 @@
+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)
+    end
+  end
+end

data/lib/rails-settings/scoped_settings.rb

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,121 @@
+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?
+        true
+      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

data/lib/rails-settings/version.rb

@@ -0,0 +1,7 @@
+module RailsSettings
+  class << self
+    def version
+      "0.7.4"
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: jdx-rails-settings
+version: !ruby/object:Gem::Version
+  version: 0.7.4
+platform: ruby
+authors:
+- Jason Lee
+- Squeegy
+- Georg Ledermann
+- 100hz
+- JobAdx
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra-activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\n  This is improved from rails-settings, added caching.\n  Settings
+  plugin for Rails that makes managing a table of global key,\n  value pairs easy.
+  Think of it like a global Hash stored in you database,\n  that uses simple ActiveRecord
+  like methods for manipulation.\n\n  Keep track of any global setting that you dont
+  want to hard code into your rails app.\n  You can store any kind of object.  Strings,
+  numbers, arrays, or any object.\n  "
+email: admin@jobadx.com
+executables: []
+extensions: []
+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/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/bharthur/rails-settings-cached
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Settings plugin for Rails that makes managing a table of global keys.
+test_files: []