conject 0.0.1

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'simplecov' # SimpleCov must come first!
+# This start/config code could alternatively go in .simplecov in project root:
+SimpleCov.start do
+  add_filter "/spec/"
+  add_filter "/borrowed_active_support_inflector.rb" # We stole it precious, our specs only hit about 47% of the functions, just to prove we have this library ready to go
+end
+
+PROJECT_ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+
+$LOAD_PATH << "#{PROJECT_ROOT}/lib"
+$LOAD_PATH << "#{PROJECT_ROOT}/spec/samples"
+ENV["APP_ENV"] = "rspec"
+
+require 'conject'
+
+# Load all support files
+Dir["#{PROJECT_ROOT}/spec/support/*.rb"].each do |support|
+  require support
+end
+
+RSpec.configure do |config|
+  config.include LoadPathHelpers
+end
+

data/spec/support/load_path_helpers.rb

@@ -0,0 +1,27 @@
+
+module LoadPathHelpers
+  def test_data_path(rel_path='')
+    "#{PROJECT_ROOT}/spec/test_data/#{rel_path}"
+  end
+
+  def append_load_path(path)
+    @appended_load_paths ||= []
+    @appended_load_paths << path
+    $LOAD_PATH << path
+  end
+
+  def append_test_load_path(path)
+    append_load_path test_data_path(path)
+  end
+
+  def restore_load_path
+    (@appended_load_paths || []).each do |path|
+      remove_load_path path
+    end
+  end
+
+  def remove_load_path(path)
+    $LOAD_PATH.delete path
+  end
+end
+

data/spec/test_data/basic_composition/fence.rb

@@ -0,0 +1,5 @@
+class Fence
+  construct_with :wood, :nails
+
+  public :wood, :nails
+end

data/spec/test_data/basic_composition/front_desk.rb

@@ -0,0 +1,2 @@
+class FrontDesk
+end

data/spec/test_data/basic_composition/grass.rb

@@ -0,0 +1,2 @@
+class Grass
+end

data/spec/test_data/basic_composition/guest.rb

@@ -0,0 +1,5 @@
+class Guest
+  construct_with :tv, :front_desk
+
+  public :tv, :front_desk
+end

data/spec/test_data/basic_composition/lobby.rb

@@ -0,0 +1,5 @@
+class Lobby
+  construct_with :front_desk
+
+  public :front_desk
+end

data/spec/test_data/basic_composition/nails.rb

@@ -0,0 +1,2 @@
+class Nails
+end

data/spec/test_data/basic_composition/tv.rb

@@ -0,0 +1,2 @@
+class Tv
+end

data/spec/test_data/basic_composition/wood.rb

@@ -0,0 +1,2 @@
+class Wood
+end

data/spec/test_data/simple_stuff/some_random_class.rb

@@ -0,0 +1,2 @@
+class SomeRandomClass
+end

data/spike/arity_funny_business_in_different_ruby_versions.rb

@@ -0,0 +1,34 @@
+$: << "../lib"
+require 'object_context'
+require 'object_context/utilities'
+
+class A
+end
+
+class B
+  def initialize
+  end
+end
+
+class C
+  def initialize(*x)
+  end
+end
+
+class D
+  def initialize(x)
+  end
+end
+
+
+#
+# RUBY 1.9.2 says Object#initialize is arity -1
+# RUBY 1.9.3 (and 1.8.7??) say it's 0 (as expected)
+# This discrepancy is being handled by ObjectContext::Utilities.has_zero_arg_constructor?
+#
+puts "RUBY_PLATFORM: #{RUBY_PLATFORM}"
+puts "RUBY_VERSION: #{RUBY_VERSION}"
+[A,B,C,D].each do |c|
+  puts "Class #{c}#initialize arity: #{c.instance_method(:initialize).arity}"
+  puts "Class #{c} has_zero_arg_constructor?: #{ObjectContext::Utilities.has_zero_arg_constructor?(c)}"
+end

data/spike/depends_on_spike.rb

