system_settings 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 321c73f1b71d88e67c98191025ac69b6fa58ea6dbbaa838cb5a6eaea6622337a
-  data.tar.gz: 17bd42a54230f37063f618fe2cfebc3875410d3879757e9ed38138990c6a952d
+  metadata.gz: 213bb372d94ea27ce951f424559b1e19812248cca9df0f66136d4776d9848fb8
+  data.tar.gz: 0530b07ab886e8e2515d957c839b37c1eb7817d90deb2e1e2996d10457c08efa
 SHA512:
-  metadata.gz: 4231c986165f29d944aec79b4cc5239ccc9f7d614ef710ec77e452a238f8579ec3afcf20c09c0701ec49b3a89547ebbfcc3e4f395a71d024b1349fadb8df1cfc
-  data.tar.gz: bab2dd0fbf7b7f5f38ea38e4ebdcb1d732eb0254a2e3278925ac16408cca8d3c05c898137c92e7916c2b4f85c6105a9ad1e1ec5be0e51eb9d8a0fa617ff3fd47
+  metadata.gz: 5d4ea1661ba9b875628ae3ac32e26cb593607ce8e470bc651287d105e23889b6794a1db594dff754dc1fcf89f0118995b4dc544c1d4d9a8fbfc3391d20e532a6
+  data.tar.gz: 397e5ade494169a4ff92c6bab9abada406c4d5ae9b2e3725a1ac282ec2d7cb7a066f8f7c69a724826d1e20bd3dc97f4decf48a80c08c61c54ad8a80193bdfcea

data/app/controllers/system_settings/application_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class ApplicationController < ActionController::Base
-    protect_from_forgery with: :exception
-  end
+class SystemSettings::ApplicationController < ActionController::Base
+  protect_from_forgery with: :exception
+
+  ActiveSupport.run_load_hooks(:system_settings_application_controller, self)
 end

data/app/controllers/system_settings/settings_controller.rb

@@ -1,34 +1,32 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class SettingsController < SystemSettings::ApplicationController
-    RETURN_ATTRIBUTES = %w[id name type value description].freeze
-    before_action :set_setting, only: [:edit, :show, :update]
+class SystemSettings::SettingsController < SystemSettings::ApplicationController
+  RETURN_ATTRIBUTES = %w[id name type value description].freeze
+  before_action :set_setting, only: [:edit, :show, :update]
 
-    def index
-      @settings = SystemSettings::Setting.order(:name)
-    end
+  def index
+    @settings = SystemSettings::Setting.order(:name)
+  end
 
-    def edit; end
+  def edit; end
 
-    def show; end
+  def show; end
 
-    def update
-      if @setting.update(setting_params)
-        redirect_to setting_path(@setting)
-      else
-        render :edit
-      end
+  def update
+    if @setting.update(setting_params)
+      redirect_to setting_path(@setting)
+    else
+      render :edit
     end
+  end
 
-    private
+  private
 
-    def set_setting
-      @setting = SystemSettings::Setting.find(params[:id])
-    end
+  def set_setting
+    @setting = SystemSettings::Setting.find(params[:id])
+  end
 
-    def setting_params
-      params.require(:setting).permit(:value)
-    end
+  def setting_params
+    params.require(:setting).permit(:value)
   end
 end

data/app/helpers/system_settings/application_helper.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module SystemSettings::ApplicationHelper
-  SEPARATOR = ";".freeze
+  SEPARATOR = ";"
 
   def format_value(value)
     if value.respond_to?(:each)

data/app/models/system_settings/application_record.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-  end
+class SystemSettings::ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
 end

data/app/models/system_settings/boolean_setting.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class BooleanSetting < SystemSettings::Setting
-    attribute :value, :boolean
-    validates :value, inclusion: [true, false]
-  end
+class SystemSettings::BooleanSetting < SystemSettings::Setting
+  attribute :value, :boolean
+  validates :value, inclusion: [true, false]
 end

data/app/models/system_settings/configurator.rb

