preferencias 0.0.1

data/lib/preferencias/preferences/preferable_class_methods.rb

@@ -0,0 +1,51 @@
+module Preferencias
+  module PreferableClassMethods
+
+    def preference(name, type, *args)
+      options = args.extract_options!
+      options.assert_valid_keys(:default)
+      default = options[:default]
+      default = ->{ options[:default] } unless default.is_a?(Proc)
+
+      # cache_key will be nil for new objects, then if we check if there
+      # is a pending preference before going to default
+      define_method preference_getter_method(name) do
+        preferences.fetch(name) do
+          default.call
+        end
+      end
+
+      define_method preference_setter_method(name) do |value|
+        value = convert_preference_value(value, type)
+        preferences[name] = value
+
+        # If this is an activerecord object, we need to inform
+        # ActiveRecord::Dirty that this value has changed, since this is an
+        # in-place update to the preferences hash.
+        preferences_will_change! if respond_to?(:preferences_will_change!)
+      end
+
+      define_method preference_default_getter_method(name), &default
+
+      define_method preference_type_getter_method(name) do
+        type
+      end
+    end
+
+    def preference_getter_method(name)
+      "preferred_#{name}".to_sym
+    end
+
+    def preference_setter_method(name)
+       "preferred_#{name}=".to_sym
+    end
+
+    def preference_default_getter_method(name)
+      "preferred_#{name}_default".to_sym
+    end
+
+    def preference_type_getter_method(name)
+      "preferred_#{name}_type".to_sym
+    end
+  end
+end

data/lib/preferencias/preferences/scoped_store.rb

@@ -0,0 +1,33 @@
+module Preferencias
+  class ScopedStore
+    def initialize(prefix, suffix = nil)
+      @prefix = prefix
+      @suffix = suffix
+    end
+
+    def store
+      Preferencias::Store.instance
+    end
+
+    def fetch(key, &block)
+      store.fetch(key_for(key), &block)
+    end
+
+    def []=(key, value)
+      store[key_for(key)] = value
+    end
+
+    def delete(key)
+      store.delete(key_for(key))
+    end
+
+    private
+    def key_for(key)
+      [rails_cache_id, @prefix, key, @suffix].compact.join('/')
+    end
+
+    def rails_cache_id
+      ENV['RAILS_CACHE_ID']
+    end
+  end
+end

data/lib/preferencias/preferences/store.rb

@@ -0,0 +1,98 @@
+# Use singleton class Preferencias::Store.instance to access
+#
+# StoreInstance has a persistence flag that is on by default,
+# but we disable database persistence in testing to speed up tests
+#
+
+require 'singleton'
+
+module Preferencias
+
+  class StoreInstance
+    attr_accessor :persistence
+
+    def initialize
+      @cache = ::Rails.cache
+      @persistence = true
+    end
+
+    def set(key, value)
+      @cache.write(key, value)
+      persist(key, value)
+    end
+    alias_method :[]=, :set
+
+    def exist?(key)
+      @cache.exist?(key) ||
+      should_persist? && Preference.where(:key => key).exists?
+    end
+
+    def get(key)
+      # return the retrieved value, if it's in the cache
+      # use unless nil? incase the value is actually boolean false
+      #
+      unless (val = @cache.read(key)).nil?
+        return val
+      end
+
+      if should_persist?
+        # If it's not in the cache, maybe it's in the database, but
+        # has been cleared from the cache
+
+        # does it exist in the database?
+        if preference = Preference.find_by_key(key)
+          # it does exist
+          val = preference.value
+        else
+          # use the fallback value
+          val = yield
+        end
+
+        # Cache either the value from the db or the fallback value.
+        # This avoids hitting the db with subsequent queries.
+        @cache.write(key, val)
+
+        return val
+      else
+        yield
+      end
+    end
+    alias_method :fetch, :get
+
+    def delete(key)
+      @cache.delete(key)
+      destroy(key)
+    end
+
+    def clear_cache
+      @cache.clear
+    end
+
+    private
+
+    def persist(cache_key, value)
+      return unless should_persist?
+
+      preference = Preference.where(:key => cache_key).first_or_initialize
+      preference.value = value
+      preference.save
+    end
+
+    def destroy(cache_key)
+      return unless should_persist?
+
+      preference = Preference.find_by_key(cache_key)
+      preference.destroy if preference
+    end
+
+    def should_persist?
+      @persistence && Preference.table_exists?
+    end
+
+  end
+
+  class Store < StoreInstance
+    include Singleton
+  end
+
+end

