mournful_settings 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Rob Nichols
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,74 @@
+= Mournful Settings
+
+Adds a settings class to a rails app. The settings are mournful because
+they can be stored encrypted. Aren't puns wonderful.
+
+== Installation
+
+    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 Setting < MournfulSettings::Setting 
+    end
+
+=== Fields
+Each setting has five fields:
+
+[name]         Identifies the setting. Used in 'for' (see below)
+
+[value]        The value being stored.
+
+[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'.
+
+[description]  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.
+
+=== Retrieving a setting
+ 
+To use a stored setting, use the 'for' class method:
+
+    Setting.create(:name => 'pi', :value => '3.14159', :value_type => 'number')
+
+    Setting.for(:pi)    -->   3.14159
+
+== Encryption
+
+By default mournful settings uses a blowfish cipher to encrypt settings, and
+its own key string.
+
+=== Set key
+
+If you wish to use your own encryption key, you can define the key in
+an initializer, like this:
+
+    Setting::Cipher.key = 'your key'
+
+=== Change cipher
+
+Mournful settings uses Ruby's OpenSSL::Cipher. If you wish to use to change
+the cipher from blowfish, you can alter it like this:
+
+    Setting::Cipher.config = 'aes-128-cbc'
+
+To see a list of the available options use:
+
+    puts OpenSSL::Cipher.ciphers
+
+See: http://ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/Cipher.html

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rdoc/task'
+require 'rake/testtask'
+require 'logger'
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.rdoc" # page to start on
+  rdoc.title = "Dibber Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end
+
+namespace :mournful_settings do
+  
+  namespace :db do
+    task :environment do
+      require 'active_record'
+      environment = ENV['RAILS_ENV'] || 'development'
+      ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database =>  "test/dummy/db/#{environment}.sqlite3.db"
+    end
+
+    desc "Migrate the database"
+    task(:migrate => :environment) do
+      ActiveRecord::Migrator.migrate("db/migrate", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    end
+
+    desc "Roll back the database"
+    task(:rollback => :environment) do
+      ActiveRecord::Migrator.rollback("db/migrate")
+    end
+  end
+  
+end

data/lib/mournful_settings/railtie.rb

@@ -0,0 +1,11 @@
+require 'mournful_settings'
+require 'rails'
+module MournfulSettings
+  class Railtie < Rails::Railtie
+    # makes mournful_settings rake tasks available to host app
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__),'../tasks/*.rake')].each { |f| load f }
+    end 
+    
+  end
+end

data/lib/mournful_settings/setting/cipher.rb

@@ -0,0 +1,43 @@
+module MournfulSettings
+  class Setting < ActiveRecord::Base
+
+    # Based on http://philtoland.com/post/807114394/simple-blowfish-encryption-with-ruby
+    module Cipher
+      def self.cipher(mode, data)
+        cipher = OpenSSL::Cipher::Cipher.new(config).send(mode)
+        cipher.key = Digest::SHA256.digest(key)
+        cipher.update(data) << cipher.final
+      end
+
+      def self.encrypt(data)
+        cipher(:encrypt, data)
+      end
+
+      def self.decrypt(text)
+        cipher(:decrypt, text)
+      end
+      
+      def self.key=(text)
+        @key = text
+      end
+      
+      def self.key
+        @key ||= 'Set your own with Setting::Cipher.key = your_key'
+      end
+      
+      def self.config=(text)
+        raise "'#{text}' is not a value cipher" unless OpenSSL::Cipher::Cipher.ciphers.include?(text)
+        @config = text 
+      end
+      
+      def self.config
+        @config ||= blowfish_cipher
+      end
+      
+      def self.blowfish_cipher
+        'bf-cbc' 
+      end
+    end
+    
+  end
+end

data/lib/mournful_settings/setting.rb

@@ -0,0 +1,106 @@
+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 :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)
+      setting = find_by_name(name)
+      setting.value if setting
+    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 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

@@ -0,0 +1,3 @@
+module MournfulSettings
+  VERSION = "0.0.1"
+end

data/lib/mournful_settings.rb

@@ -0,0 +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
+
+module MournfulSettings
+    
+end

