remove dry-rb + compatible with new ruby/rails

Author: accessd

.gitignore

@@ -10,3 +10,4 @@ spec/dummy/db/*.sqlite3
 spec/dummy/log/*.log
 spec/dummy/tmp/
 coverage/
+.ruby-version

CHANGES.md

@@ -2,6 +2,12 @@
 
 * YOUR CONTRIBUTIONS HERE
 
+## v2.0.0
+
+* removing dry-rb
+* add rails-settings-cached as dependency
+* add support for ruby 3.1 and new Rails
+
 ## v1.3.5
 * use dry-validation < 1.0
 

Gemfile

@@ -1,8 +1,9 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 
 gemspec
 
 group :development, :test do
-  gem "sqlite3"
-  gem "rails-settings-cached", '0.5.4'
+  gem 'pry'
+  gem 'sqlite3'
+  gem 'rails-settings-cached', '2.8.2'
 end

README.md

@@ -6,32 +6,20 @@ Rails settings UI
 [![Code Climate](https://codeclimate.com/github/accessd/rails-settings-ui/badges/gpa.svg)](https://codeclimate.com/github/accessd/rails-settings-ui)
 [![Test Coverage](https://codeclimate.com/github/accessd/rails-settings-ui/badges/coverage.svg)](https://codeclimate.com/github/accessd/rails-settings-ui/coverage)
 
-A Rails Engine to manage your application settings. Includes validation. Compatible with Rails 5.
-It compatible with [rails-settings-cached](https://github.com/huacnlee/rails-settings-cached) gem.
+A Rails Engine to manage your application settings. Includes validation. Compatible with Rails 7.
+It depends on [rails-settings-cached](https://github.com/huacnlee/rails-settings-cached) gem.
 
 Preview:
 
 ![ScreenShot](https://raw.github.com/accessd/rails-settings-ui/master/doc/img/settings-page.png)
 
-Live example: http://rails-settings-ui.herokuapp.com/
-
 How to
 -----
 
 Add to Gemfile
 
     gem 'rails-settings-ui'
 
-then add
-
-    gem 'rails-settings-cached'
-
-or
-
-    gem 'rails-settings'
-
-or your fork of rails-settings.
-
 If you want to use bootstrap interface you need also include bootstrap stylesheets to your app.
 You may use [bootstrap-sass](https://github.com/twbs/bootstrap-sass) gem for that.
 
@@ -115,55 +103,24 @@ if you don't specify labels in locale config, you'll get:
   settings:
     attributes:
       launch_mode:
-        help_block: 'Rocket launch mode'
+        help_block: 'launch mode'
 ```
 
 Validations
 -------------
 
-To validation work is required the default settings in the proper format, eg:
+Validations work based on default value for setting or by explicitly specify type for setting, eg:
 
-For rails-settings-cached up to 0.5.8:
+    class Settings < RailsSettings::Base
+      cache_prefix { "v1" }
 
-    class Settings < RailsSettings::CachedSettings
-      defaults[:company_name] = "Company name"
-      defaults[:head_name] = "Head name"
-      defaults[:manager_premium] = 19
-      defaults[:show_contract_fields] = true
-      defaults[:launch_mode] = [:auto, :manual]
+      field :company_name, type: :string, default: "Company name"
+      field :head_name, default: "Head name"
+      field :manager_premium, default: 19
+      field :show_contract_fields, default: true
+      field :launch_mode, default: [:auto, :manual]
     end
 
-For rails-settings-cached with version >= 0.6.0 default settings moved to YAML config file (config/app.yml), so
-defaults should looks like:
-
-```yaml
-  defaults: &defaults
-    rocket_name: "Foo"
-    limit: 123
-    launch_mode:
-      - auto
-      - manual
-    spaceports:
-      - plesetsk
-      - baikonur
-    style:
-      border_color: 'e0e0e0'
-      block_color: 'ffffff'
-      title:
-        font: "Tahoma"
-        size: "12"
-        color: '107821'
-
-  development:
-    <<: *defaults
-
-  test:
-    <<: *defaults
-
-  production:
-    <<: *defaults
-```
-
 Views
 -------------
 
@@ -192,10 +149,10 @@ Alternatively, to have custom rules just for rails-setting-ui you can:
 
     Rails.application.config.to_prepare do
       RailsSettingsUi::ApplicationController.module_eval do
-        before_filter :check_settings_permissions # for Rails 3
-        before_action :check_settings_permissions # starting from Rails 4
+        before_action :check_settings_permissions
 
         private
+
         def check_settings_permissions
           render status: 403 unless current_user && can_manage_settings?(current_user)
         end

app/controllers/rails_settings_ui/settings_controller.rb

@@ -1,16 +1,24 @@
 class RailsSettingsUi::SettingsController < RailsSettingsUi::ApplicationController
   include RailsSettingsUi::SettingsHelper
   before_action :collection
-  before_action :validate_settings, only: :update_all
+  before_action :cast_settings_params, only: :update_all
 
   def index
   end
 
   def update_all
-    if @errors.any?
+    if @casted_settings[:errors].any?
+      @errors = @casted_settings[:errors]
       render :index
     else
-      coerced_values.each { |name, value| RailsSettingsUi.settings_klass[name] = value }
+      @casted_settings.map do |name, value|
+        next if name == 'errors'
+
+        sc = RailsSettingsUi.setting_config(name)
+        next if sc[:readonly] == true
+
+        RailsSettingsUi.settings_klass.public_send("#{name}=", value)
+      end
       flash[:success] = t('settings.index.settings_saved')
       redirect_to [:settings]
     end
@@ -19,23 +27,19 @@ def update_all
   private
 
   def collection
-    all_settings_without_ignored = all_settings.reject{ |name, _description| RailsSettingsUi.ignored_settings.include?(name.to_sym) }
+    all_settings_without_ignored = all_settings.reject do |name, _description|
+      RailsSettingsUi.ignored_settings.include?(name.to_sym)
+    end
     @settings = Hash[all_settings_without_ignored]
     @errors = {}
   end
 
-  def validate_settings
-    # validation schema accepts hash (http://dry-rb.org/gems/dry-validation/forms/) so we're converting
-    # ActionController::Parameters => ActiveSupport::HashWithIndifferentAccess
-    @errors = RailsSettingsUi::SettingsFormValidator.new(default_settings, settings_from_params).errors
-  end
-
-  def coerced_values
-    RailsSettingsUi::SettingsFormCoercible.new(default_settings, settings_from_params).coerce!
+  def cast_settings_params
+    @casted_settings = RailsSettingsUi::TypeConverter.cast(settings_from_params)
   end
 
   def settings_from_params
-    settings_params = params['settings'].deep_dup
+    settings_params = params['settings'].deep_dup || {}
     if settings_params.respond_to?(:to_unsafe_h)
       settings_params.to_unsafe_h
     else

app/helpers/rails_settings_ui/settings_helper.rb

@@ -70,20 +70,15 @@ def message_for_default_value_missing
     content_tag(:span, I18n.t("settings.errors.default_missing"), class: "label label-warning")
   end
 
-  def get_collection_method
-    case Rails::VERSION::STRING
-    when /4\.0\.\d+/ || /3\..*/
-      :all
-    else
-      :get_all
-    end
-  end
-
   def default_value_for_setting(setting_name)
     RailsSettingsUi.defaults_for_settings.with_indifferent_access[setting_name.to_sym]
   end
 
   def all_settings
