modularity 0.6.1 → 2.0.0

data/README.md

@@ -0,0 +1,148 @@
+Modularity 2 - Traits and partial classes for Ruby
+==================================================
+
+Modularity enhances Ruby's [`Module`] so it can be used traits and partial classes.
+This allows very simple definition of meta-programming macros like the
+`has_many` that you know from Rails.
+
+Modularity also lets you organize large models into multiple source files
+in a way that is less awkward than using modules.
+
+Note that this is **Modularity 2**, which has a different syntax older version.
+Modularity 1 users can use [a script to migrate their code](#migrating-from-modularity-1)
+or use the [modularity1 branch](https://github.com/makandra/modularity/tree/modularity1).
+
+
+Example 1: Easy meta-programming macros
+----------------------------------------
+
+Ruby allows you to construct classes using meta-programming macros like
+`acts_as_tree` or `has_many :items`. These macros will add methods,
+callbacks, etc. to the calling class. However, right now Ruby (and Rails) makes it awkward to define
+such macros in your project as part of your application domain.
+
+Modularity allows you to extract common behaviour into reusable macros by defining traits with parameters.
+Your macros can live in your application, allowing you to express your application domain in both classes
+and macros.
+
+Here is an example of a `strip_field` macro, which created setter methods that remove leading and trailing whitespace from newly assigned values:
+
+    # app/models/article.rb
+    class Article
+      include DoesStripFields[:name, :brand]
+    end
+
+    # app/models/shared/does_strip_fields.rb
+    module DoesStripFields
+      as_trait do |*fields|
+        fields.each do |field|
+          define_method("#{field}=") do |value|
+            self[field] = value.strip
+          end
+        end
+      end
+    end
+  
+We like to add `app/models/shared` and `app/controllers/shared` to the load paths of our Rails projects.
+These are great places to store macros that are re-used from multiple classes.
+
+
+Example 2: Mixins with class methods
+------------------------------------
+
+Using a module to add both instance methods and class methods is
+[very awkward](http://redcorundum.blogspot.com/2006/06/mixing-in-class-methods.html).
+Modularity does away with the clutter and lets you say this:
+
+    # app/models/model.rb
+    class Model
+      include Mixin
+    end
+
+    # app/models/mixin.rb
+    module Mixin
+      as_trait do
+        def instance_method
+          # ...
+        end
+        def self.class_method
+          # ..
+        end
+      end
+    end
+
+`private` and `protected` will also work as expected when defining a trait.
+
+
+Example 3: Splitting a model into multiple source files
+-------------------------------------------------------
+
+Models are often concerned with multiple themes like "authentication", "contact info" or "permissions", each requiring
+a couple of validations and callbacks here, and some method there. Modularity lets you organize your model into multiple
+partial classes, so each file can deal with a single aspect of your model:
+
+    # app/models/user.rb
+    class User < ActiveRecord::Base
+      include User::DoesAuthentication
+      include User::DoesAddress
+    end
+
+    # app/models/user/does_authentication.rb
+    module User::DoesAuthentication
+      as_trait do
+        # methods, validations, etc. regarding usernames and passwords go here
+      end
+    end
+
+    # app/models/user/does_permissions.rb
+    module User::DoesPermissions
+      as_trait do
+        # methods, validations, etc. regarding contact information go here
+      end
+    end
+
+Some criticism has been raised for splitting large models into files like this.
+Essentially, even though have an easier time navigating your code, you will still
+have one giant model with many side effects.
+
+There are [many better ways](http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/)
+to decompose a huge Ruby class.
+
+
+Installation
+------------
+
+Add the following to your `Gemfile`:
+
+    gem 'modularity', '>=2'
+
+Now run `bundle install`.
+
+
+Migrating from Modularity 1
+---------------------------
+
+If you have been using Modularity 1 with the `does` syntax, we provide a script to migrate your Ruby project
+automatically.
+
+1. Make sure your project has tests and you have a backup of your files (or pushed your commits to Git)
+
+2. From your project directory, do this:
+
+        find . -name "*.rb" | migrate-modularity1-to-modularity2
+
+3. The script will rename your files and change your code. It will also syntax-check your files after conversion
+   (since the script is not perfect).
+
+4. Check the diff to see what the script has done.
+
+5. Run tests to see if everything still works.
+
+
+
+
+Credits
+-------
+
+Henning Koch from [makandra.com](http://makandra.com/)
+

data/bin/migrate-modularity1-to-modularity2

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/../lib/modularity/migrator'
+
+ARGV.each do |path|
+  Modularity::Migrator.migrate(path)
+end

data/lib/modularity.rb

@@ -1,2 +1 @@
-require 'modularity/does'
-
+require 'modularity/as_trait'

data/lib/modularity/as_trait.rb

@@ -1,9 +1,40 @@
 module Modularity
+
+  class ParametrizedTrait < Module
+
+    def initialize(blank_trait, args)
+      @args = args
+      @macro = blank_trait.instance_variable_get(:@modularity_macro)
+      include(blank_trait)
+    end
+
+    def included(base)
+      base.class_exec(*@args, &@macro)
+    end
+
+  end
+
   module AsTrait
-    def as_trait(&block)
-      @trait_macro = block
+
+    def as_trait(&macro)
+
+      @modularity_macro = macro
+
+      def self.included(base)
+        unless base.is_a?(ParametrizedTrait)
+          base.class_exec(&@modularity_macro)
+        end
+
+      end
+
+      def self.[](*args)
+        blank_trait = self
+        ParametrizedTrait.new(blank_trait, args)
+      end
+
     end
+
   end
 end
 
-Object.send :include, Modularity::AsTrait
+Module.send(:include, Modularity::AsTrait)

data/lib/modularity/migrator.rb

@@ -0,0 +1,53 @@
+gem 'activesupport'
+require 'active_support/all'
+require 'fileutils'
+
+module Modularity
+  class Migrator
+    class << self
+
+      def migrate(old_path)
+        old_path = File.expand_path(old_path)
+        new_path = fix_filename(old_path)
+        rename(old_path, new_path) unless old_path == new_path
+        old_code = File.read(new_path)
+        new_code = fix_code(old_code)
+        rewrite_file(new_path, new_code) unless old_code == new_code
+        puts "Migrated #{old_path}"
+        `ruby -c #{new_path}`
+        new_code
+      end
+
+      private
+
+      def fix_filename(path)
+        path = File.expand_path(path)
+        new_path = path.sub(/\/([^\/]+)_trait\.rb$/, '/does_\\1.rb')
+        new_path
+      end
+
+      def fix_code(code)
+        code = code.gsub(/module (.*?)([A-Za-z0-9_]+)Trait\b/, 'module \\1Does\\2')
+        code = code.gsub(/does ['":]([A-Za-z0-9\_\/]+)(?:'|"|$)(?:,\s*(.*)$)?/) do
+          trait_path = $1
+          parameters = $2
+          trait_path = trait_path.sub(/([A-Za-z0-9\_]+)$/, 'does_\\1')
+          trait_class = trait_path.camelize # don't use classify, it removes plurals!
+          substituted = "include #{trait_class}"
+          substituted << "[#{parameters}]" if parameters
+          substituted
+        end
+        code
+      end
+
+      def rename(old, new)
+        FileUtils.mv(old, new)
+      end
+
+      def rewrite_file(path, content)
+        File.open(path, "w") { |file| file.write(content) }
+      end
+
+    end
+  end
+end

data/lib/modularity/version.rb

@@ -1,3 +1,3 @@
 module Modularity
-  VERSION = '0.6.1'
+  VERSION = '2.0.0'
 end

data/modularity.gemspec

@@ -18,5 +18,6 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec', '<2')
+  s.add_development_dependency('rspec_candy')
 
 end

data/spec/modularity/as_trait_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe Modularity::AsTrait do
+
+  describe '.included' do
+    
+    before :each do
+      @doing_class = Class.new
+    end
+
+    describe 'without parameters' do
+  
+      it "applies the trait macro of the given module" do
+
+        module DoesSome
+          as_trait do
+            some_trait_included
+          end
+        end
+
+        @doing_class.should_receive(:some_trait_included)
+
+        @doing_class.class_eval do
+          include DoesSome
+        end
+
+      end
+
+      it "applies the trait macro of the given namespaced module" do
+
+        module Some
+          module DoesChild
+            as_trait do
+              some_child_trait_included
+            end
+          end
+        end
+
+        @doing_class.should_receive(:some_child_trait_included)
+
+        @doing_class.class_eval do
+          include Some::DoesChild
+        end
+
+      end
+
+      it "lets a trait define methods with different visibility" do
+
+        module DoesVisibility
+          as_trait do
+            def public_method_from_trait
+            end
+            protected
+            def protected_method_from_trait
+            end
+            private
+            def private_method_from_trait
+            end
+          end
+        end
+
+        @doing_class.class_eval do
+          include DoesVisibility
+        end
+
+        instance = @doing_class.new
+
+        instance.public_methods.collect(&:to_s).should include("public_method_from_trait")
+        instance.protected_methods.collect(&:to_s).should include("protected_method_from_trait")
+        instance.private_methods.collect(&:to_s).should include("private_method_from_trait")
+
+      end
+
+      it 'appends methods outside the trait macro' do
+
+        module HybridModule
+
+          as_trait do
+            define_method :trait_method do
+            end
+          end
+
+          def vanilla_method
+          end
+
+        end
+
+        @doing_class.class_eval do
+          include HybridModule
+        end
+
+        instance = @doing_class.new
+
+        instance.should respond_to(:trait_method)
+        instance.should respond_to(:vanilla_method)
+
+      end
+
+      it 'applies multiple trait macros' do
+
+        module FirstTrait
+          as_trait do
+            define_method :first do
+            end
+          end
+        end
+
+        module SecondTrait
+          as_trait do
+            define_method :second do
+            end
+          end
+        end
+
+        @doing_class.class_eval do
+          include FirstTrait
+          include SecondTrait
+        end
+
+        instance = @doing_class.new
+
+        instance.should respond_to(:first)
+        instance.should respond_to(:second)
+
+      end
+
+    end
+
+    describe "with parameters" do
+
+      it "it applies a trait macro with parameters" do
+
+        module DoesCallMethod
+          as_trait do |field|
+            send(field)
+          end
+        end
+
+        @doing_class.should_receive(:foo)
+        @doing_class.class_eval do
+          include DoesCallMethod[:foo]
+        end
+
+      end
+
+      it "facilitates metaprogramming acrobatics" do
+
+        module DoesDefineConstantMethod
+          as_trait do |name, return_value|
+            define_method name do
+              return_value
+            end
+          end
+        end
+
+        @doing_class.class_eval do
+          include DoesDefineConstantMethod["some_method", "some_return_value"]
+        end
+
+        instance = @doing_class.new
+        instance.should respond_to(:some_method)
+        instance.some_method.should == "some_return_value"
+      end
+
+      it "allies to call an unparametrized trait macro with an empty parameter list" do
+
+        module DoesSome
+          as_trait do
+            some_trait_included
+          end
+        end
+
+        @doing_class.should_receive(:some_trait_included)
+
+        @doing_class.class_eval do
+          include DoesSome[]
+        end
+
+      end
+
+      it 'appends methods outside the trait macro' do
+
+        module HybridModuleWithParameters
+
+          as_trait do |name|
+            define_method name do
+            end
+          end
+
+          def vanilla_method
+          end
+
+        end
+
+        @doing_class.class_eval do
+          include HybridModuleWithParameters[:trait_method]
+        end
+
+        instance = @doing_class.new
+
+        instance.should respond_to(:trait_method)
+        instance.should respond_to(:vanilla_method)
+
+      end
+
+    end
+
+  end
+
+end

data/spec/modularity/migrator_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+require 'modularity/migrator' # this is an optional file and thus not loaded automatically
+
+describe Modularity::Migrator do
+
+  subject do
+    Modularity::Migrator
+  end
+
+  describe '.fix_filename' do
+
+    it 'should replace the suffix _trait with a prefix does' do
+      subject.send(:fix_filename, '/path/to/search_trait.rb').should == '/path/to/does_search.rb'
+    end
+
+    it "should not rename files that don't end in _trait.rb" do
+      subject.send(:fix_filename, '/path/to/search.rb').should == '/path/to/search.rb'
+    end
+
+  end
+
+  describe '.fix_code' do
+
+    it 'renames a module FooBarTrait to DoesFooBar' do
+
+      old_code = <<-RUBY
+        module Namespace::FooBarTrait
+          as_trait do
+            define_method :foo do
+            end
+            define_method :bar do
+            end
+          end
+        end
+      RUBY
+
+      new_code = <<-RUBY
+        module Namespace::DoesFooBar
+          as_trait do
+            define_method :foo do
+            end
+            define_method :bar do
+            end
+          end
+        end
+      RUBY
+
+      subject.send(:fix_code, old_code).should == new_code
+    end
+
+    it "does not rename modules that aren't traits" do
+
+      old_code = <<-RUBY
+        module Namespace::FooBar
+          def foo
+          end
+          def bar
+          end
+        end
+      RUBY
+
+      subject.send(:fix_code, old_code).should == old_code
+    end
+
+    it 'replaces does calls with include' do
+
+      old_code = <<-RUBY
+        class User < ActiveRecord::Base
+          does 'user/search'
+          does 'user/account_settings'
+          does 'trashable'
+        end
+      RUBY
+
+      new_code = <<-RUBY
+        class User < ActiveRecord::Base
+          include User::DoesSearch
+          include User::DoesAccountSettings
+          include DoesTrashable
+        end
+      RUBY
+
+      subject.send(:fix_code, old_code).should == new_code
+    end
+
+    it 'puts does parameters into square brackets' do
+
+      old_code = <<-RUBY
+        class User < ActiveRecord::Base
+          does 'flag', :active, :default => true
+          does 'record/search', :field => :email
+        end
+      RUBY
+
+      new_code = <<-RUBY
+        class User < ActiveRecord::Base
+          include DoesFlag[:active, :default => true]
+          include Record::DoesSearch[:field => :email]
+        end
+      RUBY
+
+      subject.send(:fix_code, old_code).should == new_code
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
 $: << File.join(File.dirname(__FILE__), "/../lib" )
 
 require "#{File.dirname(__FILE__)}/../lib/modularity"
+require 'rspec_candy/all'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: modularity
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-23 00:00:00.000000000 +02:00
+date: 2014-01-08 00:00:00.000000000 +01:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &23087620 !ruby/object:Gem::Requirement
+  requirement: &22585700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *23087620
+  version_requirements: *22585700
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &23087020 !ruby/object:Gem::Requirement
+  requirement: &22585200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - <
@@ -33,26 +33,38 @@ dependencies:
         version: '2'
   type: :development
   prerelease: false
-  version_requirements: *23087020
+  version_requirements: *22585200
+- !ruby/object:Gem::Dependency
+  name: rspec_candy
+  requirement: &22584740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *22584740
 description: Traits and partial classes for Ruby
 email: github@makandra.de
-executables: []
+executables:
+- migrate-modularity1-to-modularity2
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
 - MIT-LICENSE
-- README.rdoc
+- README.md
 - Rakefile
+- bin/migrate-modularity1-to-modularity2
 - lib/modularity.rb
 - lib/modularity/as_trait.rb
-- lib/modularity/does.rb
-- lib/modularity/inflector.rb
+- lib/modularity/migrator.rb
 - lib/modularity/version.rb
 - modularity.gemspec
-- spec/as_trait_spec.rb
-- spec/does_spec.rb
+- spec/modularity/as_trait_spec.rb
+- spec/modularity/migrator_spec.rb
 - spec/rcov.opts
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -69,21 +81,22 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2498377129858303393
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2498377129858303393
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.3.9.5
 signing_key: 
 specification_version: 3
 summary: Traits and partial classes for Ruby
-test_files:
-- spec/as_trait_spec.rb
-- spec/does_spec.rb
-- spec/rcov.opts
-- spec/spec.opts
-- spec/spec_helper.rb
+test_files: []

data/README.rdoc

@@ -1,106 +0,0 @@
-= modularity - Traits and partial classes for Ruby
-
-Modularity provides traits and partial classes for Ruby.
-This lets you organize large models into multiple source files.
-It also allows very simple definition of meta-programming macros,
-as you might now from <tt>acts_as_something</tt> type of plugins,
-or the macros Rails provides for your models.
-
-Modularity traits are to your models what partials are for your Rails views.
-
-== Example 1: Splitting a model into multiple source files
-
-Models are often concerned with multiple themes like "authentication", "contact info" or "permissions", each requiring
-a couple of validations and callbacks here, and some method there. Modularity lets you organize your model into multiple
-partial classes, so each file can deal with a single aspect of your model:
-
-  # app/models/user.rb
-  class User < ActiveRecord::Base
-    does "user/authentication"
-    does "user/address"
-  end
-  
-  # app/models/user/authentication_trait.rb
-  module User::AuthenticationTrait
-    as_trait do
-      # methods, validations, etc. regarding usernames and passwords go here
-    end
-  end
-  
-  # app/models/user/permissions_trait.rb
-  module User::PermissionsTrait
-    as_trait do
-      # methods, validations, etc. regarding contact information go here
-    end
-  end
-
-== Example 2: Easy meta-programming macros
-
-Ruby allows you to construct classes using meta-programming macros like <tt>acts_as_tree</tt> or <tt>has_many :items</tt>.
-These macros will add methods, callbacks, etc. to the calling class. Hoever, right now Ruby (and Rails) makes it awkward to define
-such macros in your project as part of your application domain.
-
-Modularity allows you to extract common behaviour into reusable macros by defining traits with parameters. Your macros can live in your
-application, allowing you to express your application domain in both classes and macros.
-
-Here is an example of a <tt>strip_field</tt> macro, which created setter methods that remove leading and trailing whitespace from newly assigned values:
-
-  # app/models/article.rb
-  class Article
-    does "strip_fields", :name, :brand
-  end
-
-  # app/models/shared/strip_fields_trait.rb
-  module StripFieldsTrait
-    as_trait do |*fields|
-      fields.each do |field|
-        define_method("#{field}=") do |value|
-          self[field] = value.strip
-        end
-      end
-    end
-  end
-  
-We like to add <tt>app/models/shared</tt> and <tt>app/controllers/shared</tt> to the load paths of our Rails projects. These are great places to store macros
-that are re-used from multiple classes.
-
-== Example 3: Mixins with class methods
-
-Using a module to add both instance methods and class methods is {very awkward}[http://redcorundum.blogspot.com/2006/06/mixing-in-class-methods.html].
-Modularity does away with the clutter and lets you say this:
-
-  # app/models/model.rb
-  class Model
-    does "mixin"
-  end
-
-  # app/models/mixin_trait.rb
-  module MixinTrait
-    as_trait do
-      def instance_method
-        # ...
-      end
-      def self.class_method
-        # ..
-      end
-  end
-  
-<tt>private</tt> and <tt>protected</tt> will also work as expected when defining a trait.
-
-== Installation
-
-    sudo gem install modularity
-
-  
-== Note if you're still on Ruby 1.8.6
-
-Modularity requires Ruby 1.8.7. Earlier versions are missing <tt>class_exec</tt>. You might be able to hack in <tt>class_exec</tt>
-using {this}[http://github.com/brynary/rspec/blob/f80d61a399b34f58084a378c85a43a95ff484619/lib/spec/extensions/instance_exec.rb] as a guide, but it's not pretty.
-
-== Credits
-
-Henning Koch
-
-{makandra.com}[http://makandra.com/]
-
-{gem-session.com}[http://gem-session.com/]

data/lib/modularity/does.rb

@@ -1,23 +0,0 @@
-require 'modularity/inflector'
-require 'modularity/as_trait'
-
-module Modularity
-  module Does
-
-    def self.included(base)
-      base.extend ClassMethods
-    end
-    
-    module ClassMethods
-      def does(trait_name, *args)
-        trait_name = "#{Modularity::Inflector.camelize(trait_name.to_s)}Trait"
-        trait = Modularity::Inflector.constantize(trait_name)
-        macro = trait.instance_variable_get("@trait_macro") or raise "Missing trait directive in #{trait_name}"
-        class_exec(*args, &macro)
-      end
-    end
-
-  end
-end
-
-Object.send :include, Modularity::Does

data/lib/modularity/inflector.rb

@@ -1,60 +0,0 @@
-# These methods are backported from Rails so modularity works with plain Ruby.
-
-module Modularity
-  class Inflector
-    class << self
-
-      # File activesupport/lib/active_support/inflector.rb, line 178
-      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-        if first_letter_in_uppercase
-          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-        else
-          lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
-        end
-      end
-
-      
-    if Module.method(:const_get).arity == 1
-      # Tries to find a constant with the name specified in the argument string:
-      #
-      #   "Module".constantize     # => Module
-      #   "Test::Unit".constantize # => Test::Unit
-      #
-      # The name is assumed to be the one of a top-level constant, no matter whether
-      # it starts with "::" or not. No lexical context is taken into account:
-      #
-      #   C = 'outside'
-      #   module M
-      #     C = 'inside'
-      #     C               # => 'inside'
-      #     "C".constantize # => 'outside', same as ::C
-      #   end
-      #
-      # NameError is raised when the name is not in CamelCase or the constant is
-      # unknown.
-      def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
-
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-        end
-        constant
-      end
-    else
-      def constantize(camel_cased_word) #:nodoc:
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
-
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
-        end
-        constant
-      end
-    end
-
-    end
-  end
-end

data/spec/as_trait_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-module Trait
-  as_trait do
-    "hi world"
-  end
-end
-
-module ParametrizedTrait
-  as_trait do |name|
-    "hi, #{name}"
-  end
-end
-
-describe Modularity::AsTrait do
-
-  describe 'as_trait' do
-
-    it "should let modules save a proc upon loading" do
-      Trait.instance_variable_get("@trait_macro").call.should == "hi world"
-    end
-
-    it "should let modules save a proc with parameters upon loading" do
-      ParametrizedTrait.instance_variable_get("@trait_macro").call("jean").should == "hi, jean"
-    end
-
-  end
-  
-end

data/spec/does_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-module SomeTrait
-  as_trait do
-    some_trait_included
-  end
-end
-
-module Some
-  module ChildTrait
-    as_trait do
-      some_child_trait_included
-    end
-  end
-end
-
-module CallMethodTrait
-  as_trait do |field|
-    send(field)
-  end
-end
-
-module VisibilityTrait
-  as_trait do
-    def public_method_from_trait
-    end
-    protected
-    def protected_method_from_trait
-    end
-    private
-    def private_method_from_trait
-    end
-  end
-end
-
-module DefineConstantMethodTrait
-  as_trait do |name, return_value|
-    define_method name do
-      return_value
-    end
-  end
-end
-
-class Doer
-end
-
-describe Modularity::AsTrait do
-
-  describe 'does' do
-  
-    it "should apply the named module" do
-      Doer.should_receive(:some_trait_included)
-      Doer.class_eval do
-        does "some"
-      end
-    end
-    
-    it "should apply a namespaced module, using slash-notation like require" do
-      Doer.should_receive(:some_child_trait_included)
-      Doer.class_eval do
-        does "some/child"
-      end
-    end
-    
-    it "should class_eval the as_trait proc on the doer" do
-      Doer.should_receive(:foo)
-      Doer.class_eval do
-        does "call_method", :foo
-      end
-    end
-    
-    it "should allow the trait to define methods with different visibility" do
-      Doer.class_eval do
-        does "visibility"
-      end
-      instance = Doer.new
-      instance.public_methods.collect(&:to_s).should include("public_method_from_trait")
-      instance.protected_methods.collect(&:to_s).should include("protected_method_from_trait")
-      instance.private_methods.collect(&:to_s).should include("private_method_from_trait")
-    end
-    
-    it "should allow the trait to perform metaprogramming acrobatics" do
-      Doer.class_eval do
-        does "define_constant_method", "some_method", "some_return_value"
-      end
-      instance = Doer.new
-      instance.should respond_to(:some_method)
-      instance.some_method.should == "some_return_value"
-    end
-
-  end
-
-end