@@ -1,136 +1,134 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class Configurator
-    class << self
-      def from_file(file_name, kernel_class: Kernel)
-        file_name = file_name.to_path if file_name.respond_to?(:to_path)
-        raise SystemSettings::Errors::SettingsReadError, "The file name must either be a String or implement #to_path" unless file_name.is_a?(String)
-        raise SystemSettings::Errors::SettingsReadError, "#{file_name} file does not exist" unless File.exist?(file_name)
-        raise SystemSettings::Errors::SettingsReadError, "#{file_name} file not readable" unless File.readable?(file_name)
-        SystemSettings.instrument("system_settings.from_file", path: file_name) do |payload|
-          file_content = File.read(file_name)
-          new(kernel_class: kernel_class).tap do |obj|
-            obj.instance_eval(file_content, file_name, 1)
-            payload[:items] = obj.items
-          end
+class SystemSettings::Configurator
+  class << self
+    def from_file(file_name, kernel_class: Kernel)
+      file_name = file_name.to_path if file_name.respond_to?(:to_path)
+      raise SystemSettings::Errors::SettingsReadError, "The file name must either be a String or implement #to_path" unless file_name.is_a?(String)
+      raise SystemSettings::Errors::SettingsReadError, "#{file_name} file does not exist" unless File.exist?(file_name)
+      raise SystemSettings::Errors::SettingsReadError, "#{file_name} file not readable" unless File.readable?(file_name)
+      SystemSettings.instrument("system_settings.from_file", path: file_name) do |payload|
+        file_content = File.read(file_name)
+        new(kernel_class: kernel_class).tap do |obj|
+          obj.instance_eval(file_content, file_name, 1)
+          payload[:items] = obj.items
         end
       end
+    end
 
-      def purge
-        new.purge
-      end
+    def purge
+      new.purge
     end
+  end
 
-    attr_reader :items
+  attr_reader :items
 
-    def initialize(kernel_class: Kernel, &block)
-      @items = []
-      @kernel_class = kernel_class
-      return unless block_given?
-      if block.arity == 1
-        yield self
-      else
-        instance_exec(&block)
-      end
+  def initialize(kernel_class: Kernel, &block)
+    @items = []
+    @kernel_class = kernel_class
+    return unless block_given?
+    if block.arity == 1
+      yield self
+    else
+      instance_exec(&block)
     end
+  end
 
-    def string(name, value: nil, description: nil, &blk)
-      add(name, SystemSettings::StringSetting, value: value, description: description, &blk)
-    end
+  def string(name, value: nil, description: nil, &blk)
+    add(name, SystemSettings::StringSetting, value: value, description: description, &blk)
+  end
 
-    def string_list(name, value: nil, description: nil, &blk)
-      add(name, SystemSettings::StringListSetting, value: value || [], description: description, &blk)
-    end
+  def string_list(name, value: nil, description: nil, &blk)
+    add(name, SystemSettings::StringListSetting, value: value || [], description: description, &blk)
+  end
 
-    def integer(name, value: nil, description: nil, &blk)
-      add(name, SystemSettings::IntegerSetting, value: value, description: description, &blk)
-    end
+  def integer(name, value: nil, description: nil, &blk)
+    add(name, SystemSettings::IntegerSetting, value: value, description: description, &blk)
+  end
 
-    def integer_list(name, value: nil, description: nil, &blk)
-      add(name, SystemSettings::IntegerListSetting, value: value || [], description: description, &blk)
-    end
+  def integer_list(name, value: nil, description: nil, &blk)
+    add(name, SystemSettings::IntegerListSetting, value: value || [], description: description, &blk)
+  end
 
-    def boolean(name, value: nil, description: nil, &blk)
-      add(name, SystemSettings::BooleanSetting, value: value, description: description, &blk)
-    end
+  def boolean(name, value: nil, description: nil, &blk)
+    add(name, SystemSettings::BooleanSetting, value: value, description: description, &blk)
+  end
 
-    def decimal(name, value: nil, description: nil, &blk)
-      add(name, SystemSettings::DecimalSetting, value: value, description: description, &blk)
-    end
+  def decimal(name, value: nil, description: nil, &blk)
+    add(name, SystemSettings::DecimalSetting, value: value, description: description, &blk)
+  end
 
-    def decimal_list(name, value: nil, description: nil, &blk)
-      add(name, SystemSettings::DecimalListSetting, value: value || [], description: description, &blk)
-    end
+  def decimal_list(name, value: nil, description: nil, &blk)
+    add(name, SystemSettings::DecimalListSetting, value: value || [], description: description, &blk)
+  end
 
