active_type 0.1.0

data/lib/active_type/virtual_attributes.rb

@@ -0,0 +1,166 @@
+module ActiveType
+
+  class InvalidAttributeNameError < StandardError; end
+  class MissingAttributeError < StandardError; end
+
+  module VirtualAttributes
+
+    class VirtualColumn < ActiveRecord::ConnectionAdapters::Column
+
+      def initialize(name, type)
+        @name = name
+        @type = type
+      end
+
+      def type_cast(value)
+        case @type
+        when :integer
+          case value
+          when FalseClass
+            0
+          when TrueClass
+            1
+          when "", nil
+            nil
+          else
+            value.to_i
+          end
+        when :timestamp, :datetime
+          if ActiveRecord::Base.time_zone_aware_attributes
+            time = super
+            if time
+              ActiveSupport::TimeWithZone.new(nil, Time.zone, time)
+            else
+              time
+            end
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+    end
+
+    class AccessorGenerator
+
+      def initialize(mod)
+        @module = mod
+      end
+
+      def generate_accessors(name)
+        validate_attribute_name!(name)
+        generate_reader(name)
+        generate_writer(name)
+      end
+
+      private
+
+      def generate_reader(name)
+        @module.module_eval <<-BODY, __FILE__, __LINE__ + 1
+          def #{name}
+            read_virtual_attribute('#{name}')
+          end
+        BODY
+      end
+
+      def generate_writer(name)
+        @module.module_eval <<-BODY, __FILE__, __LINE__ + 1
+          def #{name}=(value)
+            write_virtual_attribute('#{name}', value)
+          end
+        BODY
+      end
+
+      def validate_attribute_name!(name)
+        unless name.to_s =~ /\A[A-z0-9_]*\z/
+          raise InvalidAttributeNameError.new("'#{name}' is not a valid name for a virtual attribute")
+        end
+      end
+
+    end
+
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :virtual_columns_hash
+      self.virtual_columns_hash = {}
+    end
+
+    def initialize(*)
+      @virtual_attributes = {}
+      @virtual_attributes_cache = {}
+      super
+    end
+
+    def [](name)
+      if self.singleton_class._has_virtual_column?(name)
+        read_virtual_attribute(name)
+      else
+        super
+      end
+    end
+
+    def []=(name, value)
+      if self.singleton_class._has_virtual_column?(name)
+        write_virtual_attribute(name, value)
+      else
+        super
+      end
+    end
+
+    def read_virtual_attribute(name)
+      name = name.to_s
+      @virtual_attributes_cache[name] ||= begin
+        self.singleton_class._virtual_column(name).type_cast(@virtual_attributes[name])
+      end
+    end
+
+    def write_virtual_attribute(name, value)
+      name = name.to_s
+      @virtual_attributes_cache.delete(name)
+      @virtual_attributes[name] = value
+    end
+
+    module ClassMethods
+
+      def _virtual_column(name)
+        virtual_columns_hash[name.to_s] || begin
+          if defined?(super)
+            super
+          else
+            raise MissingAttributeError.new("Undefined attribute '#{name}'")
+          end
+        end
+      end
+
+      def _has_virtual_column?(name)
+        virtual_columns_hash.has_key?(name.to_s) || begin
+          if defined?(super)
+            super
+          else
+            false
+          end
+        end
+      end
+
+      def generated_virtual_attribute_methods
+        @generated_virtual_attribute_methods ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+
+      def attribute(name, type)
+        self.virtual_columns_hash = virtual_columns_hash.merge(name.to_s => VirtualColumn.new(name, type))
+        AccessorGenerator.new(generated_virtual_attribute_methods).generate_accessors(name)
+      end
+
+    end
+
+  end
+
+end

data/lib/active_type.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require 'active_type/version'
+
+require 'active_type/record'
+require 'active_type/object'