data/lib/tasks/mournful_settings.rake

@@ -0,0 +1,28 @@
+namespace :mournful_settings do
+
+  desc 'Outputs a mournful test message'
+  task(:task_test => :environment) do
+    puts "Able to access mournful tasks located at #{File.dirname(__FILE__)}"
+  end
+  
+  namespace :install do
+    # TODO - register within 'rake railties:install:migrations'
+    desc 'Copies mournful_settings migrations to host rails app'
+    task(:migrations => :environment) do
+      mournful_migrate_path = File.expand_path("../../db/migrate", File.dirname(__FILE__)) 
+      rails_migrate_path = File.expand_path("db/migrate", Rails.root)
+      scope = :mournful_settings
+      migration = ActiveRecord::Migration.new
+      output = migration.copy rails_migrate_path, {scope => mournful_migrate_path}
+      if output.empty?
+        puts "No migrations copied to #{rails_migrate_path}"
+      else
+        puts "Migrations created at #{rails_migrate_path}:"
+        files = output.collect{|m| m.filename.sub rails_migrate_path, ""}
+        files.each{|m| puts "\t#{m}"}
+      end
+    end
+  end
+  
+  
+end

data/test/dummy/lib/setting.rb

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

data/test/dummy/test/setting_test.rb

@@ -0,0 +1,118 @@
+require_relative '../../test_helper'
+
+class SettingTest < Test::Unit::TestCase
+  
+  def setup
+    @value = 'A secret'
+    Setting::Cipher.config = 'aes-128-cbc'
+    Setting::Cipher.key = 'something else'
+  end
+  
+  def teardown
+    Setting.delete_all
+  end
+  
+  def test_inheritence
+    assert_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.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 = Setting.create(:name => value_type, :value => value, :value_type => value_type, :encrypted => true)
+      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
+    Setting::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, Setting.for(setting.name.to_sym))
+    end
+  end
+
+  def test_for_when_no_matching_setting
+    assert_nil(Setting.for(:nothing), "Should return nil when setting doesn't exist")
+  end
+  
+  def test_setting_an_invalid_cipher_config
+    assert_raises RuntimeError do
+      Setting::Cipher.config = 'invalid'
+    end
+  end
+  
+  private
+  def text_setting 
+    @text_setting ||= Setting.create(:name => 'text_setting', :value => 'foo', :value_type => 'text')
+  end
+  
+  def number_setting
+    @number_setting ||= Setting.create(:name => 'number_setting', :value => '1.33333333333333', :value_type => 'number')    
+  end
+  
+  def decimal_setting
+    @decimal_setting ||= Setting.create(:name => 'decimal_setting', :value => '4.55', :value_type => 'decimal')    
+  end
+  
+  def encrypted_setting
+    @encrypted_setting ||= Setting.create(:name => 'encrypted_setting', :value => @value, :value_type => 'text', :encrypted => true)
+  end
+  
+  def database_value_for(setting)
+    sql = "SELECT value FROM mournful_settings_settings WHERE id = #{setting.id}"
+    Setting.connection.select_value(sql)
+  end
+  
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+
+require 'active_record'
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database =>  "test/dummy/db/test.sqlite3.db"

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: mournful_settings
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rob Nichols
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Packages up code needed to pull data from YAML files when seeding, and
+  adds a process log.
+email:
+- rob@undervale.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mournful_settings/version.rb
+- lib/mournful_settings/setting/cipher.rb
+- lib/mournful_settings/setting.rb
+- lib/mournful_settings/railtie.rb
+- lib/mournful_settings.rb
+- lib/tasks/mournful_settings.rake
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- test/dummy/lib/setting.rb
+- test/dummy/db/development.sqlite3.db
+- test/dummy/db/test.sqlite3.db
+- test/dummy/test/setting_test.rb
+- test/test_helper.rb
+homepage: https://github.com/reggieb/mournful_settings
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Tool for adding encrypted settings to an app.
+test_files:
+- test/dummy/lib/setting.rb
+- test/dummy/db/development.sqlite3.db
+- test/dummy/db/test.sqlite3.db
+- test/dummy/test/setting_test.rb
+- test/test_helper.rb