codeodor-with 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-01-12
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,17 @@
+History.txt
+Manifest.txt
+README
+README.rdoc
+Rakefile
+lib/with.rb
+lib/with_on_object.rb
+lib/with_sexp_processor.rb
+script/console
+script/destroy
+script/generate
+test/foo.rb
+test/test_helper.rb
+test/test_with.rb
+test/with_on_object_test.rb
+test/with_test.rb
+with.tmproj

data/README

@@ -0,0 +1,105 @@
+= with
+
+* http://github.com/codeodor/with/tree/master
+
+== DESCRIPTION:
+
+I sometimes get a little descriptive with my variable names, so when you're doing a lot of work 
+specifically with one object, it gets especially ugly and repetetive, making the code harder to 
+read than it needs to be:
+
+@contract_participants_on_drugs.contract_id = params[:contract_id]
+@contract_participants_on_drugs.participant_name = params[:participant_name]
+@contract_participants_on_drugs.drug_conviction = DrugConvictions.find(:wtf => 'this is getting ridiculous')
+...
+
+And so on. It gets ridiculous.
+
+Utility Belt implements a with(object) method via a change to Object:
+
+class Object
+  #utility belt implementation
+  def with(object, &block)
+    object.instance_eval &block
+  end
+end
+
+Unfortunately, that just executes the block in the context of the object, so there isn't any 
+crossover, nor can you perform assignments with attr_accessors (that I was able to do, anyway).
+
+So, here's With.object() to fill the void. 
+
+With.object(@foo) do 
+ a = "wtf"
+ b = "this is not as bad"
+end
+
+In the above example, @foo.a and @foo.b are the variables getting set.
+
+If you prefer, you can require 'with_on_object' instead and use the notation with(object) do ... end.
+
+The tests in the /test directory offer more examples of what's been implemented and tested so far 
+(except where noted - namely performing assignment to a variable that was declared outside the 
+block, and is not on @foo).
+
+Not everything is working yet, but it works for the simplest, most common cases I've run up 
+against. More complex tests are on the way, along with code to make them pass.
+
+Special thanks to Reg Braithwaite, for help and ideas along the way.
+
+
+== FEATURES/PROBLEMS:
+
+The tests in the /test directory offer more examples of what's been implemented and tested so far 
+(except where noted - namely performing assignment to a variable that was declared outside the 
+block, and is not on @foo).
+
+== SYNOPSIS:
+
+require 'with'
+With.object(@foo) do 
+ a = "wtf"
+ b = "this is not as bad"
+end
+
+or 
+
+require 'with_on_object'
+with(@foo) do 
+ a = "wtf"
+ b = "this is not as bad"
+end
+
+== REQUIREMENTS:
+
+* Ruby2Ruby
+* ParseTree
+
+== INSTALL:
+
+* sudo gem install codeodor-with -s http://gems. github.com
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIX
+
+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/Rakefile

@@ -0,0 +1,27 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/with'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('with', With::VERSION) do |p|
+  p.developer('Sammy Larbi', 'sam@codeodor.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/lib/with.rb

@@ -0,0 +1,96 @@
+require 'with_sexp_processor'
+require 'parse_tree'
+
+class With
+  VERSION = "0.0.1"
+  def self.object(the_object, &block)
+    @the_object = the_object
+    @original_context = block.binding 
+    
+    anonymous_class = Class.new
+    anonymous_class.instance_eval { define_method("the_block", block) }
+    anonymous_class_as_sexp = ParseTree.translate(anonymous_class)
+    
+    our_block_sexp = anonymous_class_as_sexp[3][2][2]
+    our_block_sexp = transform(our_block_sexp)
+    
+    transformed_block = lambda { eval(WithSexpProcessor.new.process(our_block_sexp)) } #, block.binding) }
+    transformed_block.call
+  end
+  
+  private
+  def self.convert_single_statement_to_block(node)
+    node = [:block, node] if node[0] != :block
+    return node
+  end
+  
+  def self.statements_to_process
+    [:dasgn_curr, :lasgn, :fcall, :vcall]
+  end
+  
+  def self.transform( node )
+    node = convert_single_statement_to_block node 
+    
+    node.each_with_index do |statement, i|
+      next if i == 0 
+      
+      statement_type = statement[0]  
+      statement = self.method("transform_#{statement_type.to_s}").call(statement) if statements_to_process.include? statement_type 
+      node[i] = statement 
+    end
+    
+    return node
+  end
+  
+  def self.transform_dasgn_curr statement
+      var_name = statement[1].to_s
+      value = statement[2]
+      new_method = (var_name+"=").to_sym
+      
+      #binds to original context since we lose original_object name and cannot eval in that context
+      value[1] = eval(value[1].to_s, @original_context) if (value[0]==:lvar || value[0]==:vcall) && !@the_object.respond_to?(value[1].to_s)
+      
+      if value[0]==:fcall
+        func = value[1]
+        args = value[2]
+        arg_list = ""
+        args.each_with_index do |arg, j|
+          next if j == 0
+          
+          arg[1] = eval(arg[1].to_s, @original_context) if arg[0] != :lit
+          
+          arg_list << arg[1].to_s 
+          arg_list << "," if j < args.length-1
+        end
+        funcall = "#{func}(#{arg_list})"
+        
+        value=[:lit, eval(funcall, @original_context)]  
+      end
+      
+      statement = [:attrasgn, [:lvar, :the_object], new_method, value]
+  end
+  
+  def self.transform_lasgn statement
+      method = statement[2][1]
+      if @the_object.respond_to?(method)
+        lvar = statement[1]
+        statement = [:lasgn, lvar, [:call, [:lvar, :the_object], method]]
+      end
+  end
+  
+  def self.transform_fcall statement
+      method = statement[1]
+      args = statement[2]
+      args.each_with_index do |arg, j|
+        next if j == 0
+        arg[1] = eval(arg[1].to_s, @original_context) if arg[0] == :lvar && !@the_object.respond_to?(arg[1].to_s)
+      end
+      statement = [:call, [:lvar, :the_object], method, args]
+  end
+      
+  def self.transform_vcall statement
+    method = statement[1]
+    statement = [:call, [:lvar, :the_object], method]
+  end
+    
+end

data/lib/with_on_object.rb

@@ -0,0 +1,7 @@
+require 'with'
+class Object
+  def with(object, &block)
+    With.object(object, &block)
+  end
+end
+    

data/lib/with_sexp_processor.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'ruby2ruby'
+
+class WithSexpProcessor < Ruby2Ruby
+  
+  def process_vcall(exp)
+    exp.shift.to_s
+  end  
+  
+  def process(exp)
+    hacked=true && hack_nil unless nil.respond_to? "empty?"
+    result = super(exp)
+    unhack_nil if hacked
+    return result
+  end
+  
+  private
+  def hack_nil
+    ::NilClass.module_eval do
+      def empty?
+        true
+      end
+    end
+  end
+  
+  def unhack_nil
+    ::NilClass.module_eval do
+      def empty?
+        throw NoMethodError, "undefined method `empty?' for nil:NilClass"
+      end
+    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/with.rb'}"
+puts "Loading with gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/foo.rb

@@ -0,0 +1,21 @@
+class Foo
+  attr_accessor :get, :a, :b
+  def initialize
+    @get = "get!"
+    @a = 'a'
+    @b = 'b'
+  end
+
+  def show
+    puts inspect
+  end
+
+  def change
+    @a = "changed!"
+  end
+
+  def set(c, d)
+    @a = c
+    @b = d
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/with'

data/test/test_with.rb

@@ -0,0 +1,103 @@
+require 'with'
+require 'test/unit'
+require 'foo'
+
+
+
+class TestWith < Test::Unit::TestCase
+
+  def setup
+    @foo = Foo.new
+  end
+  
+  def test_With_works_with_attr_accessor_assignment
+    foo = Foo.new
+    With.object(foo) do 
+      get = 'got!'
+    end
+    assert(foo.get == "got!")
+  end
+  
+  def test_With_works_with_two_attr_accessor_assignments
+    # Seems strange, but one line blocks don't show up as blocks after running through ParseTree, 
+    # so this exercises the more common case, whereas the previous test exercises the uncommon one. 
+    With.object(@foo) do 
+      get = 'got!'
+      a = 'b'
+    end
+    assert(@foo.get == "got!")
+    assert(@foo.a == "b")
+  end
+  
+  def test_With_works_with_method_call_no_args
+    With.object(@foo) do 
+      get = 'got!'
+      change
+    end
+    assert(@foo.a == "changed!")
+  end
+
+  def test_With_works_with_method_call_with_args
+    With.object @foo do
+      set("c", "d")
+      set("d", "e")
+    end
+    assert @foo.a == "d"
+    assert @foo.b == "e"
+  end
+  
+  def test_With_ignores_calls_to_methods_where_foo_respond_to?_is_false
+    With.object(@foo) do 
+      puts 
+    end
+    assert( true )
+  end
+  
+  def test_With_works_with_assignment_to_outside_method_call_no_args
+    def outter 
+      5
+    end 
+    With.object(@foo) do 
+      a = outter
+    end
+    
+    assert(@foo.a == 5) 
+  end
+
+  def test_With_works_with_assignment_to_outside_lvar
+    outter = "outside"
+    With.object(@foo) do 
+      outter = get
+    end
+    assert( outter == @foo.get ) 
+    #this fails. unsure how / if it should stay as part of the spec
+    #problem is that (as far as I can tell) it will need to evaluate the post-transformation 
+    #block in the original context, whereas it currently needs to be executed in a diff one
+    #this would be a lot easier - less transforms on other specs - if we could find the variable 
+    #name of "@foo" within With.object
+  end
+  
+  def test_With_works_with_assignment_to_outside_method_call_with_args
+    def f(x,y)
+      398
+    end
+    With.object(@foo) do 
+      a = f(1,3)
+    end
+    assert(@foo.a == 398)
+  end
+  
+  def test_With_works_with_method_call_with_args_using_non_literals
+    def f2(x,y)
+      398
+    end
+    x = 2
+    y = 5
+    With.object(@foo) do 
+      a = f2(x,y)
+    end
+    assert(@foo.a == 398)
+  end
+  
+  
+end

data/test/with_on_object_test.rb

@@ -0,0 +1,101 @@
+require '../lib/with_on_object'
+require 'test/unit'
+require 'foo'
+
+class TestWithOnObject < Test::Unit::TestCase
+
+  def setup
+    @foo = Foo.new
+  end
+  
+  def test_With_works_with_attr_accessor_assignment
+    foo = Foo.new
+    with(foo) do 
+      get = 'got!'
+    end
+    assert(foo.get == "got!")
+  end
+  
+  def test_With_works_with_two_attr_accessor_assignments
+    # Seems strange, but one line blocks don't show up as blocks after running through ParseTree, 
+    # so this exercises the more common case, whereas the previous test exercises the uncommon one. 
+    with(@foo) do 
+      get = 'got!'
+      a = 'b'
+    end
+    assert(@foo.get == "got!")
+    assert(@foo.a == "b")
+  end
+  
+  def test_With_works_with_method_call_no_args
+    with(@foo) do 
+      get = 'got!'
+      change
+    end
+    assert(@foo.a == "changed!")
+  end
+
+  def test_With_works_with_method_call_with_args
+    With.object @foo do
+      set("c", "d")
+      set("d", "e")
+    end
+    assert @foo.a == "d"
+    assert @foo.b == "e"
+  end
+  
+  def test_With_ignores_calls_to_methods_where_foo_respond_to?_is_false
+    with(@foo) do 
+      puts 
+    end
+    assert( true )
+  end
+  
+  def test_With_works_with_assignment_to_outside_method_call_no_args
+    def outter 
+      5
+    end 
+    with(@foo) do 
+      a = outter
+    end
+    
+    assert(@foo.a == 5) 
+  end
+
+  def test_With_works_with_assignment_to_outside_lvar
+    outter = "outside"
+    with(@foo) do 
+      outter = get
+    end
+    assert( outter == @foo.get ) 
+    #this fails. unsure how / if it should stay as part of the spec
+    #problem is that (as far as I can tell) it will need to evaluate the post-transformation 
+    #block in the original context, whereas it currently needs to be executed in a diff one
+    #this would be a lot easier - less transforms on other specs - if we could find the variable 
+    #name of "@foo" within With.object
+  end
+  
+  def test_With_works_with_assignment_to_outside_method_call_with_args
+    def f(x,y)
+      398
+    end
+    with(@foo) do 
+      a = f(1,3)
+    end
+    assert(@foo.a == 398)
+  end
+  
+  def test_With_works_with_method_call_with_args_using_non_literals
+    def f(x,y)
+      398
+    end
+    x = 2
+    y = 5
+    with(@foo) do 
+      a = f(x,y)
+    end
+    assert(@foo.a == 398)
+  end
+  
+  
+end

data/test/with_test.rb

@@ -0,0 +1,103 @@
+require '../lib/with'
+require 'test/unit'
+require 'foo'
+
+
+
+class TestWith < Test::Unit::TestCase
+
+  def setup
+    @foo = Foo.new
+  end
+  
+  def test_With_works_with_attr_accessor_assignment
+    foo = Foo.new
+    With.object(foo) do 
+      get = 'got!'
+    end
+    assert(foo.get == "got!")
+  end
+  
+  def test_With_works_with_two_attr_accessor_assignments
+    # Seems strange, but one line blocks don't show up as blocks after running through ParseTree, 
+    # so this exercises the more common case, whereas the previous test exercises the uncommon one. 
+    With.object(@foo) do 
+      get = 'got!'
+      a = 'b'
+    end
+    assert(@foo.get == "got!")
+    assert(@foo.a == "b")
+  end
+  
+  def test_With_works_with_method_call_no_args
+    With.object(@foo) do 
+      get = 'got!'
+      change
+    end
+    assert(@foo.a == "changed!")
+  end
+
+  def test_With_works_with_method_call_with_args
+    With.object @foo do
+      set("c", "d")
+      set("d", "e")
+    end
+    assert @foo.a == "d"
+    assert @foo.b == "e"
+  end
+  
+  def test_With_ignores_calls_to_methods_where_foo_respond_to?_is_false
+    With.object(@foo) do 
+      puts 
+    end
+    assert( true )
+  end
+  
+  def test_With_works_with_assignment_to_outside_method_call_no_args
+    def outter 
+      5
+    end 
+    With.object(@foo) do 
+      a = outter
+    end
+    
+    assert(@foo.a == 5) 
+  end
+
+  def test_With_works_with_assignment_to_outside_lvar
+    outter = "outside"
+    With.object(@foo) do 
+      outter = get
+    end
+    assert( outter == @foo.get ) 
+    #this fails. unsure how / if it should stay as part of the spec
+    #problem is that (as far as I can tell) it will need to evaluate the post-transformation 
+    #block in the original context, whereas it currently needs to be executed in a diff one
+    #this would be a lot easier - less transforms on other specs - if we could find the variable 
+    #name of "@foo" within With.object
+  end
+  
+  def test_With_works_with_assignment_to_outside_method_call_with_args
+    def f(x,y)
+      398
+    end
+    With.object(@foo) do 
+      a = f(1,3)
+    end
+    assert(@foo.a == 398)
+  end
+  
+  def test_With_works_with_method_call_with_args_using_non_literals
+    def f(x,y)
+      398
+    end
+    x = 2
+    y = 5
+    With.object(@foo) do 
+      a = f(x,y)
+    end
+    assert(@foo.a == 398)
+  end
+  
+  
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: codeodor-with
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sammy Larbi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-12 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: "I sometimes get a little descriptive with my variable names, so when you're doing a lot of work  specifically with one object, it gets especially ugly and repetetive, making the code harder to  read than it needs to be:  @contract_participants_on_drugs.contract_id = params[:contract_id] @contract_participants_on_drugs.participant_name = params[:participant_name] @contract_participants_on_drugs.drug_conviction = DrugConvictions.find(:wtf => 'this is getting ridiculous') ...  And so on. It gets ridiculous.  Utility Belt implements a with(object) method via a change to Object:  class Object #utility belt implementation def with(object, &block) object.instance_eval &block end end  Unfortunately, that just executes the block in the context of the object, so there isn't any  crossover, nor can you perform assignments with attr_accessors (that I was able to do, anyway).  So, here's With.object() to fill the void.   With.object(@foo) do  a = \"wtf\" b = \"this is not as bad\" end  In the above example, @foo.a and @foo.b are the variables getting set.  If you prefer, you can require 'with_on_object' instead and use the notation with(object) do ... end.  The tests in the /test directory offer more examples of what's been implemented and tested so far  (except where noted - namely performing assignment to a variable that was declared outside the  block, and is not on @foo).  Not everything is working yet, but it works for the simplest, most common cases I've run up  against. More complex tests are on the way, along with code to make them pass.  Special thanks to Reg Braithwaite, for help and ideas along the way."
+email: 
+- sam@codeodor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README
+- README.rdoc
+- Rakefile
+- lib/with.rb
+- lib/with_on_object.rb
+- lib/with_sexp_processor.rb
+- script/console
+- script/destroy
+- script/generate
+- test/foo.rb
+- test/test_helper.rb
+- test/test_with.rb
+- test/with_on_object_test.rb
+- test/with_test.rb
+- with.tmproj
+has_rdoc: true
+homepage: http://github.com/codeodor/with/tree/master
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: with
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: "I sometimes get a little descriptive with my variable names, so when you're doing a lot of work  specifically with one object, it gets especially ugly and repetetive, making the code harder to  read than it needs to be:  @contract_participants_on_drugs.contract_id = params[:contract_id] @contract_participants_on_drugs.participant_name = params[:participant_name] @contract_participants_on_drugs.drug_conviction = DrugConvictions.find(:wtf => 'this is getting ridiculous') .."
+test_files: 
+- test/test_helper.rb
+- test/test_with.rb