-    RailsSettingsUi.settings_klass.public_send(get_collection_method)
+    stored_settings = RailsSettingsUi.settings_klass.public_send(:all).each_with_object({}) do |s, hsh|
+      hsh[s.var] = s.value
+    end.with_indifferent_access
+
+    stored_settings.merge(RailsSettingsUi.default_settings.merge(stored_settings))
   end
 end

config/locales/en.yml

@@ -1,8 +1,7 @@
 en:
   errors:
-    form_hash?: Invalid hash
-    int?: Invalid numeric
-    float?: Invalid numeric
+    invalid_hash: Invalid hash
+    invalid_numeric: Invalid numeric
   settings:
     index:
       title: Settings

lib/rails-settings-ui.rb

@@ -3,8 +3,7 @@
 require 'rails-settings-ui/route_delegator'
 require 'rails-settings-ui/version'
 
-require "rails-settings-ui/settings_form_validator"
-require "rails-settings-ui/settings_form_coercible"
+require "rails-settings-ui/type_converter"
 
 module RailsSettingsUi
   mattr_accessor :parent_controller
@@ -45,12 +44,21 @@ def settings_klass
       settings_class.constantize
     end
 
+    def setting_config(name)
+      defined_fields = RailsSettingsUi.settings_klass.public_send(:all).defined_fields
+      defined_fields.find { |s| s[:key] == name }
+    end
+
     def default_settings
