docile 1.0.5 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75054a395059cd55ba3132c00dc49ae15cc6b954
-  data.tar.gz: 71f6114e6ac5d727240bd50c8e967127af688a53
+  metadata.gz: 57d90aa5d94c06fab36bcf2ad9c058e8b3c7ec3b
+  data.tar.gz: c73f0d3af5a1d87fcc3ae562e2c90bdd7e06b724
 SHA512:
-  metadata.gz: 57476b49adfb0e49f909c391420f6c7b1fdacd2fcf5aaced53443bd3c138ca6ca70ba047b261c9c20dc899a1a35e70950d3582f0dc267d33a2d5748dfd53aee1
-  data.tar.gz: 46b4708db7b9cb68b3f1415edb0f07d5dcc49ba6d86831a51b96e1774abcea346aa3f7412e106572d32893f2473ff7ccddae0596470efad85a1c08a1d737b91c
+  metadata.gz: 2ed37d882ad062a8ae1dc02963582c57ed51383b7916176964a55ad4833ee34e93a98743382d527113554f8cef5774ef96e8e681396de00b11bfdcb4bda80bef
+  data.tar.gz: a000461e5ffe9649801875b2d0228d1a5d61510813713a90fe5cfb4aa594abaaa52e7f2554ec57113eb0b679712f39be469664ccbe82f0ed9afbb9c1f1324d8b

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/HISTORY.md

@@ -1,5 +1,9 @@
 # HISTORY
 
+## [v1.1.0 (Jul 29, 2013)](http://github.com/ms-ati/docile/compare/v1.0.5...v1.1.0)
+
+  - add functional-style DSL objects via `Docile#dsl_eval_immutable`
+
 ## [v1.0.5 (Jul 28, 2013)](http://github.com/ms-ati/docile/compare/v1.0.4...v1.0.5)
 
   - achieve 100% yard docs coverage

data/README.md

@@ -1,19 +1,21 @@
 # Docile