-    def persist(only: [])
-      SystemSettings.instrument("system_settings.persist", items: @items) do |payload|
-        if settings_table_exists?
-          SystemSettings::Setting.transaction do
-            if only.empty?
-              @items.each { |item| create_or_update_item(item) }
-            else
-              only.each do |wanted_name|
-                item = @items.find { |i| i[:name] == wanted_name } || begin
-                  loaded_names = @items.empty? ? "(none)" : @items.map{ |i| i[:name] }.join("\n")
-                  message = <<~MESSAGE.strip
-                    Couldn't persist system setting #{wanted_name}. There are no items by this name. Could it be a typo?
-
-                    Configurator has loaded following items:
-                    #{loaded_names}
-                  MESSAGE
-                  raise(SystemSettings::Errors::NotLoadedError, message)
-                end
-                create_or_update_item(item)
+  def persist(only: [])
+    SystemSettings.instrument("system_settings.persist", items: @items) do |payload|
+      if settings_table_exists?
+        SystemSettings::Setting.transaction do
+          if only.empty?
+            @items.each { |item| create_or_update_item(item) }
+          else
+            only.each do |wanted_name|
+              item = @items.find { |i| i[:name] == wanted_name } || begin
+                loaded_names = @items.empty? ? "(none)" : @items.map{ |i| i[:name] }.join("\n")
+                message = <<~MESSAGE.strip
+                  Couldn't persist system setting #{wanted_name}. There are no items by this name. Could it be a typo?
+
+                  Configurator has loaded following items:
+                  #{loaded_names}
+                MESSAGE
+                raise(SystemSettings::Errors::NotLoadedError, message)
               end
+              create_or_update_item(item)
             end
           end
-          payload[:success] = true
-        else
-          warn "SystemSettings: Settings table has not been created!"
-          payload[:success] = false
         end
+        payload[:success] = true
+      else
+        warn "SystemSettings: Settings table has not been created!"
+        payload[:success] = false
       end
     end
+  end
 
-    def purge
-      SystemSettings.instrument("system_settings.purge") do |payload|
-        if settings_table_exists?
-          SystemSettings::Setting.delete_all
-          payload[:success] = true
-        else
-          payload[:success] = false
-        end
+  def purge
+    SystemSettings.instrument("system_settings.purge") do |payload|
+      if settings_table_exists?
+        SystemSettings::Setting.delete_all
+        payload[:success] = true
+      else
+        payload[:success] = false
       end
     end
+  end
 
-    private
+  private
 
-    def warn(*args)
-      @kernel_class.warn(*args)
-    end
+  def warn(*args)
+    @kernel_class.warn(*args)
+  end
 
-    def settings_table_exists?
-      SystemSettings::Setting.table_exists?
-    end
+  def settings_table_exists?
+    SystemSettings::Setting.table_exists?
+  end
 
-    def add(name, class_const, value:, description:)
-      value = yield(value) if block_given?
-      value = value.call if value.is_a?(Proc)
-      @items.push(name: name, class: class_const, value: value, description: description)
-    end
+  def add(name, class_const, value:, description:)
+    value = yield(value) if block_given?
+    value = value.call if value.is_a?(Proc)
+    @items.push(name: name, class: class_const, value: value, description: description)
+  end
 
-    def create_or_update_item(item)
-      persisted_record = SystemSettings::Setting.find_by(name: item[:name])
-      if persisted_record
-        if persisted_record.class == item[:class]
-          persisted_record.update!(description: item[:description])
-        else
-          warn "SystemSettings: Type mismatch detected! Previously #{item[:name]} had type #{persisted_record.class.name} but you are loading #{item[:class].name}"
-        end
+  def create_or_update_item(item)
+    persisted_record = SystemSettings::Setting.find_by(name: item[:name])
+    if persisted_record
+      if persisted_record.class == item[:class]
+        persisted_record.update!(description: item[:description])
       else
-        item[:class].create!(name: item[:name], value: item[:value], description: item[:description])
+        warn "SystemSettings: Type mismatch detected! Previously #{item[:name]} had type #{persisted_record.class.name} but you are loading #{item[:class].name}"
       end
+    else
+      item[:class].create!(name: item[:name], value: item[:value], description: item[:description])
     end
   end
 end

