mournful_settings 0.0.6 → 0.1.0

data/README.rdoc

@@ -7,48 +7,54 @@ they can be stored encrypted. Aren't puns wonderful.
 
     gem mournful_settings
 
-Setting are stored in a database table 'mournful_settings_settings'. To add 
-mournful_settings migrations to the host app run this rake task:
-
-    rake mournful_settings:install:migrations
-
-Then run 'rake db:migrate' to create the 'mournful_settings_settings' table
-
 == Usage
 
-In the host rails app, create a class you wish to use as the object to hold
-settings, and have it inherit from MournfulSettings::Setting. For example
-(/app/models/settings.rb)
+    class MySetting < ActiveRecord::Base
+
+      acts_as_mournful_setting
 
-    class Setting < MournfulSettings::Setting 
     end
 
 === Fields
-Each setting has five fields:
 
-[name]         Identifies the setting. Used in 'for' (see below)
+Each setting should have five fields:
 
-[value]        The value being stored.
+[name]         String: Identifies the setting. Used in 'for' (see below)
 
-[value_type]   Values are stored as strings. value_type defines how that string 
-               should be presented. For example, '1.23' with value_type 'number' 
-               will be presented as numeric 1.23. If the value_type was 'text'
-               the value returned would be '1.23'.
+[value]        String: The value being stored.
 
-[description]  Information about the setting being stored
+[value_type]   String: defines how that string should be presented. For example, 
+               '1.23' with value_type 'number' will be presented as numeric 1.23. 
+               If the value_type was 'text' the value returned would be '1.23'.
+
+[description]  String or Text: Information about the setting being stored
 
 [encrypted]    Boolean: If set to true, the value will be stored in an encrypted 
                format. Otherwise the value will be stored as plain text.
 
+See db/migrate/001_create_settings.rb for an example migration.
+
+=== Forcing encryption
+
+If you wish to force all settings to be either encrypted or not, you can 
+overwrite the encrypted? method. For example, if you wanted all settings to
+be encrypted:
+
+    def encrypted?
+      true
+    end
+
+If you use this option, you do not need an encrypted field in the database 
+
 === Retrieving a setting
  
 To use a stored setting, use the 'for' class method:
 
-    Setting.create(:name => 'pi', :value => '3.14159', :value_type => 'number')
+    MySetting.create(:name => 'pi', :value => '3.14159', :value_type => 'number')
 
-    Setting.for(:pi)    -->   3.14159
+    MySetting.for(:pi)    -->   3.14159
 
-In this example, Setting.for(:pi) will return nil if there is no Setting
+In this example, MySetting.for(:pi) will return nil if there is no MySetting
 with a name of 'pi' in the database.
 
 === Supplying a default
@@ -56,18 +62,16 @@ with a name of 'pi' in the database.
 If you wish an alternative value to be returned if no matching setting has been
 defined, you can add a default to the for declaration.
 
-    Setting.for(:pi, 3.14)
+    MySetting.for(:pi, 3.14)
 
 This will return 3.14 until a 'pi' setting has been created.
 
-The 
-
 == Encryption
 
 By default mournful settings are encrypted. You can choose not to encrypt a
 setting, by setting :encrypted => false. 
 