data/spec/active_type/extended_record/single_table_inheritance_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module STISpec
+
+  class Parent < ActiveRecord::Base
+    self.table_name = 'sti_records'
+  end
+
+  class Child < Parent
+  end
+
+  class ExtendedChild < ActiveType::Record[Child]
+  end
+
+  class ExtendedExtendedChild < ActiveType::Record[ExtendedChild]
+  end
+
+end
+
+
+describe 'ActiveType::Record[STIModel]' do
+
+  describe 'persistence' do
+
+    def should_save_and_load(save_as, load_as)
+      record = save_as.new(:persisted_string => "string")
+      record.save.should be_true
+
+      reloaded_child = load_as.find(record.id)
+      reloaded_child.persisted_string.should == "string"
+      reloaded_child.should be_a(load_as)
+    end
+
+    it 'can save and load the active type record' do
+
+      should_save_and_load(STISpec::ExtendedChild, STISpec::ExtendedChild)
+    end
+
+    it 'can save as base and load as active type record' do
+      should_save_and_load(STISpec::Child, STISpec::ExtendedChild)
+    end
+
+    it 'can save as active type and load as base record' do
+      should_save_and_load(STISpec::ExtendedChild, STISpec::Child)
+    end
+
+    it 'can load via the base class and convert to active type record' do
+      record = STISpec::ExtendedChild.new(:persisted_string => "string")
+      record.save.should be_true
+
+      reloaded_child = STISpec::Child.find(record.id).becomes(STISpec::ExtendedChild)
+      reloaded_child.persisted_string.should == "string"
+      reloaded_child.should be_a(STISpec::ExtendedChild)
+    end
+
+    it 'can save classes further down the inheritance tree' do
+      should_save_and_load(STISpec::ExtendedExtendedChild, STISpec::ExtendedExtendedChild)
+    end
+
+  end
+
+end

data/spec/active_type/extended_record_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module ExtendedRecordSpec
+
+  class BaseRecord < ActiveRecord::Base
+    self.table_name = 'records'
+  end
+
+  class BaseActiveTypeRecord < ActiveType::Record
+    self.table_name = 'records'
+
+    attribute :virtual_string, :string
+  end
+
+  class ExtendedRecord < ActiveType::Record[BaseRecord]
+    attribute :another_virtual_string, :string
+  end
+
+  class ExtendedActiveTypeRecord < ActiveType::Record[BaseActiveTypeRecord]
+    attribute :another_virtual_string, :string
+  end
+
+
+  class ExtendedRecordWithValidations < ExtendedActiveTypeRecord
+    validates :persisted_string, :presence => true
+    validates :virtual_string, :presence => true
+    validates :another_virtual_string, :presence => true
+  end
+
+end
+
+
+describe "ActiveType::Record[ActiveRecord::Base]" do
+
+  subject { ExtendedRecordSpec::ExtendedRecord.new }
+
+  it 'is inherits from the base type' do
+    subject.should be_a(ExtendedRecordSpec::BaseRecord)
+  end
+
+  describe 'constructors' do
+    subject { ExtendedRecordSpec::ExtendedRecord }
+
+    it_should_behave_like 'ActiveRecord-like constructors', { :persisted_string => "persisted string", :another_virtual_string => "another virtual string" }
+  end
+
+  describe 'accessors' do
+    it_should_behave_like 'ActiveRecord-like accessors', { :persisted_string => "persisted string", :another_virtual_string => "another virtual string" }
+  end
+
+  describe 'persistence' do
+    it 'persists to the database' do
+      subject.persisted_string = "persisted string"
+      subject.save.should be_true
+
+      subject.class.find(subject.id).persisted_string.should == "persisted string"
+    end
+  end
+
+  describe '.find' do
+    it 'returns an instance of the extended model' do
+      subject.save
+
+      subject.class.find(subject.id).should be_a(subject.class)
+    end
+  end
+
+end
+
+
+describe "ActiveType::Record[ActiveType::Record]" do
+
+  subject { ExtendedRecordSpec::ExtendedActiveTypeRecord.new }
+
+  it 'is inherits from the base type' do
+    subject.should be_a(ExtendedRecordSpec::BaseActiveTypeRecord)
+  end
+
+  it 'has the same model name as the base class' do
+    subject.class.model_name.singular.should == ExtendedRecordSpec::BaseActiveTypeRecord.model_name.singular
+  end
+
+  describe 'constructors' do
+    subject { ExtendedRecordSpec::ExtendedActiveTypeRecord }
+
+    it_should_behave_like 'ActiveRecord-like constructors', { :persisted_string => "persisted string", :virtual_string => "virtual string", :another_virtual_string => "another virtual string" }
+  end
+
+  describe 'accessors' do
+    it_should_behave_like 'ActiveRecord-like accessors', { :persisted_string => "persisted string", :virtual_string => "virtual string", :another_virtual_string => "another virtual string" }
+  end
+
+  describe 'validations' do
+    subject { ExtendedRecordSpec::ExtendedRecordWithValidations.new }
+
+    it { should have(1).error_on(:persisted_string) }
+    it { should have(1).error_on(:virtual_string) }
+    it { should have(1).error_on(:another_virtual_string) }
+  end
+
+  describe 'persistence' do
+    it 'persists to the database' do
+      subject.persisted_string = "persisted string"
+      subject.save.should be_true
+
+      subject.class.find(subject.id).persisted_string.should == "persisted string"
+    end
+  end
+
+  describe '.find' do
+    it 'returns an instance of the extended model' do
+      subject.save
+
+      subject.class.find(subject.id).should be_a(subject.class)
+    end
+  end
+
+end

