ampex 1.0.0 → 1.1.0

data/README.markdown

@@ -1,5 +1,8 @@
 The Ampex (`&X`) library provides a Metavariable X that can be used in conjunction with the unary ampersand to create anonymous blocks in a slightly more readable way than the default. It was inspired by the clever `Symbol#to_proc` method which handles the most common case very elegantly, and discussion with Sam Stokes who created an earlier version.
 
+Usage
+-----
+
 At its simplest, `&X` can be used as a drop-in replacement for `Symbol#to_proc`:
 
     [1,2,3].map &X.to_s
@@ -21,12 +24,18 @@ And, as everything in ruby is a method, create readable expressions without the
     ["a", "b", "c"].map &(X * 2)
       # => ["aa", "bb", "cc"]
 
+    [{}].each &X[1] = 2
+      # => [{1 => 2}]
+
 As an added bonus, the effect is transitive — you can chain method calls:
 
     [1, 2, 3].map &X.to_f.to_s
       # => ["1.0", "2.0", "3.0"]
 
-There are two things to watch out for:
+Gotchas
+-------
+
+There are a few things to watch out for:
 
 Firstly, `&X` can only appear on the left:
 
@@ -52,6 +61,14 @@ Secondly, other arguments or operands will only be evaluated once, and not every
     [1, 2].map{ |x| x + (i += 1) }
       # => [2, 4]
 
+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.
+
+
+Epilogue
+--------
 
 For bug-fixes or enhancements, please contact the author: Conrad Irwin <conrad.irwin@gmail.com>
 

data/lib/ampex.rb

@@ -4,23 +4,74 @@ require 'blankslate'
 #
 # For detailed usage notes, please see README.markdown
 #
-class Metavariable < BlankSlate 
-  def initialize(parent=nil, &block)
-    @block = block
-    @parent = parent
+class Metavariable < BlankSlate
+
+  # When you pass an argument with & in ruby, you're actually calling #to_proc
+  # on the object. So it's Symbol#to_proc that makes the &:to_s trick work,
+  # and Metavariable#to_proc that makes &X work.
+  attr_reader :to_proc
+
+  def initialize(&block)
+    @to_proc = block || lambda{|x| x}
   end
 
+  # Each time a method is called on a Metavariable, we want to create a new
+  # Metavariable that is like the last but does something more.
+  #
+  # The end result of calling X.one.two will be like:
+  #
+  # lambda{|x|
+  #   (lambda{|x|
+  #     (lambda{|x| x}).call(x).one
+  #   }).call(x).two
+  # }
+  #
   def method_missing(name, *args, &block)
-    Metavariable.new(self) { |x| x.send(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 =~ /=$/
+    mv
   end
 
-  def to_proc
-    lambda do |x|
-      if @block
-        x = @parent.to_proc.call(x) if @parent
-        @block.call x
-      else
-        x
+  private
+
+  # In order to support assignment via &X (expressions of the form &X['one'] = 2),
+  # we need to add 2.to_proc (because assignment in ruby always returns the operand)
+  #
+  # Luckily, we only need to do this for a very short time.
+  #
+  # When given an expression such as:
+  #
+  #  ary.map(&X[args(a)] = :two)
+  #
+  # the order of execution is:
+  #  args(a)
+  #  X[_] = :two    \_ need to patch here
+  #  :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.
+  #
+  # 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.
+  #
+  def self.temporarily_monkeypatch(klass, mv)
+    klass.send :class_variable_set, :'@@metavariable', mv
+    klass.class_eval do
+
+      alias_method(:to_proc_without_metavariable, :to_proc) rescue nil
+      def to_proc
+        self.class.class_eval do
+
+          undef to_proc
+          alias_method(:to_proc, :to_proc_without_metavariable) rescue nil
+          undef to_proc_without_metavariable rescue nil
+
+          # Remove the metavariable from the class and return its proc
+          remove_class_variable(:'@@metavariable').to_proc
+        end
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ampex
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Conrad Irwin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-18 00:00:00 +00:00
+date: 2010-11-28 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency