conject 0.0.1

data/spec/acceptance/regression/nested_contexts_spec.rb

@@ -0,0 +1,86 @@
+
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe "nested contexts" do
+  subject { Conject.default_object_context }
+
+  let(:root_context) { Conject.default_object_context }
+
+  before do
+    append_test_load_path "basic_composition"
+    require 'lobby'
+    require 'front_desk'
+    require 'guest'
+    require 'tv'
+  end
+
+  after do
+    restore_load_path
+  end
+
+  it "can create an object within a subcontext" do
+    root_context.in_subcontext do |hotel|
+      front_desk = hotel[:front_desk]
+      front_desk.should be
+      front_desk.class.should == FrontDesk
+    end
+  end
+
+  it "reuse objects within themselves, but do not share with peer contexts" do
+    front_desk = nil
+    another_front_desk = nil
+
+    root_context.in_subcontext do |hotel|
+      front_desk = hotel[:front_desk]
+      hotel[:front_desk].object_id.should == front_desk.object_id
+      hotel.directly_has?(:front_desk).should be_true
+    end
+
+    root_context.in_subcontext do |hotel|
+      another_front_desk = hotel[:front_desk]
+      hotel[:front_desk].object_id.should == another_front_desk.object_id
+    end
+
+    another_front_desk.object_id.should_not == front_desk.object_id
+  end
+
+  it "provide dependencies by generating objects within itself" do
+    root_context.in_subcontext do |hotel|
+      lobby = hotel[:lobby]
+      lobby.front_desk.should be
+      lobby.front_desk.should == hotel[:front_desk]
+
+      hotel.directly_has?(:front_desk).should be_true
+      hotel.directly_has?(:lobby).should be_true
+
+      root_context.has?(:front_desk).should_not be_true
+      root_context.has?(:lobby).should_not be_true
+    end
+  end
+
+  it "provide dependencies via its parent context, THEN generating objects within itself" do
+    root_context.in_subcontext do |hotel|
+      lobby = hotel[:lobby] # this establishes the lobby and front desk in the hotel context
+
+      hotel.in_subcontext do |room|
+        guest = room[:guest]
+        # Guest should have reference to TV from the room context, and front desk from the hotel context
+        guest.tv.should be
+        guest.front_desk.should be
+
+        # Double check which contexts own which objects
+        room.directly_has?(:guest).should be_true
+        room.directly_has?(:tv).should be_true
+
+        hotel.directly_has?(:guest).should_not be_true
+        hotel.directly_has?(:tv).should_not be_true
+
+        guest.front_desk.should == hotel[:front_desk]
+        room.directly_has?(:front_desk).should_not be_true
+        hotel.directly_has?(:front_desk).should be_true
+      end
+    end
+  end
+
+end
+

data/spec/conject/borrowed_active_support_inflector_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+#
+# Some super-basic specs that don't really exercise Inflector,
+# but demonstrate that we have this capability built-in 
+# when using ObjectContext.
+#
+describe "Borrowed ActiveSupport Inflector" do
+  describe "#camelize" do
+    it "converts underscored strings to camel case" do
+      "four_five_six".camelize.should == "FourFiveSix"
+    end
+
+    it "leaves camel case words along" do
+      "HoppingSizzler".camelize.should == "HoppingSizzler"
+    end
+  end
+
+  describe "#underscore" do
+    it "converts camel-case words to underscored" do
+      "HoppingSizzler".underscore.should == "hopping_sizzler"
+    end
+
+    it "leaves underscored strings alone" do
+      "four_five_six".underscore.should == "four_five_six"
+    end
+  end
+end

data/spec/conject/class_ext_construct_with_spec.rb

