rubyjs 0.7.0

data/vendor/ParseTree-1.7.1/Manifest.txt

@@ -0,0 +1,22 @@
+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/README.txt

@@ -0,0 +1,110 @@
+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/Rakefile

@@ -0,0 +1,41 @@
+# -*- 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/bin/parse_tree_abc

@@ -0,0 +1,89 @@
+#!/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/bin/parse_tree_audit

@@ -0,0 +1,28 @@
+#!/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/bin/parse_tree_deps

@@ -0,0 +1,62 @@
+#!/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/bin/parse_tree_show

@@ -0,0 +1,49 @@
+#!/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/demo/printer.rb

@@ -0,0 +1,20 @@
+#!/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/lib/composite_sexp_processor.rb

@@ -0,0 +1,49 @@
+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