tunable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8f46c7acc701e5042514bd5e5b38aaf6e7d55f36
+  data.tar.gz: d64dacc173796faffd043002b8984df92f2f744a
+SHA512:
+  metadata.gz: 4f3b123409df4270709860c7f0f02ae43e738450905ef44494664a01ef54c583a5897ca723e8fc120e849c465b1a26fdd5d2060c369551fa59e2a1e479ae497f
+  data.tar.gz: 8c89d8944a34e84aa30c79ac91504aa120c31d6788bbe01f2ecabc61ea98f01a2c0098fae763458df75529a8f09153868d90eb1fea2f6c9b9fabe8f76b8ba1b3

data/.gitignore

@@ -0,0 +1 @@
+*~

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# specified in tuktuk.gemspec
+gemspec

data/README.md

@@ -0,0 +1,115 @@
+Tunable
+=======
+
+Pluggable settings for your AR models.
+
+The code
+--------
+
+Let's set up notification settings for our Users.
+
+``` rb
+class User < ActiveRecord::Base
+  include Tunable::Model
+
+  has_settings :notify => :activity, :new_messages, :weekly_report
+
+end
+```
+
+Now we can do:
+
+``` rb
+  user = User.create(:name => 'John Lennon')
+  user.get_setting(:notify, :activity) # => nil
+
+  user.settings = { notify: { activity: true } }
+  user.save
+
+  user.get_setting(:notify, :activity) # => true
+```
+
+Tunable also lets you set defaults for your settings. Here's how.
+
+
+``` rb
+class User < ActiveRecord::Base
+  include Tunable::Model
+
+  has_settings :notify => {
+    activity:      { default: false },
+    new_messages:  { default: true },
+    weekly_report: { default: true }
+  }
+
+end
+```
+
+Now we can do:
+
+``` rb
+  user = User.create(:name => 'John Lennon')
+  user.get_setting(:notify, :new_messages) # => true (default value)
+
+  user.settings = { notify: { new_messages: false } }
+  user.save
+
+  user.get_setting(:notify, :new_messages) # => false
+```
+
+Tunable also provides a `main_settings` helper that sets up main level settings.
+
+``` rb
+class User < ActiveRecord::Base
+  include Tunable::Model
+
+  # in this case we're not setting a default value for the :no_cookies setting
+  main_settings :no_cookies, :language => { :default => 'en' }
+
+end
+```
+
+Now let's see what happens.
+
+
+``` rb
+  user = User.create(:name => 'Paul MacCartney')
+  user.no_cookies # => nil
+  user.language # => 'en'
+
+  user.language = 'es'
+  user.no_cookies = true
+  user.save
+
+  user.no_cookies # => true
+  user.language # => 'es'
+```
+
+You can also set a lambda to return the default setting for a model.
+
+
+```
+class User < ActiveRecord::Base
+
+  main_settings :layout_color => {
+    :default => lambda { |user| user.is_admin? ? 'black' : 'blue' }
+  }
+
+end
+```
+
+Then:
+
+``` rb
+  user = User.create(:name => 'Ringo Starr', :admin => false)
+  user.layout_color # => 'blue'
+  user.admin = true
+  user.layout_color # => 'black'
+```
+
+That's pretty much it.
+
+Boring stuff
+------------
+
+Copyright (c) Fork Ltd. (http://forkhq.com), released under the MIT license.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+end

data/generators/tunable_migration/templates/migration.rb

@@ -0,0 +1,23 @@
+class TunableMigration < ActiveRecord::Migration
+  def self.up
+    create_table :settings do |t|
+      t.column :context, :string
+      t.column :key, :string
+      t.column :value, :string
+
+      t.column :settable_id, :integer
+      t.column :settable_type, :string
+      t.column :created_at, :datetime
+    end
+
+    add_index :settings, [:settable_id, :settable_type]
+    add_index :settings, [:settable_id, :context, :key], :unique => true
+  end
+
+  def self.down
+    remove_index :settings, :name => "index_settings_on_settable_id_and_settable_type"
+    remove_index :settings, :name => "index_settings_on_settable_id_and_context_and_key"
+
+    drop_table :settings
+  end
+end

data/generators/tunable_migration/tunable_migration_generator.rb

@@ -0,0 +1,7 @@
+class TunableMigrationGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => "acts_as_settable_migration"
+    end
+  end
+end

data/lib/tunable/core_ext.rb

@@ -0,0 +1,41 @@
+require 'tunable/emoji_fix'
+
+module Tunable
+
+  module ActiveRecordExtensions
+
+    def import(columns, values, options = {})
+      if columns.length != values[0].length
+        raise ArgumentError "Column and row lengths must match!"
+      end
+
+      columns_array = columns.map { |column| connection.quote_column_name(column) }
+
+      values_array = values.map do |arr|
+        row_values = []
+        arr.each_with_index do |val, i|
+          row_values << connection.quote(val)
+        end
+        row_values.join(',')
+      end
+
+      values_array = values_array.map{ |str| str.gsub(EmojiFix::REGEX, " ") }
+      insert_method = options[:method] || 'INSERT'
+      sql = "#{insert_method} INTO `#{self.table_name}` (#{columns_array.join(',')}) VALUES "
+
+      # sqlite3 does not support multiple insert/replace,
+      # so we need to generate a transaction with separate queries
+      if ActiveRecord::Base.connection.adapter_name.downcase == 'sqlite'
+        values_array.each do |vals|
+          row_sql = "#{sql}(#{vals})"
+          connection.execute(row_sql)
+        end
+      else
+        sql += "(#{values_array.join('),(')})"
+        connection.execute(sql)
+      end
+    end
+
+  end
+
+end

data/lib/tunable/emoji_fix.rb

@@ -0,0 +1,5 @@
+module EmojiFix
+
+  REGEX = /[\u{203C}\u{2049}\u{20E3}\u{2122}\u{2139}\u{2194}-\u{2199}\u{21A9}-\u{21AA}\u{231A}-\u{231B}\u{23E9}-\u{23EC}\u{23F0}\u{23F3}\u{24C2}\u{25AA}-\u{25AB}\u{25B6}\u{25C0}\u{25FB}-\u{25FE}\u{2600}-\u{2601}\u{260E}\u{2611}\u{2614}-\u{2615}\u{261D}\u{263A}\u{2648}-\u{2653}\u{2660}\u{2663}\u{2665}-\u{2666}\u{2668}\u{267B}\u{267F}\u{2693}\u{26A0}-\u{26A1}\u{26AA}-\u{26AB}\u{26BD}-\u{26BE}\u{26C4}-\u{26C5}\u{26CE}\u{26D4}\u{26EA}\u{26F2}-\u{26F3}\u{26F5}\u{26FA}\u{26FD}\u{2702}\u{2705}\u{2708}-\u{270C}\u{270F}\u{2712}\u{2714}\u{2716}\u{2728}\u{2733}-\u{2734}\u{2744}\u{2747}\u{274C}\u{274E}\u{2753}-\u{2755}\u{2757}\u{2764}\u{2795}-\u{2797}\u{27A1}\u{27B0}\u{2934}-\u{2935}\u{2B05}-\u{2B07}\u{2B1B}-\u{2B1C}\u{2B50}\u{2B55}\u{3030}\u{303D}\u{3297}\u{3299}\u{1F004}\u{1F0CF}\u{1F170}-\u{1F171}\u{1F17E}-\u{1F17F}\u{1F18E}\u{1F191}-\u{1F19A}\u{1F1E7}-\u{1F1EC}\u{1F1EE}-\u{1F1F0}\u{1F1F3}\u{1F1F5}\u{1F1F7}-\u{1F1FA}\u{1F201}-\u{1F202}\u{1F21A}\u{1F22F}\u{1F232}-\u{1F23A}\u{1F250}-\u{1F251}\u{1F300}-\u{1F320}\u{1F330}-\u{1F335}\u{1F337}-\u{1F37C}\u{1F380}-\u{1F393}\u{1F3A0}-\u{1F3C4}\u{1F3C6}-\u{1F3CA}\u{1F3E0}-\u{1F3F0}\u{1F400}-\u{1F43E}\u{1F440}\u{1F442}-\u{1F4F7}\u{1F4F9}-\u{1F4FC}\u{1F500}-\u{1F507}\u{1F509}-\u{1F53D}\u{1F550}-\u{1F567}\u{1F5FB}-\u{1F640}\u{1F645}-\u{1F64F}\u{1F680}-\u{1F68A}]/
+
+end

data/lib/tunable/hasher.rb

@@ -0,0 +1,30 @@
+module Tunable
+
+  module Hasher
+
+    def self.flatten(hash, primary_key, secondary_key = nil)
+      if secondary_key.nil?
+        hashify_using(hash, primary_key)
+      else
+        double_hashify_using(hash, primary_key, secondary_key)
+      end
+    end
+
+    private
+
+    def self.hashify_using(hash, key)
+      return {} if hash.empty?
+      Hash[*hash.collect { |v| [v.send(key).to_sym, v.normalized_value] }.flatten]
+    end
+
+    def self.double_hashify_using(hash, primary_key, secondary_key)
+      return {} if hash.empty?
+      c = {}
+      hash.collect { |e| c[e.send(primary_key).to_sym] = {} }
+      hash.collect { |e| c[e.send(primary_key).to_sym][e.send(secondary_key).to_sym] = e.normalized_value }
+      c
+    end
+
+  end
+
+end

data/lib/tunable/model.rb

@@ -0,0 +1,260 @@
+require 'active_support/concern'
+require 'tunable/setting'
+require 'tunable/hasher'
+
+module Tunable
+
+  COLUMNS = [:context, :key, :value, :settable_id, :settable_type]
+
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      # class variables for main settings and defaults
+      class_variable_set('@@main_settings', [])
+      class_variable_set('@@default_settings', {})
+
+      # declare relationship
+      has_many :settings, :class_name => "Tunable::Setting", :as => :settable, :dependent => :delete_all
+
+      # and make sure settings are saved after any changes
+      after_save :save_new_settings
+    end
+
+    module ClassMethods
+
+      def default_settings(context)
+        class_variable_get('@@default_settings')[context.to_sym] || {}
+      end
+
+      def main_settings_list
+        class_variable_get('@@main_settings')
+      end
+
+      def set_default_setting(key, field, value)
+        hash = class_variable_get('@@default_settings')
+        hash[key.to_sym] = {} unless hash[key.to_sym]
+        hash[key.to_sym][field.to_sym] = value
+
+        class_variable_set('@@default_settings', hash)
+      end
+
+      def has_settings(contexts)
+
+        contexts.each do |name, options|
+
+          if options.is_a?(Array)
+            res = {}
+            options.each { |el| res[el.keys.first] = el.values.first }
+          else
+            res = options
+          end
+
+          res.each do |field, opts|
+            if opts.is_a?(Hash)
+              default = opts[:default]
+            else
+              default = opts
+            end
+
+            set_default_setting(name, field, default) unless default.nil?
+          end
+        end
+
+      end
+
+      def main_settings(*options)
+
+        if options[0].is_a?(Hash)
+          fields = options[0]
+        else # no defaults
+          fields = {}
+          options.each { |key| fields[key] = {} }
+        end
+
+        fields.each do |field, opts|
+
+          if opts.is_a?(Hash)
+            strict  = opts[:strict]
+            default = opts[:default]
+          else
+            default = opts
+            strict = false
+          end
+
+          main_settings_list.push(field)
+          set_default_setting(:main, field, default) unless default.nil?
+
+          define_method field do
+            if instance_variable_defined?("@setting_main_#{field}")
+              # the instance var is already normalized to 1/0 when called by the setter
+              Tunable.getter_value(instance_variable_get("@setting_main_#{field}"))
+            else
+              current = main_settings[field.to_sym]
+              default_value = default.is_a?(Proc) ? default.call(self) : default
+              current.nil? ? default_value : current
+            end
+          end
+
+          define_method "#{field}?" do
+            main_setting_on?(field.to_sym)
+          end
+
+          define_method "#{field}_changed?" do
+            changes[field.to_sym].present?
+          end
+
+          define_method "#{field}=" do |raw_value|
+
+            if strict && !default.nil? && !Tunable.matching_type(raw_value, default)
+              raise "Invalid value: #{raw_value}. Expected #{default.class}, got #{raw_value.class}"
+            end
+
+            value   = Tunable.normalize_value(raw_value)
+            current = Tunable.normalize_value(send("#{field}"))
+            # debug "Setting #{field} to #{value} (#{value.class}), current: #{current} (#{current.class})"
+
+            if value === current
+              send('changed_attributes').delete(field) # in case we had set if before
+              return
+            end
+
+            instance_variable_set("@setting_main_#{field}", value)
+
+            if value.nil?
+              main_settings.delete(field.to_sym)
+              queue_setting_for_deletion(:main, field)
+            else
+              main_settings[field.to_sym] = value
+              queue_setting_for_update(:main, field, value)
+            end
+          end
+
+        end
+
+      end # main_settings
+
+    end # ClassMethods
+
+    # instance methods below
+
+    def settings=(hash)
+      puts hash.inspect
+      Tunable::Setting.store_many(hash, self)
+    end
+
+    def settings_hash
+      if modified_settings.any?
+        puts "Settings have been changed. Hash will be incomplete."
+      end
+
+      @object_hashed_settings ||= Hasher.flatten(settings.reload, :context, :key)
+    end
+
+    def get_setting(context, key)
+      val = settings_context(context)[key]
+
+      # if value is nil or no default is set, stop here
+      return val if !val.nil? or self.class.default_settings(context)[key.to_sym].nil?
+
+      self.class.default_settings(context)[key.to_sym]
+    end
+
+    def get_main_setting(key)
+      get_setting(:main, key)
+    end
+
+    def settings_context(context)
+      settings_hash[context.to_sym] || {}
+    end
+
+    def main_settings
+      settings_context(:main)
+    end
+
+    def clear_instance_settings
+      @object_hashed_settings = nil
+      @settings = nil # so settings get reloaded from DB
+    end
+
+    def setting_off?(context, key)
+      get_setting(context, key) == false
+    end
+
+    def setting_on?(context, key)
+      get_setting(context, key) == true
+    end
+
+    def queue_setting_for_update(context, key, val)
+      if self.class.main_settings_list.include?(key.to_sym)
+        send('changed_attributes')[key.to_sym] = val
+      end
+      (modified_settings[context.to_sym] ||= {})[key.to_sym] = val
+    end
+
+    def queue_setting_for_deletion(context, key)
+      if self.class.main_settings_list.include?(key)
+        send('changed_attributes')[key.to_sym] = nil
+      end
+      (deleted_settings[context.to_sym] ||= []) << key.to_sym
+    end
+
+    private
+
+    def modified_settings
+      @modified_settings ||= {}
+    end
+
+    def deleted_settings
+      @deleted_settings ||= {}
+    end
+
+    def delete_setting(context, key)
+      Tunable::Setting.delete_all(
+        :context       => context.to_s,
+        :key           => key.to_s,
+        :settable_type => self.class.model_name.to_s,
+        :settable_id   => self.id
+      )
+    end
+
+    def save_new_settings
+
+      if modified_settings.any?
+        # debug "Saving new settings: #{modified_settings.inspect}"
+        new_settings = []
+
+        modified_settings.each do |context, fields|
+          fields.each do |key, value|
+            # even though we do normalize on the setters, not all settings are
+            # main settings, so we need to make sure we normalize here again
+            normalized_value = Tunable.normalize_value(value)
+
+            new_settings << [context.to_s, key.to_s, normalized_value, self.id, self.class.model_name.to_s]
+            # remove_instance_variable("@setting_main_#{key}") if context == :main
+          end
+        end
+
+        Tunable::Setting.import(Tunable::COLUMNS, new_settings, { :method => 'REPLACE' }) # from lib/core_ext
+      end
+
+      if deleted_settings.any?
+        # puts deleted_settings.inspect
+        deleted_settings.each do |context, fields|
+          fields.each do |key|
+            delete_setting(context.to_s, key.to_s)
+            # remove_instance_variable("@setting_main_#{key}") if context == :main
+          end
+        end
+      end
+
+      self.clear_instance_settings
+      @modified_settings = {}
+      @deleted_settings = {}
+
+      true # make sure the other callbacks are triggered
+    end
+
+  end
+
+end

data/lib/tunable/normalizer.rb

@@ -0,0 +1,34 @@
+module Tunable
+
+  module Normalizer
+
+    TRUTHIES = ['true', 't', 'on', 'yes', 'y', '1'].freeze
+    FALSIES  = ['false', 'f', 'off', 'no', 'n', '0'].freeze
+
+    def normalize_value(val)
+      return 1 if TRUTHIES.include?(val.to_s)
+      return 0 if FALSIES.include?(val.to_s)
+      return if val.blank? # false.blank? returns true so this needs to go after the 0 line
+      val
+    end
+
+    def getter_value(normalized)
+      return normalized === 1 ? true : normalized === 0 ? false : normalized
+    end
+
+    # Called from Setting#normalized_value and DeviceActions#toggle_action
+    def normalize_and_get(val)
+      getter_value(normalize_value(val))
+    end
+
+    def matching_type(a, b)
+      if [true, false].include?(a)
+        return [true, false].include?(b)
+      else
+        a.class == b.class
+      end
+    end
+
+  end
+
+end

data/lib/tunable/setting.rb

@@ -0,0 +1,59 @@
+require 'tunable/core_ext'
+
+module Tunable
+
+  class Setting < ActiveRecord::Base
+    extend ActiveRecordExtensions
+
+    belongs_to :settable, :polymorphic => true
+
+    # scope :for_context, lambda { |context|
+    #   return if context.blank?
+    #   where(:context => context)
+    # }
+
+    # scope :main, lambda { where(:context => 'main') }
+
+    # scope :get, lambda { |key|
+    #   return if key.blank?
+    #   where(:key => key)
+    # }
+
+    # this method regenerates all settings when updating a device.
+    # we first remove all the settings (we dont get params from disabled modules)
+    def self.store_many(hash, object)
+      wipe_all(object) and return if hash.blank?
+
+      hash.each do |context, fields|
+        fields.each do |key, val|
+          if val.blank? && object.settings_context(context.to_sym)[key.to_sym].present?
+
+            # setting was present and now deleted
+            object.queue_setting_for_deletion(context, key)
+
+          elsif val != object.settings_context(context.to_sym)[key.to_sym]
+
+            # settings different from previous, so update
+            object.queue_setting_for_update(context, key, val)
+          end
+        end
+      end
+    end
+
+    def self.wipe_all(object)
+      count = object.settings.where("`context` != 'main'").delete_all
+      # debug "#{count} deleted settings."
+      true
+    end
+
+    def normalized_value
+      Tunable.normalize_and_get(self[:value])
+    end
+
+    def value=(val)
+      self[:value] = Tunable.normalize_value(val)
+    end
+
+  end
+
+end

data/lib/tunable/version.rb

@@ -0,0 +1,5 @@
+module Tunable
+
+  VERSION = '0.0.1'
+
+end

data/lib/tunable.rb

@@ -0,0 +1,6 @@
+require 'tunable/model'
+require 'tunable/normalizer'
+
+module Tunable
+  extend Normalizer
+end

data/spec/schema.rb

@@ -0,0 +1,17 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table "settings", :force => true do |t|
+    t.integer  "settable_id",   :limit => 11
+    t.string   "settable_type"
+    t.string   "context"
+    t.string   "key"
+    t.string   "value"
+    t.datetime "created_at"
+  end
+
+  add_index "settings", ["settable_id", "context", "key"], name: "index_settings_on_settable_id_and_context_and_key", unique: true, using: :btree
+  add_index "settings", ["settable_id", "settable_type"], name: "index_settings_on_settable_id_and_settable_type", using: :btree
+
+  create_table :tunable_models, :force => true do |t|
+    t.column :name, :string
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'active_support'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  "adapter" => "sqlite3", "database" => ':memory:'
+)
+
+ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+
+this_path = File.dirname(__FILE__)
+load File.join(this_path, '/schema.rb')
+require File.join(this_path, '..', 'lib', 'tunable.rb')
+
+class TunableModel < ActiveRecord::Base
+  include Tunable::Model
+end
+
+def load_main_settings!
+
+  TunableModel.main_settings \
+    :boolean_setting,
+    :number_setting,
+    :empty_setting,
+    :on_off_setting,
+    :y_n_setting,
+    :other_setting
+
+=begin
+  TunableModel.main_settings ({
+    :boolean_setting => { :default => true },
+    :number_setting  => { :default => false },
+    :empty_setting   => { },
+    :on_off_setting  => { },
+    :y_n_setting     => { :default => 'y', :strict => false },
+    :other_setting   => { }
+  })
+=end
+
+end