data/app/models/system_settings/decimal_list_setting.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class DecimalListSetting < SystemSettings::Setting
-    attribute :value, SystemSettings::Type::DecimalList.new(scale: 6)
-    validates :value, "system_settings/list_of_decimals": true
-  end
+class SystemSettings::DecimalListSetting < SystemSettings::Setting
+  attribute :value, SystemSettings::Type::DecimalList.new(scale: 6)
+  validates :value, "system_settings/list_of_decimals": true
 end

data/app/models/system_settings/decimal_setting.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class DecimalSetting < SystemSettings::Setting
-    attribute :value, :decimal, scale: 6
-    validates :value, numericality: true
-  end
+class SystemSettings::DecimalSetting < SystemSettings::Setting
+  attribute :value, :decimal, scale: 6
+  validates :value, numericality: true
 end

data/app/models/system_settings/errors/error.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  module Errors
-    class Error < StandardError
-    end
+module SystemSettings::Errors
+  class Error < StandardError
   end
 end

data/app/models/system_settings/errors/not_found_error.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  module Errors
-    class NotFoundError < SystemSettings::Errors::Error
-    end
+module SystemSettings::Errors
+  class NotFoundError < SystemSettings::Errors::Error
   end
 end

data/app/models/system_settings/errors/not_loaded_error.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  module Errors
-    class NotLoadedError < SystemSettings::Errors::Error
-    end
+module SystemSettings::Errors
+  class NotLoadedError < SystemSettings::Errors::Error
   end
 end

data/app/models/system_settings/errors/settings_read_error.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  module Errors
-    class SettingsReadError < SystemSettings::Errors::Error
-    end
+module SystemSettings::Errors
+  class SettingsReadError < SystemSettings::Errors::Error
   end
 end

data/app/models/system_settings/integer_list_setting.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class IntegerListSetting < SystemSettings::Setting
-    attribute :value, SystemSettings::Type::IntegerList.new(limit: 8)
-    validates :value, "system_settings/list_of_integers": true
-  end
+class SystemSettings::IntegerListSetting < SystemSettings::Setting
+  attribute :value, SystemSettings::Type::IntegerList.new(limit: 8)
+  validates :value, "system_settings/list_of_integers": true
 end

data/app/models/system_settings/integer_setting.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class IntegerSetting < SystemSettings::Setting
-    attribute :value, :integer, limit: 8
-    validates :value, numericality: { only_integer: true }
-  end
+class SystemSettings::IntegerSetting < SystemSettings::Setting
+  attribute :value, :integer, limit: 8
+  validates :value, numericality: { only_integer: true }
 end

data/app/models/system_settings/list_of_decimals_validator.rb

@@ -1,37 +1,35 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class ListOfDecimalsValidator < ActiveModel::EachValidator
-    LIST_REGEXP = /\A[+-]?\d+(?:\.\d+){0,1}(?:; *[+-]?\d+(?:\.\d+){0,1})*\z/.freeze
-    SINGLE_REGEXP = /\A[+-]?\d+(?:\.\d+){0,1}\z/.freeze
+class SystemSettings::ListOfDecimalsValidator < ActiveModel::EachValidator
+  LIST_REGEXP = /\A[+-]?\d+(?:\.\d+){0,1}(?:; *[+-]?\d+(?:\.\d+){0,1})*\z/.freeze
+  SINGLE_REGEXP = /\A[+-]?\d+(?:\.\d+){0,1}\z/.freeze
 
-    def validate_each(record, attr_name, value)
-      came_from_user = :"#{attr_name}_came_from_user?"
+  def validate_each(record, attr_name, value)
+    came_from_user = :"#{attr_name}_came_from_user?"
 
-      raw_value = record.read_attribute_before_type_cast(attr_name) if record.respond_to?(came_from_user) && record.public_send(came_from_user)
-      raw_value ||= value
+    raw_value = record.read_attribute_before_type_cast(attr_name) if record.respond_to?(came_from_user) && record.public_send(came_from_user)
+    raw_value ||= value
 
-      raw_value = value if record_attribute_changed_in_place?(record, attr_name)
+    raw_value = value if record_attribute_changed_in_place?(record, attr_name)
 