-
-Definition: *Ready to accept control or instruction; submissive* [[1]]
-
-Tired of overly complex DSL libraries and hairy meta-programming?
-
-Let's make our Ruby DSLs more docile...
-
-[1]: http://www.google.com/search?q=docile+definition   "Google"
-
 [![Gem Version](https://badge.fury.io/rb/docile.png)](http://badge.fury.io/rb/docile)
 [![Build Status](https://travis-ci.org/ms-ati/docile.png)](https://travis-ci.org/ms-ati/docile)
 [![Dependency Status](https://gemnasium.com/ms-ati/docile.png)](https://gemnasium.com/ms-ati/docile)
 [![Code Climate](https://codeclimate.com/github/ms-ati/docile.png)](https://codeclimate.com/github/ms-ati/docile)
 [![Coverage Status](https://coveralls.io/repos/ms-ati/docile/badge.png)](https://coveralls.io/r/ms-ati/docile)
 
+Ruby makes it possible to create very expressive **Domain Specific
+Languages**, or **DSL**'s for short. However, it requires some deep knowledge and
+somewhat hairy meta-programming to get the interface just right.
+
+"Docile" means *Ready to accept control or instruction; submissive* [[1]]
+
+Instead of each Ruby project reinventing this wheel, let's make our Ruby DSL
+coding a bit more docile...
+
+[1]: http://www.google.com/search?q=docile+definition   "Google"
+
 ## Basic Usage
 
 Let's say that we want to make a DSL for modifying Array objects.
@@ -26,12 +28,12 @@ with_array([]) do
   pop
   push 3
 end
-# => [1, 3]
+#=> [1, 3]
 ```
 
 No problem, just define the method `with_array` like this:
 
-``` ruby
+```ruby
 def with_array(arr=[], &block)
   Docile.dsl_eval(arr, &block)
 end
@@ -53,7 +55,7 @@ pizza do
   pepperoni
   sauce @sauce_level
 end
-# => #<Pizza:0x00001009dc398 @cheese=true, @pepperoni=true, @bacon=false, @sauce=:extra>
+#=> #<Pizza:0x00001009dc398 @cheese=true, @pepperoni=true, @bacon=false, @sauce=:extra>
 ```
 
 And let's say we have a PizzaBuilder, which builds a Pizza like this:
@@ -83,7 +85,7 @@ def pizza(&block)
 end
 ```
 
-It's just that easy! 
+It's just that easy!
 
 [2]: http://stackoverflow.com/questions/328496/when-would-you-use-the-builder-pattern  "Builder Pattern"
 
@@ -147,12 +149,49 @@ end
 
 [3]: http://www.sinatrarb.com "Sinatra"
 
+## Functional-Style DSL Objects
+
+Sometimes, you want to use an object as a DSL, but it doesn't quite fit the
+[imperative](http://en.wikipedia.org/wiki/Imperative_programming) pattern shown
+above.
+
+Instead of methods like
+[Array#push](http://www.ruby-doc.org/core-2.0/Array.html#method-i-push), which
+modifies the object at hand, it has methods like
+[String#reverse](http://www.ruby-doc.org/core-2.0/String.html#method-i-reverse),
+which returns a new object without touching the original. Perhaps it's even
+[frozen](http://www.ruby-doc.org/core-2.0/Object.html#method-i-freeze) in
+order to enforce [immutability](http://en.wikipedia.org/wiki/Immutable_object).
+
+Wouldn't it be great if we could just treat these methods as a DSL as well?
+
+```ruby
+with_immutable_string("I'm immutable!".freeze) do
+  reverse
+  upcase
+end
+#=> "!ELBATUMMI M'I"
+```
+
+No problem, just define the method `with_immutable_string` like this:
+
+```ruby
+def with_immutable_string(str="", &block)
+  Docile.dsl_eval_immutable(str, &block)
+end
+```
+
+All set!
+
 ## Features
 
-  1.  method lookup falls back from the DSL object to the block's context
-  2.  local variable lookup falls back from the DSL object to the block's context
-  3.  instance variables are from the block's context only
-  4.  nested dsl evaluation
+  1.  Method lookup falls back from the DSL object to the block's context
+  2.  Local variable lookup falls back from the DSL object to the block's
+        context
+  3.  Instance variables are from the block's context only
+  4.  Nested DSL evaluation, correctly chaining method and variable handling
+        from the inner to the outer DSL scopes
+  5.  Alternatives for both imperative and functional styles of DSL objects
 
 ## Installation
 
@@ -173,12 +212,14 @@ Version 1.0.x works on [all ruby versions since 1.8.7](https://github.com/ms-ati
 ## Note on Patches/Pull Requests
 
   * Fork the project.
-  * Setup your development environment with: gem install bundler; bundle install
+  * Setup your development environment with:
+      `gem install bundler; bundle install`
   * Make your feature addition or bug fix.
-  * Add tests for it. This is important so I don't break it in a
-    future version unintentionally.
+  * Add tests for it. This is important so I don't break it in a future version
+      unintentionally.
   * Commit, do not mess with rakefile, version, or history.
-    (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+      (if you want to have your own version, that is fine but bump version in a
+      commit by itself I can ignore when I pull)
   * Send me a pull request. Bonus points for topic branches.
 
 ## Copyright

data/lib/docile.rb

@@ -1,9 +1,12 @@
 require "docile/version"
+require "docile/execution"
 require "docile/fallback_context_proxy"
+require "docile/chaining_fallback_context_proxy"
 
-# Docile keeps your Ruby DSLs tame and well-behaved
-# @see http://ms-ati.github.com/docile/
+# Docile keeps your Ruby DSLs tame and well-behaved.
 module Docile
+  extend Execution
+
   # Execute a block in the context of an object whose methods represent the
   # commands in a DSL.
   #
@@ -11,8 +14,9 @@ module Docile
   #
   # Use this method to execute an *imperative* DSL, which means that:
   #
-  #   1. each command mutates the state of the DSL context object
-  #   2. the return values of the commands are ignored
+  #   1. Each command mutates the state of the DSL context object
+  #   2. The return value of each command is ignored
+  #   3. The final return value is the original context object
   #
   # @example Use a String as a DSL
   #   Docile.dsl_eval("Hello, world!") do
@@ -36,21 +40,45 @@ module Docile
   #                         `dsl` context object
   # @return      [Object] the `dsl` context object after executing the block
   def dsl_eval(dsl, *args, &block)
-    block_context = eval("self", block.binding)
-    proxy_context = FallbackContextProxy.new(dsl, block_context)
-    begin
-      block_context.instance_variables.each do |ivar|
-        value_from_block = block_context.instance_variable_get(ivar)
-        proxy_context.instance_variable_set(ivar, value_from_block)
-      end
-      proxy_context.instance_exec(*args, &block)
-    ensure
-      block_context.instance_variables.each do |ivar|
-        value_from_dsl_proxy = proxy_context.instance_variable_get(ivar)
-        block_context.instance_variable_set(ivar, value_from_dsl_proxy)
-      end
-    end
+    exec_in_proxy_context(dsl, FallbackContextProxy, *args, &block)
     dsl
   end
   module_function :dsl_eval
+
+  # Execute a block in the context of an immutable object whose methods,
+  # and the methods of their return values, represent the commands in a DSL.
+  #
+  # @note Use with a *functional* DSL (commands return successor
+  #       context objects)
+  #
+  # Use this method to execute a *functional* DSL, which means that:
+  #
+  #   1. The original DSL context object is never mutated
+  #   2. Each command returns the next DSL context object
+  #   3. The final return value is the value returned by the last command
+  #
+  # @example Use a frozen String as a DSL
+  #   Docile.dsl_eval_immutable("I'm immutable!".freeze) do
+  #     reverse
+  #     upcase
+  #   end
+  #   #=> "!ELBATUMMI M'I"
+  #
+  # @example Use a Float as a DSL
+  #   Docile.dsl_eval_immutable(84.5) do
+  #     fdiv(2)
+  #     floor
+  #   end
+  #   #=> 42
+  #
+  # @param dsl   [Object] immutable context object whose methods make up the
+  #                       initial DSL
+  # @param args  [Array]  arguments to be passed to the block
+  # @yield                the block of DSL commands to be executed against the
+  #                         `dsl` context object and successor return values
+  # @return      [Object] the return value of the final command in the block
+  def dsl_eval_immutable(dsl, *args, &block)
+    exec_in_proxy_context(dsl, ChainingFallbackContextProxy, *args, &block)
+  end
+  module_function :dsl_eval_immutable
 end

data/lib/docile/chaining_fallback_context_proxy.rb

@@ -0,0 +1,20 @@
+require "docile/fallback_context_proxy"
+
+module Docile
+  # @api private
+  #
+  # Operates in the same manner as {FallbackContextProxy}, but replacing
+  # the primary `receiver` object with the result of each proxied method.
+  #
+  # This is useful for implementing DSL evaluation for immutable context
+  # objects.
+  #
+  # @see Docile#dsl_eval_immutable
+  class ChainingFallbackContextProxy < FallbackContextProxy
+    # Proxy methods as in {FallbackContextProxy#method_missing}, replacing
+    # `receiver` with the returned value.
+    def method_missing(method, *args, &block)
+      @__receiver__ = super(method, *args, &block)
+    end
+  end
+end

data/lib/docile/execution.rb

@@ -0,0 +1,36 @@
+module Docile
+  # @api private
+  #
+  # A namespace for functions relating to the execution of a block agsinst a
+  # proxy object.
+  module Execution
+    # Execute a block in the context of an object whose methods represent the
+    # commands in a DSL, using a specific proxy class.
+    #
+    # @param dsl        [Object] context object whose methods make up the
+    #                            (initial) DSL
+    # @param proxy_type [FallbackContextProxy,
+    #                    ChainingFallbackContextProxy]
+    #                            class to instantiate as the proxy context
+    # @param args       [Array]  arguments to be passed to the block
+    # @yield                     the block of DSL commands to be executed
+    # @return           [Object] the return value of the block
+    def exec_in_proxy_context(dsl, proxy_type, *args, &block)
+      block_context = eval("self", block.binding)
+      proxy_context = proxy_type.new(dsl, proxy_type.new(dsl, block_context))
+      begin
+        block_context.instance_variables.each do |ivar|
+          value_from_block = block_context.instance_variable_get(ivar)
+          proxy_context.instance_variable_set(ivar, value_from_block)
+        end
+        proxy_context.instance_exec(*args, &block)
+      ensure
+        block_context.instance_variables.each do |ivar|
+          value_from_dsl_proxy = proxy_context.instance_variable_get(ivar)
+          block_context.instance_variable_set(ivar, value_from_dsl_proxy)
+        end
+      end
+    end
+    module_function :exec_in_proxy_context
+  end
+end

data/lib/docile/fallback_context_proxy.rb

@@ -1,12 +1,18 @@
 require 'set'
 
 module Docile
+  # @api private
+  #
   # A proxy object with a primary receiver as well as a secondary
   # fallback receiver.
   #
   # Will attempt to forward all method calls first to the primary receiver,
   # and then to the fallback receiver if the primary does not handle that
   # method.
+  #
+  # This is useful for implementing DSL evaluation in the context of an object.
+  #
+  # @see Docile#dsl_eval
   class FallbackContextProxy
     # The set of methods which will **not** be proxied, but instead answered
     # by this object directly.

data/lib/docile/version.rb

@@ -1,4 +1,4 @@
 module Docile
   # The current version of this library
-  VERSION = "1.0.5"
+  VERSION = "1.1.0"
 end

data/spec/docile_spec.rb

@@ -2,24 +2,36 @@ require "spec_helper"
 
 describe Docile do
 
-  context :dsl_eval do
+  describe "#dsl_eval" do
+
+    context "when DSL context object is an Array" do
+      let(:array) { [] }
+      let!(:result) { execute_dsl_against_array }
+
+      def execute_dsl_against_array
+        Docile.dsl_eval(array) do
+          push 1
+          push 2
+          pop
+          push 3
+        end
+      end
 
-    it "should return the DSL object" do
-      Docile.dsl_eval([]) do
-        push 1
-        push 2
-        pop
-        push 3
-      end.should == [1, 3]
-    end
+      it "executes the block against the DSL context object" do
+         array.should == [1, 3]
+      end
 
-    it "should use the __id__ method of the proxy object" do
-      arr = []
-      Docile.dsl_eval(arr) { __id__.should_not == arr.__id__ }
-    end
+      it "returns the DSL object after executing block against it" do
+         result.should == array
+      end
+
+      it "doesn't proxy #__id__"  do
+        Docile.dsl_eval(array) { __id__.should_not == array.__id__ }
+      end
 
-    it "should raise NoMethodError if the DSL object doesn't implement the method" do
-      expect { Docile.dsl_eval([]) { no_such_method } }.to raise_error(NoMethodError)
+      it "raises NoMethodError if the DSL object doesn't implement the method" do
+        expect { Docile.dsl_eval(array) { no_such_method } }.to raise_error(NoMethodError)
+      end
     end
 
     Pizza = Struct.new(:cheese, :pepperoni, :bacon, :sauce)
@@ -34,13 +46,22 @@ describe Docile do
       end
     end
 
-    it "should handle a Builder pattern" do
-      @sauce = :extra
-      Docile.dsl_eval(PizzaBuilder.new) do
-        bacon
-        cheese
-        sauce @sauce
-      end.build.should == Pizza.new(true, false, true, :extra)
+    context "when DSL context object is a Builder pattern" do
+      let(:builder) { PizzaBuilder.new }
+      let(:result) { execute_dsl_against_builder_and_call_build }
+
+      def execute_dsl_against_builder_and_call_build
+        @sauce = :extra
+        Docile.dsl_eval(builder) do
+          bacon
+          cheese
+          sauce @sauce
+        end.build
+      end
+
+      it "returns correctly built object" do
+        result.should == Pizza.new(true, false, true, :extra)
+      end
     end
 
     class InnerDSL
@@ -65,12 +86,12 @@ describe Docile do
       Docile.dsl_eval(OuterDSL.new, &block)
     end
 
-    def parameterized(*args, &block)
-      Docile.dsl_eval(OuterDSL.new, *args, &block)
-    end
+    context "when given parameters for the DSL block" do
+      def parameterized(*args, &block)
+        Docile.dsl_eval(OuterDSL.new, *args, &block)
+      end
 
-    context "parameters" do
-      it "should pass parameters to the block" do
+      it "passes parameters to the block" do
         parameterized(1,2,3) do |x,y,z|
           x.should == 1
           y.should == 2
@@ -78,11 +99,11 @@ describe Docile do
         end
       end
 
-      it "should find parameters before methods" do
+      it "finds parameters before methods" do
         parameterized(1) { |a| a.should == 1 }
       end
 
-      it "should find outer parameters in inner dsl scope" do
+      it "find outer dsl parameters in inner dsl scope" do
         parameterized(1,2,3) do |a,b,c|
           inner_with_params(c) do |d,e|
             a.should == 1
@@ -95,140 +116,207 @@ describe Docile do
       end
     end
 
-    context "methods" do
-      it "should find method of outer dsl in outer dsl scope" do
-        outer { a.should == 'a' }
-      end
+    context "when DSL blocks are nested" do
 
-      it "should find method of inner dsl in inner dsl scope" do
-        outer { inner { b.should == 'b' } }
-      end
+      context "method lookup" do
+        it "finds method of outer dsl in outer dsl scope" do
+          outer { a.should == 'a' }
+        end
 
-      it "should find method of outer dsl in inner dsl scope" do
-        outer { inner { a.should == 'a' } }
-      end
+        it "finds method of inner dsl in inner dsl scope" do
+          outer { inner { b.should == 'b' } }
+        end
 
-      it "should find method of block's context in outer dsl scope" do
-        def c; 'c'; end
-        outer { c.should == 'c' }
-      end
+        it "finds method of outer dsl in inner dsl scope" do
+          outer { inner { a.should == 'a' } }
+        end
 
-      it "should find method of block's context in inner dsl scope" do
-        def c; 'c'; end
-        outer { inner { c.should == 'c' } }
-      end
+        it "finds method of block's context in outer dsl scope" do
+          def c; 'c'; end
+          outer { c.should == 'c' }
+        end
+
+        it "finds method of block's context in inner dsl scope" do
+          def c; 'c'; end
+          outer { inner { c.should == 'c' } }
+        end
 
-      it "should find method of outer dsl in preference to block context" do
-        def a; 'not a'; end
-        outer { a.should == 'a' }
-        outer { inner { a.should == 'a' } }
+        it "finds method of outer dsl in preference to block context" do
+          def a; 'not a'; end
+          outer { a.should == 'a' }
+          outer { inner { a.should == 'a' } }
+        end
       end
-    end
 
-    context "local variables" do
-      it "should find local variable from block context in outer dsl scope" do
-        foo = 'foo'
-        outer { foo.should == 'foo' }
+      context "local variable lookup" do
+        it "finds local variable from block context in outer dsl scope" do
+          foo = 'foo'
+          outer { foo.should == 'foo' }
+        end
+
+        it "finds local variable from block definition in inner dsl scope" do
+          bar = 'bar'
+          outer { inner { bar.should == 'bar' } }
+        end
       end
 
-      it "should find local variable from block definition in inner dsl scope" do
-        bar = 'bar'
-        outer { inner { bar.should == 'bar' } }
+      context "instance variable lookup" do
+        it "finds instance variable from block definition in outer dsl scope" do
+          @iv1 = 'iv1'; outer { @iv1.should == 'iv1' }
+        end
+
+        it "proxies instance variable assignments in block in outer dsl scope back into block's context" do
+          @iv1 = 'foo'; outer { @iv1 = 'bar' }; @iv1.should == 'bar'
+        end
+
+        it "finds instance variable from block definition in inner dsl scope" do
+          @iv2 = 'iv2'; outer { inner { @iv2.should == 'iv2' } }
+        end
+
+        it "proxies instance variable assignments in block in inner dsl scope back into block's context" do
+          @iv2 = 'foo'; outer { inner { @iv2 = 'bar' } }; @iv2.should == 'bar'
+        end
       end
+
     end
 
-    context "instance variables" do
-      it "should find instance variable from block definition in outer dsl scope" do
-        @iv1 = 'iv1'; outer { @iv1.should == 'iv1' }
+    context "when DSL context object is a Dispatch pattern" do
+      class DispatchScope
+        def params
+          { :a => 1, :b => 2, :c => 3 }
+        end
       end
 
-      it "should proxy instance variable assignments in block in outer dsl scope back into block's context" do
-        @iv1 = 'foo'; outer { @iv1 = 'bar' }; @iv1.should == 'bar'
-      end
+      class MessageDispatch
+        include Singleton
+
+        def initialize
+          @responders = {}
+        end
+
+        def add_responder path, &block
+          @responders[path] = block
+        end
 
-      it "should find instance variable from block definition in inner dsl scope" do
-        @iv2 = 'iv2'; outer { inner { @iv2.should == 'iv2' } }
+        def dispatch path, request
+          Docile.dsl_eval(DispatchScope.new, request, &@responders[path])
+        end
       end
 
-      it "should proxy instance variable assignments in block in inner dsl scope back into block's context" do
-        @iv2 = 'foo'; outer { inner { @iv2 = 'bar' } }; @iv2.should == 'bar'
+      def respond(path, &block)
+        MessageDispatch.instance.add_responder(path, &block)
       end
-    end
 
-    class DispatchScope
-      def params
-        { :a => 1, :b => 2, :c => 3 }
+      def send_request(path, request)
+        MessageDispatch.instance.dispatch(path, request)
       end
-    end
 
-    class MessageDispatch
-      include Singleton
+      it "dispatches correctly" do
+        @first = @second = nil
 
-      def initialize
-        @responders = {}
-      end
+        respond '/path' do |request|
+          @first = request
+        end
 
-      def add_responder path, &block
-        @responders[path] = block
-      end
+        respond '/new_bike' do |bike|
+          @second = "Got a new #{bike}"
+        end
+
+        def x(y) ; "Got a #{y}"; end
+        respond '/third' do |third|
+          x(third).should == 'Got a third thing'
+        end
+
+        fourth = nil
+        respond '/params' do |arg|
+          fourth = params[arg]
+        end
+
+        send_request '/path', 1
+        send_request '/new_bike', 'ten speed'
+        send_request '/third', 'third thing'
+        send_request '/params', :b
 
-      def dispatch path, request
-        Docile.dsl_eval(DispatchScope.new, request, &@responders[path])
+        @first.should == 1
+        @second.should == 'Got a new ten speed'
+        fourth.should == 2
       end
-    end
 
-    def respond path, &block
-      MessageDispatch.instance.add_responder path, &block
     end
 
-    def send_request path, request
-      MessageDispatch.instance.dispatch path, request
-    end
+  end
 
-    it "should handle the dispatch pattern" do
-      @first = @second = nil
-      respond '/path' do |request|
-        @first = request
-      end
+  describe "#dsl_eval_immutable" do
+
+    context "when DSL context object is a frozen String" do
+      let(:original) { "I'm immutable!".freeze }
+      let!(:result) { execute_non_mutating_dsl_against_string }
 
-      respond '/new_bike' do |bike|
-        @second = "Got a new #{bike}"
+      def execute_non_mutating_dsl_against_string
+        Docile.dsl_eval_immutable(original) do
+          reverse
+          upcase
+        end
       end
 
-      def x(y) ; "Got a #{y}"; end
-      respond '/third' do |third|
-        x(third).should == 'Got a third thing'
+      it "doesn't modify the original string" do
+         original.should == "I'm immutable!"
       end
 
-      fourth = nil
-      respond '/params' do |arg|
-        fourth = params[arg]
+      it "chains the commands in the block against the DSL context object" do
+         result.should == "!ELBATUMMI M'I"
       end
+    end
 
-      send_request '/path', 1
-      send_request '/new_bike', 'ten speed'
-      send_request '/third', 'third thing'
-      send_request '/params', :b
+    context "when DSL context object is a number" do
+      let(:original) { 84.5 }
+      let!(:result) { execute_non_mutating_dsl_against_number }
 
-      @first.should == 1
-      @second.should == 'Got a new ten speed'
-      fourth.should == 2
-    end
+      def execute_non_mutating_dsl_against_number
+        Docile.dsl_eval_immutable(original) do
+          fdiv(2)
+          floor
+        end
+      end
 
+      it "chains the commands in the block against the DSL context object" do
+         result.should == 42
+      end
+    end
   end
 
-  context "FallbackContextProxy#instance_variables" do
+end
 
-    it "should preserve the class (String or Symbol) normally returned by current ruby version" do
-      @a = 1
-      expected_type = instance_variables.first.class
+describe Docile::FallbackContextProxy do
+
+  describe "#instance_variables" do
+    subject { create_fcp_and_set_one_instance_variable.instance_variables }
+    let(:expected_type_of_names) { type_of_ivar_names_on_this_ruby }
+    let(:actual_type_of_names) { subject.first.class }
+    let(:excluded) { Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES }
 
+    def create_fcp_and_set_one_instance_variable
       fcp = Docile::FallbackContextProxy.new(nil, nil)
       fcp.instance_variable_set(:@foo, "foo")
+      fcp
+    end
 
-      fcp.instance_variables.first.class.should == expected_type
+    def type_of_ivar_names_on_this_ruby
+      @a = 1
+      instance_variables.first.class
     end
 
+    it "returns proxied instance variables" do
+      subject.map(&:to_sym).should include(:@foo)
+    end
+
+    it "doesn't return non-proxied instance variables" do
+      subject.map(&:to_sym).should_not include(*excluded)
+    end
+
+    it "preserves the type (String or Symbol) of names on this ruby version" do
+      actual_type_of_names.should == expected_type_of_names
+    end
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: docile
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
 platform: ruby
 authors:
 - Marc Siegel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-28 00:00:00.000000000 Z
+date: 2013-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -104,6 +104,7 @@ extra_rdoc_files: []
 files:
 - .coveralls.yml
 - .gitignore
+- .rspec
 - .ruby-gemset
 - .ruby-version
 - .travis.yml
@@ -115,6 +116,8 @@ files:
 - Rakefile
 - docile.gemspec
 - lib/docile.rb
+- lib/docile/chaining_fallback_context_proxy.rb
+- lib/docile/execution.rb
 - lib/docile/fallback_context_proxy.rb
 - lib/docile/version.rb
 - spec/docile_spec.rb