@@ -0,0 +1,146 @@
+$: << "."
+require 'metaid'
+require 'set'
+
+class ObjectDefinition
+  attr_reader :component_names, :owner, :construction_type, :singleton
+
+  def initialize(opts={})
+    @owner = opts[:owner]
+    @component_names = opts[:component_names] || []
+    @construction_type = :instance
+    @singleton = true
+  end
+end
+
+
+class Class
+
+  def depends_on(*syms)
+    #puts "Class #{name} wishes to be constructed with #{syms.inspect}"
+
+    klass = self
+
+    object_def = ObjectDefinition.new(:owner => klass, :component_names => syms)
+    klass.meta_def :object_definition do
+      object_def
+    end
+
+
+    klass.class_def_private :components do 
+      @_components ||= {}
+    end
+
+    syms.each do |object_name|
+      class_def_private object_name do
+        components[object_name]
+      end
+    end
+
+    klass.class_def_private :set_components do |component_map|
+      required = object_def.component_names.to_set
+      provided = component_map.keys.to_set
+      if required != provided
+        msg = "Wrong components when building new #{object_def.owner}:"
+
+        missing = required - provided
+        msg << "Required objects not provided: #{missing.to_a.inspect}" unless missing.empty?
+
+        unexpected = provided - required
+        msg << "Unexpected objects: #{unexpected.to_a.inspect}" unless unexpected.empty?
+      end
+
+      components.clear.merge! component_map
+
+    end
+
+    # Tidbits of state that our dynamically-defined functions herein
+    # will close over.
+    object_context_prep = {
+      :initialize_has_been_wrapped => false,  # keep track of when a class's :initialize method has been wrapped
+    }
+    # klass.meta_def :object_context_prep do
+    #   @_object_context_prep ||= {
+    #     :initialize_has_been_wrapped => false
+    #   }
+    # end
+
+    # Alias :new such that we can wrap and invoke it later
+    klass.meta_eval do 
+      alias_method :actual_new, :new
+    end
+
+    # Override default :new behavior for this class:
+    klass.meta_def :new do |component_map|
+
+      # We only want to do the following one time, but we've waited until now
+      # in order to make sure our metaprogramming didn't get ahead of the user's
+      # own definition of initialize:
+      unless object_context_prep[:initialize_has_been_wrapped]
+        puts "  (wrapping :initialize, should only happen once)"
+
+        # Define a new wrapper'd version of initialize that accepts and uses a component map
+        alias_method :actual_initialize, :initialize
+        class_def :initialize do |component_map|
+          # Apply the given components
+          set_components component_map
+
+          # Invoke the normal initialize method.
+          # User-defined initialize method may accept 0 args, or it may accept a single arg
+          # which will be the component map.
+          arg_count = method(:actual_initialize).arity
+          case arg_count
+          when 0
+            actual_initialize
+          when 1
+            actual_initialize component_map
+          else
+            # We're not equipped to handle this
+            raise "User-defined initialize method defined with #{arg_count} paramters; must either be 0, or 1 to receive the component map."
+          end
+        end
+        # Make a note that the initialize wrapper has been applied
+        object_context_prep[:initialize_has_been_wrapped] = true
+      end
+
+      # Instantiate an instance
+      actual_new component_map 
+    end
+  end
+
+  def has_object_definition?
+    respond_to?(:object_definition) and !object_definition.nil?
+  end
+
+end
+
+class Car
+  depends_on :doors
+
+  def initialize(cm)
+    puts "User defined initialize: Construcing a new Car #{cm}. Can talk about doors=#{doors}"
+  end
+
+end
+
+class Doors
+  def initialize
+    puts "Doors constructed the old fashioned way"
+    $stdout.flush
+  end
+end
+
+c = Car.new(:doors => "whatever")
+$stdout.flush
+d = Doors.new
+c2 = Car.new(:doors => "more whatever")
+p c
+p d
+p c2
+#p c2.components # will fail, components should be private
+puts "Doors has an object def? #{Doors.has_object_definition?}"
+puts "Car has an object def? #{Car.has_object_definition?}"
+p Car.object_definition
+puts "Car class requires components: #{Car.object_definition.component_names}"
+puts "OK! (If this line prints out then the basic premise is working, though we're not really doing anything to assign components yet)"
+

data/spike/donkey_fail.rb

@@ -0,0 +1,48 @@
+$: << "."
+require 'object_definition'
+
+class Donkey
+  depends_on :head, :legs
+
+  def journey
+    head.talk
+    legs.walk
+  end
+end
+
+class Head
+  depends_on :eyes, :mouth
+
+  def talk
+    mouth.bray
+    eyes.roll
+  end
+end
+
+class Legs
+  def walk
+    puts "Clop clop!"
+  end
+end
+
+class Eyes
+  def roll
+    puts "(eye roll)"
+  end
+end
+
+class Mouth
+  def bray
+    puts "HAWWW!!"
+  end
+end
+
+donkey = Donkey.new(
+  :head => Head.new(
+    :one => "dude",
+    :two => "dudes",
+  ),
+  :legs => Legs.new,
+)
+
+donkey.journey

data/spike/donkey_journey.rb

@@ -0,0 +1,50 @@
+$: << "."
+require 'object_definition'
+
+class Donkey
+  depends_on :head, :legs
+
+  def journey
+    head.talk
+    legs.walk
+  end
+
+end
+
+class Head
+  depends_on :eyes, :mouth
+
+  def talk
+    mouth.bray
+    eyes.roll
+  end
+end
+
+class Legs
+  def walk
+    puts "Clop clop!"
+  end
+end
+
+class Eyes
+  def roll
+    puts "(eye roll)"
+  end
+end
+
+class Mouth
+  def bray
+    puts "HAWWW!!"
+  end
+end
+
+donkey = Donkey.new(
+  :head => Head.new(
+    :mouth => Mouth.new,
+    :eyes => Eyes.new
+  ),
+  :legs => Legs.new
+)
+
+donkey.journey
+

