activeadmin_settings_cached 2.2.0 → 3.0.0

data/lib/activeadmin_settings_cached/model.rb

@@ -4,6 +4,8 @@ module ActiveadminSettingsCached
   class Model
     include ::ActiveModel::Model
 
+    NUMERIC_TYPES = %i[integer float big_decimal].freeze
+
     attr_reader :attributes
 
     def initialize(args = {})
@@ -13,71 +15,68 @@ module ActiveadminSettingsCached
       assign_attributes(merge_attributes(args))
     end
 
-    def field_name(settings_name)
-      has_key? ? "#{attributes[:key]}.#{settings_name}" : settings_name
+    # Editable fields grouped by rails-settings-cached scope
+    def fields_by_scope
+      fields.group_by { |field| field[:scope] }
     end
 
-    def field_options(settings_name, key_name)
-      default_value = defaults[settings_name]
-      value = settings[key_name]
-
-      input_opts = if default_value.is_a?(Array)
-                     {
-                       collection: default_value,
-                       selected: value,
-                     }
-                   elsif (default_value.is_a?(TrueClass) || default_value.is_a?(FalseClass)) &&
-                         display[settings_name].to_s == 'boolean'
-                     {
-                       input_html: { checked: value }, label: '', checked_value: 'true', unchecked_value: 'false'
-                     }
-                   else
-                     {
-                       input_html: { value: value, placeholder: default_value },
-                     }
-                   end
+    def fields
+      settings_model.editable_keys.map { |key| settings_model.get_field(key) }.select do |field|
+        scopes.nil? || scopes.include?(field[:scope])
+      end
+    end
 
-      { as: display[settings_name], label: false }
-        .merge!(input_opts)
+    def keys
+      fields.map { |field| field[:key] }
     end
 
-    def settings
-      data = has_key? ? load_settings_by_key : load_settings
-      return unless data
+    def field_options(key)
+      field = settings_model.get_field(key)
+      options = field[:options] || {}
+      input_html = { value: form_value(key), placeholder: format_value(field[:type], default(field)) }
 
-      ::ActiveSupport::OrderedHash[data.to_a.sort { |a, b| a.first <=> b.first }]
-    end
+      input_opts = if options[:option_values]
+                     { as: :select, collection: options[:option_values], selected: value(key), include_blank: false }
+                   else
+                     case field[:type]
+                     when :boolean
+                       # Formtastic nests the checkbox into its label, so blank it
+                       { as: :boolean, label: '', input_html: { checked: value(key) },
+                         checked_value: 'true', unchecked_value: 'false' }
+                     when :array, :hash
+                       { as: :text, input_html: input_html.merge(rows: 5) }
+                     when *NUMERIC_TYPES
+                       { as: :number, input_html: input_html }
+                     else
+                       { as: :string, input_html: input_html }
+                     end
+                   end
 
-    def defaults
-      settings_model.respond_to?(:defaults) ?
-          settings_model.defaults :
-          ::RailsSettings::Default
-    end
+      input_opts[:hint] = options[:help_text] if options[:help_text]
+      input_opts[:as] = display[key] if display[key]
 
-    def defaults_keys
-      settings_model.respond_to?(:defaults) ?
-          settings_model.defaults.keys :
-          ::RailsSettings::Default.instance.keys
+      { label: false }.merge(input_opts)
     end
 
-    def display
-      attributes[:display]
+    def value(key)
+      settings_model.public_send(key)
     end
 
-    def [](param)
-      settings_model[param]
+    # Value as rendered in the form, used to detect changes on save
+    def form_value(key)
+      format_value(settings_model.get_field(key)[:type], value(key))
     end
 
-    def []=(param, value)
-      settings_model[param] = value
+    def changed?(key, input)
+      normalize(input) != normalize(form_value(key))
     end
 
     def save(key, value)
-      if has_key?
-        settings_model.merge!(attributes[:key], { clean_key(key) => value })
-      else
-        self[key] = value
-      end
+      settings_model.public_send("#{key}=", value)
+    end
+
+    def display
+      attributes[:display]
     end
 
     def persisted?
@@ -86,22 +85,29 @@ module ActiveadminSettingsCached
 
     alias_method :to_hash, :attributes
 
-    protected
+    private
 
-    def load_settings
-      settings_model.public_send(meth, attributes[:starting_with])
+    def scopes
+      Array(attributes[:scope]).map(&:to_sym).presence
     end
 
-    def load_settings_by_key
-      self[attributes[:key]]
+    def default(field)
+      field[:default].is_a?(Proc) ? field[:default].call : field[:default]
     end
 
-    def has_key?
-      attributes[:key].present?
+    def format_value(type, value)
+      case type
+      when :array
+        Array(value).join("\n")
+      when :hash
+        value.blank? ? '' : value.to_hash.deep_stringify_keys.to_yaml.sub(/\A---\n/, '')
+      else
+        value.to_s
+      end
     end
 
