feature_setting 1.5.4 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee3d92b918ce890829a5ecf064a20f39444a6482
-  data.tar.gz: 3431c83ef4bd43e641f8bfd7e577d7322e40c97a
+  metadata.gz: e4fa65d93cd0a275f8b1ce550a644d77e6f6f0c4
+  data.tar.gz: 74a5eee2cc3f170f8e8654d9d0b81e6f0b51b4bf
 SHA512:
-  metadata.gz: 82608414414a113c07e7f3be8aad19c8a96855c05280de162c5c54003d0d77babe116daafa6c047c34fb0f5021accfb8ed9f1f3783fbee58a755240f100d0cb8
-  data.tar.gz: 5b02277fbc40074d8bed18c46b3eef7212d7347a723563bdbd1dad783a42b8d9cade07ee582b7c09dd6e936be1af3c01a44a201cd7fc8c89ff4408864a87e8dd
+  metadata.gz: 83cb8a1d0164a2f0f13987cb8da5f7b5ef88d39917e83d3cd8d2235668d7c608bcc06e06f7ed4ebba17e591dd72e31ff2c637c63c366db3c7fab839d56575aea
+  data.tar.gz: 24feeeb3faea28ae6ecc6f3ea56f61bba1615586ed0596f3c0f72026a24902fad5abb62f848cd84923b1fe90c469c63ed592444d3519e7a2c4158498c65ce1ba

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+.byebug_history

data/README.md

@@ -114,9 +114,18 @@ Settings.setting_one = 2000
 Settings.setting_one # => 2000
 
 # other ways to set setting values:
-Settings.set!(setting_one: 1000)
-Settings.set!(:setting_one, 1000)
-Settings.set!('setting_one', 1000)
+Settings.update!(setting_one: 1000)
+Settings.update!(:setting_one, 1000)
+Settings.update!('setting_one', 1000)
+```
+
+**NEW IN VERSION 1.6:** Hashes values can be updated individually and will not overwrite the entire hash:
+```ruby
+Settings.setting_five = { key1: 'another_value' }
+=> setting_five:  { key1: 'another_value', key2: 'value2' }
+
+Settings.setting_five = { key3: 'value3' }
+=> setting_five:  { key1: 'another_value', key2: 'value2', key3: 'value3' }
 ```
 
 Default values for settings are defined in your class and current values are persisted in the database.
@@ -149,6 +158,14 @@ Features.defined_features
 Settings.defined_settings
 ```
 
