ampex 1.1.1 → 1.1.2

data/README.markdown

@@ -13,7 +13,12 @@ However the real strength in the library comes from allowing you to call methods
     [1,"2",3].select &X.is_a?(String)
       # => ["2"]
 
-And, as everything in ruby is a method, create readable expressions without the noise of a one-argument block:
+And to chain method calls:
+
+    [1, 2, 3].map &X.to_f.to_s
+      # => ["1.0", "2.0", "3.0"]
+
+As everything in Ruby is a method call, you can create readable expressions without the noise of a one-argument block:
 
     [{1 => 2}, {1 => 3}].map &X[1]
       # => [2, 3]
@@ -27,10 +32,11 @@ And, as everything in ruby is a method, create readable expressions without the
     [{}].each &X[1] = 2
       # => [{1 => 2}]
 
-As an added bonus, the effect is transitive — you can chain method calls:
+You can use this in any place a block is expected, for example to create a lambda:
 
-    [1, 2, 3].map &X.to_f.to_s
-      # => ["1.0", "2.0", "3.0"]
+    normalizer = lambda &X.to_s.downcase
+    normalizer.call :HelloWorld
+      # => "helloworld"
 
 Gotchas
 -------
@@ -64,14 +70,20 @@ Secondly, other arguments or operands will only be evaluated once, and not every
 Bugs
 ----
 
-If you create an assigning callable (e.g. `X[a] = b`, `X.a = b` ) without an immediate preceding `&`, then `b.class#to_proc` will return the assigning callable the first time, and only the first time, you call it. If you want to get access to an assigning callable that you've defined using `&X`, you must do: `lambda &X[a] = b` instead.
-
+In normal usage there are no known bugs. That said, if you accidentally miss the `&` from in front of the `X`, in an expression that ends in an assignment (e.g. `X.formatter = :inspect`); then the `#to_proc` method of the object assigned will respond with the expression generated by that `X` the next time you call it from anywhere else in the same thread.
 
 Epilogue
 --------
 
+`&X` has been tested on MRI ruby 1.8.6, 1.8.7 and 1.9.2 and jruby 1.5.3. It is thread-safe.
+
 For bug-fixes or enhancements, please contact the author: Conrad Irwin <conrad.irwin@gmail.com>
 
-For an up-to-date version, try http://github.com/rapportive-oss/ampex
+For an up-to-date version, try <https://github.com/rapportive-oss/ampex>
 
 This library is copyrighted under the MIT license, see LICENSE.MIT for details.
+
+See also
+--------
+
+* <https://github.com/danielribeiro/RubyUnderscore> — which uses an underscore in place of `&X` and works by rewriting the syntax tree.

data/lib/ampex.rb

@@ -28,7 +28,7 @@ class Metavariable < BlankSlate
   #
   def method_missing(name, *args, &block)
     mv = Metavariable.new { |x| @to_proc.call(x).send(name, *args, &block) }
-    Metavariable.temporarily_monkeypatch(args.last.class, mv) if name.to_s =~ /[^!=]=$/
+    Metavariable.temporarily_monkeypatch(args.last, :to_proc) { mv.to_proc } if name.to_s =~ /[^!=<>]=$/
     mv
   end
 
@@ -49,28 +49,57 @@ class Metavariable < BlankSlate
   #  :two.to_proc  _/  and  un-patch here
   #  ary.map &_
   #
-  # There is a risk if someone uses an amp-less X, and assigns something with to_proc
-  # (most likely a symbol), and then uses .map(&:to_i), as &:to_i will return the
-  # behaviour of their metavariable.
+  # We go to some lengths to ensure that, providing the & and the X are adjacent,
+  # it's not possible to get different behaviour in the rest of the program; despite
+  # the temporary mutation of potentially global state.
   #
-  # There are other things that might notice us doing this, if people are listening
-  # on various method_added hooks, or have overridden class_eval, etc. But I'm not
-  # too worried.
+  # We can't really do anything if the & has been split from the X, consider:
   #
-  def self.temporarily_monkeypatch(klass, mv)
-    klass.send :class_variable_set, :'@@metavariable', mv
-    klass.class_eval do
+  #   assigner = (X[0] = :to_i)
+  #   assigner == :to_i
+  #     # => true
+  #   [1,2,3].map(&:to_i)
+  #     # => NoMethodError: undefined method `[]=' for 1:Fixnum
+  #
+  # Just strongly encourage use of:
+  #   assigner = lambda &X = :to_i
+  #   assigner == :to_i
+  #     # => false
+  #   [1,2,3].map(&:to_i)
+  #     # => [1,2,3]
+  #
+  def self.temporarily_monkeypatch(instance, method_name, &block)
+
+    Thread.exclusive do
+      @monkey_patch_count = @monkey_patch_count ? @monkey_patch_count + 1 : 0
+      stashed_method_name = :"#{method_name}_without_metavariable_#{@monkey_patch_count}"
+      thread = Thread.current
+
+      # Try to get a handle on the object's singleton class, but fall back to using
+      # its actual class where that is not possible (i.e. for numbers and symbols)
+      klass = (class << instance; self; end) rescue instance.class
+      klass.class_eval do
+
+        alias_method(stashed_method_name, method_name) rescue nil
+        define_method(method_name) do
+
+          todo = block
+
+          Thread.exclusive do
+            if self.equal?(instance) && thread.equal?(Thread.current)
 
-      alias_method(:to_proc_without_metavariable, :to_proc) rescue nil
-      def to_proc
-        self.class.class_eval do
+              klass.class_eval do
+                undef_method(method_name)
+                alias_method(method_name, stashed_method_name) rescue nil
+                undef_method(stashed_method_name) rescue nil
+              end
 
-          undef to_proc
-          alias_method(:to_proc, :to_proc_without_metavariable) rescue nil
-          undef to_proc_without_metavariable rescue nil
+            else
+              todo = method(stashed_method_name)
+            end
+          end
 
-          # Remove the metavariable from the class and return its proc
-          remove_class_variable(:'@@metavariable').to_proc
+          todo.call
         end
       end
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ampex
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 23
   prerelease: false
   segments: 
   - 1
   - 1
-  - 1
-  version: 1.1.1
+  - 2
+  version: 1.1.2
 platform: ruby
 authors: 
 - Conrad Irwin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-02 00:00:00 -08:00
+date: 2010-12-04 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency