rubyjs 0.7.1 → 0.8.0

data/vendor/ParseTree-1.7.1-patched/Manifest.txt

@@ -1,22 +0,0 @@
-History.txt
-Manifest.txt
-README.txt
-Rakefile
-bin/parse_tree_abc
-bin/parse_tree_audit
-bin/parse_tree_deps
-bin/parse_tree_show
-demo/printer.rb
-lib/composite_sexp_processor.rb
-lib/parse_tree.rb
-lib/sexp.rb
-lib/sexp_processor.rb
-lib/unique.rb
-test/pt_testcase.rb
-test/something.rb
-test/test_all.rb
-test/test_composite_sexp_processor.rb
-test/test_parse_tree.rb
-test/test_sexp.rb
-test/test_sexp_processor.rb
-validate.sh

data/vendor/ParseTree-1.7.1-patched/README.txt

@@ -1,110 +0,0 @@
-ParseTree
-    http://rubyforge.org/projects/parsetree/
-    http://www.zenspider.com/ZSS/Products/ParseTree/
-    support@zenspider.com
-
-** DESCRIPTION:
-
-ParseTree is a C extension (using RubyInline) that extracts the parse
-tree for an entire class or a specific method and returns it as a
-s-expression (aka sexp) using ruby's arrays, strings, symbols, and
-integers. 
-
-As an example:
-
-  def conditional1(arg1)
-    if arg1 == 0 then
-      return 1
-    end
-    return 0
-  end
-
-becomes:
-
-  [:defn,
-    :conditional1,
-    [:scope,
-     [:block,
-      [:args, :arg1],
-      [:if,
-       [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],
-       [:return, [:lit, 1]],
-       nil],
-      [:return, [:lit, 0]]]]]
-
-** FEATURES/PROBLEMS:
-  
-+ Uses RubyInline, so it just drops in.
-+ Includes SexpProcessor and CompositeSexpProcessor.
-	+ Allows you to write very clean filters.
-+ Includes parse_tree_show, which lets you quickly snoop code.
-	+ echo "1+1" | parse_tree_show -f for quick snippet output.
-+ Includes parse_tree_abc, which lets you get abc metrics on code.
-	+ abc metrics = numbers of assignments, branches, and calls.
-	+ whitespace independent metric for method complexity.
-+ Includes parse_tree_deps, which shows you basic class level dependencies.
-+ Only works on methods in classes/modules, not arbitrary code.
-+ Does not work on the core classes, as they are not ruby (yet).
-
-** SYNOPSYS:
-
-  sexp_array = ParseTree.new.parse_tree(klass)
-
-or:
-
-  class MyProcessor < SexpProcessor
-    def initialize
-      super
-      self.strict = false
-    end
-    def process_lit(exp)
-      val = exp.shift
-      return val
-    end
-  end
-
-or:
-
-  % ./parse_tree_show myfile.rb
-
-or:
-
-  % echo "1+1" | ./parse_tree_show -f
-
-or:
-
-  % ./parse_tree_abc myfile.rb
-
-** REQUIREMENTS:
-
-+ RubyInline 3 or better.
-
-** INSTALL:
-
-+ sudo rake install
-+ or: sudo gem install ParseTree
-
-** LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2001-2004 Ryan Davis, Zen Spider Software
-
-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/vendor/ParseTree-1.7.1-patched/Rakefile

@@ -1,41 +0,0 @@
-# -*- ruby -*-
-
-require 'rubygems'
-require 'hoe'
-
-$: << "../../RubyInline/dev"
-require './lib/parse_tree.rb'
-
-Hoe.new("ParseTree", ParseTree::VERSION) do |p|
-  p.rubyforge_name = "parsetree"
-  p.summary = "Extract and enumerate ruby parse trees."
-  p.description = p.paragraphs_of("README.txt", 2).join("\n\n")
-  p.changes = p.paragraphs_of("History.txt", 1).join("\n\n")
-  p.clean_globs << File.expand_path("~/.ruby_inline")
-  p.extra_deps << ['RubyInline', '>= 3.2.0']
-  p.spec_extras[:require_paths] = proc { |paths| paths << 'test' }
-end
-
-desc 'Run against ruby 1.9 (from a multiruby install) with -d.'
-task :test19 do
-  sh "~/.multiruby/install/1_9/bin/ruby -d #{Hoe::RUBY_FLAGS} test/test_all.rb #{Hoe::FILTER}"
-end
-
-desc 'Run in gdb'
-task :debug do
-  puts "RUN: r -d #{Hoe::RUBY_FLAGS} test/test_all.rb #{Hoe::FILTER}"
-  sh "gdb ~/.multiruby/install/19/bin/ruby"
-end
-
-desc 'Run a very basic demo'
-task :demo do
-  sh "echo 1+1 | ruby #{Hoe::RUBY_FLAGS} ./bin/parse_tree_show -f"
-end
-
-desc 'Show what tests are not sorted'
-task :sort do
-  sh "pgrep '^    \\\"(\\w+)' test/pt_testcase.rb | cut -f 2 -d\\\" > x"
-  sh "sort x > y"
-  sh "diff x y"
-  sh "rm -f x y"
-end

