schizo 0.1.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp
+doc
+vendor

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3

data/CHANGELOG

@@ -0,0 +1,5 @@
+0.1.1
+	* Updated gemspec info
+
+0.1.0
+	* Initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dci.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,175 @@
+== Schizo {<img src="https://secure.travis-ci.org/cjbottaro/schizo.png" />}[http://travis-ci.org/cjbottaro/schizo]
+
+Schizo is a libary that aids in using DCI (data, context and interaction) in Ruby/Rails projects.  It aims
+to overcome some of the shortcomings of using plain <tt>Object#extend</tt>, namely the issue that extending
+a role can permenantly alter a class.
+
+== Quickstart
+
+Dive in...
+
+  class User < ActiveRecord::Base
+    include Schizo::Data
+  end
+
+  module Poster
+    extend Schizo::Role
+
+    extended do
+      has_many :posts
+    end
+
+    def post_count_in_english
+      "#{name} has #{posts.count} post(s)"
+    end
+  end
+
+  user = User.find(1)
+  user.as(Poster) do |poster|
+    poster.respond_to?(:posts) # => true
+    user.respond_to?(:posts)   # => false
+
+    poster.respond_to?(:post_count_in_english) # => true
+    user.respond_to?(:post_count_in_english)   # => false
+
+    poster.kind_of?(User)     # => true
+    poster.instance_of?(User) # => true
+    
+    poster.class.name # => "User"
+  end
+
+== DCI
+
+{\http://en.wikipedia.org/wiki/Data,_context_and_interaction}[http://en.wikipedia.org/wiki/Data,_context_and_interaction]
+
+{\http://mikepackdev.com/blog_posts/24-the-right-way-to-code-dci-in-ruby}[http://mikepackdev.com/blog_posts/24-the-right-way-to-code-dci-in-ruby]
+
+{\http://saturnflyer.com/blog/jim/2011/10/04/oop-dci-and-ruby-what-your-system-is-vs-what-your-system-does/}[http://saturnflyer.com/blog/jim/2011/10/04/oop-dci-and-ruby-what-your-system-is-vs-what-your-system-does/]
+
+{\http://victorsavkin.com/post/13966712168/dci-in-ruby}[http://victorsavkin.com/post/13966712168/dci-in-ruby]
+
+{\http://andrzejonsoftware.blogspot.com/2011/02/dci-and-rails.html}[http://andrzejonsoftware.blogspot.com/2011/02/dci-and-rails.html]
+
+== The Problem
+
+So what's wrong with just using <tt>Object#extend</tt>?  Nothing, until you want to alter an instance's class
+as a side effect of adorning it with a role... which happens often when using ActiveRecord.
+
+Consider the following use of DCI and ActiveRecord with plain old <tt>Object#extend</tt>:
+
+  class User < ActiveRecord::Base
+  end
+
+  module Poster
+    def self.extended(object)
+      object.class.class_eval do
+        has_many :posts
+      end
+    end
+
+    def post_count_in_english
+      "#{name} has #{posts.count} post(s)"
+    end
+  end
+
+  user1 = User.find(1)
+  user1.extend(Poster)
+  user1.respond_to?(:posts) # Ok
+
+  user2 = User.find(2)
+  user2.respond_to?(:posts) # Oops, extending user1 ended up changing *all* users!
+
+That goes against the core concept in DCI that your data should only be injected with behavior for a specific
+context.
+
+== The Magic
+
+So how does Schizo work?  It creates <i>facade classes</i> and <i>facade objects</i> that stand in for the
+classes and objects you really want.  The facades try to quack as best they can like the real objects/classes.
+
+This is easier to explain in an example (continuing from the Quickstart example):
+
+  user = User.find(1)
+  user.as(Poster) do |poster|
+    poster.kind_of?(User)     # => true
+    poster.instance_of?(User) # => true
+    
+    poster.class.name # => "User"
+    poster.class      # => Schizo::Facades::User::Poster
+  end
+
+<tt>Schizo::Facades::User::Poster</tt> inherits from +User+, that's why <tt>poster.kind_of?(User)</tt> works natrually.
+<tt>poster.instance_of?(User)</tt> works because of the facade consciously trying to quack like +User+.
+
+== Facades and Objects
+
+So knowing you're working with a facade instead of the original object, some of the gotchas become obvious.
+
+  class Foo
+    include Schizo::Data
+    attr_reader :bar
+    def initialize
+      @bar = "low"
+    end
+  end
+
+  module Baz
+    extend Schizo::Role
+    def set_bar(value)
+      @bar = value
+    end
+  end
+
+  foo = Foo.new
+  baz = foo.as(Baz)
+  baz.set_bar("high")
+  baz.bar # => "high"
+  foo.bar # => "low"
+
+Makes perfect sense, right?  But what about this...
+
+  foo = Foo.new
+  foo.as(Baz) do |baz|
+    baz.set_bar("high")
+  end
+  foo.bar # => "high"
+
+What?!  Nah, it's really simple.  At the end of the code block, +baz.actualize+ is called.  All +#actualize+ does
+is copy over the instances variables from the facade to the real object.
+
+You can get the exact same affect by doing:
+
+  foo = Foo.new
+  baz = foo.as(Baz)
+  baz.set_bar("high")
+  baz.actualize
+  foo.bar # => "high"
+
+Hmm, maybe +#actualize+ should be renamed +#converge+... what do you think?
+
+== Multiple Roles and Nesting
+
+You can adorn a data object with more than one role...
+
+  poster = User.new.as(Poster)
+  commenter = poster.as(Commenter) # Has all the methods of a Commenter AND Poster
+
+Alternatively...
+
+  User.new.as(Poster) do |poster|
+    poster.as(Commenter) do |commenter|
+      # Has all the methods of a Commenter AND Poster
+    end
+  end
+
+== Documentation
+
+{\http://doc.stochasticbytes.com/schizo/index.html}[http://doc.stochasticbytes.com/schizo/index.html]
+
+== Contact
+
+{@cjbottaro}[http://twitter.com/cjbottaro]
+
+== Liscense
+
+MIT or something

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+
+require 'active_record'
+require 'yaml'
+require 'logger'
+require 'rspec/core/rake_task'
+
+ENV["RAILS_ENV"] ||= "test"
+
+task :default => :spec
+
+desc "Run specs (default)"
+RSpec::Core::RakeTask.new(:spec => :migrate) do |t|
+  t.rspec_opts = "--color -f d"
+end
+
+desc "Migrate the database through scripts in db/migrate. Target specific version with VERSION=x"
+task :migrate => :environment do
+  ActiveRecord::Migrator.migrate('db/migrate', ENV["VERSION"] ? ENV["VERSION"].to_i : nil )
+end
+
+task :environment do
+  FileUtils.mkdir_p("tmp")
+  ActiveRecord::Base.establish_connection(YAML::load(File.open('db/database.yml')))
+  ActiveRecord::Base.logger = Logger.new(File.open('tmp/database.log', 'a'))
+end
+

data/db/database.yml

@@ -0,0 +1,2 @@
+adapter: sqlite3
+database: "tmp/test.db"

data/db/migrate/001_create_users.rb

@@ -0,0 +1,8 @@
+class CreateUsers < ActiveRecord::Migration
+  def change
+    create_table :users do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end

data/db/migrate/002_create_posts.rb

@@ -0,0 +1,9 @@
+class CreatePosts < ActiveRecord::Migration
+  def change
+    create_table :posts do |t|
+      t.integer :user_id
+      t.string :title
+      t.timestamps
+    end
+  end
+end

data/lib/schizo/data.rb

@@ -0,0 +1,32 @@
+module Schizo
+
+  # Include Data into a class to give it the ability to be adorned with a Role.
+  module Data
+
+    # Adorn a Data object with a Role.
+    #
+    # If a block is given, then a facade for _self_ is yielded to the block and the return value
+    # is _self_ with the facade's instance variables copied over to it.
+    #   user.name = "callie"
+    #   user.as(Poster) do |poster|
+    #     poster.name = "coco"
+    #   end
+    #   user.name # => "coco"
+    #
+    # Without a block, a facade for _self_ is returned.
+    #   user.name = "callie"
+    #   poster = user.as(Poster)
+    #   poster.name = "coco"
+    #   user.name # => "callie"
+    def as(role, &block)
+      facade = Facade::ObjectBuilder.new(self, role).product
+      if block_given?
+        block.call(facade)
+        facade.actualize
+      else
+        facade
+      end
+    end
+
+  end
+end

data/lib/schizo/facade/base.rb

@@ -0,0 +1,44 @@
+module Schizo
+  # Rdoc won't let me :nodoc: this module.  Nothing to see here.
+  module Facade
+
+    # This module is included in each Data object facade's class.
+    module Base
+
+      def self.included(mod) #:nodoc:
+        mod.extend(ClassMethods)
+        mod.class_eval <<-STR
+          attr_reader :#{DCI_INSTANCE_VARIABLE.to_s[1..-1]}
+        STR
+      end
+
+      module ClassMethods #:nodoc:
+
+        def name
+          superclass.name || "AnonClass#{object_id}"
+        end
+
+      end
+
+      def initialize(object, role) #:nodoc:
+        instance_variable_set(DCI_INSTANCE_VARIABLE, Struct.new(:object, :role).new(object, role))
+      end
+
+      def instance_of?(klass) #:nodoc:
+        # This is to get it working with nested facades.  We need to traverse
+        # superclasses until we get to the first real (non facade) superclass.
+        my_superclass = self.class.superclass
+        while my_superclass.ancestors.include?(Base) and my_superclass
+          my_superclass = my_superclass.superclass
+        end
+        my_superclass == klass
+      end
+
+      # Copy a facade's instance variables to the object it's facading for.
+      def actualize
+        dci.object.tap{ |object| Schizo::Facade.copy_instance_variables(self, object) }
+      end
+
+    end
+  end
+end

data/lib/schizo/facade/class_builder.rb

@@ -0,0 +1,53 @@
+module Schizo
+  module Facade #:nodoc:
+    class ClassBuilder #:nodoc:
+
+      attr_reader :base, :role
+
+      def initialize(base, role)
+        @base, @role = base, role
+      end
+
+      def product
+        @product ||= role_class
+      end
+
+    private
+
+      def module_name
+        base.name || "AnonClass#{base.object_id}"
+      end
+
+      def role_name
+        role.name || "AnonRole#{role.object_id}"
+      end
+
+      def container_module
+        @container_module ||= begin
+          if Schizo::Facades.const_defined?(module_name, false)
+            Schizo::Facades.const_get(module_name)
+          else
+            Schizo::Facades.const_set(module_name, Module.new)
+          end
+        end
+      end
+
+      def role_class
+        @role_class ||= begin
+          if container_module.const_defined?(role_name, false)
+            container_module.const_get(role_name)
+          else
+            container_module.const_set(role_name, build)
+          end
+        end
+      end
+      
+      def build
+        Class.new(base){ include Base }.tap do |klass|
+          klass.class_eval(&role.extended_block) if role.extended_block
+        end
+      end
+
+    end
+  end
+end

data/lib/schizo/facade/object_builder.rb

@@ -0,0 +1,49 @@
+module Schizo
+  module Facade #:nodoc:
+
+    DCI_INSTANCE_VARIABLE = :@dci
+
+    def self.copy_instance_variables(from, to)
+      from.instance_variables.each do |ivar_name|
+        ivar = from.instance_variable_get(ivar_name)
+        to.instance_variable_set(ivar_name, ivar) unless ivar_name == DCI_INSTANCE_VARIABLE
+      end
+    end
+
+    class ObjectBuilder #:nodoc:
+      attr_reader :object, :role
+
+      def initialize(object, role)
+        @object, @role = object, role
+      end
+
+      def product
+        @product ||= build
+      end
+
+    private
+
+      def facade_class
+        @facade_class ||= ClassBuilder.new(object.class, role).product
+      end
+
+      def build
+        facade_class.new(object, role).tap do |facade|
+
+          # This is to get nesting to work.  Because each facade keeps a reference to the object
+          # it's facading for, we can traverse nested facades.  Each time we find one, we extend
+          # its role into facade we're building.
+          previous_facade = object
+          while previous_facade.respond_to?(:dci)
+            facade.extend(previous_facade.dci.role)
+            previous_facade = previous_facade.dci.object
+          end
+
+          facade.extend(role)
+          Schizo::Facade.copy_instance_variables(object, facade)
+        end
+      end
+
+    end
+  end
+end

data/lib/schizo/facade.rb

@@ -0,0 +1,9 @@
+require "schizo/facade/base"
+require "schizo/facade/class_builder"
+require "schizo/facade/object_builder"
+
+module Schizo
+  # This module solely exists to store facade classes.
+  module Facades #:nodoc:
+  end
+end

data/lib/schizo/role.rb

@@ -0,0 +1,44 @@
+module Schizo
+
+  # Extend a module with Role to make that module a _role_.
+  #   module RoleA
+  #     extend Schizo::Role
+  #
+  #     def method_a
+  #     end
+  #
+  #     def method_b
+  #     end
+  #   end
+  module Role
+
+    # call-seq:
+    #   extended{ ... }
+    #
+    # Call this method with a block and that block will be evaled by the Data object's class when
+    # the Data object is adorned with this role.
+    #   module Poster
+    #     extend Schizo::Role
+    #
+    #     extended do
+    #       has_many :posts
+    #     end
+    #   end
+    #
+    #   User.new.as(Poster).do |poster|
+    #     poster.posts.create :title => "My first post!"
+    #   end
+    def extended(object = nil, &block)
+      if block_given?
+        @extended_block = block
+      else
+        super
+      end
+    end
+
+    def extended_block #:nodoc:
+      @extended_block
+    end
+
+  end
+end

data/lib/schizo/version.rb

@@ -0,0 +1,3 @@
+module Schizo #:nodoc:
+  VERSION = "0.1.1"
+end

data/lib/schizo.rb

@@ -0,0 +1,8 @@
+require "schizo/data"
+require "schizo/role"
+require "schizo/version"
+require "schizo/facade"
+
+# The top level module; acts as a namespace.
+module Schizo
+end

data/schizo.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "schizo/version"
+
+Gem::Specification.new do |s|
+  s.name        = "schizo"
+  s.version     = Schizo::VERSION
+  s.authors     = ["Christopher J. Bottaro"]
+  s.email       = ["cjbottaro@alumni.cs.utexas.edu"]
+  s.homepage    = "https://github.com/cjbottaro/schizo"
+  s.summary     = %q{DCI (data, context and interaction) for Ruby / Rails / ActiveRecord}
+  s.description = %q{DCI (data, context and interaction) for Ruby / Rails / ActiveRecord}
+
+  s.rubyforge_project = "schizo"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "activerecord"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "rdoc"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "rake"
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/active_record/attributes_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe "an ActiveRecord instance" do
+  context "adorned with a role" do
+
+    let(:role) do
+      Module.new do
+        extend Schizo::Role
+        def set_name(name)
+          self.name = name
+        end
+      end
+    end
+
+    let(:user){ User.new :name => "christopher" }
+
+    let(:adorned_user){ user.as(role) }
+
+    it "setting attributes should affect the original instance because they aren't duped" do
+      adorned_user.set_name("callie")
+      adorned_user.should be_name_changed
+      adorned_user.name.should == "callie"
+      user.name.should == "callie"
+      user.should be_name_changed
+    end
+
+    context "saving" do
+
+      before(:all){ adorned_user.save }
+
+      it "does not affect the original instance's status as a new record" do
+        adorned_user.should_not be_new_record
+        user.should be_new_record
+      end
+
+      it "unless #actualize is called" do
+        adorned_user.actualize
+        user.should_not be_new_record
+      end
+
+    end
+
+  end
+end

data/spec/active_record/has_many_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe "an ActiveRecord instance" do
+  context "extended with a role that has_many :posts" do
+
+    let(:user){ User.create! :name => "chris" }
+
+    let(:role) do
+      Module.new do
+        extend Schizo::Role
+        extended do
+          has_many :posts
+        end
+      end
+    end
+
+    let(:adorned_user){ user.as(role) }
+
+    it "responds to #posts" do
+      adorned_user.should respond_to(:posts)
+      user.should_not respond_to(:posts)
+    end
+
+    context "#posts" do
+
+      it "works with #<<" do
+        post = Post.new :title => "first"
+        post.should be_a_new_record
+        adorned_user.posts << post
+        post.should_not be_a_new_record
+        adorned_user.posts.count.should == 1
+      end
+
+      it "works with #build" do
+        post = adorned_user.posts.build :title => "second"
+        post.should be_a_new_record
+        adorned_user.save!
+        post.should_not be_a_new_record
+        adorned_user.posts.find(post.id).should == post
+      end
+
+      it "works with #create" do
+        post = adorned_user.posts.create :title => "third"
+        post.should_not be_a_new_record
+        adorned_user.posts.find(post.id).should == post
+      end
+
+    end
+
+  end
+end

data/spec/facade/class_builder_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "schizo/facade"
+
+module Schizo
+  module Facade
+
+    describe ClassBuilder do
+
+      let(:base) do
+        Class.new do
+          def self.name; "Foo"; end
+        end
+      end
+
+      let(:role) do
+        Module.new do
+          extend Role
+          extended do
+            @test_var = 1
+          end
+        end
+      end
+
+      let(:builder) do
+        ClassBuilder.new(base, role)
+      end
+
+      context "#initialize" do
+
+        it "sets base and role" do
+          builder.base.should == base
+          builder.role.should == role
+        end
+
+      end
+
+      context "#product" do
+
+        it "returns a facade class" do
+          builder.product.tap do |facade|
+            facade.should be_a(Class)
+            facade.ancestors.should include(base)
+            facade.ancestors.should include(Base)
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/facade/class_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+module Schizo
+  module Facade
+
+    describe "a facade class" do
+
+      let(:base) do
+        Class.new do
+          def self.name; "Foo"; end
+        end
+      end
+
+      let(:role) do
+        Module.new do
+          extend Role
+          extended do
+            @test_var = 1
+          end
+        end
+      end
+
+      let(:builder) do
+        ClassBuilder.new(base, role)
+      end
+
+      let(:facade) do
+        builder.product
+      end
+
+      it "has the same #name as its superclass" do
+        facade.name.should == "Foo"
+        base.name.should == "Foo"
+      end
+
+      it "#initialize has arity == 2" do
+        base.instance_method(:initialize).arity.should < 2
+        facade.instance_method(:initialize).arity.should == 2
+      end
+
+      it "has class evaled the extended block of the role" do
+        facade.should be_instance_variable_defined(:@test_var)
+      end
+
+      it "is defined in Schizo::Facades" do
+        facade.should == Schizo::Facades.const_get(base.name).const_get("AnonRole#{role.object_id}")
+      end
+
+      it "is a singleton" do
+        facade.object_id.should == ClassBuilder.new(base, role).product.object_id
+      end
+
+    end
+
+  end
+end

data/spec/facade/object_builder_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+module Schizo
+  module Facade
+
+    describe(ObjectBuilder) do
+
+      let(:base) do
+        Class.new do
+        end
+      end
+
+      let(:role) do
+        Module.new do
+          extend Role
+          def bar(v)
+            @bar = v
+          end
+        end
+      end
+
+      let(:object) do
+        base.new
+      end
+
+      let(:builder) do
+        ObjectBuilder.new(object, role)
+      end
+
+      context "#initialize" do
+
+        it "sets object and role" do
+          builder.object.should == object
+          builder.role.should == role
+        end
+
+      end
+
+      context "#product" do
+
+        it "returns a facade object" do
+          builder.product.should be_a(base)
+          builder.product.should be_instance_of(base)
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/facade/object_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+module Schizo
+  module Facade
+
+    describe "a facade object" do
+
+      let(:base) do
+        Class.new do
+        end
+      end
+
+      let(:role) do
+        Module.new do
+          extend Role
+          def bar(v)
+            @bar = v
+          end
+        end
+      end
+
+      let(:object) do
+        base.new
+      end
+
+      let(:builder) do
+        ObjectBuilder.new(object, role)
+      end
+
+      let(:facade) do
+        builder.product
+      end
+
+      it "is not the same as the original object" do
+        facade.should_not == object
+      end
+
+      it "responds to methods defined in its role" do
+        facade.should respond_to(:bar)
+      end
+
+      it "calling methods should not affect original object" do
+        facade.bar("test")
+        facade.instance_variable_get(:@bar).should == "test"
+        object.instance_variable_get(:@bar).should be_nil
+      end
+
+      context "#actualize" do
+
+        before(:all) do
+          facade.bar("blah")
+          facade.actualize
+        end
+
+        it "returns the original object" do
+          facade.actualize.should == object
+        end
+
+        it "sets instance variables in the original object" do
+          object.instance_variable_get(:@bar).should == "blah"
+        end
+
+        it "does not set any internal dci instance variables" do
+          object.instance_variable_defined?(Schizo::Facade::DCI_INSTANCE_VARIABLE).should be_false
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/nested_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+describe "a nested facade for ClassA with RoleA, RoleB and RoleC" do
+
+  let(:class_a) do
+    Class.new do
+      include Schizo::Data
+      attr_reader :foo, :bar, :baz
+    end
+  end
+
+  let(:role_a) do
+    Module.new do
+      extend Schizo::Role
+      def set_foo; @foo = "foo"; end
+    end
+  end
+
+  let(:role_b) do
+    Module.new do
+      extend Schizo::Role
+      def set_bar; @bar = "bar"; end
+    end
+  end
+
+  let(:role_c) do
+    Module.new do
+      extend Schizo::Role
+      def set_baz; @baz = "baz"; end
+    end
+  end
+
+  let(:object) do
+    class_a.new
+  end
+
+  let(:facade_a) do
+    object.as(role_a)
+  end
+
+  let(:facade_b) do
+    facade_a.as(role_b)
+  end
+
+  let(:facade_c) do
+    facade_b.as(role_c)
+  end
+
+  it "#instance_of?(ClassA) is true" do
+    facade_c.should be_instance_of(class_a)
+  end
+
+  it "#kind_of?(ClassA) is true" do
+    facade_c.should be_kind_of(class_a)
+  end
+
+  it "should have methods from RoleA, RoleB and RoleC" do
+    facade_a.should respond_to(:set_foo)
+    facade_a.should_not respond_to(:set_bar)
+    facade_a.should_not respond_to(:set_baz)
+
+    facade_b.should respond_to(:set_foo)
+    facade_b.should respond_to(:set_bar)
+    facade_a.should_not respond_to(:set_baz)
+
+    facade_c.should respond_to(:set_foo)
+    facade_c.should respond_to(:set_bar)
+    facade_c.should respond_to(:set_baz)
+  end
+
+  it "#actualize should walk up the chain" do
+    facade_c.set_foo
+    facade_c.set_bar
+    facade_c.set_baz
+
+    facade_c.foo.should == "foo"
+    facade_c.bar.should == "bar"
+    facade_c.baz.should == "baz"
+
+    facade_b.foo.should be_nil
+    facade_b.bar.should be_nil
+    facade_b.baz.should be_nil
+
+    facade_a.foo.should be_nil
+    facade_a.bar.should be_nil
+    facade_a.baz.should be_nil
+
+    facade_c.actualize
+
+    facade_b.foo.should == "foo"
+    facade_b.bar.should == "bar"
+    facade_b.baz.should == "baz"
+
+    facade_a.foo.should be_nil
+    facade_a.bar.should be_nil
+    facade_a.baz.should be_nil
+
+    facade_b.actualize
+
+    facade_a.foo.should == "foo"
+    facade_a.bar.should == "bar"
+    facade_a.baz.should == "baz"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require "schizo"
+require "active_record"
+require "pry"
+
+ActiveRecord::Base.establish_connection(YAML::load(File.open('db/database.yml')))
+
+class User < ActiveRecord::Base
+  include Schizo::Data
+end
+
+class Post < ActiveRecord::Base
+  include Schizo::Data
+end
+
+RSpec.configure do |config|
+  #config.mock_with :rr
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: schizo
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Christopher J. Bottaro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70202402544160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70202402544160
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70202402543320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70202402543320
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70202402542560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70202402542560
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70202402541760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70202402541760
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70202402706420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70202402706420
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70202402705740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70202402705740
+description: DCI (data, context and interaction) for Ruby / Rails / ActiveRecord
+email:
+- cjbottaro@alumni.cs.utexas.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG
+- Gemfile
+- README.rdoc
+- Rakefile
+- db/database.yml
+- db/migrate/001_create_users.rb
+- db/migrate/002_create_posts.rb
+- lib/schizo.rb
+- lib/schizo/data.rb
+- lib/schizo/facade.rb
+- lib/schizo/facade/base.rb
+- lib/schizo/facade/class_builder.rb
+- lib/schizo/facade/object_builder.rb
+- lib/schizo/role.rb
+- lib/schizo/version.rb
+- schizo.gemspec
+- spec/active_record/attributes_spec.rb
+- spec/active_record/has_many_spec.rb
+- spec/facade/class_builder_spec.rb
+- spec/facade/class_spec.rb
+- spec/facade/object_builder_spec.rb
+- spec/facade/object_spec.rb
+- spec/nested_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/cjbottaro/schizo
+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: -910995716218782308
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -910995716218782308
+requirements: []
+rubyforge_project: schizo
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: DCI (data, context and interaction) for Ruby / Rails / ActiveRecord
+test_files:
+- spec/active_record/attributes_spec.rb
+- spec/active_record/has_many_spec.rb
+- spec/facade/class_builder_spec.rb
+- spec/facade/class_spec.rb
+- spec/facade/object_builder_spec.rb
+- spec/facade/object_spec.rb
+- spec/nested_spec.rb
+- spec/spec_helper.rb