-    Setting.create(
+    MySetting.create(
       :name => 'pi', 
       :value => '3.14159', 
       :value_type => 'number',
@@ -80,12 +84,12 @@ Out of the box, encryption uses a blowfish cipher, and a generic key string.
 
 If you wish to use your own encryption key, you can define the key like this:
 
-    MournfulSettings::Setting::Cipher.key = 'your key'
+    MySetting::Cipher.key = 'your key'
 
 Mournful settings uses Ruby's OpenSSL::Cipher. If you wish to change
 the cipher from blowfish, you can alter it like this:
 
-    MournfulSettings::Setting::Cipher.config = 'aes-128-cbc'
+    MySetting::Cipher.config = 'aes-128-cbc'
 
 To see a list of the available options use:
 
@@ -107,7 +111,7 @@ config/application:
         .....
 
         config.before_initialize do
-          MournfulSettings::Setting::Cipher.key = 'your key'
+          MySetting::Cipher.key = 'your key'
         end
       end
     end
@@ -119,9 +123,9 @@ See: http://guides.rubyonrails.org/configuring.html#initialization-events
 If you change the cipher configuration, existing encrypted settings will break.
 Therefore, to make the change after you have started using encrypted settings,
 you must decrypt your settings, make the change and then re-encrypt the settings 
-again. To ease this task, use the Setting.recrypt_all method:
+again. To ease this task, use the MySetting.recrypt_all method:
 
-    Setting.recrypt_all { Setting::Cipher.key = 'your key' }
+    MySetting.recrypt_all { MySetting::Cipher.key = 'your key' }
 
 So the process would be:
 
@@ -130,6 +134,45 @@ So the process would be:
 - Add/Update the configuration code in the app
 - Start the server
 
+== Add functionality by inheritance
+
+The original design for mournful settings relied on the class in the hosting
+app, inheriting its functionality from MournfulSettings::Setting. This 
+functionality is still supported.
+
+For example
+(/app/models/settings.rb)
+
+    class Setting < MournfulSettings::Setting 
+    end
+
+=== Database
+
+When inheriting MournfulSettings::Setting, settings are stored in a database 
+table 'mournful_settings_settings'. This table can be configured via migrations. 
+To add mournful_settings migrations to the host app run this rake task:
+
+    rake mournful_settings:install:migrations
+
+Then run 'rake db:migrate' to create the 'mournful_settings_settings' table.
+
+=== Updating inherited Setting to use acts_as_mournful_setting
+
+The class Setting above could be modified to work with acts_as_mournful_setting,
+like this:
+
+    class Setting < ActiveRecord::Base
+  
+      self.table_name = 'mournful_settings_settings'
+
+      acts_as_mournful_setting
+
+    end
+
+This demonstrates the main advantage of using acts_as_mounful_settings, in that
+you are not restricted as to the table name you wish to use, and it is easier
+to extend the functionality of the setting class.
+
 == Integration with ActiveAdmin
 
 Mournful settings contains an ActiveAdmin register file, that allows settings to 
@@ -137,11 +180,11 @@ be managed from within the parent app's active_admin space. Of course
 ActiveAdmin needs to be installed and working in the parent rails application,
 for this to work.
 
-To use the Mournful settings' ActiveAdmin register files, add this to the 
-active_admin initializer in your application.
+If your host class is Settings, you can use the Mournful settings' ActiveAdmin 
+register files by adding this to the active_admin initializer in your 
+application.
 
     config.load_paths << MournfulSettings.active_admin_load_path
 
-Alternatively, copy lib/active_admin/admin/setting.rb to app/admin within
-the host rails app, and modify it as you desire.
-
+Alternatively, use lib/active_admin/admin/setting.rb as a template for your
+own register file.

data/lib/active_record/acts/mournful_setting.rb

@@ -0,0 +1,22 @@
+require 'mournful_settings/setting_methods'
+module ActiveRecord
+  module Acts
+    module MournfulSetting
+           
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+      
+      module ClassMethods
+        def acts_as_mournful_setting
+          include MournfulSettings::SettingMethods
+          extend MournfulSettings::SettingMethods::ClassMethods
+        end
+        
+      end
+      
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, ActiveRecord::Acts::MournfulSetting)

data/lib/mournful_settings/setting.rb

@@ -1,118 +1,9 @@
-require 'base64'
-require_relative 'setting/cipher'
 module MournfulSettings
   class Setting < ActiveRecord::Base
     
     self.table_name = 'mournful_settings_settings'
        
-    VALUE_TYPES = ['text', 'number', 'decimal']
-    
-    before_save :set_encrypted_true_unless_false
-    before_save :encrypt_value
-
-    validates :value_type, :presence => true, :inclusion => {:in => VALUE_TYPES}
-    validates :value, :presence => true
-    validates :name, :uniqueness => true, :presence => true
-
-    def self.value_types
-      VALUE_TYPES
-    end
-    
-    def self.for(name, default = nil)
-      setting = find_by_name(name)
-      setting ? setting.value : default
-    end
-
-    def value
-      if value_type.present? 
-        parent_value = encrypted? ? decrypt(super) : super
-        
-        case value_type.to_s
-          when 'number'
-            parent_value.to_f
-          when 'decimal'
-            BigDecimal.new(parent_value.to_s)
-          else
-            parent_value
-        end
-      end
-    end
-    
-    def self.recrypt_all &do_while_unencrypted
-      encrypted = where(:encrypted => true)
-      encrypted.each {|s| s.encrypted = false; s.save}
-      do_while_unencrypted.call if do_while_unencrypted
-      encrypted.each {|s| s.encrypted = true; s.save}
-    end
-        
-    private
-    def encrypt(text)
-      add_separators Base64.encode64 Cipher.encrypt text.to_s
-    end
-    
-    def decrypt(text)
-      if is_encrypted?(text)
-        Cipher.decrypt Base64.decode64 remove_separators text
-      else
-        text
-      end
-    end
-    
-    def is_encrypted?(text)
-      inside_separators_and_is_base64_encoded?(text)
-    end
-
-    def inside_separators_and_is_base64_encoded?(text)
-      return unless text.kind_of? String
-      bytes = text.bytes.to_a
-      return unless bytes[0] == separator_byte
-      return unless bytes[-1] == separator_byte
-      return unless bytes[-2] == last_byte_of_base_64_encoded_text
-      non_white_space_with_equal_sign_packing =~ text[1..-3]
-    end
-    
-    def non_white_space_with_equal_sign_packing 
-      /\S+=*/
-    end
-    
-    def set_encrypted_true_unless_false
-      self.encrypted = true unless self.encrypted == false
-    end
-
-    
-    def encrypt_value  
-      if encrypted?
-        self.value = encrypt(self.value)
-      else
-        self.value = decrypt(self.value)
-      end
-    end
-    
-    def add_separators(text)
-      [separator, text, separator].join
-    end
-    
-    def remove_separators(text)
-      text.gsub(separator, "")
-    end
-   
-    # Used to delimit encrypted values to make identification more reliable
-    def separator
-      separator_byte.chr 
-    end
-    
-    
-    def separator_byte
-      31 # ASCII unit separator
-    end
-    
-    def last_byte_of_base_64_encoded_text
-      line_feed_byte
-    end
-    
-    def line_feed_byte
-      10
-    end
+    acts_as_mournful_setting
     
   end
 end

data/lib/mournful_settings/{setting → setting_methods}/cipher.rb

@@ -1,5 +1,5 @@
 module MournfulSettings
-  class Setting < ActiveRecord::Base
+  module SettingMethods 
 
     # Based on http://philtoland.com/post/807114394/simple-blowfish-encryption-with-ruby
     module Cipher

data/lib/mournful_settings/setting_methods.rb

@@ -0,0 +1,120 @@
+require 'base64'
+require_relative 'setting_methods/cipher'
+module MournfulSettings
+  module SettingMethods 
+    
+    VALUE_TYPES = ['text', 'number', 'decimal']
+       
+    def self.included(base)
+      base.before_save :set_encrypted_true_unless_false
+      base.before_save :encrypt_value
+
+      base.validates :value_type, :presence => true, :inclusion => {:in => VALUE_TYPES}
+      base.validates :value, :presence => true
+      base.validates :name, :uniqueness => true, :presence => true
+    end
+    
+    module ClassMethods
+      def value_types
+        VALUE_TYPES
+      end
+
+      def for(name, default = nil)
+        setting = find_by_name(name)
+        setting ? setting.value : default
+      end
+      
+      def recrypt_all &do_while_unencrypted
+        encrypted = where(:encrypted => true)
+        encrypted.each {|s| s.encrypted = false; s.save}
+        do_while_unencrypted.call if do_while_unencrypted
+        encrypted.each {|s| s.encrypted = true; s.save}
+      end
+    end
+
+    def value
+      if value_type.present? 
+        parent_value = encrypted? ? decrypt(super) : super
+        
+        case value_type.to_s
+          when 'number'
+            parent_value.to_f
+          when 'decimal'
+            BigDecimal.new(parent_value.to_s)
+          else
+            parent_value
+        end
+      end
+    end
+        
+    private
+    def encrypt(text)
+      add_separators Base64.encode64 Cipher.encrypt text.to_s
+    end
+    
+    def decrypt(text)
+      if is_encrypted?(text)
+        Cipher.decrypt Base64.decode64 remove_separators text
+      else
+        text
+      end
+    end
+    
+    def is_encrypted?(text)
+      inside_separators_and_is_base64_encoded?(text)
+    end
+
+    def inside_separators_and_is_base64_encoded?(text)
+      return unless text.kind_of? String
+      bytes = text.bytes.to_a
+      return unless bytes[0] == separator_byte
+      return unless bytes[-1] == separator_byte
+      return unless bytes[-2] == last_byte_of_base_64_encoded_text
+      non_white_space_with_equal_sign_packing =~ text[1..-3]
+    end
+    
+    def non_white_space_with_equal_sign_packing 
+      /\S+=*/
+    end
+    
+    def set_encrypted_true_unless_false
+      self.encrypted = true unless self.encrypted == false
+    end
+
+    
+    def encrypt_value  
+      if encrypted?
+        self.value = encrypt(self.value)
+      else
+        self.value = decrypt(self.value)
+      end
+    end
+    
+    def add_separators(text)
+      [separator, text, separator].join
+    end
+    
+    def remove_separators(text)
+      text.gsub(separator, "")
+    end
+   
+    # Used to delimit encrypted values to make identification more reliable
+    def separator
+      separator_byte.chr 
+    end
+    
+    
+    def separator_byte
+      31 # ASCII unit separator
+    end
+    
+    def last_byte_of_base_64_encoded_text
+      line_feed_byte
+    end
+    
+    def line_feed_byte
+      10
+    end
+    
+  end
+end

data/lib/mournful_settings/version.rb

@@ -1,14 +1,22 @@
 module MournfulSettings
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end
 
 # History
 # =======
 # 
+# 0.1.0: Acts As Mournful Setting
+# -------------------------------
+# Changes the way Mournful settings are used. Settings can now be defined via
+# an acts_as_mournful_setting declaration rather than inheriting from 
+# MournfulSettings::Setting. Inheritance is still supported 
+# 
+# 
 # 0.0.6: Adds default option
 # --------------------------
 # Allows alternative to be set, that will be used until setting defined
 # 
+# 
 # 0.0.5: Corrects gem description
 # -------------------------------
 # No functional change.

data/lib/mournful_settings.rb

@@ -1,6 +1,7 @@
 require 'active_record'
-require_relative 'mournful_settings/setting'
 require_relative "mournful_settings/railtie" if defined?(Rails) # needed for rake tasks to be loaded into host app
+require_relative 'active_record/acts/mournful_setting'
+require_relative 'mournful_settings/setting'
 
 module MournfulSettings
   

data/test/dummy/lib/setting.rb

@@ -1,5 +1,5 @@
 require_relative '../../../lib/mournful_settings'
 
 class Setting < MournfulSettings::Setting
-  
+
 end

data/test/dummy/lib/setting_actor.rb

@@ -0,0 +1,9 @@
+require_relative '../../../lib/mournful_settings'
+
+class SettingActor < ActiveRecord::Base
+  
+  self.table_name = 'mournful_settings_settings'
+  
+  acts_as_mournful_setting
+  
+end

data/test/dummy/test/setting_actor_test.rb

@@ -0,0 +1,155 @@
+require_relative '../../test_helper'
+require 'setting_actor'
+
+class SettingActorTest < Test::Unit::TestCase
+  
+  def setup
+    @value = 'A secret'
+    SettingActor::Cipher.config = 'aes-128-cbc'
+    SettingActor::Cipher.key = 'something else'
+  end
+  
+  def teardown
+    SettingActor.delete_all
+  end
+  
+  def test_inheritence
+    assert_not_kind_of(MournfulSettings::Setting, text_setting)   
+  end
+  
+  def test_number_value
+    assert_kind_of(Float, number_setting.value)
+  end
+
+  def test_text_value
+    assert_kind_of(String, text_setting.value)
+  end
+
+  def test_decimal_value
+    assert_kind_of(BigDecimal, decimal_setting.value)
+  end
+  
+  def test_encrypted_value
+    assert_kind_of(String, encrypted_setting.reload.value)
+    assert_equal(@value, encrypted_setting.value)
+  end
+  
+  def test_encrypted_value_is_encrypted_in_database
+    database_value = database_value_for(encrypted_setting)
+    assert_not_equal(database_value, encrypted_setting.value)
+  end
+  
+  def test_encrypted_with_different_value_types
+    {
+      'text' => 'this is a load of text',
+      'number' => 1.33333333,
+      'decimal' => 1.44
+    }.each do |value_type, value|
+      setting = SettingActor.create(:name => value_type, :value => value, :value_type => value_type)
+      assert_equal(value, setting.value)
+      assert_not_equal(database_value_for(setting), setting.value)
+      assert_not_equal(database_value_for(setting).to_s, setting.value.to_s)
+    end
+  end
+  
+  def test_encrypting_an_existing_setting
+    value = number_setting.value
+    number_setting.encrypted = true
+    assert number_setting.save, "Should be able to save a setting after changing it to encrypted"
+    assert_equal(value, number_setting.value)
+  end
+  
+  def test_unencrypting_an_encrypted_setting
+    encrypted_setting.encrypted = false
+    assert encrypted_setting.save, "Should be able to save a setting after changing it to unencrypted"
+    assert_equal(@value, encrypted_setting.value)
+  end
+
+  def test_valid_types
+    SettingActor::VALUE_TYPES.each do |valid_type|
+      number_setting.value_type = valid_type
+      assert(number_setting.valid?, "number_setting should be valid when value_type = #{valid_type}")
+    end
+  end
+
+  def test_invalid_type
+    number_setting.value_type = 'invalid'
+    assert(number_setting.invalid?, "number_setting should be invalid")
+  end
+
+  def test_for
+    [number_setting, text_setting, decimal_setting, encrypted_setting].each do |setting|
+      assert_equal(setting.value, SettingActor.for(setting.name.to_sym))
+    end
+  end
+
+  def test_for_when_no_matching_setting
+    assert_nil(SettingActor.for(:nothing), "Should return nil when setting doesn't exist")
+  end
+  
+  def test_for_with_default_provided
+    default = 'Something else'
+    assert_equal(default, SettingActor.for(:nothing, default))
+  end
+  
+  def test_setting_an_invalid_cipher_config
+    assert_raises RuntimeError do
+      SettingActor::Cipher.config = 'invalid'
+    end
+  end
+  
+  def test_changing_cipher
+    cipher = 'bf-cbc'
+    assert_not_equal(cipher, SettingActor::Cipher.config)
+    test_encrypted_value
+    SettingActor::Cipher.config = cipher
+    assert_equal(cipher, SettingActor::Cipher.config)
+    assert_raise OpenSSL::Cipher::CipherError do
+      test_encrypted_value
+    end
+  end
+  
+  def test_changing_key
+    key = 'Some new key'
+    assert_not_equal(key, SettingActor::Cipher.key)
+    test_encrypted_value
+    SettingActor::Cipher.key = key
+    assert_equal(key, SettingActor::Cipher.key)
+    assert_raise OpenSSL::Cipher::CipherError do
+      test_encrypted_value
+    end
+  end
+  
+  def test_recrypt_all
+    key = 'Some new key'
+    assert_not_equal(key, SettingActor::Cipher.key)
+    test_encrypted_value
+    SettingActor.recrypt_all { SettingActor::Cipher.key = key }
+    assert_equal(key, SettingActor::Cipher.key)
+    test_encrypted_value
+  end
+ 
+  private
+  def text_setting 
+    @text_setting ||= SettingActor.create(:name => 'text_setting', :value => 'foo', :value_type => 'text', :encrypted => false)
+  end
+  
+  def number_setting
+    @number_setting ||= SettingActor.create(:name => 'number_setting', :value => '1.33333333333333', :value_type => 'number', :encrypted => false)    
+  end
+  
+  def decimal_setting
+    @decimal_setting ||= SettingActor.create(:name => 'decimal_setting', :value => '4.55', :value_type => 'decimal', :encrypted => false)    
+  end
+  
+  def encrypted_setting
+    @encrypted_setting ||= SettingActor.create(:name => 'encrypted_setting', :value => @value, :value_type => 'text')
+  end
+  
+  def database_value_for(setting)
+    sql = "SELECT value FROM mournful_settings_settings WHERE id = #{setting.id}"
+    SettingActor.connection.select_value(sql)
+  end
+  
+  
+end

data/test/dummy/test/setting_test.rb

@@ -1,4 +1,5 @@
 require_relative '../../test_helper'
+require 'setting'
 
 class SettingTest < Test::Unit::TestCase
   

data/test/test_helper.rb

@@ -1,4 +1,5 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'dummy','lib')
 
 require 'test/unit'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mournful_settings
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-11 00:00:00.000000000 Z
+date: 2013-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -51,9 +51,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/active_record/acts/mournful_setting.rb
 - lib/mournful_settings/version.rb