data/vendor/ParseTree-1.7.1-patched/bin/parse_tree_abc

@@ -1,89 +0,0 @@
-#!/usr/local/bin/ruby -ws
-
-# ABC metric
-#
-# Assignments, Branches, and Calls
-#
-# A simple way to measure the complexity of a function or method.
-
-if defined? $I and String === $I then
-  $I.split(/:/).each do |dir|
-    $: << dir
-  end
-end
-
-PARSE_TREE_ABC=true
-
-begin require 'rubygems' rescue LoadError end
-require 'sexp'
-require 'parse_tree'
-require 'sexp_processor'
-
-old_classes = []
-ObjectSpace.each_object(Module) do |klass|
-  old_classes << klass
-end
-
-ARGV.each do |name|
-  begin
-    require name
-  rescue NameError => err
-    $stderr.puts "ERROR requiring #{name}. Perhaps you need to add some -I's?\n\n#{err}"
-  end
-end
-
-new_classes = []
-ObjectSpace.each_object(Module) do |klass|
-  new_classes << klass
-end
-
-score = {}
-
-new_classes -= old_classes
-
-klasses = Sexp.from_array(ParseTree.new.parse_tree(*new_classes))
-klasses.each do |klass|
-  klass.shift # :class
-  klassname = klass.shift
-  klass.shift # superclass
-  methods = klass
-
-  methods.each do |defn|
-    a=b=c=0
-    defn.shift
-    methodname = defn.shift
-    tokens = defn.structure.flatten
-    tokens.each do |token|
-      case token
-      when :attrasgn, :attrset, :dasgn_curr, :iasgn, :lasgn, :masgn then
-        a += 1
-      when :and, :case, :else, :if, :iter, :or, :rescue, :until, :when, :while  then
-        b += 1
-      when :call, :fcall, :super, :vcall, :yield then
-        c += 1
-      when :args, :argscat, :array, :begin, :block, :block_arg, :block_pass, :bool, :cfunc, :colon2, :const, :cvar, :defined, :defn, :dregx, :dstr, :dvar, :dxstr, :ensure, :false, :fbody, :gvar, :hash, :ivar, :lit, :long, :lvar, :match2, :match3, :nil, :not, :nth_ref, :return, :scope, :self, :splat, :str, :to_ary, :true, :unknown, :value, :void, :zarray, :zarray, :zclass, :zsuper then
-        # ignore
-      else
-        puts "unhandled token #{token.inspect}" if $VERBOSE
-      end
-    end
-    key = ["#{klassname}.#{methodname}", a, b, c]
-    val = Math.sqrt(a*a+b*b+c*c)
-    score[key] = val
-  end
-end
-
-puts "|ABC| = Math.sqrt(assignments^2 + branches^2 + calls^2)"
-puts
-count = 1
-ta = tb = tc = tval = 0
-score.sort_by { |k,v| v }.reverse.each do |key,val|
-  name, a, b, c = *key
-  ta += a
-  tb += b
-  tc += c
-  tval += val
-  printf "%3d) %-50s = %2d + %2d + %2d = %6.2f\n", count, name, a, b, c, val
-  count += 1
-end rescue nil
-printf "%3d) %-50s = %2d + %2d + %2d = %6.2f\n", count, "Total", ta, tb, tc, tval

data/vendor/ParseTree-1.7.1-patched/bin/parse_tree_audit

@@ -1,28 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-require 'parse_tree'
-
-all_nodes = ParseTree::NODE_NAMES
-
-ARGV.each do |processor|
-  require processor
-end
-
-ObjectSpace.each_object(Class) do |klass| 
-  if klass < SexpProcessor then
-
-    processor = klass.new
-    processors = klass.public_instance_methods(true).grep(/process_/)
-
-    if processor.strict then
-      puts "#{klass.name}:"
-      puts
-
-      # TODO: check unsupported against supported
-      processors = processors.map { |m| m[8..-1].intern } + processor.unsupported
-      unsupported = all_nodes - processors 
-      p unsupported.sort_by { |sym| sym.to_s }
-      puts
-    end
-  end
-end

data/vendor/ParseTree-1.7.1-patched/bin/parse_tree_deps

