setting_accessors 0.3.0 → 1.0.0

data/.codeclimate.yml

@@ -1,66 +0,0 @@
----
-engines:
-  rubocop:
-    enabled: true
-  eslint:
-    enabled: true
-  csslint:
-    enabled: true
-ratings:
-  paths:
-  - "**.rb"
-  - "**.js"
-  - "**.jsx"
-  - "**.css"
-exclude_paths:
-- test/**/*
-# This is a sample .codeclimate.yml configured for Engine analysis on Code
-# Climate Platform. For an overview of the Code Climate Platform, see here:
-# http://docs.codeclimate.com/article/300-the-codeclimate-platform
-
-# Under the engines key, you can configure which engines will analyze your repo.
-# Each key is an engine name. For each value, you need to specify enabled: true
-# to enable the engine as well as any other engines-specific configuration.
-
-# For more details, see here:
-# http://docs.codeclimate.com/article/289-configuring-your-repository-via-codeclimate-yml#platform
-
-# For a list of all available engines, see here:
-# http://docs.codeclimate.com/article/296-engines-available-engines
-
-engines:
-# to turn on an engine, add it here and set enabled to `true`
-# to turn off an engine, set enabled to `false` or remove it
-  rubocop:
-    enabled: true
-  golint:
-    enabled: true
-  gofmt:
-    enabled: true
-  eslint:
-    enabled: true
-  csslint:
-    enabled: true
-
-# Engines can analyze files and report issues on them, but you can separately
-# decide which files will receive ratings based on those issues. This is
-# specified by path patterns under the ratings key.
-
-# For more details see here:
-# http://docs.codeclimate.com/article/289-configuring-your-repository-via-codeclimate-yml#platform
-
-# Note: If the ratings key is not specified, this will result in a 0.0 GPA on your dashboard.
-
-# ratings:
-#   paths:
-#   - app/**
-#   - lib/**
-#   - "**.rb"
-#   - "**.go"
-
-# You can globally exclude files from being analyzed by any engine using the
-# exclude_paths key.
-
-#exclude_paths:
-#- spec/**/*
-#- vendor/**/*

data/lib/setting_accessors/accessor.rb