+Cache settings or features:
+
+```ruby
+Features.cache_features!
+Settings.cache_settings!
+```
+Note that a simple call to `Features.init_features!` or `Settings.init_settings!` respectively will remove caching.
+
 You can create as many Setting or Feature classes as you desire. Here are some examples:
 
 ```ruby

data/feature_setting.gemspec

@@ -24,6 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake', '>= 10.0'
   spec.add_development_dependency 'rspec', '>= 3.0'
   spec.add_development_dependency 'sqlite3'
-  spec.add_development_dependency 'byebug', '>= 0'
-  spec.add_development_dependency 'codeclimate-test-reporter', '>= 0'
+  spec.add_development_dependency 'byebug'
 end

data/lib/feature_setting/orm/active_record/fs_feature.rb

@@ -34,20 +34,45 @@ module FeatureSetting
       def init_features!(remove_old_features = false)
         features.each do |key, value|
           self.create_with(key: key, enabled: value, klass: klass).find_or_create_by(klass: klass, key: key)
-          define_singleton_method("#{key}_enabled?") do
-            record = self.where(key: key, klass: klass).first
-            record.enabled
-          end
-          define_singleton_method("enable_#{key}!") do
-            enable!(key)
-          end
-          define_singleton_method("disable_#{key}!") do
-            disable!(key)
-          end
+          define_checker_method(key)
+          define_enabler_method(key)
+          define_disabler_method(key)
         end
         remove_old_features! if remove_old_features
       end
 
+      def cache_features!
+        features.each do |key, value|
+          self.create_with(key: key, enabled: value, klass: klass).find_or_create_by(klass: klass, key: key)
+          value = self.where(key: key, klass: klass).first.enabled
+          define_checker_method(key) { value }
+          define_enabler_method(key) { false }
+          define_disabler_method(key) { false }
+        end
+      end
+
+      def define_checker_method(key, &block)
+        block = Proc.new do
+          record = self.where(key: key, klass: klass).first
+          record.enabled
+        end unless block_given?
+        define_singleton_method("#{key}_enabled?") { block.call }
+      end
+
+      def define_enabler_method(key, &block)
+        block = Proc.new do
+          enable!(key)
+        end unless block_given?
+        define_singleton_method("enable_#{key}!") { block.call }
+      end
+
+      def define_disabler_method(key, &block)
+        block = Proc.new do
+          disable!(key)
+        end unless block_given?
+        define_singleton_method("disable_#{key}!") { block.call }
+      end
+
       def remove_old_features!
         self.where(key: all_stored_features - defined_features).destroy_all
       end

data/lib/feature_setting/orm/active_record/fs_setting.rb

@@ -4,8 +4,8 @@ require 'json'
 module FeatureSetting
   class FsSetting < ActiveRecord::Base
     SETTINGS = {
-      test: 'value',
-    }
+      test: 'value'
+    }.freeze
 
     def settings
       self.class::SETTINGS
@@ -17,56 +17,77 @@ module FeatureSetting
 
     class << self
       def settings
-        self.new.settings
+        new.settings
       end
 
       def klass
-        self.new.klass.to_s
+        new.klass.to_s
       end
 
       def init_settings!(remove_old_settings = false)
         settings.each do |key, value|
-          self.create_with(key: key, value: convert_to_string(value, value.class.to_s), value_type: value.class.to_s, klass: klass).find_or_create_by(klass: klass, key: key)
+          create_with(key: key, value: convert_to_string(value, value.class.to_s), value_type: value.class.to_s, klass: klass).find_or_create_by(klass: klass, key: key)
           define_getter_method(key)
           define_setter_method(key)
         end
         remove_old_settings! if remove_old_settings
       end
 
-      def define_getter_method(key)
-        define_singleton_method(key.to_s) do
-          record = self.where(key: key, klass: klass).first
-          convert_to_type(record.value, record.value_type)
+      def cache_settings!
+        settings.each do |key, value|
+          create_with(key: key, value: convert_to_string(value, value.class.to_s), value_type: value.class.to_s, klass: klass).find_or_create_by(klass: klass, key: key)
+          record = where(key: key, klass: klass).first
+          value = convert_to_type(record.value, record.value_type)
+          define_getter_method(key) { value }
         end
       end
 
+      def define_getter_method(key, &block)
+        block = Proc.new do
+          record = where(key: key, klass: klass).first
+          convert_to_type(record.value, record.value_type)
+        end unless block_given?
+
+        define_singleton_method(key.to_s) { block.call }
+      end
+
       def define_setter_method(key)
         define_singleton_method("#{key}=") do |value|
-          record = self.where(key: key, klass: klass).first
           set!(key, value)
         end
       end
 
       def remove_old_settings!
-        self.where(klass: klass, key: all_stored_keys - defined_keys).destroy_all
+        where(klass: klass, key: all_stored_keys - defined_keys).destroy_all
       end
 
       def reset_settings!
-        self.where(klass: klass).destroy_all
+        where(klass: klass).destroy_all
         init_settings!
       end
 
-      def set!(key = nil, value = nil, **hash)
-        key = existing_key(key, hash)
-        fail 'ERROR: FsSetting key is missing or does not exist.' unless key
+      def set!(key = nil, value = nil)
+        raise 'ERROR: FsSetting key is missing or does not exist.' unless defined_keys.include?(key.to_s)
+
+        record = where(key: key.to_s, klass: klass).first
+        old_value = convert_to_type(record.value, record.value_type)
+
+        if record.value_type == 'Hash'
+          raise 'ERROR: The value for a setting of type Hash must be a Hash.' unless value.is_a?(Hash)
+
+          new_value = old_value.update(value)
+          value_type = 'Hash'
+        else
+          new_value = value
+          value_type = value.class.to_s
+        end
 
-        record = self.where(key: key, klass: klass).first
-        new_value = hash.values.first || value
         record.update_attributes(
           value: convert_to_string(new_value, new_value.class.to_s),
-          value_type: new_value.class.to_s
+          value_type: value_type
         )
       end
+      alias_method :update!, :set!
 
       def existing_key(key = nil, hash = {})
         settings.key?(hash.keys.first) || settings.key?(key.to_sym)
@@ -81,7 +102,7 @@ module FeatureSetting
 
       def stored_settings
         hash = {}
-        self.where(klass: klass).each do |record|
+        where(klass: klass).each do |record|
           hash[record.key.to_sym] = convert_to_type(record.value, record.value_type)
         end
 
@@ -91,7 +112,7 @@ module FeatureSetting
       private
 
       def all_stored_keys
-        self.all.pluck(:key)
+        all.pluck(:key)
       end
 
       def convert_to_type(value, type)
@@ -106,6 +127,8 @@ module FeatureSetting
           false
         when 'Fixnum'
           value.to_i
+        when 'Integer'
+          value.to_i
         when 'Float'
           value.to_f
         when 'Symbol'
@@ -119,12 +142,10 @@ module FeatureSetting
 
       def convert_to_string(value, type)
         case type
-        when 'Hash'
+        when 'Hash', 'Hashie::Mash'
           value.to_json
         when 'Array'
           value.join('|||')
-        when 'Hash'
-          value.to_json
         else
           value.to_s
         end

data/lib/feature_setting/version.rb

@@ -1,3 +1,3 @@
 module FeatureSetting
-  VERSION = "1.5.4"
+  VERSION = "1.6.0"
 end

data/lib/feature_setting.rb

@@ -2,6 +2,7 @@ require 'active_support/all'
 require 'feature_setting/version'
 require 'feature_setting/orm/active_record/fs_setting'
 require 'feature_setting/orm/active_record/fs_feature'
+require 'byebug'
 
 module FeatureSetting
 end

data/lib/generators/feature_setting/install/templates/migrations/create_fs_tables.rb

@@ -1,4 +1,4 @@
-class CreateFsTables < ActiveRecord::Migration
+class CreateFsTables < ActiveRecord::Migration[4.2]
   def self.up
     create_table :fs_features do |t|
       t.string :key
@@ -15,4 +15,9 @@ class CreateFsTables < ActiveRecord::Migration
       t.timestamps null: false
     end
   end
+
+  def self.down
+    drop_table :fs_features
+    drop_table :fs_settings
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feature_setting
 version: !ruby/object:Gem::Version
-  version: 1.5.4
+  version: 1.6.0
 platform: ruby
 authors:
 - Indro De
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-09 00:00:00.000000000 Z
+date: 2019-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -122,20 +122,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
-  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: This gem introduces the concept of "features" and "settings" to your
   Rails app. It provides an easy way to define such features and settings with default
   values right in your code and will persist them in the database.
@@ -182,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: A lightweight feature/setting DSL for Rails applications.