-      record.errors.add(attr_name, :not_a_list_of_decimals) unless matches_list_of_decimals_regexp?(raw_value)
-    end
+    record.errors.add(attr_name, :not_a_list_of_decimals) unless matches_list_of_decimals_regexp?(raw_value)
+  end
 
-    private
+  private
 
-    def record_attribute_changed_in_place?(record, attr_name)
-      record.respond_to?(:attribute_changed_in_place?) &&
-        record.attribute_changed_in_place?(attr_name.to_s)
-    end
+  def record_attribute_changed_in_place?(record, attr_name)
+    record.respond_to?(:attribute_changed_in_place?) &&
+      record.attribute_changed_in_place?(attr_name.to_s)
+  end
 
-    def matches_list_of_decimals_regexp?(raw_value)
-      case raw_value
-      when String
-        LIST_REGEXP.match?(raw_value)
-      when Array
-        raw_value.all? { |v| SINGLE_REGEXP.match?(v.to_s) }
-      else
-        false
-      end
+  def matches_list_of_decimals_regexp?(raw_value)
+    case raw_value
+    when String
+      LIST_REGEXP.match?(raw_value)
+    when Array
+      raw_value.all? { |v| SINGLE_REGEXP.match?(v.to_s) }
+    else
+      false
     end
   end
 end

data/app/models/system_settings/list_of_integers_validator.rb

@@ -1,37 +1,35 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class ListOfIntegersValidator < ActiveModel::EachValidator
-    LIST_REGEXP = /\A[+-]?\d+(?:; *[+-]?\d+)*\z/.freeze
-    SINGLE_REGEXP = /\A[+-]?\d+\z/.freeze
+class SystemSettings::ListOfIntegersValidator < ActiveModel::EachValidator
+  LIST_REGEXP = /\A[+-]?\d+(?:; *[+-]?\d+)*\z/.freeze
+  SINGLE_REGEXP = /\A[+-]?\d+\z/.freeze
 
-    def validate_each(record, attr_name, value)
-      came_from_user = :"#{attr_name}_came_from_user?"
+  def validate_each(record, attr_name, value)
+    came_from_user = :"#{attr_name}_came_from_user?"
 
-      raw_value = record.read_attribute_before_type_cast(attr_name) if record.respond_to?(came_from_user) && record.public_send(came_from_user)
-      raw_value ||= value
+    raw_value = record.read_attribute_before_type_cast(attr_name) if record.respond_to?(came_from_user) && record.public_send(came_from_user)
+    raw_value ||= value
 
-      raw_value = value if record_attribute_changed_in_place?(record, attr_name)
+    raw_value = value if record_attribute_changed_in_place?(record, attr_name)
 
-      record.errors.add(attr_name, :not_a_list_of_integers) unless matches_list_of_integers_regexp?(raw_value)
-    end
+    record.errors.add(attr_name, :not_a_list_of_integers) unless matches_list_of_integers_regexp?(raw_value)
+  end
 
-    private
+  private
 
-    def record_attribute_changed_in_place?(record, attr_name)
-      record.respond_to?(:attribute_changed_in_place?) &&
-        record.attribute_changed_in_place?(attr_name.to_s)
-    end
+  def record_attribute_changed_in_place?(record, attr_name)
+    record.respond_to?(:attribute_changed_in_place?) &&
+      record.attribute_changed_in_place?(attr_name.to_s)
+  end
 
-    def matches_list_of_integers_regexp?(raw_value)
-      case raw_value
-      when String
-        LIST_REGEXP.match?(raw_value)
-      when Array
-        raw_value.all? { |v| SINGLE_REGEXP.match?(v.to_s) }
-      else
-        false
-      end
+  def matches_list_of_integers_regexp?(raw_value)
+    case raw_value
+    when String
+      LIST_REGEXP.match?(raw_value)
+    when Array
+      raw_value.all? { |v| SINGLE_REGEXP.match?(v.to_s) }
+    else
+      false
     end
   end
 end

data/app/models/system_settings/list_of_strings_validator.rb

@@ -1,38 +1,36 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class ListOfStringsValidator < ActiveModel::EachValidator
-    NON_WHITESPACE_REGEXP = /[^[:space:]]/.freeze
+class SystemSettings::ListOfStringsValidator < ActiveModel::EachValidator
+  NON_WHITESPACE_REGEXP = /[^[:space:]]/.freeze
 