@@ -1,189 +0,0 @@
-#
-# Helper class to make accessing record specific settings easier
-#
-class SettingAccessors::Accessor
-
-  def initialize(record)
-    @record        = record
-    @temp_settings = {}
-  end
-
-  #
-  # Tries to retrieve the given setting's value from the temp settings
-  # (already read/written values in this instance). If the setting hasn't been
-  # used before, its value is retrieved from the database.
-  #
-  # If a setting hasn't been read by this record (instance) before, its value
-  # is stored in the local read set.
-  #
-  # TODO: See if this causes problems with read settings not being updated by external changes.
-  #       User1: Read Setting X
-  #       User2: Update Setting X
-  #       User1: Read Setting X -> Gets old value from temp settings.
-  #   This shouldn't be too dangerous as the system state will be refreshed with every request though.
-  #
-  def [](key)
-    return @temp_settings[key.to_sym] if has_key?(key)
-    value = SettingAccessors.setting_class.get(key, @record)
-    @temp_settings[key.to_sym] = value unless value.nil?
-    value
-  end
-
-  #
-  # Tries to fetch a setting value using the provided key and #[].
-  # It will only return the +default+ value if there is
-  #   - no temporary setting with the given key AND
-  #   - no already persisted setting (see #[])
-  #
-  def fetch(key, default = nil)
-    result = self[key]
-    return default if result.nil? && !has_key?(key)
-    result
-  end
-
-  #
-  # Like #fetch, but it will store the default value as a temporary setting
-  # if no actual setting value could be found. This is useful to further work
-  # with default setting values.
-  # The default value is cloned (using #dup to avoid copying object states) before
-  # it is assigned. This will not work for singleton instances like true, false, etc.
-  #
-  def fetch_and_store(key, default = nil)
-    result = self[key]
-    if result.nil? && !has_key?(key)
-      self[key] = default.duplicable? ? default.dup : default
-    else
-      result
-    end
-  end
-
-  def has_key?(key)
-    @temp_settings.has_key?(key.to_sym)
-  end
-
-  #
-  # Writes a setting's value
-  #
-  def []=(key, val)
-    set_value_before_type_cast(key, val)
-    @temp_settings[key.to_sym] = SettingAccessors::Internal.converter(value_type(key)).convert(val)
-  end
-
-  #
-  # Tries to find a setting for this record.
-  # If none is found, will return the default setting value
-  # specified in the setting config file.
-  #
-  def get_or_default(key)
-    fetch_and_store(key, SettingAccessors.setting_class.get_or_default(key, @record))
-  end
-
-  #
-  # Tries to find a setting for this record first.
-  # If none is found, tries to find a global setting with the same name
-  #
-  def get_or_global(key)
-    fetch_and_store(key, SettingAccessors.setting_class.get(key))
-  end
-
-  #
-  # Tries to find a setting for this record first,
-  # if none is found, it will return the given value instead.
-  #
-  def get_or_value(key, value)
-    fetch_and_store(key, value)
-  end
-
-  def get_with_fallback(key, fallback = nil)
-    return self[key] if fallback.nil?
-
-    case fallback.to_s
-      when 'default' then get_or_default(key)
-      when 'global'  then get_or_global(key)
-      else get_or_value(key, fallback)
-    end
-  end
-
-  #
-  # @return [String] the setting's value type in the +@record+'s context
-  #
-  def value_type(key)
-    SettingAccessors::Internal.setting_value_type(key, @record)
-  end
-
-  #----------------------------------------------------------------
-  #               ActiveRecord Helper Methods Emulation
-  #----------------------------------------------------------------
-
-  def value_was(key, fallback = nil)
-    return SettingAccessors.setting_class.get(key, @record) if fallback.nil?
-
-    case fallback.to_s
-      when 'default' then SettingAccessors.setting_class.get_or_default(key, @record)
-      when 'global'  then SettingAccessors.setting_class.get(key)
-      else fallback
-    end
-  end
-
-  def value_changed?(key)
-    self[key] != value_was(key)
-  end
-
-  def value_before_type_cast(key)
-    SettingAccessors::Internal.lookup_nested_hash(@values_before_type_casts, key.to_s) || self[key]
-  end
-
-  protected
-
-  #
-  # Keeps a record of the originally set value for a setting before it was
-  # automatically converted.
-  #
-  def set_value_before_type_cast(key, value)
-    @values_before_type_casts ||= {}
-    @values_before_type_casts[key.to_s] = value
-  end
-
-  #
-  # Validates the new setting values.
-  # If there is an accessor for the setting, the errors will be
-  # directly forwarded to it, otherwise to :base
-  #
-  # Please do not call this method directly, use the IntegrationValidator
-  # class instead, e.g.
-  #
-  #   validates_with SettingAccessors::IntegrationValidator
-  #
-  def validate!
-    @temp_settings.each do |key, value|
-      validation_errors = SettingAccessors.setting_class.validation_errors(key, value, @record)
-      validation_errors.each do |message|
-        if @record.respond_to?("#{key}=")
-          @record.errors.add(key, message)
-        else
-          @record.errors.add :base, :invalid_setting, :name => key, :message => message
-        end
-      end
-    end
-  end
-
-  #
-  # Saves the new setting values into the database
-  # Please note that there is no check if the values changed their
-  # in the meantime.
-  #
-  # Also, this method expects that the settings were validated
-  # before using #validate! and will therefore not perform
-  # validations itself.
-  #
-  def persist!
-    @temp_settings.each do |key, value|
-      Setting.create_or_update(key, value, @record)
-    end
-    flush!
-  end
-
-  def flush!
-    @temp_settings = {}
-  end
-end

data/lib/setting_accessors/converter.rb

@@ -1,71 +0,0 @@
-#
-# This class hopefully will hopefully one day mimic ActiveRecord's
-# attribute assigning methods, meaning that a conversion to the column type
-# is done as soon as a new value is assigned by the programmer.
-#
-# If the value cannot be parsed in the required type, +nil+ is assigned.
-# Please make sure that you specify the correct validations in settings.yml
-# or assigned model to avoid this.
-#
-# Currently supported types:
-#   - Fixnum
-#   - String
-#   - Boolean
-#
-# If the type is 'polymorphic', it is not converted at all.
-#
-class SettingAccessors::Converter
-
-  def initialize(value_type)
-    @value_type = value_type
-  end
-
-  #
-  # Converts the setting's value to the correct type
-  #
-  def convert(new_value)
-    #If the value is set to be polymorphic, we don't have to convert anything.
-    return new_value if @value_type.to_s == 'polymorphic'
-
-    #ActiveRecord only converts non-nil values to their database type
-    #during assignment
-    return new_value if new_value.nil?
-
-    parse_method = :"parse_#{@value_type}"
-
-    if private_methods.include?(parse_method)
-      send(parse_method, new_value)
-    else
-      Rails.logger.warn("Invalid Setting type: #{@value_type}")
-      new_value
-    end
-  end
-
-  private
-
-  def parse_boolean(value)
-    case value
-      when TrueClass, FalseClass
-        value
-      when String
-        return true if %w[true 1].include?(value.downcase)
-        return false if %w[false 0].include?(value.downcase)
-        nil
-      when Fixnum
-        return true if value == 1
-        return false if value.zero?
-        nil
-      else
-        nil
-    end
-  end
-
-  def parse_integer(value)
-    value.to_i
-  end
-
-  def parse_string(value)
-    value.to_s
-  end
-
-end

data/lib/setting_accessors/integration_validator.rb