@@ -0,0 +1,226 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "Class" do
+
+  describe ".construct_with" do
+    subject do
+      Class.new do
+        construct_with :object1, :object2
+
+        def initialize
+          @saw = "initialize has access to #{object1} and #{object2}"
+        end
+
+        def explain
+          "Made of #{object1} and #{object2}"
+        end
+
+        def to_s
+          @saw
+        end
+      end
+    end
+
+    it "lets you construct instances with sets of named objects" do
+      instance = subject.new :object1 => "first object", :object2 => "second object"
+      instance.explain.should == "Made of first object and second object"
+    end
+
+    it "sets objects before initialize is invoked" do
+      instance = subject.new :object1 => "one", :object2 => "two"
+      instance.to_s.should == "initialize has access to one and two"
+    end
+
+    it "defines the object accessors as private" do
+      instance = subject.new :object1 => "one", :object2 => "two"
+      lambda do instance.object1 end.should raise_error(NoMethodError)
+      lambda do instance.object2 end.should raise_error(NoMethodError)
+    end
+
+    describe "when user defines initialize with one argument" do
+      subject do
+        Class.new do
+          construct_with :ant, :aardvark
+
+          attr_reader :map_string, :also
+
+          def initialize(map)
+            @map_string = map.inspect
+            @also = "Preset #{ant} and #{aardvark}"
+          end
+        end
+      end
+
+      let :map do { :ant => "red", :aardvark => "blue" } end
+
+      it "passes along the object map" do
+        subject.new(map).map_string.should == map.inspect
+      end
+
+      it "still pre-sets the object accessors" do
+        subject.new(map).also.should == "Preset red and blue"
+      end
+    end
+
+    describe "when user defines initialize with var args" do
+      subject do
+        Class.new do
+          construct_with :ant, :aardvark
+
+          attr_reader :map_string, :also
+
+          def initialize(*stuff)
+            map = stuff.shift
+            @map_string = map.inspect
+            @also = "Preset #{ant} and #{aardvark}"
+          end
+        end
+      end
+
+      let :map do { :ant => "red", :aardvark => "blue" } end
+
+      it "passes along the object map" do
+        subject.new(map).map_string.should == map.inspect
+      end
+
+      it "still pre-sets the object accessors" do
+        subject.new(map).also.should == "Preset red and blue"
+      end
+    end
+
+    describe "when user defines initialize with too many args" do
+      subject do
+        Class.new do
+          construct_with :beevis, :butthead
+          def initialize(one,two)
+            # won't ever get run because the .new override will freak due to our arity
+          end
+        end
+      end
+
+      let :map do { :beevis => "nh nh!", :butthead => "uhhh huh huh" } end
+
+      it "raises an error due to invalid #initialize signature" do
+        lambda do subject.new(map) end.should raise_error(RuntimeError, /initialize method defined with 2 parameters/) 
+      end
+    end
+
+    describe "when user doesn't define an initialize" do
+      subject do
+        Class.new do
+          construct_with :something
+          def to_s
+            "Something is #{something}"
+          end
+        end
+      end
+
+      it "works normally" do
+        subject.new(:something => "normal").to_s.should == "Something is normal"
+      end
+    end
+
+    describe "when no object map is supplied to constructor" do
+      it "raises a typical argument error" do
+        lambda do subject.new end.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "when object map does not contain any required objects" do
+      it "raises a composition error explaining missing objects" do
+        lambda do subject.new({}) end.should raise_error(
+          Conject::CompositionError, 
+          /missing required.*object1.*object2/i
+        )
+      end
+    end
+
+    describe "when object map contains only SOME of the required objects" do
+      it "raises a composition error explaining which missing objects" do
+        lambda do subject.new(:object2 => "ok") end.should raise_error(
+          Conject::CompositionError, 
+          /missing required.*object1/i
+        )
+      end
+    end
+
+    describe "when object map contains objects that are not accepted" do
+      it "raises a composition error explaining rejected objects" do
+        lambda do 
+          subject.new(
+            :object1 => "ok",
+            :object2 => "ok",
+            :not_even_supposed => "to be here", 
+            :stop => "whining"
+          ) 
+        end.should raise_error(
+          Conject::CompositionError, 
+          /unexpected object.*not_even_supposed.*stop/i
+        )
+      end
+    end
+
+    describe "when object map has a mix of missing and unexpected objects" do
+      it "raises a composition error explaining missing and rejected objects" do
+        lambda do 
+          subject.new(
+            :object1 => "ok",
+            :not_even_supposed => "to be here"
+          )
+        end.should raise_error(
+          Conject::CompositionError, 
+          /missing required.*object2.*unexpected object.*not_even_supposed/i
+        )
+      end
+    end
+
+  end
+
+  describe ".object_definition" do
+    subject do 
+      Class.new do
+        construct_with :cats, :dogs
+      end
+    end
+
+    it "exists on classes that use construct_with" do
+      subject.should respond_to(:object_definition)
+    end
+
+    it "references the owning class" do
+      subject.object_definition.owner.should == subject
+    end
+
+    it "contains the list of required object names for construction of new instances" do
+      subject.object_definition.component_names.to_set.should == [:cats,:dogs].to_set
+    end
+
+    describe "for classes that don't use construct_with" do
+
+      before do
+        append_test_load_path "simple_stuff"
+        require 'some_random_class'
+      end
+
+      after do
+        restore_load_path
+      end
+
+      it "doesn't exist" do
+        require 'some_random_class'
+        SomeRandomClass.should_not respond_to(:object_definition)
+      end
+    end
+  end
+
+  describe ".has_object_definition?" do
+    it "returns false for all regular classes" do
+      Class.new.has_object_definition?.should be_false
+    end
+
+    it "returns true for classes that use construct_with" do
+      Class.new do construct_with :a end.has_object_definition?.should be_true
+    end
+  end
+
+end