-    def validate_each(record, attr_name, value)
-      came_from_user = :"#{attr_name}_came_from_user?"
+  def validate_each(record, attr_name, value)
+    came_from_user = :"#{attr_name}_came_from_user?"
 
-      raw_value = record.read_attribute_before_type_cast(attr_name) if record.respond_to?(came_from_user) && record.public_send(came_from_user)
-      raw_value ||= value
+    raw_value = record.read_attribute_before_type_cast(attr_name) if record.respond_to?(came_from_user) && record.public_send(came_from_user)
+    raw_value ||= value
 
-      raw_value = value if record_attribute_changed_in_place?(record, attr_name)
+    raw_value = value if record_attribute_changed_in_place?(record, attr_name)
 
-      record.errors.add(attr_name, :not_a_list_of_strings) unless matches_list_of_strings_regexp?(raw_value)
-    end
+    record.errors.add(attr_name, :not_a_list_of_strings) unless matches_list_of_strings_regexp?(raw_value)
+  end
 
-    private
+  private
 
-    def record_attribute_changed_in_place?(record, attr_name)
-      record.respond_to?(:attribute_changed_in_place?) &&
-        record.attribute_changed_in_place?(attr_name.to_s)
-    end
+  def record_attribute_changed_in_place?(record, attr_name)
+    record.respond_to?(:attribute_changed_in_place?) &&
+      record.attribute_changed_in_place?(attr_name.to_s)
+  end
 
-    def matches_list_of_strings_regexp?(raw_value)
-      case raw_value
-      when String
-        raw_value.split(SystemSettings::Type::StringList::DELIMITER_REGEXP).all? do |value|
-          NON_WHITESPACE_REGEXP.match?(value)
-        end
-      when Array
-        raw_value.all? { |v| NON_WHITESPACE_REGEXP.match?(v.to_s) }
-      else
-        false
+  def matches_list_of_strings_regexp?(raw_value)
+    case raw_value
+    when String
+      raw_value.split(SystemSettings::Type::StringList::DELIMITER_REGEXP).all? do |value|
+        NON_WHITESPACE_REGEXP.match?(value)
       end
+    when Array
+      raw_value.all? { |v| NON_WHITESPACE_REGEXP.match?(v.to_s) }
+    else
+      false
     end
   end
 end

data/app/models/system_settings/setting.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class Setting < SystemSettings::ApplicationRecord
-    validates :type, presence: true
-    validates :name, presence: true, uniqueness: true
-  end
+class SystemSettings::Setting < SystemSettings::ApplicationRecord
+  validates :type, presence: true
+  validates :name, presence: true, uniqueness: true
 end

data/app/models/system_settings/string_list_setting.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class StringListSetting < SystemSettings::Setting
-    attribute :value, SystemSettings::Type::StringList.new
-    validates :value, "system_settings/list_of_strings": true
-  end
+class SystemSettings::StringListSetting < SystemSettings::Setting
+  attribute :value, SystemSettings::Type::StringList.new
+  validates :value, "system_settings/list_of_strings": true
 end

data/app/models/system_settings/string_setting.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  class StringSetting < SystemSettings::Setting
-    attribute :value, :string
-    validates :value, presence: true
+class SystemSettings::StringSetting < SystemSettings::Setting
+  attribute :value, :string
+  validates :value, presence: true
 
-    def value=(original_value)
-      next_value = original_value.to_s.blank? ? nil : original_value.to_s.strip
-      super(next_value)
-    end
+  def value=(original_value)
+    next_value = original_value.to_s.blank? ? nil : original_value.to_s.strip
+    super(next_value)
   end
 end

data/app/models/system_settings/type/decimal_list.rb

@@ -1,41 +1,39 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  module Type
-    class DecimalList < ActiveModel::Type::Value
-      SEPARATOR = ";"
+module SystemSettings::Type
+  class DecimalList < ActiveModel::Type::Value
+    SEPARATOR = ";"
 
-      def initialize(precision: nil, limit: nil, scale: nil)
-        super
-        @single_type = ActiveModel::Type::Decimal.new(precision: precision, limit: limit, scale: scale)
-      end
+    def initialize(precision: nil, limit: nil, scale: nil)
+      super
+      @single_type = ActiveModel::Type::Decimal.new(precision: precision, limit: limit, scale: scale)
+    end
 