-    def clean_key(key)
-      key.is_a?(Symbol) ? key : "#{key.sub("#{attributes[:key]}.", '')}"
+    def normalize(value)
+      value.to_s.gsub("\r\n", "\n").strip
     end
 
     def assign_attributes(args = {})
@@ -110,8 +116,7 @@ module ActiveadminSettingsCached
 
     def default_attributes
       {
-        starting_with: nil,
-        key: nil,
+        scope: nil,
         model_name: ::ActiveadminSettingsCached.config.model_name,
         display: ::ActiveadminSettingsCached.config.display
       }
@@ -126,13 +131,5 @@ module ActiveadminSettingsCached
     def settings_model
       attributes[:model_name]
     end
-
-    def meth
-      if Rails.version >= '4.1.0'
-        :get_all
-      else
-        :all
-      end
-    end
   end
 end

data/lib/activeadmin_settings_cached/options.rb

@@ -4,11 +4,10 @@ module ActiveadminSettingsCached
   module Options
     VALID_OPTIONS = [
       :model_name,
-      :starting_with,
+      :scope,
       :template,
       :template_object,
       :display,
-      :key,
       :title,
       :after_save
     ].freeze

data/lib/activeadmin_settings_cached/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveadminSettingsCached
-  VERSION = '2.2.0'
+  VERSION = '3.0.0'.freeze
 end

data/lib/activeadmin_settings_cached.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'activeadmin_settings_cached/model'
+require 'activeadmin_settings_cached/options'
+require 'activeadmin_settings_cached/dsl'
 require 'activeadmin_settings_cached/engine'
 
 module ActiveadminSettingsCached

data/spec/model_spec.rb

@@ -9,165 +9,120 @@ RSpec.describe ActiveadminSettingsCached::Model do
     end
   end
 
-  before(:all) do
-    Setting.merge!('some', {
-      'first_setting' => 'CCC',
-      'second_setting' => true
-    })
+  before do
+    ActiveadminSettingsCached.config.display = {}
   end
 
-  let(:all_options) do
-    {
-      model_name: 'Setting',
-      starting_with: 'base.',
-      key: nil,
-      display: {'base.first_setting' => 'string', 'base.second_setting' => 'boolean'}
-    }
-  end
-
-  let(:key_options) do
-    {
-      model_name: 'Setting',
-      starting_with: nil,
-      key: 'some',
-      display: {'some.first_setting' => 'string', 'base.second_setting' => 'boolean'}
-    }
-  end
+  subject(:object) { described_class.new(options) }
 
-  let(:no_options) do
-    {}
-  end
+  let(:options) { { model_name: 'Setting', scope: :base, display: { 'title' => 'text' } } }
 
   context '#attributes' do
-    before do
-      ActiveadminSettingsCached.config.display = {}
-    end
-
     it 'set options' do
-      object = described_class.new(all_options)
       expect(object.attributes).to eq({
-                                         starting_with: all_options[:starting_with],
-                                         key: nil,
-                                         model_name: Setting,
-                                         display: all_options[:display]
-                                       })
+                                        scope: :base,
+                                        model_name: Setting,
+                                        display: { 'title' => 'text' }
+                                      })
     end
 
-    it 'set default options' do
-      object = described_class.new(no_options)
-      expect(object.attributes).to eq({
-                                         starting_with: nil,
-                                         key: nil,
-                                         model_name: Setting,
-                                         display: {}
-                                       })
-    end
+    context 'without options' do
+      let(:options) { {} }
 
-    it 'set key options' do
-      object = described_class.new(key_options)
-      expect(object.attributes).to eq({
-                                         starting_with: nil,
-                                         key: key_options[:key],
-                                         model_name: Setting,
-                                         display: key_options[:display]
-                                       })
+      it 'set default options' do
+        expect(object.attributes).to eq({
+                                          scope: nil,
+                                          model_name: Setting,
+                                          display: {}
+                                        })
+      end
     end
   end
 
-  context '#field_name' do
-    it 'with keyed name' do
-      object = described_class.new(key_options)
-      expect(object.field_name('first_setting')).to eq('some.first_setting')
+  context '#keys' do
+    it 'returns editable keys of scope' do
+      expect(object.keys).to eq %w[title captcha_enabled user_limit tax_rate default_locale]
     end
 
-    it 'with normal name' do
-      object = described_class.new(all_options)
-      expect(object.field_name('base.first_setting')).to eq('base.first_setting')
+    context 'with several scopes' do
+      let(:options) { { scope: %i[base second] } }
+
+      it { expect(object.keys).to include('title', 'admin_emails') }
+      it { expect(object.keys).not_to include('app_name', 'secret') }
+    end
+
+    context 'without scope' do
+      let(:options) { {} }
+
+      it { expect(object.keys).to include('app_name', 'title', 'admin_emails') }
+      it { expect(object.keys).not_to include('secret') }
     end
   end
 