@@ -1,62 +0,0 @@
-#!/usr/local/bin/ruby -ws
-
-old_classes = []; new_classes = []
-
-ObjectSpace.each_object(Module) { |klass| old_classes << klass } if defined? $a
-
-require 'pp'
-
-begin require 'rubygems' rescue LoadError end
-require 'parse_tree'
-require 'sexp_processor'
-
-ObjectSpace.each_object(Module) { |klass| old_classes << klass } unless defined? $a
-
-class DependencyAnalyzer < SexpProcessor
-
-  attr_reader :dependencies
-  attr_accessor :current_class
-
-  def initialize
-    super
-    self.auto_shift_type = true
-    @dependencies = Hash.new { |h,k| h[k] = [] }
-    @current_method = nil
-    @current_class = nil
-  end
-
-  def self.process(*klasses)
-    analyzer = self.new
-    klasses.each do |start_klass|
-      analyzer.current_class = start_klass
-      analyzer.process(ParseTree.new.parse_tree(start_klass))
-    end
-
-    deps = analyzer.dependencies
-    deps.keys.sort_by {|k| k.to_s}.each do |dep_to|
-      dep_from = deps[dep_to]
-      puts "#{dep_to}: #{dep_from.uniq.sort.join(", ")}"
-    end
-  end
-
-  def process_defn(exp)
-    name = exp.shift
-    @current_method = name
-    return s(:defn, name, process(exp.shift), process(exp.shift))
-  end
-
-  def process_const(exp)
-    name = exp.shift
-    const = (defined?($c) ? @current_class.name : "#{@current_class}.#{@current_method}")
-    is_class = ! (Object.const_get(name) rescue nil).nil?
-    @dependencies[name] << const if is_class
-    return s(:const, name)
-  end
-end
-
-if __FILE__ == $0 then
-  ARGV.each { |name| require name }
-  ObjectSpace.each_object(Module) { |klass| new_classes << klass }
-  new_classes.delete DependencyAnalyzer unless defined? $a
-  DependencyAnalyzer.process(*(new_classes - old_classes))
-end

data/vendor/ParseTree-1.7.1-patched/bin/parse_tree_show

@@ -1,49 +0,0 @@
-#!/usr/local/bin/ruby -ws
-
-require 'pp'
-begin require 'rubygems' rescue LoadError end
-require 'parse_tree'
-
-def discover_new_classes_from
-  old_classes = []
-  ObjectSpace.each_object(Module) do |klass|
-    old_classes << klass
-  end
-
-  yield
-
-  new_classes = []
-  ObjectSpace.each_object(Module) do |klass|
-    new_classes << klass
-  end
-
-  new_classes -= old_classes
-  new_classes = [ eval($c) ] if defined? $c
-  new_classes
-end
-
-$f = false unless defined? $f
-
-new_classes = discover_new_classes_from do
-  ARGV.unshift "-" if ARGV.empty?
-  ARGV.each do |name|
-    if name == "-" then
-      code = $stdin.read
-      code = "class Example; def example; #{code}; end; end" if $f
-      eval code unless code.nil?
-    else
-      require name
-    end
-  end
-end
-
-result = ParseTree.new.parse_tree(*new_classes)
-
-result = result[0][3][2][1][2..-1] if $f
-
-unless defined? $q then
-  pp result
-else
-  p result
-end
-

data/vendor/ParseTree-1.7.1-patched/demo/printer.rb

@@ -1,20 +0,0 @@
-#!/usr/local/bin/ruby -w
-require 'rubygems'
-require 'sexp_processor'
-
-class QuickPrinter < SexpProcessor
-  def initialize
-    super
-    self.strict = false
-    self.auto_shift_type = true
-  end
-  def process_defn(exp)
-    name = exp.shift
-    args = process exp.shift
-    body = process exp.shift
-    puts "  def #{name}"
-    return s(:defn, name, args, body)
-  end
-end
-
-QuickPrinter.new.process(*ParseTree.new.parse_tree(QuickPrinter))

data/vendor/ParseTree-1.7.1-patched/lib/composite_sexp_processor.rb

@@ -1,49 +0,0 @@
-require 'sexp_processor'
-
-##
-# Implements the Composite pattern on SexpProcessor. Need we say more?
-#
-# Yeah... probably. Implements a SexpProcessor of SexpProcessors so
-# you can easily chain multiple to each other. At some stage we plan
-# on having all of them run +process+ and but only ever output
-# something when +generate+ is called, allowing for deferred final
-# processing.
-
-class CompositeSexpProcessor < SexpProcessor
-
-  ##
-  # The list o' processors to run.
-
-  attr_reader :processors
-
-  def initialize # :nodoc:
-    super
-    @processors = []
-  end
-
-  ##
-  # Add a +processor+ to the list of processors to run.
-
-  def <<(processor)
-    raise ArgumentError, "Can only add sexp processors" unless
-      SexpProcessor === processor
-    @processors << processor
-  end
-
-  ##
-  # Run +exp+ through all of the processors, returning the final
-  # result.
-
-  def process(exp)
-    @processors.each do |processor|
-      exp = processor.process(exp)
-    end
-    exp
-  end
-
-  def on_error_in(node_type, &block)
-    @processors.each do |processor|
-      processor.on_error_in(node_type, &block)
-    end
-  end
-end