friendly-attributes 0.7.1.1 → 0.7.2

data/.gitignore

@@ -0,0 +1,45 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+#
+# For TextMate
+#*.tmproj
+#tmtags
+#
+# For emacs:
+#*~
+#\#*
+#.\#*
+#
+# For vim:
+#*.swp
+spec/config.yml
+log
+friendly-attributes.tmproj

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+before_script:
+  - mysql -e 'create database friendly_attributes_test;'
+  - cp spec/config.sample.yml spec/config.yml

data/.yardopts

@@ -0,0 +1 @@
+--no-private lib/**/*.rb - CHANGELOG.md LICENSE.txt

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    friendly-attributes (0.7.2)
+      activerecord (~> 2.3.18)
+      ihoka-friendly (~> 0.7.0)
+      memcached (~> 0.20.1)
+      yajl-ruby (~> 0.7.7)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activerecord (2.3.18)
+      activesupport (= 2.3.18)
+    activesupport (2.3.18)
+    database_cleaner (0.5.2)
+    diff-lcs (1.1.3)
+    ihoka-friendly (0.7.0)
+      activesupport (~> 2.3.18)
+      rufus-json (~> 0.2.3)
+      sequel (~> 3.16.0)
+      will_paginate (~> 2.3.15)
+    memcached (0.20.1)
+    mysql (2.8.1)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.2)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    rufus-json (0.2.7)
+    sequel (3.16.0)
+    will_paginate (2.3.16)
+    yajl-ruby (0.7.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  database_cleaner (~> 0.5.0)
+  friendly-attributes!
+  mysql (~> 2.8.1)
+  rspec (~> 2.5.0)

data/README.md

@@ -1,5 +1,8 @@
 # Friendly Attributes
 
+[![Build Status](https://travis-ci.org/ihoka/friendly-attributes.png)](https://travis-ci.org/ihoka/friendly-attributes)
+
+
 Extend your ActiveRecord models with attributes dynamically, without any schema migrations.
 
 ## Description

data/Rakefile

@@ -0,0 +1,25 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rcov = true
+  spec.rcov_opts = %w{-I spec:lib --exclude gems\/,spec\/}
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "friendly-attributes #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.7.2

data/friendly-attributes.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name = %q{friendly-attributes}
+  s.version = "0.7.1.1"
+
+  s.authors     = ["Istvan Hoka"]
+  s.date        = %q{2011-04-10}
+  s.description = %q{Pattern to add fields to ActiveRecord models, using an associated document, without needing schema migrations.}
+  s.email       = %q{istvan.hoka@gmail.com}
+  s.homepage    = %q{http://github.com/ihoka/friendly-attributes}
+  s.licenses    = ["MIT"]
+  s.summary     = %q{Extend ActiveRecord models using Friendly ORM delegate models}
+  s.version     = File.read(File.dirname(__FILE__) + '/VERSION')
+
+  s.add_development_dependency 'mysql', '~> 2.8.1'
+  s.add_development_dependency 'rspec', '~> 2.5.0'
+  s.add_development_dependency 'database_cleaner', '~> 0.5.0'
+  s.add_dependency 'ihoka-friendly', '~> 0.7.0'
+  s.add_dependency 'activerecord', '~> 2.3.18'
+  s.add_dependency 'yajl-ruby', '~> 0.7.7'
+  s.add_dependency 'memcached', '~> 0.20.1'
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+end
+

data/spec/config.sample.yml

@@ -0,0 +1,6 @@
+test:
+  :adapter:  "mysql"
+  :host:     "localhost"
+  :user:     "root"
+  :password:
+  :database: "friendly_attributes_test"

data/spec/friendly_attributes/base_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe FriendlyAttributes::Base do
+  use_database_cleanup
+  
+  let(:friendly_model) {
+    Class.new(FriendlyAttributes::Base) do
+      cattr_accessor :active_record_key
+    end.tap { |c| c.active_record_key = active_record_key }
+  }
+  let(:active_record_key) { :ar_id }
+  let(:details) { mock(FriendlyAttributes::Base) }
+  
+  describe ".find_or_build_by_active_record_id" do
+    
+    context "when the record does not exist" do
+      before(:each) do
+        friendly_model.should_receive(:first).with(:ar_id => 42).and_return(nil)
+      end
+      
+      it "builds a new record with the active_record_id" do
+        friendly_model.should_receive(:new).with(:ar_id => 42).and_return(details)
+        friendly_model.find_or_build_by_active_record_id(42).should == details
+      end
+      
+      it "with options present, it builds a new record with the options and active_record_id" do
+        friendly_model.should_receive(:new).with(:ar_id => 42, :foo => "foo").and_return(details)
+        friendly_model.find_or_build_by_active_record_id(42, :foo => "foo").should == details
+      end
+    end
+    
+    context "when the record exists" do
+      it "finds the record" do
+        friendly_model.should_receive(:first).with(:ar_id => 42).and_return(details)
+        friendly_model.find_or_build_by_active_record_id(42).should == details
+      end
+    end
+  end
+  
+  describe "#write_active_record_id" do
+    let(:friendly_instance) { friendly_model.new }
+    
+    it "sets the active_record_id using the configured attribute writer" do
+      friendly_instance.should_receive(:"#{active_record_key}=").with(42).and_return(42)
+      friendly_instance.write_active_record_id(42).should == 42
+    end
+  end
+  
+  describe "#read_active_record_id" do
+    let(:friendly_instance) { friendly_model.new }
+    
+    it "sets the active_record_id using the configured attribute writer" do
+      friendly_instance.should_receive(active_record_key).and_return(42)
+      friendly_instance.read_active_record_id.should == 42
+    end
+  end
+  
+  describe "#update_if_changed_with_model" do
+    let(:friendly_instance) { friendly_model.new }
+    
+    before(:each) do
+      friendly_instance.stub(:save => false, :changed? => false, :read_active_record_id => 42)
+    end
+    
+    context "when the active_record_id is not set" do
+      before(:each) do
+        friendly_instance.should_receive(:read_active_record_id).and_return(nil)
+      end
+      
+      it "sets the active_record_id" do
+        friendly_instance.should_receive(:write_active_record_id).with(42)
+        friendly_instance.update_if_changed_with_model(42)
+      end
+    end
+    
+    context "when the active_record_id is set" do
+      before(:each) do
+        friendly_instance.should_receive(:read_active_record_id).and_return(42)
+      end
+      
+      it "does not reset the active_record_id" do
+        friendly_instance.should_not_receive(:write_active_record_id)
+        friendly_instance.update_if_changed_with_model(42)
+      end
+    end
+    
+    context "when changed" do
+      before(:each) do
+        friendly_instance.should_receive(:changed?).and_return(true)
+      end
+      
+      it "saves the record" do
+        friendly_instance.should_receive(:save).and_return(true)
+        friendly_instance.update_if_changed_with_model(42).should be_true
+      end
+    end
+    
+    context "when not changed" do
+      before(:each) do
+        friendly_instance.should_receive(:changed?).and_return(false)
+      end
+      
+      it "saves the record" do
+        friendly_instance.should_not_receive(:save)
+        friendly_instance.update_if_changed_with_model(42).should be_false
+      end
+    end
+  end
+  
+  describe "#attributes" do
+    let(:details) { UserDetails.create(attributes) }
+    let(:attributes) { { :name => "Foo", :birth_year => 1970, :shoe_size => 42, :subscribed => true, UserDetails.active_record_key => 55 } }
+    
+    it "returns a hash of all the model's attributes" do
+      actual = details.attributes
+      actual.should include(attributes)
+      actual[:created_at].should be_an_instance_of(Time)
+      actual[:updated_at].should be_an_instance_of(Time)
+      actual[:id].should be_an_instance_of(Friendly::UUID)
+    end
+  end
+end

data/spec/friendly_attributes/class_methods_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe FriendlyAttributes::ClassMethods do
+  let(:friendly_model)    { mock_friendly_model }
+  let(:ar_model)          {
+    Class.new {
+      include ActiveRecordFake
+      extend FriendlyAttributes::ClassMethods
+    }
+  }
+  
+  let(:details_delegator) { mock(FriendlyAttributes::DetailsDelegator) }
+  
+  class FakeUploader; end
+  
+  describe ".friendly_details" do
+    let(:attributes) do
+      {
+        String  => :foo,
+        Integer => [:bar, :baz]
+      }
+    end
+    
+    before(:each) do
+      details_delegator.stub(:setup_delegated_attributes)
+    end
+    
+    context "with an initializer block" do
+      def yielded_inside(instance)
+        @yielded_instance = instance
+      end
+
+      let(:initializer) do
+        example = self
+
+        proc {
+          example.yielded_inside(self)
+        }
+      end
+      
+      it "instance_evals the initializer block on the DetailsDelegator instance" do
+        FriendlyAttributes::DetailsDelegator.
+          should_receive(:new).
+          with(friendly_model, ar_model, attributes, {}).
+          and_return(details_delegator)
+        
+        ar_model.friendly_details(friendly_model, attributes, &initializer).should == details_delegator
+        @yielded_instance.should == details_delegator
+      end
+    end
+    
+    context "with attributes and options" do
+      let(:options) { { :active_record_key => :user_id } }
+      
+      before(:each) do
+        FriendlyAttributes::DetailsDelegator.stub(:new => details_delegator)
+      end
+      
+      def do_details
+        ar_model.friendly_details(friendly_model, attributes, options).should == details_delegator
+      end
+      
+      it "instantiates a new DetailsDelegator" do
+        FriendlyAttributes::DetailsDelegator.should_receive(:new).with(friendly_model, ar_model, attributes, options).and_return(details_delegator)
+        do_details
+      end
+      
+      it "sets up the delegated attributes" do
+        details_delegator.should_receive(:setup_delegated_attributes)
+        do_details
+      end
+    end
+    
+    context "without a block" do
+      it "instantiates a new DetailsDelegator" do
+        FriendlyAttributes::DetailsDelegator.should_receive(:new).with(friendly_model, ar_model, attributes, {}).and_return(details_delegator)
+        ar_model.friendly_details(friendly_model, attributes).should == details_delegator
+      end
+    end
+  end
+  
+  describe ".friendly_mount_uploader" do
+    let(:foo_value) { mock("Friendly attribute value") }
+    
+    before(:each) do
+      ar_model.stub(:mount_uploader => nil)
+      
+      foo = foo_value
+      
+      ar_model.class_eval do
+        define_method(:read_friendly_attribute) do |attribute|
+          attribute.should == :foo
+          foo
+        end
+        
+        define_method(:write_friendly_attribute) do |attribute, value|
+          value.tap do
+            attribute.should == :foo
+            value.should == foo
+          end
+        end
+      end
+    end
+    
+    it "mounts the uploader" do
+      ar_model.should_receive(:mount_uploader).with(:foo, FakeUploader)
+      ar_model.friendly_mount_uploader :foo, FakeUploader
+    end
+    
+    it "aliases #read_friendly_attribute to #read_uploader" do
+      ar_model.friendly_mount_uploader :foo, FakeUploader
+      ar_object = ar_model.new
+      
+      ar_object.read_uploader(:foo).should == foo_value
+    end
+    
+    it "aliases #read_friendly_attribute to #read_uploader" do
+      ar_model.friendly_mount_uploader :foo, FakeUploader
+      ar_object = ar_model.new
+      
+      ar_object.write_uploader(:foo, foo_value).should == foo_value
+    end
+  end
+end

data/spec/friendly_attributes/configuration_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe FriendlyAttributes::Configuration do
+  subject { configuration }
+  
+  let(:configuration) { FriendlyAttributes::Configuration.new(active_record_model) }
+  let(:active_record_model) { User }
+  
+  describe "#initialize" do
+    its(:model)              { should == active_record_model }
+    its(:details_delegators) { should == [] }
+    its(:attributes)         { should == {} }
+  end
+  
+  describe "#add" do
+    let(:delegator) { mock(FriendlyAttributes::DetailsDelegator, :delegated_attributes => delegated_attributes, :friendly_model => UserDetails) }
+    let(:delegated_attributes) { { :foo => Integer, :bar => String } }
+    
+    it "adds a delegator to the details_delegators collection" do
+      configuration.add(delegator)
+      configuration.details_delegators.should == [delegator]
+    end
+  end
+  
+  describe "#add_attribute" do
+    it "adds the attribute to the attributes collection" do
+      configuration.add_attribute(:foo, UserDetails)
+      configuration.attributes.should == { :foo => UserDetails }
+    end
+  end
+  
+  describe "Configuration with delegators added" do
+    let(:friendly_models)      { [UserDetails, UserSecondDetails] }
+    let(:delegated_attributes) {
+      {
+        UserDetails => { :foo => Integer, :bar => String },
+        UserSecondDetails => { :baz => Date }
+      }
+    }
+    let(:details_delegators) {
+      friendly_models.map do |fm|
+        mock(FriendlyAttributes::DetailsDelegator,
+          :friendly_model => fm,
+          :delegated_attributes => delegated_attributes[fm])
+      end
+    }
+    
+    before(:each) do
+      details_delegators.each do |delegator|
+        configuration.add(delegator)
+      end
+    end
+    
+    describe "#model_for_attribute" do
+      it "returns the FriendlyAttributes model associated with the attribute" do
+        configuration.add_attribute(:foo, UserDetails)
+        configuration.model_for_attribute(:foo).should == UserDetails
+      end
+    end
+    
+    describe "#friendly_models" do
+      its(:friendly_models) { should == friendly_models }
+    end
+    
+    describe "#map_models" do
+      let(:map_model_map) {
+        {}.tap do |h|
+          friendly_models.each_with_index do |m, i|
+            h[m] = i
+          end
+        end
+      }
+
+      it "maps over the friendly models" do
+        configuration.map_models do |model|
+          map_model_map[model]
+        end.sort.should == map_model_map.values.sort
+      end
+    end
+    
+    describe "#each_model" do
+      let(:each_model_map) {
+        {}.tap do |h|
+          friendly_models.each_with_index do |m, i|
+            h[m] = i
+          end
+        end
+      }
+
+      it "iterates over the friendly models" do
+        result = []
+        configuration.each_model do |model|
+          result << each_model_map[model]
+        end
+        result.sort.should == each_model_map.values.sort
+      end
+    end
+  end
+end