data/spec/active_type/object_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+
+module ObjectSpec
+
+  class Object < ActiveType::Object
+
+    attribute :virtual_string, :string
+    attribute :virtual_integer, :integer
+    attribute :virtual_time, :datetime
+    attribute :virtual_date, :date
+    attribute :virtual_boolean, :boolean
+
+  end
+
+
+  class ObjectWithValidations < Object
+
+    validates :virtual_string, :presence => true
+
+  end
+
+
+  class ObjectWithOverrides < Object
+
+    attribute :overridable_test, :string
+
+    def overridable_test
+      super + super
+    end
+
+  end
+
+
+  class InheritingObject < Object
+    attribute :another_virtual_string, :string
+  end
+
+
+  class IncludingObject < Object
+
+    module Module
+      extend ActiveSupport::Concern
+
+      included do
+        attribute :another_virtual_string, :string
+      end
+    end
+
+    include Module
+  end
+
+
+  class ObjectWithCallbacks < Object
+
+    before_save :before_save_callback
+    before_validation :before_validation_callback
+    after_save :after_save_callback
+
+    def before_save_callback
+    end
+
+    def before_validation_callback
+    end
+
+    def after_save_callback
+    end
+
+  end
+
+  class Child < ActiveRecord::Base
+  end
+
+  class ObjectWithBelongsTo < Object
+
+    attribute :child_id, :integer
+
+    belongs_to :child
+
+  end
+
+
+end
+
+
+describe ActiveType::Object do
+
+  subject { ObjectSpec::Object.new }
+
+  describe 'constructors' do
+    subject { ObjectSpec::Object }
+
+    it_should_behave_like 'ActiveRecord-like constructors', { :virtual_string => "string", :virtual_integer => 100, :virtual_time => Time.now, :virtual_date => Date.today, :virtual_boolean => true }
+
+  end
+
+  describe 'mass assignment' do
+    it_should_behave_like 'ActiveRecord-like mass assignment', { :virtual_string => "string", :virtual_integer => 100, :virtual_time => Time.now, :virtual_date => Date.today, :virtual_boolean => true }
+  end
+
+  describe 'accessors' do
+    it_should_behave_like 'ActiveRecord-like accessors', { :virtual_string => "string", :virtual_integer => 100, :virtual_time => Time.now, :virtual_date => Date.today, :virtual_boolean => true }
+  end
+
+  describe 'overridable attributes' do
+    subject { ObjectSpec::ObjectWithOverrides.new }
+
+    it 'is possible to override attributes with super' do
+      subject.overridable_test = "test"
+
+      subject.overridable_test.should == "testtest"
+    end
+  end
+
+  describe 'attribute name validation' do
+    it 'crashes when trying to define an invalid attribute name' do
+      klass = Class.new(ActiveType::Object)
+      expect {
+        klass.class_eval do
+          attribute :"<attr>", :string
+        end
+      }.to raise_error(ActiveType::InvalidAttributeNameError)
+    end
+  end
+
+  context 'coercible' do
+    describe 'string columns' do
+      it_should_behave_like 'a coercible string column', :virtual_string
+    end
+
+    describe 'integer columns' do
+      it_should_behave_like 'a coercible integer column', :virtual_integer
+    end
+
+    describe 'date columns' do
+      it_should_behave_like 'a coercible date column', :virtual_date
+    end
+
+    describe 'time columns' do
+      it_should_behave_like 'a coercible time column', :virtual_time
+    end
+
+    describe 'boolean columns' do
+      it_should_behave_like 'a coercible boolean column', :virtual_boolean
+    end
+  end
+
+  describe 'inherited classes' do
+
+    it 'sees attributes of both classes' do
+      object = ObjectSpec::InheritingObject.new
+      object.virtual_string = "string"
+      object.another_virtual_string = "another string"
+
+      object.virtual_string.should == "string"
+      object.another_virtual_string.should == "another string"
+    end
+
+    it 'does not define the attribute on the parent class' do
+      object = ObjectSpec::Object.new
+      object.should_not respond_to(:another_virtual_string)
+    end
+
+  end
+
+  describe 'included modules' do
+    it 'sees attributes of the included module' do
+      object = ObjectSpec::IncludingObject.new
+      object.virtual_string = "string"
+      object.another_virtual_string = "another string"
+
+      object.virtual_string.should == "string"
+      object.another_virtual_string.should == "another string"
+    end
+
+    it 'does not define the attribute on the parent class' do
+      object = ObjectSpec::Object.new
+      object.should_not respond_to(:another_virtual_string)
+    end
+  end
+
+  describe 'validations' do
+    subject { ObjectSpec::ObjectWithValidations.new }
+
+    it { should have(1).error_on(:virtual_string) }
+
+    it 'has no errors if validations pass' do
+      subject.virtual_string = "foo"
+
+      subject.should be_valid
+      subject.should have(:no).errors_on(:virtual_string)
+    end
+
+    it 'causes #save to return false' do
+      subject.save.should be_false
+    end
+  end
+
+  describe '#belongs_to' do
+    subject { ObjectSpec::ObjectWithBelongsTo.new }
+
+    it_should_behave_like 'a belongs_to association', :child, ObjectSpec::Child
+  end
+
+  describe '#save' do
+    subject { ObjectSpec::ObjectWithCallbacks.new }
+
+    it "returns true" do
+      subject.save
+    end
+
+    %w[before_validation before_save after_save].each do |callback|
+
+      it "calls #{callback}" do
+        subject.should_receive("#{callback}_callback")
+
+        subject.save.should be_true
+      end
+
+    end
+
+    %w[before_validation before_save].each do |callback|
+
+      it "aborts the chain when #{callback} returns false" do
+        subject.stub("#{callback}_callback" => false)
+
+        subject.save.should be_false
+      end
+
+    end
+
+  end
+
+  describe '.find' do
+    it 'raises an error' do
+      expect do
+        ObjectSpec::Object.find(1)
+      end.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  describe '.all' do
+    it 'returns []' do
+      ObjectSpec::Object.all.should == []
+    end
+  end
+
+  describe '.create' do
+    it 'returns an object' do
+      object = ObjectSpec::Object.create(:virtual_string => "string")
+
+      object.should be_a(ObjectSpec::Object)
+      object.virtual_string.should == "string"
+    end
+  end
+
+end