<?xml version="1.0" encoding="UTF-8"?>
<commit>
  <added type="array">
    <added>
      <filename>lib/module_creation_helper/extensions/module.rb</filename>
    </added>
  </added>
  <modified type="array">
    <modified>
      <diff>@@ -29,10 +29,8 @@ you will want to associate a runtime class with an actual name.
 
 Traditionally, you would create new classes like so:
 
-  &gt;&gt; c = Class.new
-  =&gt; #&lt;Class:0x480e388&gt;
-  &gt;&gt; Object.const_set('Foo', c)
-  =&gt; Foo
+  c = Class.new               # =&gt; #&lt;Class:0x480e388&gt;
+  Object.const_set('Foo', c)  # =&gt; Foo
 
 Although this isn't very hard, there are two problems:
 (1) It's a repetitive process that should be DRYed.
@@ -50,9 +48,9 @@ To understand the second problem, consider the following:
 When a class inherits from Foo, Ruby will invoke the +inherited+ callback.  For
 example,
 
-  &gt;&gt; c = Class.new(Foo)
-  inherited class: #&lt;Class:0x47fb92c&gt;, name:
-  =&gt; #&lt;Class:0x47fb92c&gt;
+  c = Class.new(Foo)
+  # inherited class: #&lt;Class:0x47fb92c&gt;, name:
+  # =&gt; #&lt;Class:0x47fb92c&gt;
 
 As you can see from output in this example, since the class has not yet been
 assigned to a constant, it is anonymous and does not yet have a name.
@@ -67,9 +65,9 @@ Class since Class inherits from Module.
 
 Using the same example as before,
 
-  &gt;&gt; c = Class.create('Bar', :superclass =&gt; Foo)
-  inherited class: Bar, name: Bar
-  =&gt; Bar
+  c = Class.create('Bar', :superclass =&gt; Foo)
+  # inherited class: Bar, name: Bar
+  # =&gt; Bar
 
 As you can see, the name of the class is now available during the +inherited+
 callback and is automatically assigned to the 'Bar' constant in Object.
@@ -79,24 +77,24 @@ callback and is automatically assigned to the 'Bar' constant in Object.
 In addition to specifying the superclass, you can also specify the parent
 module/class like so:
 
-  &gt;&gt; c = Class.create('Bar', :superclass =&gt; Foo, :parent =&gt; MyModule)
-  inherited class: MyModule::Bar, name: MyModule::Bar
-  =&gt; MyModule::Bar
+  c = Class.create('Bar', :superclass =&gt; Foo, :parent =&gt; MyModule)
+  # inherited class: MyModule::Bar, name: MyModule::Bar
+  # =&gt; MyModule::Bar
 
 === Defining class/module methods
 
 As you normally could when creating a new class, you can provide an additional
 block that defines the body of the class.  For example,
 
-  &gt;&gt; c = Class.create('Bar', :superclass =&gt; Foo, :parent =&gt; MyModule) do
-  ?&gt;   def say_hello
-  ?&gt;     'hello'
-  ?&gt;   end
-  ?&gt; end
-  inherited class: MyModule::Bar, name: MyModule::Bar
-  =&gt; Bar
-  &gt;&gt; Bar.new.say_hello
-  =&gt; &quot;hello&quot;
+  c = Class.create('Bar', :superclass =&gt; Foo, :parent =&gt; MyModule) do
+    def say_hello
+      'hello'
+    end
+  end
+  # inherited class: MyModule::Bar, name: MyModule::Bar
+  # =&gt; Bar
+  Bar.new.say_hello
+  # =&gt; &quot;hello&quot;
 
 == Dependencies
 </diff>
      <filename>README.rdoc</filename>
    </modified>
    <modified>
      <diff>@@ -1,60 +1 @@
-module PluginAWeek #:nodoc:
-  module ModuleCreationHelper
-    # Creates a new module with the specified name.  This is essentially the
-    # same as actually defining the module like so:
-    # 
-    #   module NewModule
-    #   end
-    # 
-    # or as a class:
-    # 
-    #   class NewClass &lt; SuperKlass
-    #   end
-    # 
-    # Configuration options:
-    # * +superclass+ - The class to inherit from.  This only applies when using Class#create.  Default is Object.
-    # * +parent+ - The class/module that contains this module.  Default is Object.
-    # 
-    # Examples:
-    # 
-    #   Module.create('Foo')                                                      # =&gt; Foo
-    #   Module.create('Bar', :parent =&gt; Foo)                                      # =&gt; Foo::Bar
-    #   Class.create('Waddle')                                                    # =&gt; Waddle
-    #   Class.create('Widdle', :parent =&gt; Waddle)                                 # =&gt; Waddle::Widdle
-    #   Class.create('Woddle', :superclass =&gt; Waddle::Widdle, :parent =&gt; Waddle)  # =&gt; Waddle::Woddle
-    #   Waddle::Woddle.superclass                                                 # =&gt; Waddle::Widdle
-    def create(name, options = {}, &amp;block)
-      options.assert_valid_keys(
-        :superclass,
-        :parent
-      )
-      raise ArgumentError, 'Modules cannot have superclasses' if options[:superclass] &amp;&amp; self.to_s == 'Module'
-      
-      options.reverse_merge!(
-        :superclass =&gt; Object,
-        :parent =&gt; Object
-      )
-      parent = options[:parent]
-      superclass = options[:superclass]
-      
-      if superclass != Object
-        superclass = &quot; &lt; ::#{superclass}&quot;
-      else
-        superclass = ''
-      end
-      
-      parent.class_eval &lt;&lt;-end_eval
-        #{self.to_s.downcase} #{name}#{superclass}
-        end
-      end_eval
-      
-      mod = parent.const_get(name)
-      mod.class_eval(&amp;block) if block_given?
-      mod
-    end
-  end
-end
-
-Module.class_eval do
-  extend PluginAWeek::ModuleCreationHelper
-end
+require 'module_creation_helper/extensions/module'</diff>
      <filename>lib/module_creation_helper.rb</filename>
    </modified>
  </modified>
  <removed type="array"/>
  <parents type="array">
    <parent>
      <id>cdd8b52668bad5d79af6d933e3004f7e49598272</id>
    </parent>
  </parents>
  <author>
    <name>Aaron Pfeifer</name>
    <email>aaron.pfeifer@gmail.com</email>
  </author>
  <url>http://github.com/pluginaweek/module_creation_helper/commit/42ee1210fc75b76adbb8aa0a077db36b6aafdb3b</url>
  <id>42ee1210fc75b76adbb8aa0a077db36b6aafdb3b</id>
  <committed-date>2008-07-05T10:10:27-07:00</committed-date>
  <authored-date>2008-07-05T10:10:27-07:00</authored-date>
  <message>Reorganize core extensions into a separate module
Update format of examples</message>
  <tree>ea5707e0b56884ab9e0cf477d32f35db3ffd3499</tree>
  <committer>
    <name>Aaron Pfeifer</name>
    <email>aaron.pfeifer@gmail.com</email>
  </committer>
</commit>