-      def type
-        :decimal_list
-      end
+    def type
+      :decimal_list
+    end
 
-      def deserialize(value)
-        result = value.presence && JSON.parse(value)
-        if result.is_a?(Array)
-          result.map { |v| @single_type.cast(v) }
-        else
-          result
-        end
+    def deserialize(value)
+      result = value.presence && JSON.parse(value)
+      if result.is_a?(Array)
+        result.map { |v| @single_type.cast(v) }
+      else
+        result
       end
+    end
 
-      def serialize(value)
-        JSON.dump(value) unless value.nil?
-      end
+    def serialize(value)
+      JSON.dump(value) unless value.nil?
+    end
 
-      private
+    private
 
-      def cast_value(value)
-        case value
-        when Array
-          value.map { |v| @single_type.cast(v) }
-        when String
-          value.split(SEPARATOR).map { |v| @single_type.cast(v) }
-        end
+    def cast_value(value)
+      case value
+      when Array
+        value.map { |v| @single_type.cast(v) }
+      when String
+        value.split(SEPARATOR).map { |v| @single_type.cast(v) }
       end
     end
   end

data/app/models/system_settings/type/integer_list.rb

@@ -1,36 +1,34 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  module Type
-    class IntegerList < ActiveModel::Type::Value
-      SEPARATOR = ";"
+module SystemSettings::Type
+  class IntegerList < ActiveModel::Type::Value
+    SEPARATOR = ";"
 
-      def initialize(precision: nil, limit: nil, scale: nil)
-        super
-        @single_type = ActiveModel::Type::Integer.new(precision: precision, limit: limit, scale: scale)
-      end
+    def initialize(precision: nil, limit: nil, scale: nil)
+      super
+      @single_type = ActiveModel::Type::Integer.new(precision: precision, limit: limit, scale: scale)
+    end
 
-      def type
-        :integer_list
-      end
+    def type
+      :integer_list
+    end
 
-      def deserialize(value)
-        value.presence && JSON.parse(value)
-      end
+    def deserialize(value)
+      value.presence && JSON.parse(value)
+    end
 
-      def serialize(value)
-        JSON.dump(value) unless value.nil?
-      end
+    def serialize(value)
+      JSON.dump(value) unless value.nil?
+    end
 
-      private
+    private
 
-      def cast_value(value)
-        case value
-        when Array
-          value.map { |v| @single_type.cast(v) }
-        when String
-          value.split(SEPARATOR).map { |v| @single_type.cast(v) }
-        end
+    def cast_value(value)
+      case value
+      when Array
+        value.map { |v| @single_type.cast(v) }
+      when String
+        value.split(SEPARATOR).map { |v| @single_type.cast(v) }
       end
     end
   end

data/app/models/system_settings/type/string_list.rb

@@ -1,30 +1,28 @@
 # frozen_string_literal: true
 
-module SystemSettings
-  module Type
-    class StringList < ActiveModel::Type::Value
-      DELIMITER_REGEXP = /(?<=[^\\]);/.freeze
-      def type
-        :string_list
-      end
+module SystemSettings::Type
+  class StringList < ActiveModel::Type::Value
+    DELIMITER_REGEXP = /(?<=[^\\]);/.freeze
+    def type
+      :string_list
+    end
 
-      def deserialize(value)
-        value.presence && JSON.parse(value)
-      end
+    def deserialize(value)
+      value.presence && JSON.parse(value)
+    end
 
-      def serialize(value)
-        JSON.dump(value) unless value.nil?
-      end
+    def serialize(value)
+      JSON.dump(value) unless value.nil?
+    end
 
-      private
+    private
 
-      def cast_value(value)
-        case value
-        when Array
-          value.map { |v| String(v).strip }
-        when String
-          value.split(DELIMITER_REGEXP).map(&:strip).map { |str| str.gsub("\\;", ";") }
-        end
+    def cast_value(value)
+      case value
+      when Array
+        value.map { |v| String(v).strip }
+      when String
+        value.split(DELIMITER_REGEXP).map(&:strip).map { |str| str.gsub("\\;", ";") }
       end
     end
   end

data/lib/system_settings/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SystemSettings
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: system_settings
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Krists Ozols
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-17 00:00:00.000000000 Z
+date: 2020-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails