mindi 0.5

data/examples/color-namespace.rb

@@ -0,0 +1,36 @@
+# Namespace example
+
+require 'mindi'
+
+class PictureApp
+  include MinDI::InjectableContainer
+
+  class Picture
+    attr_reader :opts
+    def initialize(opts)
+      @opts = opts
+    end
+  end
+
+  class Color < Struct.new(:r, :g, :b)
+    def +(color)
+      Color.new(r + color.r, g + color.g, b + color.b)
+    end
+  end
+
+  class ColorNamespace
+    include MinDI::InjectableContainer
+
+    red     { Color.new(1,0,0) }
+    green   { Color.new(0,1,0) }
+    yellow  { red + green      }
+  end
+
+  colors  { ColorNamespace.new }
+  picture { Picture.new(:background => colors.yellow) }
+end
+
+pic_app = PictureApp.new
+pic = pic_app.picture
+raise unless pic.opts[:background] == pic_app.colors.yellow
+

data/examples/duck.rb

@@ -0,0 +1,66 @@
+# This is the basic idea of Injectable, without MinDI around it.
+
+module Injectable
+  module Injected
+    def method_missing(*args, &block)
+      @__injectable__container__ || super
+      @__injectable__container__.send(*args, &block)
+    rescue NoInjectedMethodError
+      super
+    end
+  end
+
+  def inject_into obj
+    obj.extend Injected
+    obj.instance_variable_set(:@__injectable__container__, self)
+    obj
+  end
+
+  def method_missing(m, *rest)
+    raise NoInjectedMethodError
+  end
+end
+
+class Duck
+  include Injectable
+  
+  def quack; @quack_behavior.quack; end
+  def waddle; @waddle_behavior.waddle; end
+  
+  def initialize(h)
+    @quack_behavior = h[:quack_behavior]
+    @waddle_behavior = h[:waddle_behavior]
+    
+    inject_into @quack_behavior
+    inject_into @waddle_behavior
+  end
+end
+
+class StandardQuacker
+  def quack
+    puts "QUACK!"
+  end
+end
+
+class NoisyWaddler
+  def waddle
+    quack       # note that this propagates to Duck then to quacker
+    puts "<waddle>"
+    quack
+  end
+end
+
+duck = Duck.new(
+  :quack_behavior   => StandardQuacker.new,
+  :waddle_behavior  => NoisyWaddler.new
+)
+
+duck.waddle
+
+__END__
+
+Output:
+
+QUACK!
+<waddle>
+QUACK!

data/examples/dynamic.rb

@@ -0,0 +1,24 @@
+require 'mindi'
+
+# Shows how to register services dynamically; this is usually done
+# with a "register" method in other DI frameworks, but we use method
+# definition, because that can be done dynamically in ruby.
+
+class DynamicContainer
+  include MinDI::InjectableContainer
+  
+  stuff { [foo, bar] }  # foo and bar not defined yet
+end
+
+cont = DynamicContainer.new
+
+# Add a service to DynamicContainer at service point foo.
+DynamicContainer.foo {"FOO"}
+p cont.foo    # ==> "FOO"
+
+# Add a service just to the instance cont at service point bar.
+class << cont; bar { "BAR" }; end
+p cont.bar    # ==> "BAR"
+
+# Now #stuff will work,
+p cont.stuff  # ==> ["FOO", "BAR"]

data/examples/game.rb

