virtual_keywords 0.1.0 → 0.3.0

data/lib/parsetree/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/lib/parsetree/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/lib/parsetree/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/lib/parsetree/bin/parse_tree_show

@@ -0,0 +1,63 @@
+#!/usr/local/bin/ruby -ws
+
+require 'pp'
+begin; require 'rubygems'; rescue LoadError; end
+require 'parse_tree'
+require 'sexp'
+
+$a ||= false
+$h ||= false
+$n ||= false
+$r ||= false
+$s ||= false
+$U ||= false
+$n = $n.intern if $n
+
+$u ||= ! ($U || $r)
+
+if $h then
+  puts "usage: #{File.basename $0} [options] [file...]"
+  puts "options:"
+  puts "-h      : display usage"
+  puts "-a      : all nodes, including newline"
+  puts "-n=node : only display matching nodes"
+  puts "-r      : raw arrays, no sexps"
+  puts "-s      : structural sexps, strip all content and show bare tree"
+  puts "-u      : unified sexps (now the default)"
+  puts "-U      : UNunified sexps"
+
+  exit 1
+end
+
+ARGV.push "-" if ARGV.empty?
+
+if $u then
+  require 'sexp_processor'
+  require 'unified_ruby'
+
+  class Unifier
+    include UnifiedRuby
+  end
+end
+
+parse_tree = ParseTree.new($a)
+unifier = Unifier.new if $u
+
+ARGV.each do |file|
+  ruby = file == "-" ? $stdin.read : File.read(file)
+
+  sexp = parse_tree.parse_tree_for_string(ruby, file).first
+  sexp = Sexp.from_array sexp unless $r
+  sexp = unifier.process(sexp) if $u
+  sexp = sexp.structure if $s
+
+  if $n then
+    sexp.each_of_type $n do |node|
+      p node
+    end
+  elsif defined? $q then
+    p sexp
+  else
+    pp sexp
+  end
+end

data/lib/parsetree/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/lib/parsetree/lib/gauntlet_parsetree.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/ruby -ws
+
+$f ||= false
+
+$:.unshift "../../ruby_parser/dev/lib"
+$:.unshift "../../ParseTree/dev/lib"
+
+require 'rubygems'
+require 'parse_tree'
+require 'ruby_parser'
+
+require 'gauntlet'
+
+class ParseTreeGauntlet < Gauntlet
+  def initialize
+    super
+
+    self.data = Hash.new { |h,k| h[k] = {} }
+    old_data = load_yaml data_file
+    self.data.merge! old_data
+  end
+
+  def should_skip? name
+    if $f then
+      if Hash === data[name] then
+        ! data[name].empty?
+      else
+        data[name]
+      end
+    else
+      data[name] == true # yes, == true on purpose
+    end
+  end
+
+  def diff_pp o1, o2
+    require 'pp'
+
+    File.open("/tmp/a.#{$$}", "w") do |f|
+      PP.pp o1, f
+    end
+
+    File.open("/tmp/b.#{$$}", "w") do |f|
+      PP.pp o2, f
+    end
+
+    `diff -u /tmp/a.#{$$} /tmp/b.#{$$}`
+  ensure
+    File.unlink "/tmp/a.#{$$}" rescue nil
+    File.unlink "/tmp/b.#{$$}" rescue nil
+  end
+
+  def broke name, file, msg
+    warn "bad"
+    self.data[name][file] = msg
+    self.dirty = true
+  end
+
+  def process path, name
+    begin
+      $stderr.print "  #{path}: "
+      rp = RubyParser.new
+      pt = ParseTree.new
+
+      old_ruby = File.read(path)
+
+      begin
+        pt_sexp = pt.process old_ruby
+      rescue SyntaxError => e
+        warn "unparsable pt"
+        self.data[name][path] = :unparsable_pt
+        self.dirty = true
+        return
+      end
+
+      begin
+        rp_sexp = rp.process old_ruby
+      rescue Racc::ParseError => e
+        broke name, path, e.message
+        return
+      end
+
+      if rp_sexp != pt_sexp then
+        broke name, path, diff_pp(rp_sexp, pt_sexp)
+        return
+      end
+
+      self.data[name][path] = true
+      self.dirty = true
+
+      warn "good"
+    rescue Interrupt
+      puts "User cancelled"
+      exit 1
+    rescue Exception => e
+      broke name, path, "    UNKNOWN ERROR: #{e}: #{e.message.strip}"
+    end
+  end
+
+  def run name
+    warn name
+    Dir["**/*.rb"].sort.each do |path|
+      next if path =~ /gemspec.rb/ # HACK
+      result = data[name][path]
+      next if result == true || Symbol === result
+      process path, name
+    end
+
+    if (self.data[name].empty? or
+        self.data[name].values.all? { |v| v == true }) then
+      warn "  ALL GOOD!"
+      self.data[name] = true
+      self.dirty = true
+    end
+  end
+end
+
+filter = ARGV.shift
+filter = Regexp.new filter if filter
+
+gauntlet = ParseTreeGauntlet.new
+gauntlet.run_the_gauntlet filter