@@ -1,15 +0,0 @@
-#
-# This class handles model validations for assigned records, e.g.
-# if the settings are accessed using the Accessor class in this module.
-# Only the new temp values are validated using the setting config.
-#
-# The main work is still done in the Accessor class, so we don't have
-# to access its instance variables here, this class acts as a wrapper
-# for Rails' validation chain
-#
-
-class SettingAccessors::IntegrationValidator < ActiveModel::Validator
-  def validate(record)
-    record.settings.send(:validate!)
-  end
-end

data/lib/setting_accessors/validator.rb

@@ -1,144 +0,0 @@
-class SettingAccessors::Validator < ActiveModel::Validator
-
-  def validate(record)
-    record.send(:validations).each do |key, requirement|
-      if key.to_s == 'custom'
-        Array(requirement).each do |validation|
-          run_custom_validation(record, validation)
-        end
-      elsif built_in_validation?(key)
-        send("validate_#{key}", record, requirement)
-      else
-        raise ArgumentError.new("The invalid validation '#{key}' was given in model '#{defining_model(record).to_s}'")
-      end
-    end
-  end
-
-  private
-
-  def defining_model(record)
-    if SettingAccessors::Internal.globally_defined_setting?(record.name) || !record.assignable
-      SettingAccessors.setting_class
-    else
-      record.assignable.class
-    end
-  end
-
-  #
-  # Runs a custom validation method
-  # The method may either be a Proc or an instance method in +record+.+class+
-  #
-  def run_custom_validation(record, proc)
-    case proc
-    when Proc
-      proc.call(record)
-    when Symbol
-      if defining_model(record).respond_to?(proc)
-        defining_model(record).send(proc)
-      else
-        raise ArgumentError.new "The method '#{proc}' was set up as validation method in model '#{defining_model(record).name}', but doesn't exist."
-      end
-    else
-      raise ArgumentError.new "An invalid validations method was given ('#{proc}')"
-    end
-  end
-
-  #
-  # @return [TrueClass, FalseClass] +true+ if the given validation
-  #  is a built-in one.
-  #
-  def built_in_validation?(validation_name)
-    private_methods.include?("validate_#{validation_name}".to_sym)
-  end
-
-  #
-  # Validates that the setting's value is given
-  # accepts :allow_blank and :allow_nil as options
-  #
-  def validate_presence(record, requirement)
-    return true unless requirement
-
-    if requirement.is_a?(Hash)
-      if requirement['allow_blank'] && !record.value.nil? ||
-           requirement['allow_nil'] && record.value.nil? ||
-           record.value.present?
-        true
-      else
-        add_error record, :blank
-        false
-      end
-    else
-      add_error_if record.value.nil? || record.value == '', record, :blank
-    end
-  end
-
-  #
-  # Validates numericality of the setting's value based on the options given
-  # in settings.yml
-  #
-  def validate_numericality(record, options)
-    #Test if the value is Numeric in any way (float or int)
-    add_error_if(!parse_value_as_numeric(record.value), record, :not_a_number) && return
-
-    #If the validation was set to check for integer values, do that as well
-    add_error_if(options['only_integer'] && !parse_value_as_fixnum(record.value), record, :not_an_integer)
-  end
-
-  #
-  # Validates whether the given value is a valid boolean
-  #
-  def validate_boolean(record, requirement)
-    add_error_if(requirement && parse_value_as_boolean(record.value).nil?, record, :not_a_boolean)
-  end
-
-  #----------------------------------------------------------------
-  #                        Helper Methods
-  #----------------------------------------------------------------
-
-  def add_error(record, validation, options = {})
-    record.errors.add :value, validation, options
-  end
-
-  def add_error_if(cond, record, validation, options = {})
-    add_error(record, validation, options) if cond
-    cond
-  end
-
-  #
-  # Borrowed from Rails' numericality validator
-  # @return [Float, NilClass] the given String value as a float or nil
-  #   if the value was not a valid Numeric
-  #
-  def parse_value_as_numeric(raw_value)
-    Kernel.Float(raw_value) if raw_value !~ /\A0[xX]/
-  rescue ArgumentError, TypeError
-    nil
-  end
-
-  #
-  # Borrowed from Rails' numericality validator
-  #
-  # @return [Fixnum, NilClass] the given String value as an int or nil
-  #
-  def parse_value_as_fixnum(raw_value)
-    raw_value.to_i if raw_value.to_s =~ /\A[+-]?\d+\Z/
-  end
-
-  #
-  # Tries to parse the given value as a boolean value
-  #
-  # @return [TrueClass, FalseClass, NilClass]
-  #
-  def parse_value_as_boolean(raw_value)
-    case raw_value
-      when TrueClass, FalseClass
-        raw_value
-      when String
-        return true  if %w[true 1].include?(raw_value.downcase)
-        return false if %w[false 0].include?(raw_value.downcase)
-        nil
-      else
-        nil
-    end
-  end
-end