data/spec/conject/class_finder_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Conject::ClassFinder do
+  before do
+    append_test_load_path "simple_stuff"
+    require 'some_random_class'
+  end
+
+  after do
+    restore_load_path
+  end
+
+  it "returns the class implied by the given name" do
+    c = subject.find_class('some_random_class')
+    c.should_not be_nil
+    c.should == SomeRandomClass
+  end
+
+  it "can accept symbols for object names" do
+    c = subject.find_class(:some_random_class)
+    c.should_not be_nil
+    c.should == SomeRandomClass
+  end
+
+  it "raises an error if the name doesn't imply a regular class in the current runtime" do
+    lambda do
+      subject.find_class('something_undefined')
+    end.should raise_error(/could not find class.*something_undefined/i)
+  end
+
+  it "raises an error for nil input" do
+    lambda do
+      subject.find_class('something_undefined')
+    end.should raise_error(/could not find class.*something_undefined/i)
+  end
+end

data/spec/conject/composition_error_spec.rb

@@ -0,0 +1,124 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+
+describe Conject::CompositionError do
+  subject do 
+    described_class.new construction_args
+  end
+
+  before do
+    append_test_load_path "simple_stuff"
+    require 'some_random_class'
+  end
+
+  after do
+    restore_load_path
+  end
+
+  let :construction_args do
+    {
+      :object_definition => object_definition, 
+      :provided => []
+    }
+  end
+
+  let :object_definition do
+    Conject::ObjectDefinition.new(
+      :owner => SomeRandomClass,
+      :component_names => []
+    )
+  end
+
+  describe "when missing one required component" do
+    before { object_definition.component_names << :an_object }
+    
+    it "indicates the missing object" do
+      subject.message.should == "Wrong components when building new SomeRandomClass. Missing required object(s) [:an_object]."
+    end
+  end
+
+  describe "when missing multiple required components" do
+    before do
+      object_definition.component_names << :an_object
+      object_definition.component_names << :another_object
+    end
+
+    it "indicates all missing objects" do
+      subject.message.should == "Wrong components when building new SomeRandomClass. Missing required object(s) [:an_object, :another_object]."
+    end
+  end
+
+  describe "when an unexpected component is provided" do
+    before { construction_args[:provided] = [ :surprise ] }
+
+    it "calls out the unexpected object" do
+      subject.message.should == "Wrong components when building new SomeRandomClass. Unexpected object(s) provided [:surprise]."
+    end
+  end
+
+  describe "when multiple unexpected components are provided" do
+    before { construction_args[:provided] = [ :surprise, :hello ] }
+    it "calls out all unexpected objects" do
+      subject.message.should == "Wrong components when building new SomeRandomClass. Unexpected object(s) provided [:surprise, :hello]."
+    end
+  end
+
+  describe "when unexpected components are provided AND required components are missing" do
+    before do
+      object_definition.component_names << :part_one
+      object_definition.component_names << :part_two
+      object_definition.component_names << :part_three
+      construction_args[:provided] = [ :part_two, :surprise_one, :surprise_two ]
+    end
+
+    it "generates a message for both missing AND unexpected components" do
+      subject.message.should == "Wrong components when building new SomeRandomClass. Missing required object(s) [:part_one, :part_three]. Unexpected object(s) provided [:surprise_one, :surprise_two]."
+    end
+  end
+
+  describe "without object_definition" do
+    it "has a vague message" do
+      construction_args.delete :object_definition
+      construction_args[:provided] = [ :one, :two ]
+      subject.message.should == "Failed to construct... something. Provided objects were: [:one, :two]"
+    end
+  end
+
+  describe "with nil construction args" do
+    let :construction_args do nil end
+
+    it "has a vague message" do
+      subject.message.should == "Failed to construct... something."
+    end
+  end
+
+  describe "without any args supplied at all" do
+    let :construction_args do nil end
+    it "has a vague message" do
+      described_class.new.message.should == "Failed to construct... something."
+    end
+  end
+
+  describe "without an object_definition.owner" do
+    let :object_definition do
+      Conject::ObjectDefinition.new(
+        :component_names => [:a, :b]
+        # no owner
+      )
+    end
+
+    it "uses a placeholder name, but otherwise generates good info" do
+      subject.message.should == "Wrong components when building new object. Missing required object(s) [:a, :b]."
+    end
+  end
+
+  describe "without provided object names" do
+    it "indicates which components are required but not what's missing" do
+      object_definition.component_names << :wanting
+      construction_args.delete :provided
+      # p object_definition
+      subject.message.should == "Wrong components when building new SomeRandomClass. Missing required object(s) [:wanting]."
+    end
+  end
+
+end