-  context '#field_options' do
-    it 'with default element' do
-      object = described_class.new(all_options)
-      expect(object.field_options('base.first_setting', 'base.first_setting')).to eq({as: 'string',
-                                                                label: false,
-                                                                input_html: {value: 'AAA', placeholder: 'AAA'}
-                                                               })
+  context '#fields_by_scope' do
+    let(:options) { {} }
+
+    it 'groups fields' do
+      expect(object.fields_by_scope.keys).to eq [nil, :base, :second]
     end
+  end
+
+  context '#field_options' do
+    let(:options) { {} }
 
-    it 'with keyed element' do
-      object = described_class.new(key_options)
-      expect(object.field_options('some.first_setting', 'first_setting')).to eq({as: 'string',
-                                                                label: false,
-                                                                input_html: {value: 'CCC', placeholder: 'AAA'}
-                                                               })
+    it 'with string element' do
+      expect(object.field_options('app_name')).to eq(as: :string, label: false,
+                                                     input_html: { value: 'AAA', placeholder: 'AAA' })
     end
 
-    it 'with array element' do
-      object = described_class.new(all_options.merge({display: {'base.first_setting' => 'string',
-                                                                'base.second_setting' => 'boolean',
-                                                                'base.six_setting' => 'array'}}))
-      expect(object.field_options('base.six_setting', 'base.six_setting')).to eq({as: 'array',
-                                                              label: false,
-                                                              collection: %w(a b),
-                                                              selected: %w(a b)
-                                                             })
+    it 'with number element' do
+      expect(object.field_options('user_limit')).to eq(as: :number, label: false,
+                                                       input_html: { value: '5', placeholder: '5' })
     end
 
     it 'with boolean element' do
-      object = described_class.new(all_options)
-      expect(object.field_options('base.second_setting', 'base.second_setting')).to eq({as: 'boolean',
-                                                                 label: '',
-                                                                 input_html: {checked: true},
-                                                                 checked_value: 'true',
-                                                                 unchecked_value: 'false'
-                                                                })
+      expect(object.field_options('captcha_enabled')).to eq(as: :boolean, label: '',
+                                                            input_html: { checked: true },
+                                                            checked_value: 'true', unchecked_value: 'false')
     end
-  end
 
-  context '#settings' do
-    it 'normal settings' do
-      object = described_class.new(all_options)
-      expect(object.settings).to eq(Setting.get_all('base.'))
+    it 'with select element' do
+      expect(object.field_options('default_locale')).to eq(as: :select, label: false, collection: %w[en de ru],
+                                                           selected: 'en', include_blank: false,
+                                                           hint: 'Interface language')
     end
 
-    it 'settings by key' do
-      object = described_class.new(key_options)
-      expect(object.settings).to eq(Setting['some'])
+    it 'with array element' do
+      expect(object.field_options('admin_emails')).to eq(as: :text, label: false,
+                                                         input_html: { value: "a@example.com\nb@example.com",
+                                                                       placeholder: "a@example.com\nb@example.com",
+                                                                       rows: 5 })
     end
-  end
 
-  context '#save' do
-    it 'normal settings' do
-      object = described_class.new(all_options)
-      object.save('base.first_setting', 'DDD')
-      expect(Setting['base.first_setting']).to eq('DDD')
+    it 'with hash element' do
+      expect(object.field_options('notification_options')[:input_html][:value]).to eq("send_all: true\n")
     end
 
-    it 'settings by key' do
-      object = described_class.new(key_options)
-      object.save('some.first_setting', 'LLL')
-      expect(Setting['some']['first_setting']).to eq('LLL')
+    context 'with display option' do
+      let(:options) { { display: { title: :text } } }
+
+      it { expect(object.field_options('title')[:as]).to eq :text }
     end
   end
 
-  context '#defaults' do
-    it 'normal defaults' do
-      object = described_class.new(all_options)
-      expect(object.defaults).to eq(RailsSettings::Default)
-    end
+  context '#changed?' do
+    let(:options) { {} }
 
-    it 'old defaults' do
-      allow(Setting).to receive(:defaults).and_return(RailsSettings::Default.instance)
-      object = described_class.new(all_options)
-      expect(object.defaults).to be_an_instance_of(RailsSettings::Default)
-    end
+    it { expect(object.changed?('user_limit', '5')).to eq false }
+    it { expect(object.changed?('user_limit', '6')).to eq true }
+    it { expect(object.changed?('captcha_enabled', 'true')).to eq false }
+    it { expect(object.changed?('admin_emails', "a@example.com\r\nb@example.com\r\n")).to eq false }
   end
 
-  context '#defaults_keys' do
-    it 'normal defaults keys' do
-      object = described_class.new(all_options)
-      expect(object.defaults_keys).to eq(RailsSettings::Default.instance.keys)
+  context '#save' do
+    it 'saves value' do
+      object.save('user_limit', '10')
+      expect(Setting.user_limit).to eq 10
     end
   end