@@ -0,0 +1,127 @@
+require 'mindi'
+
+Parser = Struct.new :game # add parser state vars here
+Player = Struct.new :game, :location, :contents
+World = Struct.new :game # add state vars (:time, maybe)
+Map = Struct.new :game
+  # The :game attr is useful if you want to write methods of
+  # these classes (Player for example) that refer to the other
+  # game objects. But it's not strictly necessary.
+
+Room = Struct.new :name, :contents
+
+# Sometimes, a struct is not enough...
+class Thing
+  attr_accessor :name
+  attr_reader :location
+
+  def initialize name, location = nil
+    @name = name
+    @location = location
+  end
+  
+  # Moving a Thing updates the Room it's in or Player who has it
+  def location=(loc)
+    @location.contents.delete self if @location
+    @location = loc
+    @location.contents << self if @location
+  end
+end
+
+class GameContainer
+  include MinDI::InjectableContainer
+  
+  # These are some singletons--one instance each.
+  parser  { Parser.new self }
+  player  { Player.new self, start_room, [] }
+  world   { World.new self }
+  map     { Map.new self }
+  
+  # A multiton.
+  # The |name| means there can be many things--one for each name.
+  # internally, there is a hash  stored in @thing that maps
+  # each name strign to a Thing.
+  thing { |name| Thing.new name }
+
+  # The shovel (unique with that name).
+  shovel { thing "Shovel" }
+
+  room { |name| Room.new name, [] }
+
+  start_room { room "garden" }
+  
+  # Set up some initial conditions
+  def initialize
+    # create and locate the shovel
+    shovel.location = start_room
+  end
+end
+
+game = GameContainer.new
+
+# The shovel is already defined:
+p game.shovel
+puts
+
+# Create a new thing:
+ball = game.thing("ball")
+ball.location = game.room "basement"
+p ball
+puts
+
+player = game.player
+
+# pick up the shovel and anything else in the start room
+# This could be made into a #pick_up method of Game or of Player
+player.location.contents.each { |thing| thing.location = player }
+p player.contents.map {|thing| thing.name}
+puts
+
+# move the player
+p player.location.name
+player.location = game.room "basement"
+p player.location.name
+puts
+
+# get the ball
+player.location.contents.each { |thing| thing.location = player }
+p player.contents.map {|thing| thing.name}
+puts
+
+# You can define new methods on the GameContainer that access the internal
+# storage used by the "service" methods.
+class GameContainer
+  def rooms
+    instance_variable_get(MinDI::Container.iv("room")).values
+    # because internally the "room" service uses a hash stored in
+    # an instance var with a munged name
+  end
+  
+  def things
+    instance_variable_get(MinDI::Container.iv("thing")).values
+  end
+end
+
+# Show all the rooms
+p game.rooms
+
+# Show all the things
+p game.things.map {|thing| thing.name}
+
+__END__
+
+Output:
+
+#<Thing:0xb7d862fc @name="Shovel", @location=#<struct Room name="garden", contents=[#<Thing:0xb7d862fc ...>]>>
+
+#<Thing:0xb7d85078 @name="ball", @location=#<struct Room name="basement", contents=[#<Thing:0xb7d85078 ...>]>>
+
+["Shovel"]
+
+"garden"
+"basement"
+
+["Shovel", "ball"]
+
+[#<struct Room name="garden", contents=[]>, #<struct Room name="basement", contents=[]>]
+["ball", "Shovel"]

data/examples/inject.rb

@@ -0,0 +1,141 @@
+require 'mindi'
+
+#---------------
+# Example showing how to use #inject_into to give a service object direct access
+# to other services in the container, without having to explicitly reference
+# the container object. See the GenericCopier#copy method and the #copier
+# service. This further reduces the dependence of service classes on the
+# structure of the container, since the initialize method of GenericCopier
+# doesn't need to know about reader and writer (in fact you don't even need to
+# write an initialize method in this case). The GenericCopier class can be
+# tested with a mock reader and a mock writer by adding reader and writer
+# methods.
+
+module Acme
+  class Scanner1200PDQ
+    def read
+      "this is some dummy text"
+    end
+  end
+end
+
+module FooCorp
+  class LaserPrinter5
+    def write(str)
+      puts str
+    end
+  end
+end
+
+class GenericCopier
+  def copy
+    data = reader.read
+    writer.write data
+  end
+end
+
+class SimpleOffice
+  include MinDI::InjectableContainer
+
+  copier { GenericCopier.new }
+  reader { Acme::Scanner1200PDQ.new }
+  writer { FooCorp::LaserPrinter5.new }
+end
+
+office = SimpleOffice.new
+
+office.copier.copy
+
+
+#---------------
+# This example shows that inject_into can be used to define mutually depedent
+# services more conveniently. First, a mutual dependence example without using
+# inject_into:
+
+class A
+  attr_accessor :b
+  def initialize b
+    @b = b
+  end
+end
+
+class B
+  attr_accessor :a
+  def initialize a
+    @a = a
+  end
+end
+
+class MutualContainer
+  include MinDI::BasicContainer
+
+  a { temp_a = A.new(b); b.a = temp_a; temp_a }
+    # awkward!
+  
+  b { B.new(nil) }
+    # This still doesn't work properly! There's no way to refer to 'a' yet.
+end
+
+cont = MutualContainer.new
+p cont.b.a # returns nil until after service 'a' is invoked
+p cont.a.b.a.b
+p cont.b.a # returns a
+
+#---------------
+# Next, a mutual dependence example using inject_into. Note how much
+# simpler the service implementations are!
+
+class A2
+end
+
+class B2
+end
+
+class MutualContainerUsingInjectable
+  include MinDI::InjectableContainer
+
+  a { A2.new }
+  b { B2.new }
+end
+
+cont = MutualContainerUsingInjectable.new
+p cont.b.a.b.a # everything is set up correctly
+p cont.a.b.a.b
+
+
+#---------------
+# It is even possible to inject one _container_ into another:
+
+class OuterContainer
+  include MinDI::BasicContainer
+  
+  something { [:foo, "bar", something_else] }
+    # note the reference to a service provided by the InnerContainer
+end
+
+class InnerContainer
+  include MinDI::InjectableContainer
+  
+  injected # this is the default anyway
+  outer { OuterContainer.new }
+
+  uninjected
+    # No need to mess up this little hash by injecting InnerContainer into it
+  something_else { { :baz => :zap } }
+end
+
+ic = InnerContainer.new
+
+p ic.outer.something
+
+
+#---------------
+# Using Injectable without MinDI containers.
+
+x = [1,2,3]
+y = {}
+x.extend MinDI::Injectable
+x.inject_into y
+p y.reverse
+
+

data/examples/rake-alike.rb

@@ -0,0 +1,13 @@
+require 'mindi'
+
+class Tasks
+  include MinDI::BasicContainer
+
+  a  { print "a" }
+  b  { a; print "b" }
+  c  { a; print "c" }
+  d  { b; c; print "d" }
+end
+
+Tasks.new.d
+

data/examples/simple.rb

@@ -0,0 +1,15 @@
+require 'mindi'
+
+class SimpleContainer
+  include MinDI::BasicContainer
+
+  greeting { "Hello, world\n" }
+  
+  point_at { |x,y| [x,y] }
+  
+  stuff { [greeting, point_at(100,200)] }
+end
+
+cont = SimpleContainer.new
+
+p cont.stuff   # ==> ["Hello, world\n", [100, 200]]

data/examples/test.rb

@@ -0,0 +1,117 @@
+# Examples and unit tests (sort of) for MinDI.
+
+require 'mindi'
+
+class Foo; end
+class Bar < Struct.new(:key); end
+class Point < Struct.new(:x, :y); end
+
+class MyContainer
+  include MinDI::BasicContainer
+
+  singleton :foo do
+    Foo.new
+  end
+
+  # shortcut for singleton
+  other_foo { Foo.new }
+
+  multiton :bar_for do |key|
+    Bar.new(key)
+    # The Bar instance doesn't have to receive the key, but it can.
+  end
+
+  # shortcut for multiton
+  other_bar_for { |key| Bar.new(key) }
+
+  # shortcut for multiton with multiple keys
+  point_for_xy { |x,y| Point.new(x,y) }
+
+  # Reference other services.
+  foos { [foo, other_foo] }
+
+  # We can manage services manually.
+  generic :gene do
+    @gene ||= Foo.new
+  end
+
+  # service implementations are closures
+  shared_foo = nil
+  generic :shared do
+    shared_foo ||= Foo.new
+      # shared among all MyContainer instances
+  end
+
+  threaded :per_thread do # |thread| # optional
+    Array.new
+  end
+
+  deferred :lazy do
+    $deferred_service_done = true # for testing
+    "Deferred service result"
+  end
+
+  begin
+    not_a_service
+  rescue NameError
+    # Raises an error because no block is given, so it can't possibly be
+    # a service definition. We just let the superclass's method_missing
+    # handle it.
+  else raise
+  end
+end
+
+MyContainer.service_declared_outside do
+  Bar.new(other_foo) # note scope is still the container instance
+end
+
+cont = MyContainer.new
+
+raise unless cont.foo.equal?(cont.foo)
+raise unless cont.other_foo.equal?(cont.other_foo)
+
+raise unless cont.bar_for(3).equal?(cont.bar_for(3))
+raise unless cont.other_bar_for(3).equal?(cont.other_bar_for(3))
+raise unless cont.point_for_xy(3, 33).equal?(cont.point_for_xy(3, 33))
+
+raise if cont.bar_for(3).equal?(cont.bar_for(7))
+raise if cont.other_bar_for(3).equal?(cont.other_bar_for(7))
+raise if cont.point_for_xy(3, 33).equal?(cont.point_for_xy(7, 77))
+
+raise unless cont.foos.uniq.size == 2
+
+raise unless cont.gene.is_a?(Foo)
+raise unless cont.gene.equal?(cont.gene)
+
+cont2 = MyContainer.new
+raise unless cont2.shared.equal?(cont.shared)
+
+raise unless cont.service_declared_outside.is_a?(Bar)
+
+t1 = Thread.new { cont.per_thread }
+t2 = Thread.new { cont.per_thread }
+
+raise if t1.value.equal?(t2.value)
+
+lazy = cont.lazy
+raise if $deferred_service_done
+
+lazy.grep /foo/ # Call a method, which will instantiate the object.
+raise unless $deferred_service_done
+
+# The container class may accept perameters for instantiating containers.
+class ParametricContainer
+  include MinDI::InjectableContainer
+  def initialize(name, opts = {})
+    @name = name
+    @opts = opts
+  end
+
+  thing { @opts[:thing_class].new("thing of #{@name}") }
+end
+
+tc = Struct.new(:name)
+pc = ParametricContainer.new("fred", {:thing_class => tc})
+raise unless pc.thing.name == "thing of fred"
+
+puts "all tests passed!"