-- lib/mournful_settings/setting/cipher.rb
 - lib/mournful_settings/setting.rb
+- lib/mournful_settings/setting_methods/cipher.rb
+- lib/mournful_settings/setting_methods.rb
 - lib/mournful_settings/railtie.rb
 - lib/mournful_settings.rb
 - lib/active_admin/admin/settings.rb
@@ -61,9 +63,11 @@ files:
 - MIT-LICENSE
 - Rakefile
 - README.rdoc
+- test/dummy/lib/setting_actor.rb
 - test/dummy/lib/setting.rb
 - test/dummy/db/development.sqlite3.db
 - test/dummy/db/test.sqlite3.db
+- test/dummy/test/setting_actor_test.rb
 - test/dummy/test/setting_test.rb
 - test/test_helper.rb
 homepage: https://github.com/reggieb/mournful_settings
@@ -91,8 +95,10 @@ signing_key:
 specification_version: 3
 summary: Tool for adding encrypted settings to an app.
 test_files:
+- test/dummy/lib/setting_actor.rb
 - test/dummy/lib/setting.rb
 - test/dummy/db/development.sqlite3.db
 - test/dummy/db/test.sqlite3.db
+- test/dummy/test/setting_actor_test.rb
 - test/dummy/test/setting_test.rb
 - test/test_helper.rb