rubyunderscore 0.1.0

data/README.md

@@ -0,0 +1,60 @@
+RubyUnderscore
+==============
+
+[Closures](http://metaphysicaldeveloper.wordpress.com/2009/05/02/closures-collections-and-some-functional-programming/)
+are very useful tools, and ruby
+[Enumerable](http://ruby-doc.org/core-1.8.7/classes/Enumerable.html) mixin makes them even
+more useful. 
+
+However, as you decompose more and more your iterations into a sequence of
+[maps](http://ruby-doc.org/core-1.8.7/classes/Enumerable.html#M001146),
+[selects](http://ruby-doc.org/core-1.8.7/classes/Enumerable.html#M001143),
+[rejects](http://ruby-doc.org/core-1.8.7/classes/Enumerable.html#M001144),
+[group_bys](http://ruby-doc.org/core-1.8.7/classes/Enumerable.html#M001150) and
+[reduces](http://ruby-doc.org/core-1.8.7/classes/Enumerable.html#M001148), more commonly
+you see simple blocks such as:
+
+    collection.map { |x| x.invoke }
+    dates.select { |d| d.greater_than(old_date) }
+    classes.reject { |c| c.subclasses.include?(Array) }
+
+RubyUnderscore modify classes so that you can also use a short notation for simple closures. With such, the above examples can be written as:
+
+    collection.map _.invoke
+    dates.select _.greater_than old_date
+    classes.reject _.subclasses.include? Array
+
+Just replace the iterating argument with the underscore symbol (*_*), and ditch the
+parenthesis. [More info](http://metaphysicaldeveloper.wordpress.com/2010/10/31/rubyunderscore-a-bit-of-arc-and-scala-in-ruby/)
+
+Quick Example
+----
+The example consists of getting all instance methods of String, Array, Class that end with 'd?'
+
+    require 'ruby_underscore'
+
+    class MethodFinder
+      include RubyUnderscore::Base
+
+      def find_interrogation_methods
+        [String, Array, Class].map(_.public_instance_methods.grep /d\?$/).flatten.sort.uniq
+      end
+    end
+    p MethodFinder.new.find_interrogation_methods
+
+
+Using Ruby Underscore
+----
+As in the example above, simply by including the module include RubyUnderscore::Base on the
+class, all methods (class methods as well) will allow you to use the underscore symbol to
+write simple blocks.
+
+
+Meta
+----
+
+Created by Daniel Ribeiro
+
+Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+http://github.com/danielribeiro/RubyUnderscore

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+
+task :default => [:spec]
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rubyunderscore"
+    gem.summary = %Q{Simple way to create simple blocks}
+    gem.description = %Q{It allows you to create simple blocks by using underscore symbol}
+    gem.email = "danrbr+rubyunderscore@gmail.com"
+    gem.homepage = "http://github.com/danielribeiro/RubyUnderscore"
+    gem.authors = ["Daniel Ribeiro"]
+    gem.add_dependency 'ParseTree', '=3.0.5'
+    gem.add_dependency 'ruby2ruby'
+    gem.files = FileList["[A-Z]*", "{bin,lib}/**/*"]
+#    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubyunderscore #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.libs << Dir["lib"]
+end

data/TODO

@@ -0,0 +1,7 @@
+- Better readme
+- gem and publish
+
+- enhance class
+- changer of ruby files (source)
+- debug support
+- rdoc

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/ruby_underscore.rb

@@ -0,0 +1,21 @@
+require 'tree_converters'
+
+module RubyUnderscore
+  module Base
+    module ClassMethods
+      def method_added(method_name)
+        super
+        UnderscoreEnhancer.new.enhance self, method_name
+      end
+
+      def singleton_method_added(method_name)
+        super
+        metaclass = class << self; self; end
+        UnderscoreEnhancer.new.enhance metaclass, method_name
+      end
+    end
+    def self.included(receiver)
+      receiver.extend ClassMethods
+    end
+  end
+end

data/lib/tree_converters.rb

@@ -0,0 +1,233 @@
+#gem 'ParseTree', '=3.0.5'
+require 'pp'
+require 'sexp_processor'
+require 'ruby2ruby'
+require 'unified_ruby'
+require 'parse_tree'
+module RubyUnderscore
+  class AbstractProcessor < SexpProcessor
+    def initialize
+      super
+      @alternate = SexpProcessor.new
+    end
+
+    def proceed(exp)
+      @alternate.process exp
+    end
+
+    def assert_empty(meth, exp, exp_orig)
+
+    end
+  end
+
+  module EnhancerHelper
+    # Deep Clone or arrays. Focused on arrays to be converted into sexp.
+    def clone(array)
+      a = []
+      array.each do | x |
+        a << if x.is_a? Array
+          clone(x)
+        elsif x.is_a? Symbol or x.is_a? Fixnum or x.is_a? Regexp
+          x
+        else
+          x.clone
+        end
+      end
+      a
+    end
+
+    def chain(sexp, *processorClasses)
+      processorClasses.inject(sexp) do |memo, clas|
+        clas.new.process memo
+      end
+    end
+
+    def needsEnhancing(clas, method)
+      sexpNeedsEnhancing sexpOf clas, method
+    end
+
+
+    def sexpOf(clas, method)
+      ParseTree.translate clas, method
+    end
+
+    def sexpNeedsEnhancing(sexp)
+      sexpEnhancingCount(sexp) > 0
+    end
+
+    def sexpEnhancingCount(sexp)
+      return 0 if sexp.nil?
+      parser = EnhancerDetector.new
+      parser.process clone sexp
+      return parser.enhanceCount
+    end
+
+    def assertSexpIs(sexp, type)
+      raise "Wrong sexp type: #{sexp.first}" unless sexp.first == type
+    end
+
+    class EnhancerDetector < AbstractProcessor
+      attr_reader :enhanceCount
+
+      def initialize
+        super
+        @enhanceCount = 0
+      end
+
+      def process_vcall(sexp)
+        @enhanceCount += 1 if sexp[1] == :_
+        return s *sexp
+      end
+    end
+  end
+
+  class AbstractSexp
+    attr_reader :sexp, :enhancer
+
+    include EnhancerHelper
+    def initialize(sexp, enhancer)
+      assertSexpIs sexp, type
+      @sexp = sexp
+      @enhancer = enhancer
+      deconstruct sexp[1..-1]
+    end
+
+    def s(*args)
+      enhancer.s *args
+    end
+
+    def process(arg)
+      enhancer.process arg
+    end
+
+    def regularEnhance
+      params = asArray
+      params.push(process(args)) if args
+      s *params
+    end
+
+    def subtreeNeedsEnhance?
+      enhancer.vcallCount && enhancer.vcallCount > 0
+    end
+
+    def decVcallCount
+      enhancer.vcallCount -= 1
+    end
+
+    def enhance
+      count = sexpEnhancingCount args
+      return regularEnhance unless count > 0
+      enhancer.vcallCount = count if enhancer.vcallCount.nil?
+      self.args = process args
+      if enhancer.vcallCount == 0
+        enhancer.vcallCount = nil
+      end
+      return regularEnhance unless subtreeNeedsEnhance?
+      decVcallCount
+      s :iter, s(*asArray), s(:dasgn_curr, enhancer.variableName), argumentList
+    end
+
+    def argumentList
+      args[1]
+    end
+
+
+    def deconstruct(sexp)
+      raise "subclass responsibility"
+    end
+
+    def type
+      raise "subclass responsibility"
+    end
+
+    def asArray
+      raise "subclass responsibility"
+    end
+
+  end
+
+  class Fcall < AbstractSexp
+    attr_accessor :method, :args
+    def type
+      :fcall
+    end
+
+    def deconstruct(sexp)
+      @method, @args = sexp
+    end
+
+
+    def asArray
+      [type, method]
+    end
+
+
+  end
+
+  class Call < AbstractSexp
+    attr_accessor :method, :args, :target
+    def type
+      :call
+    end
+
+    def deconstruct(sexp)
+      @target, @method, @args = sexp
+    end
+
+    def asArray
+      [type, process(target), method]
+    end
+  end
+
+
+  class VcallEnhancer < AbstractProcessor
+    attr_accessor :vcallCount
+    include EnhancerHelper
+    public :s
+
+    def initialize
+      super
+      self.vcallCount = nil
+    end
+
+    def variableName
+      :"__vcall_enhancer_i"
+    end
+
+
+    def process_vcall(sexp)
+      return s *sexp unless sexp[1] == :_
+      s(:dvar, variableName)
+    end
+
+    def process_call(sexp)
+      changeGenericCall sexp
+    end
+
+    def process_fcall(sexp)
+      changeGenericCall sexp
+    end
+
+    def changeGenericCall(sexp)
+      sexpClass(sexp.first).new(sexp, self).enhance
+    end
+    protected
+
+    def sexpClass(type)
+      return Call if type == :call
+      return Fcall if type == :fcall
+      raise "Unknown sexp: #{type}"
+    end
+  end
+
+
+  class UnderscoreEnhancer
+    include EnhancerHelper
+
+    def enhance(clas, method)
+      sexp = sexpOf clas, method
+      return unless sexpNeedsEnhancing sexp
+      clas.class_eval chain sexp, VcallEnhancer, Unifier, Ruby2Ruby
+    end
+  end
+end

data/spec/ruby_underscore_spec.rb

@@ -0,0 +1,76 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__),'..','lib')
+require 'ruby_underscore'
+
+
+class Enhanced
+  include RubyUnderscore::Base
+  def self.aPublicClassMethod
+    [__method__].map _.to_s.concat('Enhanced')
+  end
+  
+  def aPublic
+    [__method__].map _.to_s.concat('Enhanced')
+  end
+
+  def aPrivate
+    [__method__].map _.to_s.concat('Enhanced')
+  end
+end
+
+describe RubyUnderscore do
+  it "should enhance all methods of a class that includes RubyUnderscore::Base" do
+    Enhanced.new.aPublic.should == ["aPublicEnhanced"]
+  end
+
+  it "should enhance private methods as well" do
+    Enhanced.new.aPrivate.should == ["aPrivateEnhanced"]
+  end
+
+  it "should enhance class methods" do
+    Enhanced.aPublicClassMethod.should == ["aPublicClassMethodEnhanced"]
+  end
+
+  it "the original method_added of the class must call super" do
+    cl = Class.new do
+      @@original_method_added_invoked = false
+      def self.method_added(method_name)
+        super
+        @@original_method_added_invoked = true
+      end
+      include RubyUnderscore::Base
+
+      def dummy
+        'dum'
+      end
+
+      def self.original_method_added_invoked
+        @@original_method_added_invoked
+      end
+    end
+    cl.original_method_added_invoked.should be_true
+  end
+
+
+  it "will work even if the class defines singleton_method_added, but invokes super" do
+    cl = Class.new do
+      @@original_singleton_method_added_invoked = false
+      def self.singleton_method_added(method_name)
+        super
+        @@original_singleton_method_added_invoked = true
+      end
+      include RubyUnderscore::Base
+
+      def self.dummy
+        [__method__].map _.to_s.concat('Enhanced')
+      end
+
+      def self.original_singleton_method_added_invoked
+        @@original_singleton_method_added_invoked
+      end
+    end
+    cl.original_singleton_method_added_invoked.should be_true
+    cl.dummy.should == ["dummyEnhanced"]
+  end
+  
+end
+

data/spec/tree_converters_spec.rb

@@ -0,0 +1,179 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__),'..','lib')
+require 'tree_converters'
+
+# Making it simple to test.
+class RubyUnderscore::VcallEnhancer
+  def variableName
+    :x
+  end
+end
+
+
+class Array
+  def mapProc(proc)
+    map &proc
+  end
+end
+
+class Checks
+  def doesntNeedEnhancing
+    (1..20).map do |i|
+      i + 1
+    end
+  end
+
+  def stillNoEnhancing
+    _(9)
+  end
+
+  def needsEnhacing
+    [0].map _
+  end
+
+  def alsoNeedsEnhacing
+    [0].map _.to_s
+  end
+end
+
+module OutputHelper
+  def map(&block)
+    [0].map &block
+  end
+
+  def idblock(&block)
+    block
+  end
+
+  def identity_of(arg)
+    arg
+  end
+end
+
+class Input
+  include OutputHelper
+  def simple
+    [0].map _
+  end
+
+  def methodCall
+    [0].map _.to_s
+  end
+
+  def longComplexMethodChain
+    [0].map _.to_i.to_s.center(40, '-').to_s
+  end
+
+  def nested
+    ["1"].concat([0].map _.to_s)
+  end
+
+  def fcall
+    map _.to_s
+  end
+
+  def multiple_fcall
+    identity_of map _.to_s
+  end
+
+  def fcall_call_mix
+    identity_of [0].map _.to_s
+  end
+
+  def call_fcall_mix
+    [0].mapProc idblock _.to_s
+  end
+
+  def nested_enhancement_on_matrix
+    [[[:a00], [:a01]], [[:a10], [:a11]]].each(_.each(_.push(:last)))
+  end
+
+  def hasItAll
+    identity_of [[[:a00], [:a01]], [[:a10], [:a11]]].each(_.each(_.push(:last)))
+    identity_of [0].map _.to_s
+  end
+
+end
+
+class Expected
+  include OutputHelper
+  def simple
+    [0].map { |x| x }
+  end
+
+  def methodCall
+    [0].map { |x| x.to_s }
+  end
+
+  def longComplexMethodChain
+    [0].map { |x| x.to_i.to_s.center(40, '-').to_s }
+  end
+
+  def nested
+    ["1"].concat([0].map { |x| x.to_s } )
+  end
+
+  def fcall
+    map { |x| x.to_s }
+  end
+
+  def multiple_fcall
+    identity_of map { |x| x.to_s }
+  end
+
+  def fcall_call_mix
+    identity_of [0].map { |x| x.to_s }
+  end
+
+  def call_fcall_mix
+    [0].mapProc idblock { |x| x.to_s }
+  end
+
+  def nested_enhancement_on_matrix
+    [[[:a00], [:a01]], [[:a10], [:a11]]].each { |x| x.each { |x| x.push(:last)} }
+  end
+
+    def hasItAll
+    identity_of [[[:a00], [:a01]], [[:a10], [:a11]]].each { |x| x.each { |x| x.push(:last)} }
+    identity_of [0].map { |x| x.to_s }
+  end
+end
+
+describe 'TreeConverters' do
+  attr_reader :un
+
+  before(:each) do
+    @un = RubyUnderscore::UnderscoreEnhancer.new
+  end
+
+  def assert_same_after_enhancing(method)
+    un.enhance Input, method
+    input = un.sexpOf Input, method
+    output = un.sexpOf Expected, method
+    input.should == output
+    Input.new.send(method).should == Expected.new.send(method)
+  end
+
+  it "detects correctly what needs and what doesn't need enhancing" do
+    un.needsEnhancing(Checks, :doesntNeedEnhancing).should be_false
+    un.needsEnhancing(Checks, :stillNoEnhancing).should be_false
+    un.needsEnhancing(Checks, :needsEnhacing).should be_true
+    un.needsEnhancing(Checks, :alsoNeedsEnhacing).should be_true
+  end
+
+
+  it "can count correctly how many vcalls need to be enhanced" do
+    sexp = un.sexpOf Input, :nested_enhancement_on_matrix
+    un.sexpEnhancingCount(sexp).should == 2
+  end
+
+
+  [:simple, :methodCall, :longComplexMethodChain,
+    :nested, :fcall, :multiple_fcall, :fcall_call_mix,
+    :call_fcall_mix, :nested_enhancement_on_matrix, :hasItAll].
+    each do |m|
+    it m.to_s do
+      assert_same_after_enhancing m
+    end
+  end
+end
+

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: rubyunderscore
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel Ribeiro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-06 00:00:00 -02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 3
+        - 0
+        - 5
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: It allows you to create simple blocks by using underscore symbol
+email: danrbr+rubyunderscore@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- TODO
+files: 
+- README.md
+- Rakefile
+- TODO
+- VERSION
+- lib/ruby_underscore.rb
+- lib/tree_converters.rb
+- spec/tree_converters_spec.rb
+- spec/ruby_underscore_spec.rb
+has_rdoc: true
+homepage: http://github.com/danielribeiro/RubyUnderscore
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple way to create simple blocks
+test_files: 
+- spec/tree_converters_spec.rb
+- spec/ruby_underscore_spec.rb