-      if Gem.loaded_specs['rails-settings-cached'].version.to_s >= '0.6.0'
-        settings = RailsSettings::Default.instance.with_indifferent_access
+      rsc_version = Gem.loaded_specs['rails-settings-cached'].version.to_s
+
+      if rsc_version >= '2.7.0'
+        defined_fields = RailsSettingsUi.settings_klass.public_send(:all).defined_fields
+        settings = defined_fields.each_with_object({}) { |s, hsh| hsh[s[:key]] = s[:default] }.with_indifferent_access
         settings.reject { |name, _description| ignored_settings.include?(name.to_sym) }
       else
-        RailsSettingsUi.settings_klass.defaults
+        settings = RailsSettings::Default.instance.with_indifferent_access
+        settings.reject { |name, _description| ignored_settings.include?(name.to_sym) }
       end
     end
   end

lib/rails-settings-ui/type_converter.rb

@@ -0,0 +1,78 @@
+require_relative "value_types/string"
+require_relative "value_types/symbol"
+require_relative "value_types/fixnum"
+require_relative "value_types/hash"
+require_relative "value_types/duration"
+require_relative "value_types/float"
+require_relative "value_types/array"
+require_relative "value_types/boolean"
+
+module RailsSettingsUi
+  class UnknownDefaultValueType < StandardError;end
+
+  class TypeConverter
+    VALUE_TYPES_MAP = {
+      String => RailsSettingsUi::ValueTypes::String,
+      Symbol => RailsSettingsUi::ValueTypes::Symbol,
+      Fixnum => RailsSettingsUi::ValueTypes::Fixnum,
+      # ActiveSupport::HashWithIndifferentAccess => RailsSettingsUi::ValueTypes::Hash,
+      ActiveSupport::Duration => RailsSettingsUi::ValueTypes::Float,
+      Float => RailsSettingsUi::ValueTypes::Float,
+      Array => RailsSettingsUi::ValueTypes::Array,
+      FalseClass => RailsSettingsUi::ValueTypes::Boolean,
+      TrueClass => RailsSettingsUi::ValueTypes::Boolean,
+      boolean: RailsSettingsUi::ValueTypes::Boolean,
+      string: RailsSettingsUi::ValueTypes::String,
+      integer: RailsSettingsUi::ValueTypes::Fixnum,
+      float: RailsSettingsUi::ValueTypes::Float,
+      array: RailsSettingsUi::ValueTypes::Array,
+      hash: RailsSettingsUi::ValueTypes::Hash
+    }
+
+    def self.cast(settings)
+      errors = {}
+      settings.each do |name, value|
+        sc = RailsSettingsUi.setting_config(name.to_s)
+        type = setting_value_type(name, value, sc)
+        settings[name] = type.cast
+        if type.errors.any?
+          errors[name.to_sym] = type.errors
+        end
+      end
+      settings = set_non_presented_settings(settings)
+
+      settings[:errors] = errors
+      settings
+    end
+
+    def self.setting_value_type(name, value, setting_config)
+      default_setting_value_type = if setting_config[:type].nil? || setting_config[:type] == :string
+                                     setting_config[:default].class
+                                   else
+                                     setting_config[:type]
+                                   end
+
+      unless VALUE_TYPES_MAP.keys.include?(default_setting_value_type)
+        raise RailsSettingsUi::UnknownDefaultValueType,
+          "Unknown default value type #{default_setting_value_type} for #{name}"
+      end
+
+      # puts "--- #{name}: #{default_setting_value_type} ---"
+      setting_value_type_class = VALUE_TYPES_MAP[default_setting_value_type]
+      setting_value_type_class.new(value)
+    end
+
+    def self.set_non_presented_settings(settings)
+      RailsSettingsUi.default_settings.each do |name, value|
+        if !settings[name.to_sym].present?
+          if [TrueClass, FalseClass].include?(value.class)
+            settings[name.to_sym] = false
+          elsif [Array].include?(value.class)
+            settings[name.to_sym] = []
+          end
+        end
+      end
+      settings
+    end
+  end
+end

lib/rails-settings-ui/value_types/array.rb

@@ -0,0 +1,19 @@
+require_relative "base"
+
+module RailsSettingsUi
+  module ValueTypes
+    class Array < RailsSettingsUi::ValueTypes::Base
+      def cast
+        # Array presented in checkboxes
+        if ["Hash", "ActiveSupport::HashWithIndifferentAccess"].include?(value.class.name)
+          value.keys.map!(&:to_sym)
+        elsif value.class.name == 'ActionController::Parameters'
+          value.reject{|_,v| v!='on' }.keys.map!(&:to_sym)
+        # or in select tag
+        else
+          value.to_sym
+        end
+      end
+    end
+  end
+end