ampex 0.0.2

data/LICENSE.MIT

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Conrad Irwin <conrad.irwin@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,60 @@
+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.
+
+At its simplest, `&X` can be used as a drop-in replacement for `Symbol#to_proc`:
+
+    [1,2,3].map &X.to_s
+      # => ["1", "2", "3"]
+
+However the real strength in the library comes from allowing you to call methods with arguments:
+
+    [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:
+
+    [{1 => 2}, {1 => 3}].map &X[1]
+      # => [2, 3]
+
+    [1,2,3].map &-X
+      # => [-1, -2, -3]
+
+    ["a", "b", "c"].map &(X * 2)
+      # => ["aa", "bb", "cc"]
+
+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:
+
+Firstly, `&X` can only appear on the left:
+
+    [1, 2, 3].map &(X + 1)
+      # => [2, 3, 4]
+
+    [1, 2, 3].map &(1 + X) # WRONG
+      # => TypeError, "coerce must return [x, y]"
+
+    [[1],[2]].map &X.concat([2])
+      # => [[1, 2], [2, 2]]
+
+    [[1],[2]].map &[2].concat(X) # WRONG
+      # => TypeError, "Metavariable#to_ary should return Array"
+
+Secondly, other arguments or operands will only be evaluated once, and not every time:
+
+    i = 0
+    [1, 2].map &(X + (i += 1)) # WRONG
+      # => [2, 3]
+
+    i = 0
+    [1, 2].map{ |x| x + (i += 1) }
+      # => [2, 4]
+
+
+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
+
+This library is copyrighted under the MIT license, see LICENSE.MIT for details.

data/lib/ampex.rb

@@ -0,0 +1,85 @@
+require 'blankslate'
+
+# Copyright 2010 Conrad Irwin <conrad.irwin@gmail.com> MIT License
+#
+# For detailed usage notes, please see README.markdown
+#
+class Metavariable < BlankSlate 
+  def initialize(parent=nil, &block)
+    @block = block
+    @parent = parent
+  end
+
+  def method_missing(name, *args, &block)
+    Metavariable.new(self) { |x| x.send(name, *args, &block) }
+  end
+
+  def to_proc
+    lambda do |x|
+      if @block
+        x = @parent.to_proc.call(x) if @parent
+        @block.call x
+      else
+        x
+      end
+    end
+  end
+
+  def metavariable_precedence
+    @parent unless @block
+  end
+end
+
+class CallByName < BlankSlate
+  def initialize(obj, parent=nil, name=nil, args=nil, block=nil)
+    @obj = obj
+    @parent = parent
+    @name = name
+    @args = args
+    @block = block
+  end
+
+  def method_missing(name, *args, &block)
+    CallByName.new(nil, self, name, args, block)
+  end
+
+  def unwind_callbyname(*args)
+    provided.map{|x| Metavariable === x ? called[x.metavariable_precedence] : x}
+    if @parent
+      @parent.unwind_callbyname(*args).send(@name, *CallByName.merge_args(@args, args), &@block)
+    else
+      @obj
+    end
+  end
+
+  def to_proc
+    if @parent
+      lambda { |*args| unwind_callbyname(*args) }
+    else
+      lambda { |*args| @obj }
+    end
+  end
+
+  def self.merge_args(provided, called)
+  end
+end
+
+
+class Regexp
+  def [](obj)
+    CallByName.new(obj)
+  end
+end
+
+module Kernel
+  def X
+    Metavariable.new(0)
+  end
+end
+
+K = Metavariable.new(0)
+V = Metavariable.new(1)
+W = Regexp.new""
+X = 
+Y = Metavariable.new(1)
+Z = Metavariable.new(2)

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: ampex
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Conrad Irwin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-17 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: blankslate
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Why would you want to write { |x| x['one'] } when you can write &X['one'], why indeed.
+email: conrad.irwin@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ampex.rb
+- README.markdown
+- LICENSE.MIT
+has_rdoc: true
+homepage: http://github.com/rapportive-oss/ampex
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides a meta-variable X which can be used to create procs more prettily
+test_files: []
+