data/lib/preferencias/version.rb

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

data/preferences.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'preferencias/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "preferencias"
+  spec.version       = Preferencias::VERSION
+  spec.authors       = ["David Silva"]
+  spec.email         = ["davidslv@gmail.com"]
+  spec.summary       = %q{Extracted Preferences Model from Spree Ecommerce.}
+  spec.description   = %q{It's an extraction of the Spree Ecommerce Preferences. All the credits goes to the Spree authors.}
+  spec.homepage      = "https://github.com/Davidslv/preferences"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "railties", [">= 3.2", "< 4.2"]
+  spec.add_dependency "activesupport", [">= 3.2", "< 4.2"]
+  spec.add_dependency "activerecord", [">= 3.2", "< 4.2"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 0"
+  spec.add_development_dependency "rspec", "3.1.3"
+  spec.add_development_dependency "sqlite3", "~> 0"
+end

data/spec/preference_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Preferencias::Preference do
+
+  it "should require a key" do
+    preference = Preferencias::Preference.new
+    preference.key = :test
+    preference.value = true
+    expect(preference).to be_valid
+  end
+
+  describe "type coversion for values" do
+
+    def round_trip_preference(key, value = false)
+      p = Preferencias::Preference.new
+      p.value = value
+      p.key = key
+      p.save
+
+      Preferencias::Preference.find_by_key(key)
+    end
+
+    it ":boolean" do
+      value = true
+      key = "boolean_key"
+      pref = round_trip_preference(key, value)
+      expect(pref.value).to eq(value)
+    end
+
+    it "false :boolean" do
+      value = false
+      key = "boolean_key"
+      pref = round_trip_preference(key, value)
+      expect(pref.value).to eq(value)
+    end
+
+    it ":integer" do
+      value = 10
+      key = "integer_key"
+      pref = round_trip_preference(key, value)
+      expect(pref.value).to eq(value)
+    end
+
+    it ":decimal" do
+      value = 1.5
+      key = "decimal_key"
+      pref = round_trip_preference(key, value)
+      expect(pref.value).to eq(value)
+    end
+
+    it ":string" do
+      value = "This is a string"
+      key = "string_key"
+      pref = round_trip_preference(key, value)
+      expect(pref.value).to eq(value)
+    end
+
+    it ":text" do
+      value = "This is a string stored as text"
+      key = "text_key"
+      pref = round_trip_preference(key, value)
+      expect(pref.value).to eq(value)
+    end
+
+    it ":password" do
+      value = "This is a password"
+      key = "password_key"
+      pref = round_trip_preference(key, value)
+      expect(pref.value).to eq(value)
+    end
+
+    it ":any" do
+      value = [1, 2]
+      key = "any_key"
+      pref = round_trip_preference(key, value)
+      expect(pref.value).to eq(value)
+    end
+
+  end
+
+end

data/spec/preferencias/configuration_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Preferencias::Configuration do
+
+  before :all do
+    class AppConfig < Preferencias::Configuration
+      preference :color, :string, :default => :blue
+    end
+    @config = AppConfig.new
+  end
+
+  it "has named methods to access preferences" do
+    @config.color = 'orange'
+    expect(@config.color).to eq('orange')
+  end
+
+  it "uses [ ] to access preferences" do
+    @config[:color] = 'red'
+    expect( @config[:color] ).to eq('red')
+  end
+
+  it "uses set/get to access preferences" do
+    @config.set :color, 'green'
+    expect( @config.get(:color) ).to eq('green')
+  end
+
+end

data/spec/preferencias/preferable_spec.rb

@@ -0,0 +1,275 @@
+require 'spec_helper'
+
+describe Preferencias::Preferable do
+
+  before :all do
+    class A
+      include Preferencias::Preferable
+      attr_reader :id
+
+      def initialize
+        @id = rand(999)
+      end
+
+      def preferences
+        @preferences ||= default_preferences
+      end
+
+      preference :color, :string, :default => 'green'
+    end
+
+    class B < A
+      preference :flavor, :string
+    end
+  end
+
+  before :each do
+    @a = A.new
+    allow(@a).to receive_messages(:persisted? => true)
+    @b = B.new
+    allow(@b).to receive_messages(:persisted? => true)
+
+    # ensure we're persisting as that is the default
+    #
+    store = Preferencias::Store.instance
+    store.persistence = true
+  end
+
+  describe "preference definitions" do
+    it "parent should not see child definitions" do
+      expect( @a.has_preference?(:color) ).to be_truthy
+      expect( @a.has_preference?(:flavor) ).to be_falsey
+    end
+
+    it "child should have parent and own definitions" do
+      expect( @b.has_preference?(:color) ).to be_truthy
+      expect( @b.has_preference?(:flavor) ).to be_truthy
+    end
+
+    it "instances have defaults" do
+      expect(@a.preferred_color).to eq('green')
+      expect(@b.preferred_color).to eq('green')
+      expect(@b.preferred_flavor).to be_nil
+    end
+
+    it "can be asked if it has a preference definition" do
+      expect( @a.has_preference?(:color) ).to be_truthy
+      expect( @b.has_preference?(:bad) ).to be_falsey
+    end
+
+    it "can be asked and raises" do
+      expect {
+        @a.has_preference!(:flavor)
+      }.to raise_error(NoMethodError, "flavor preference not defined")
+    end
+
+    it "has a type" do
+      expect(@a.preferred_color_type).to eq(:string)
+      expect( @a.preference_type(:color) ).to eq(:string)
+    end
+
+    it "has a default" do
+      expect(@a.preferred_color_default).to eq('green')
+      expect( @a.preference_default(:color) ).to eq('green')
+    end
+
+    it "raises if not defined" do
+      expect {
+        @a.get_preference(:flavor)
+      }.to raise_error(NoMethodError, "flavor preference not defined")
+    end
+
+  end
+
+  describe "preference access" do
+    it "handles ghost methods for preferences" do
+      @a.preferred_color = 'blue'
+      expect(@a.preferred_color).to eq('blue')
+    end
+
+    it "parent and child instances have their own prefs" do
+      @a.preferred_color = 'red'
+      @b.preferred_color = 'blue'
+
+      expect(@a.preferred_color).to eq('red')
+      expect(@b.preferred_color).to eq('blue')
+    end
+
+    it "raises when preference not defined" do
+      expect {
+        @a.set_preference(:bad, :bone)
+      }.to raise_exception(NoMethodError, "bad preference not defined")
+    end
+
+    it "builds a hash of preferences" do
+      @b.preferred_flavor = :strawberry
+      expect( @b.preferences[:flavor] ).to eq('strawberry')
+      expect( @b.preferences[:color] ).to eq('green') #default from A
+    end
+
+    it "builds a hash of preference defaults" do
+      expect(@b.default_preferences).to eq({
+        flavor: nil,
+        color: 'green'
+      })
+    end
+
+    context "converts integer preferences to integer values" do
+      before do
+        A.preference :is_integer, :integer
+      end
+
+      it "with strings" do
+        @a.set_preference(:is_integer, '3')
+        expect(@a.preferences[:is_integer]).to eq(3)
+
+        @a.set_preference(:is_integer, '')
+        expect(@a.preferences[:is_integer]).to eq(0)
+      end
+
+    end
+
+    context "converts decimal preferences to BigDecimal values" do
+      before do
+        A.preference :if_decimal, :decimal
+      end
+
+      it "returns a BigDecimal" do
+        @a.set_preference(:if_decimal, 3.3)
+        expect(@a.preferences[:if_decimal].class).to eql(BigDecimal)
+      end
+
+      it "with strings" do
+        @a.set_preference(:if_decimal, '3.3')
+        expect(@a.preferences[:if_decimal]).to eql(3.3)
+
+        @a.set_preference(:if_decimal, '')
+        expect(@a.preferences[:if_decimal]).to eql(0.0)
+      end
+    end
+
+    context "converts boolean preferences to boolean values" do
+      before do
+        A.preference :is_boolean, :boolean, :default => true
+      end
+
+      it "with strings" do
+        @a.set_preference(:is_boolean, '0')
+        expect(@a.preferences[:is_boolean]).to be_falsey
+        @a.set_preference(:is_boolean, 'f')
+        expect(@a.preferences[:is_boolean]).to be_falsey
+        @a.set_preference(:is_boolean, 't')
+        expect(@a.preferences[:is_boolean]).to be_truthy
+      end
+
+      it "with integers" do
+        @a.set_preference(:is_boolean, 0)
+        expect(@a.preferences[:is_boolean]).to be_falsey
+        @a.set_preference(:is_boolean, 1)
+        expect(@a.preferences[:is_boolean]).to be_truthy
+      end
+
+      it "with an empty string" do
+        @a.set_preference(:is_boolean, '')
+        expect(@a.preferences[:is_boolean]).to be_falsey
+      end
+
+      it "with an empty hash" do
+        @a.set_preference(:is_boolean, [])
+        expect(@a.preferences[:is_boolean]).to be_falsey
+      end
+    end
+
+    context "converts any preferences to any values" do
+      before do
+        A.preference :product_ids, :any, :default => []
+        A.preference :product_attributes, :any, :default => {}
+      end
+
+      it "with array" do
+        expect(@a.preferences[:product_ids]).to be_empty
+        @a.set_preference(:product_ids, [1, 2])
+        expect(@a.preferences[:product_ids]).to eq [1, 2]
+      end
+
+      it "with hash" do
+        expect(@a.preferences[:product_attributes]).to be_empty
+        @a.set_preference(:product_attributes, {:id => 1, :name => 2})
+        expect(@a.preferences[:product_attributes]).to include(:id => 1, :name => 2)
+      end
+    end
+
+  end
+
+  describe "persisted preferables" do
+    before(:all) do
+      class CreatePrefTest < ActiveRecord::Migration
+        def self.up
+          create_table :pref_tests do |t|
+            t.string :col
+            t.text :preferences
+          end
+        end
+
+        def self.down
+          drop_table :pref_tests
+        end
+      end
+
+      @migration_verbosity = ActiveRecord::Migration.verbose
+      ActiveRecord::Migration.verbose = false
+      CreatePrefTest.migrate(:up)
+
+      class PrefTest < Preferencias::Base
+        preference :pref_test_pref, :string, :default => 'abc'
+        preference :pref_test_any, :any, :default => []
+      end
+    end
+
+    after(:all) do
+      CreatePrefTest.migrate(:down)
+      ActiveRecord::Migration.verbose = @migration_verbosity
+    end
+
+    before(:each) do
+      @pt = PrefTest.create
+    end
+
+    describe "pending preferences for new activerecord objects" do
+      it "saves preferences after record is saved" do
+        pr = PrefTest.new
+        pr.set_preference(:pref_test_pref, 'XXX')
+        expect( pr.get_preference(:pref_test_pref) ).to eql('XXX')
+        pr.save!
+        expect( pr.get_preference(:pref_test_pref) ).to eql('XXX')
+      end
+
+      it "saves preferences for serialized object" do
+        pr = PrefTest.new
+        pr.set_preference(:pref_test_any, [1, 2])
+        expect( pr.get_preference(:pref_test_any) ).to eql [1, 2]
+        pr.save!
+        expect( pr.get_preference(:pref_test_any) ).to eql [1, 2]
+      end
+    end
+
+    it "clear preferences" do
+      @pt.set_preference(:pref_test_pref, 'xyz')
+      expect(@pt.preferred_pref_test_pref).to eql('xyz')
+      @pt.clear_preferences
+      expect(@pt.preferred_pref_test_pref).to eql('abc')
+    end
+
+    it "clear preferences when record is deleted" do
+      @pt.save!
+      @pt.preferred_pref_test_pref = 'lmn'
+      @pt.save!
+      @pt.destroy
+      @pt1 = PrefTest.new(:col => 'aaaa')
+      @pt1.id = @pt.id
+      @pt1.save!
+      expect( @pt1.get_preference(:pref_test_pref) ).to eql('abc')
+    end
+  end
+
+end