has_content 0.0.2

data/CHANGELOG

@@ -0,0 +1,2 @@
+= 0.0.1
+  * Initial Release

data/MIT-LICENSE

@@ -0,0 +1,24 @@
+Copyright 2012 Ian White
+
+This plugin was developed by Ian White (http://github.com/ianwhite)
+while working at Distinctive Doors (http://distinctivedoors.co.uk/oss)
+who have kindly agreed to release this under the MIT-LICENSE.
+
+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.md

@@ -0,0 +1,13 @@
+has_content [![Build Status](https://secure.travis-ci.org/i2w/has_content.png?branch=master)](http://travis-ci.org/i2w/has_content)
+======
+
+Add a content relation to any active_record, which acts like a text field, but is actually a separate object.
+
+This means it's very easy to add/remove fields, but also the contents can be objects in their own right (useful for editing CMS stuff etc)
+
+This was developed by [Ian White](http://github.com/ianwhite) while working at [Distinctive Doors](http://distinctivedoors.co.uk/oss) who have kindly agreed to release this under the MIT-LICENSE.
+
+License
+-------
+
+This project uses the MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,42 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'HasContent'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md', 'CHANGELOG', 'MIT-LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run the specs with simplecov"
+task :simplecov => [:simplecov_env, :spec]
+task :simplecov_env do ENV['SIMPLECOV'] = '1' end
+
+task :default => :spec
+
+Bundler::GemHelper.install_tasks
+
+task :release => :check_gemfile
+
+task :check_gemfile do
+  if File.exists?("Gemfile.lock") && File.read("Gemfile.lock") != File.read("Gemfile.lock.development")
+    cp "Gemfile.lock", "Gemfile.lock.development"
+    raise "** Gemfile.lock.development has been updated, please commit these changes."
+  end
+end

data/db/migrate/create_has_content_records.rb

@@ -0,0 +1,11 @@
+class CreateHasContentRecords < ActiveRecord::Migration
+  def change
+    create_table :has_content_records, :force => true do |t|
+      t.belongs_to :owner, :polymorphic => true
+      t.string :name
+      t.text :content
+      t.timestamps
+    end
+    add_index :has_content_records, [:owner_id, :owner_type, :name], :unique => true
+  end
+end

data/lib/has_content/active_record.rb

@@ -0,0 +1,24 @@
+module HasContent
+  # has_content concern: allow spcification of content on models
+  #
+  # content is a polymorphic association that is laoded on demand, and appears as if it were a normal attribute.  
+  # The advantages being that you can add content to models without modifying the database schema, and that you
+  # can treat pieces of content as objects in their own right (for example in place editing).
+  #
+  #   class MyModel
+  #     has_content :body, :sidebar
+  #   end
+  module ActiveRecord
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      # specify that this class has the following named content
+      def has_content *names
+        include ContentOwner unless self < ContentOwner
+        options = names.extract_options!
+        raise ArgumentError, "you must supply at least one content name" if names.size == 0
+        names.each {|name| add_content(name.to_s, options)}
+      end
+    end
+  end
+end

data/lib/has_content/content_owner.rb

@@ -0,0 +1,63 @@
+module HasContent
+  module ContentOwner
+    extend ActiveSupport::Concern
+    
+    included do
+      delegate :content_names, :content_association_names, :to => 'self.class'
+      class_attribute :content_names
+      self.content_names ||= []
+    end
+    
+    # return a hash of content attributes with their content only (for loaded content only)
+    def content_attributes
+      content_names.inject({}) do |attrs, name|
+        attrs.merge!(name => send(name)) if send("#{name}_content")
+        attrs
+      end
+    end
+    
+    # include content_attributes in attributes hash
+    def attributes
+      super.merge content_attributes
+    end
+    
+    module ClassMethods
+      def content_association_names
+        content_names.map {|name| "#{name}_content"}
+      end
+    
+    protected
+      def add_content name, options = {}
+        raise ArgumentError, "name should be suitable for a simple attribute method" unless name =~ /\A[_a-z][_a-z0-9]+\Z/i
+        if content_names.include?(name)
+          raise ArgumentError, "Content #{name} is already declared in #{self.name}"
+        else
+          add_content_association name, options
+        end
+      end
+      
+      def add_content_association name, options
+        content_names << name
+        
+        has_one "#{name}_content".to_sym, options.reverse_merge(:as => 'owner', :class_name => 'HasContent::Record', :dependent => :destroy, :conditions => {name: name}, :autosave => true)
+        
+        define_method name do
+          send("find_or_build_#{name}_content").content
+        end
+        
+        define_method "#{name}=" do |value|
+          (send("find_or_build_#{name}_content").content = value).tap do |*|
+            if respond_to?(:updated_at?) && send("find_or_build_#{name}_content").changed?
+              updated_at_will_change!
+            end
+          end
+        end
+        
+        define_method "find_or_build_#{name}_content" do
+          send("#{name}_content") || send("build_#{name}_content", name: name)
+        end
+        private "find_or_build_#{name}_content".to_sym
+      end
+    end
+  end
+end

data/lib/has_content/engine.rb

@@ -0,0 +1,4 @@
+module HasContent
+  class Engine < Rails::Engine
+  end
+end

data/lib/has_content/record.rb

@@ -0,0 +1,42 @@
+module HasContent
+  class Record < ActiveRecord::Base
+    self.table_name = 'has_content_records'
+    
+    belongs_to :owner, polymorphic: true
+    
+    validates :name,  presence: true,
+                      inclusion: {in: lambda(&:allowed_names), if: :owner},
+                      uniqueness: {scope: %w(owner_id owner_type), if: :owner_persisted?}
+
+    before_create :verify_valid_owner! # this badboy is here because owner is sometimes not present at validation
+                                       # because content is a has_one on owner, with autosave true
+
+    # Contents are only ever instantiated by has_content assoc, and it's convenient for them to
+    # always refer (for links to content etc).
+    # If there is a validation problem, the save will fail silently (which is fine)
+    def initialize(*)
+      super
+      save if new_record? && owner_persisted?
+    end
+
+    def to_s
+      content
+    end
+
+    def allowed_names
+      owner.try(:content_names) || []
+    end
+    
+    protected
+    
+    def owner_persisted?
+      owner && !owner.new_record?
+    end
+    
+    # see the before_create hook above
+    def verify_valid_owner!
+      owner.reload # raises ActiveRecord::RecordNotFound if owner not found
+      valid? or raise ActiveRecord::RecordInvalid, self
+    end
+  end
+end

data/lib/has_content/version.rb

@@ -0,0 +1,3 @@
+module HasContent
+  VERSION = '0.0.2'
+end

data/lib/has_content.rb

@@ -0,0 +1,9 @@
+require 'has_content/version'
+require 'has_content/record'
+require 'has_content/content_owner'
+require 'has_content/active_record'
+require 'has_content/engine' if defined?(Rails)
+
+ActiveSupport.on_load(:active_record) do
+  include HasContent::ActiveRecord
+end

data/spec/content_owner_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'owner_shared'
+
+describe ContentOwner do
+  let(:owner) { described_class.new }
+  let(:content_name) { :body }
+  
+  it_should_behave_like "new owner with has_content"  
+  
+  its(:content_names) { should == ['body', 'excerpt', 'sidebar'] }
+  
+  its(:content_association_names) { should == ['body_content', 'excerpt_content', 'sidebar_content'] }
+  
+  describe "subclass" do
+    let(:klass) { Class.new(described_class) }
+    let(:owner) { klass.new }
+    
+    it_should_behave_like "new owner with has_content"
+
+    context 'after adding new content :thingo' do
+      before(:all) do klass.has_content :thingo end
+        
+      its(:content_names) { should == ['body', 'excerpt', 'sidebar', 'thingo'] }
+
+      its(:content_association_names) { should == ['body_content', 'excerpt_content', 'sidebar_content', 'thingo_content'] }
+    end
+
+    context 'when a content attribute is protected' do
+      before(:all) do klass.attr_protected :excerpt end
+        
+      it 'setting via attributes fails' do
+        owner.attributes = {excerpt: 'foo', body: 'bar'}
+        owner.excerpt.should be_nil
+        owner.body.should == 'bar'
+        owner.save
+        owner.reload.body_content.content.should == 'bar'
+        owner.reload.excerpt_content.content.should be_nil
+      end
+    end
+  end
+end

data/spec/has_content/active_record_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe HasContent::ActiveRecord do
+  subject { content_owner }
+  let(:content_owner) { Class.new(ActiveRecord::Base) }
+  
+  describe '.has_content(name)' do
+    subject { content_owner.has_content(name) }
+    
+    describe 'requires name be in a format suitable for a simple accessor method' do
+      ['foo bar', '123bar', 'foo!', 'foo=', 'foo-bar', 'foo+bar'].each do |invalid|
+        context invalid.inspect do
+          let(:name) { invalid }
+          it { expect { subject }.to raise_error ArgumentError }
+        end
+      end
+
+      ['_foo', 'foo_bar', 'a123bar', 'foo', 'FooBar'].each do |valid|
+        context valid.inspect do
+          let(:name) { valid }
+          it { expect { subject }.to_not raise_error }
+        end
+      end
+    end
+  end
+  
+  it '.has_content() raises ArgumentError' do
+    expect{ content_owner.has_content }.to raise_error(ArgumentError)
+  end 
+  
+  it '.has_content(<extsiting name>) raises ArgumentError' do
+    content_owner.has_content(:foo)
+    expect{ content_owner.has_content(:foo) }.to raise_error(ArgumentError)
+  end
+end

data/spec/has_content/record_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe HasContent::Record do
+  subject { record }
+
+  let(:record) { described_class.new attrs }
+  let(:attrs)  { {} }
+  
+  it "does not save itself - as it's invalid" do
+    should be_new_record
+  end
+  
+  describe 'with valid attributes' do
+    let(:attrs) { {:name => 'body', :owner => owner} }
+    let(:owner) { ContentOwner.create! }
+    
+    it "saves itself (to enable always referring relationships)" do
+      should_not be_new_record
+    end
+    
+    it { should be_valid }
+    
+    describe '[validation]' do
+      it 'requires :name' do
+        subject.name = nil
+        should_not be_valid
+      end
+    
+      it 'requires :name + :owner be unique' do
+        record.save!
+        record = described_class.new :name => 'body', :owner => owner
+        record.should_not be_valid
+        record.name = 'excerpt'
+        record.should be_valid
+        record.name = 'body'
+        record.owner = ContentOwner.create!
+        record.should be_valid
+      end
+    
+      it 'requires :name be one of owner\'s content_names' do
+        record.name = 'not_there'
+        record.should_not be_valid
+      end
+    end
+  end
+  
+  describe '#to_s' do
+    subject { record.to_s }
+    
+    it 'is the content attribute' do
+      record.content = 'foo'
+      subject.should == 'foo'
+    end
+  end
+end

data/spec/owner_shared.rb

@@ -0,0 +1,54 @@
+shared_examples_for "new owner with has_content" do
+  
+  # set the following to use this shared spec:
+  #
+  # let(:owner)        { a content owner instance }
+  # let(:content_name) { the name of the content }
+
+  it 'should be built on demand for #content reader' do
+    owner.send(content_name)
+    owner.send("#{content_name}_content").should be_kind_of(HasContent::Record)
+  end
+  
+  it 'should be built on demand for #content= writer' do
+    owner.send("#{content_name}=", 'foo')
+    owner.send("#{content_name}_content").content.should == 'foo'
+  end
+  
+  it "content should have name == content_name" do
+    owner.send(content_name)
+    owner.send("#{content_name}_content").name.should == content_name.to_s
+  end
+    
+  it "after save and reload, should have content" do
+    owner.send("#{content_name}=", "foo")
+    owner.save!
+    owner.class.find(owner.id).send(content_name).should == "foo"
+  end
+  
+  it 'should have content_attributes corresponding to contents' do
+    owner.send("#{content_name}=", "Foo")
+    owner.content_attributes[content_name.to_s].should == "Foo"
+  end
+  
+  it "should allow setting content via attributes" do
+    owner.update_attributes content_name => "Foo"
+    owner.reload.send(content_name).should == "Foo"
+  end
+  
+  context '[before being saved]' do
+    it "should not create a content record until save" do
+      lambda { owner.send(content_name) }.should_not change(HasContent::Record, :count)
+      lambda { owner.save! }.should change(HasContent::Record, :count).by(1) 
+    end
+  end
+  
+  context '[after being saved]' do
+    before { owner.save! }
+    
+    it 'should create content record on access' do
+      lambda { owner.send(content_name) }.should change(HasContent::Record, :count).by(1)
+      lambda { owner.save! }.should_not change(HasContent::Record, :count)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+ENV['RAILS_ENV'] = 'test'
+
+if ENV['SIMPLECOV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "_spec.rb"
+  end
+end
+
+begin
+  require 'pry'
+rescue LoadError
+end
+
+require 'active_record'
+require 'rspec'
+require 'database_cleaner'
+
+require_relative '../lib/has_content'
+require_relative 'test_app'
+
+DatabaseCleaner.strategy = :truncation
+DatabaseCleaner.clean_with :truncation
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.before(:each) { DatabaseCleaner.start }
+  config.after(:each)  { DatabaseCleaner.clean }
+end

data/spec/test_app.rb

@@ -0,0 +1,18 @@
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ":memory:")
+
+ActiveRecord::Migration.suppress_messages do 
+  ActiveRecord::Schema.define do
+    create_table(:content_owners, :force => true) do |t|
+      t.string :name
+      t.timestamps
+    end
+  
+    require_relative '../db/migrate/create_has_content_records'
+    CreateHasContentRecords.new.change
+  end
+end
+
+class ContentOwner < ActiveRecord::Base
+  has_content :body
+  has_content :excerpt, :sidebar
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: has_content
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Ian White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70244228437940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70244228437940
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70244228459060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70244228459060
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70244228456400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: *70244228456400
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70244228453880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70244228453880
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: &70244228452440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70244228452440
+description: Simple wrapper for adding content via a polymorphic join for any active
+  record.  Version 0.0.2.
+email:
+- ian.w.white@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- db/migrate/create_has_content_records.rb
+- lib/has_content/active_record.rb
+- lib/has_content/content_owner.rb
+- lib/has_content/engine.rb
+- lib/has_content/record.rb
+- lib/has_content/version.rb
+- lib/has_content.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+- CHANGELOG
+- spec/content_owner_spec.rb
+- spec/has_content/active_record_spec.rb
+- spec/has_content/record_spec.rb
+- spec/owner_shared.rb
+- spec/spec_helper.rb
+- spec/test_app.rb
+homepage: http://github.com/i2w/has_content
+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'
+      segments:
+      - 0
+      hash: -2447319576099344314
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2447319576099344314
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Simple wrapper for adding content via a polymorphic join for any active record
+test_files:
+- spec/content_owner_spec.rb
+- spec/has_content/active_record_spec.rb
+- spec/has_content/record_spec.rb
+- spec/owner_shared.rb
+- spec/spec_helper.rb
+- spec/test_app.rb