data/spike/go.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH << "lib"
+$LOAD_PATH << "src"
+
+require 'ruice'
+
+presenter = Ruice[:user_presenter]
+model = Ruice[:user_model]
+view = Ruice[:user_view]
+
+model.user = { :name => "Dave" }
+puts "view.name=#{view.name}"

data/spike/metaid.rb

@@ -0,0 +1,28 @@
+# Metaid == a few simple metaclass helper
+# (See http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html.)
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+end
+
+class Module
+  # Defines an instance method within a module
+  def module_def name, &blk
+    module_eval { define_method name, &blk }
+  end
+  def module_def_private name, &blk
+    module_def name, &blk
+    private name
+  end
+end
+
+class Class
+  alias class_def module_def
+  alias class_def_private module_def_private
+end

data/spike/object_definition.rb

@@ -0,0 +1,125 @@
+require 'metaid'
+require 'set'
+
+class ObjectDefinition
+  attr_reader :component_names, :owner, :construction_type, :singleton
+
+  def initialize(opts={})
+    @owner = opts[:owner]
+    @component_names = opts[:component_names] || []
+    @construction_type = :instance
+    @singleton = true
+  end
+end
+
+class CompositionError < RuntimeError
+  def initialize(opts={})
+    object_def = opts[:object_definition]
+    required = opts[:required]
+    provided = opts[:provided]
+
+    msg = "Wrong components when building new #{object_def.owner}: "
+
+    missing = required - provided
+    msg << "Missing required object(s) #{missing.to_a.inspect}. " unless missing.empty?
+
+    unexpected = provided - required
+    msg << "Encountered unexpected object(s) #{unexpected.to_a.inspect}. " unless unexpected.empty?
+
+    super msg
+  end
+end
+
+class Class
+
+  def depends_on(*syms)
+    klass = self
+
+    object_def = ObjectDefinition.new(:owner => klass, :component_names => syms)
+    klass.meta_def :object_definition do
+      object_def
+    end
+
+
+    klass.class_def_private :components do 
+      @_components ||= {}
+    end
+
+    syms.each do |object_name|
+      class_def_private object_name do
+        components[object_name]
+      end
+    end
+
+    klass.class_def_private :set_components do |component_map|
+      required = object_def.component_names.to_set
+      provided = component_map.keys.to_set
+      if required != provided
+        raise CompositionError.new(
+          :object_definition => object_def,
+          :required => required, 
+          :provided => provided)
+      end
+
+      components.clear.merge! component_map
+
+    end
+
+    # Tidbits of state that our dynamically-defined functions herein
+    # will close over.
+    object_context_prep = {
+      :initialize_has_been_wrapped => false,  # keep track of when a class's :initialize method has been wrapped
+    }
+    # klass.meta_def :object_context_prep do
+    #   @_object_context_prep ||= {
+    #     :initialize_has_been_wrapped => false
+    #   }
+    # end
+
+    # Alias :new such that we can wrap and invoke it later
+    klass.meta_eval do 
+      alias_method :actual_new, :new
+    end
+
+    # Override default :new behavior for this class:
+    klass.meta_def :new do |component_map|
+
+      # We only want to do the following one time, but we've waited until now
+      # in order to make sure our metaprogramming didn't get ahead of the user's
+      # own definition of initialize:
+      unless object_context_prep[:initialize_has_been_wrapped]
+        # Define a new wrapper'd version of initialize that accepts and uses a component map
+        alias_method :actual_initialize, :initialize
+        class_def :initialize do |component_map|
+          # Apply the given components
+          set_components component_map
+
+          # Invoke the normal initialize method.
+          # User-defined initialize method may accept 0 args, or it may accept a single arg
+          # which will be the component map.
+          arg_count = method(:actual_initialize).arity
+          case arg_count
+          when 0
+            actual_initialize
+          when 1
+            actual_initialize component_map
+          else
+            # We're not equipped to handle this
+            raise "User-defined initialize method defined with #{arg_count} paramters; must either be 0, or 1 to receive the component map."
+          end
+        end
+        # Make a note that the initialize wrapper has been applied
+        object_context_prep[:initialize_has_been_wrapped] = true
+      end
+
+      # Instantiate an instance
+      actual_new component_map 
+    end
+  end
+
+  def has_object_definition?
+    respond_to?(:object_definition) and !object_definition.nil?
+  end
+
+end
+