code_web 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 348410cac5f689ca660f4ee7da0d02186f648d2f
+  data.tar.gz: 9e4579dc7394db036a31bea93ebf50573daf6200
+SHA512:
+  metadata.gz: 5008e3f84eaede9442dcda953b4e341132ffd0d70f02b74a406583d8b89c45870cd8c62a34eb5d4e9e8052189b3d00a4be9d4c23c6537890ee909d6917a68a81
+  data.tar.gz: d42b1b115616040c5a772cb5e60733e99626c8fe6cd205e7955dcde0cbee94f4d38e325f65a4d52d6ea07a18de452e63df515afefb294c4291416fc1243ebc2a

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in code_web.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+MIT License
+
+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/README.md

@@ -0,0 +1,85 @@
+# CodeWeb
+
+This uses ruby parser to read code and find references.
+Works best when looking for finding static methods that possibly span multiple lines
+
+It generates an html file with the list of each method and the invocations.
+Each reference has a url to the place in code where it is found.
+
+The urls use textmate url format, which also works with sublime.
+I use lincastor on my machine to wire the urls to the actual editor, so any program
+will do.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'code_web'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install code_web
+
+## Usage
+
+    # if you find the reference in a file named miq_queue.rb, then color the url with #999
+    # if you find the reference in a file with the director tools, then color the url with #ccc 
+    # look for the class name MiqQueue
+    # look in the directories app, tools, and lib
+    # output the report to miq_queue.html (in html format)
+
+    $ code_web -p 'miq_queue.rb$=#999' -p 'tools/=#ccc' 'MiqQueue\b' app tools lib -o miq_queue.html
+
+## Url handline
+
+Currently, this generates urls using the textmate file protocol.
+
+I use [LinCastor] to map the url to my editor of choice, sublime.
+But there are many tools that will do this for you.
+LinCastor has worked for many many years, including my current version, 10.12.3
+
+I use the following script to wire it together:
+
+[LinCastor]: https://onflapp.wordpress.com/lincastor/
+
+```ruby
+#!/usr/bin/ruby
+
+# Parse a url according to 
+# http://blog.macromates.com/2007/the-textmate-url-scheme/
+# opens the file
+
+SUBL_PATH="/Applications/Sublime Text.app"
+SUBL_BIN_PATH="#{SUBL_PATH}/Contents/SharedSupport/bin/subl"
+
+#require 'logger'
+require 'uri'
+require 'cgi'
+
+#DEBUG = Logger.new(File.open("#{ENV['HOME']}/sublime_cmd.txt", File::WRONLY | File::APPEND|File::CREAT))
+
+subl_url=ENV['URL']
+p=CGI.parse(URI.parse(subl_url).query)
+subl_file="#{p["url"].first[7..-1]}:#{p["line"].first}"
+
+#DEBUG.info(subl_file)
+
+ret=`"#{SUBL_BIN_PATH}" "#{subl_file}"`
+#DEBUG.info("#{SUBL_BIN_PATH} #{subl_file}")
+#DEBUG.info("/handle_url")
+
+exit 0 # the handler has finished successfully
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/code_web.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'code_web/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "code_web"
+  spec.version       = CodeWeb::VERSION
+  spec.authors       = ["Keenan Brock"]
+  spec.email         = ["keenan@thebrocks.net"]
+  spec.description   = %q{Display the web of method calls in an app}
+  spec.summary       = %q{Display methods}
+  spec.homepage      = "http://github.com/kbrock/code_web"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ruby_parser"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/exe/code_web

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'code_web'
+require 'code_web/cli'
+
+CodeWeb::CLI.parse(ARGV)

data/lib/code_web/cli.rb

@@ -0,0 +1,101 @@
+require 'optparse'
+
+module CodeWeb
+  class CLI
+    def self.parse(args)
+      new(args).run
+    end
+
+    attr_accessor :code_parser
+    def method_calls ; code_parser.method_calls ; end
+    def files_parsed ; code_parser.file_count ; end
+    def arg_regex ; code_parser.arg_regex ; end
+    def method_regex=(val) ; code_parser.method_regex = val ; end
+    def arg_regex=(val) ; code_parser.arg_regex = val ; end
+    def exit_on_error=(val) ; code_parser.exit_on_error = val ; end
+    def verbose=(val) ; code_parser.verbose = val ; end
+    def debug=(val) ; code_parser.debug = val ; end
+    def debug? ; code_parser.debug? ; end
+
+    # @attribute report_generator [rw]
+    #   @return class that runs the report (i.e.: TextReport, HtmlReport) 
+    attr_accessor :report_generator
+
+    # @attribute class_map
+    #   @return [Map<Regexp,html_class>] files/directories with specal emphasis
+    attr_accessor :class_map
+
+    # @attribute arguments [r]
+    #   @return [Array<String>] command line arguments
+    attr_accessor :arguments
+
+    # @attribute filenames [rw]
+    #   @return [Array<String>] regular expression filenames
+    attr_accessor :filenames
+
+    attr_accessor :output
+
+    def initialize(arguments)
+      @arguments = arguments
+      @code_parser = CodeWeb::CodeParser.new
+      @class_map = {}
+    end
+
+    def run
+      parse_arguments
+      parse_files
+      display_results
+    end
+
+    def parse_arguments
+      #defaults
+      self.report_generator = ::CodeWeb::HtmlReport
+      self.output = STDOUT
+
+      #parsing the command line
+      OptionParser.new do |opt|
+        opt.banner = "Usage: code_web regex [file_name ...]"
+#       opt.on('-n', '--requests=count',   Integer, "Number of requests (default: #{requests})")  { |v| options[:requests] = v }
+        opt.on('-t', '--text',                      'Use text reports')                           { |v| self.report_generator = ::CodeWeb::TextReport }
+        opt.on('-a', '--arg ARG_REGEX',             'Only files with hash argument')              { |v| self.arg_regex = Regexp.new(v) }
+        opt.on('-o', '--output FILENAME',           'Output filename')                            { |v| self.output = (v == '-') ? STDOUT : File.new(v,'w') }
+        opt.on('-e', '--error-out',                 'exit on unknown tags')                       { |v| self.exit_on_error = true}
+        opt.on('-V', '--verbose',                   'verbose parsing')                            { |v| self.verbose = true}
+        opt.on('-D', '--debug',                     'debug parsing')                              { |v| self.debug = true}
+        opt.on('-p', '--pattern FILENAME_REGEX=COLOR','color to emphasize a file')                { |v| v = v.split('=') ; self.class_map[Regexp.new(v.first)] = v.last }
+        opt.on('--byebug') { require "byebug" }
+        opt.on('--pry') { require "pry" }
+        opt.on_tail("-h", "--help", "Show this message")                                          { puts opt ; exit }
+        opt.on_tail("-v", "--version", "Show version_information")                                { puts "Code Web version #{CodeWeb::VERSION}" ; exit }
+        opt.parse!(arguments)
+
+        if arguments.length == 0
+          puts opt
+          exit
+        end
+      end
+      self.method_regex = Regexp.new(arguments[0])
+      self.filenames = arguments[1..-1] || "."
+    end
+       
+    def parse_files
+      filenames.each do |arg|
+        arg = "#{arg}/**/*.rb" if Dir.exists?(arg)
+        if File.exist?(arg)
+          puts arg if debug?
+          code_parser.parse arg
+        else
+          Dir[arg].each do |file_name|
+            puts arg if debug?
+            code_parser.parse(file_name)
+          end
+        end
+      end
+    end
+
+    def display_results
+      STDOUT.puts "parsed #{files_parsed} files"
+      report_generator.new(method_calls, class_map, arg_regex, output).report
+    end
+  end
+end

data/lib/code_web/code_parser.rb

@@ -0,0 +1,229 @@
+require 'ruby_parser'
+
+module CodeWeb
+  class CodeParser
+    extend Forwardable
+    SPACES = Hash.new {|h, n| h[n] = "  " * n.to_i }
+
+    attr_accessor :method_cache
+    attr_accessor :file_count
+    attr_accessor :exit_on_error
+    attr_accessor :debug
+    attr_accessor :verbose
+    def verbose? ; @verbose ; end
+    def debug? ; @debug ; end
+    def_delegators :@method_cache, :method_regex=, :arg_regex=, :arg_regex, :method_calls
+
+    def initialize
+      @cur_method=[]
+      @indent = 0
+      @file_count = 0
+      @exit_on_error = false
+      @method_cache = CodeWeb::MethodCache.new
+    end
+
+    def traverse(ast, has_yield=false)
+      puts "#{spaces}||#{collapse_ast(ast,1)}||" if verbose?
+      puts src if ast.nil?
+      case ast.node_type
+      #dstr = define string ("abc#{here}"),
+      #evstr evaluate string (#{HERE})
+      #attrasgn = attribute assignment
+      when :block, :if, :ensure, :rescue, :case, :when, :begin,
+           :while, :until, :defined, :resbody, :match2, :match3, :dot2, :dot3,
+           :dstr, :evstr, :dsym, :dregx, :hash, :array, :return, :and, :or,
+           :next, :to_ary, :splat, :block_pass, :until, :yield,
+           /asgn/, :ivar, :arglist, :args, :kwarg, :kwargs, :kwsplat, :zsuper, :not, #statements[]
+           :super, :xstr, :for, :until, :dxstr, 
+      #these end up being no-ops:
+           :lit, :lvar, :const, :str, :nil, :gvar, :back_ref,
+           :true, :false, :colon2, :colon3, :next, :alias,
+           :nth_ref, :sclass, :cvdecl, :break, :retry, :undef,
+      #random
+           :svalue, :cvar
+        traverse_nodes(ast, 1..-1)
+      when :self
+        traverse_nodes(ast, 1..-1)
+      when :module, #name, statements[]
+           :class #name, parent, statements[]
+        in_context ast[1], true, true do
+          traverse_nodes(ast, 2..-1)
+        end
+      when :cdecl, #name, statements[]
+           :defn #name, args[], call[]
+        in_context ast[1], true do
+          traverse_nodes(ast, 2..-1)
+        end
+      when :defs #self[], name, args[], call[] # static method
+        in_context ast[2], :static do
+          traverse_nodes(ast, 2..-1)
+        end
+      when :iter #call[], yield_args[], yield_{block|call}[]
+        traverse(ast[1], :has_yield)
+        in_context 'yield', true do
+          traverse_nodes(ast, 2..-1)
+        end
+      when :call # object, statement? || const symbol, args
+        handle_method_call(ast, has_yield)
+        traverse_nodes(ast, 1..-1)
+      else
+        STDERR.puts "#{src}\n  unknown node: #{ast.node_type} #{collapse_ast(ast,1)}"
+        if exit_on_error
+          if defined?(Pry)
+            binding.pry
+          elsif defined?(Byebug)
+            byebug
+          end
+          raise "error"
+        end
+        traverse_nodes(ast, 1..-1)
+      end
+    end
+
+    def traverse_nodes(ast, *ranges)
+      ranges = [0..-1] if ranges.empty?
+      ranges.each do |range|
+        ast[range].each do |node|
+          should_call = node.is_a?(Sexp)
+          traverse(node) if should_call
+        end
+      end
+    end
+
+    def handle_method_call(ast, is_yield=false)
+      method_name = method_name_from_ast(ast[1..2])
+      args = ast[3..-1].map {|arg| collapse_ast(arg,1)}
+
+      mc = MethodCall.new(ast.file, ast.line, method_name, args, is_yield)
+      method_cache << mc
+      puts mc.to_s(spaces) if debug? # && method_cache.detect?(mc)
+    end
+
+    def method_name_from_ast(ast)
+      ast.map { |node|
+        collapse_ast(node)
+      }.compact
+    end
+
+    #TODO: add collapse_ast
+    # this one creates the true classes, not the string versions
+    # (so don't add double quotes, or do 'nil')
+    def collapse_ast(ast, max=20)
+      if ast.is_a?(Sexp)
+        if static?
+          ast = ast.gsub(Sexp.new(:self), Sexp.new(:const, self_name))
+        else
+          ast = ast.gsub(Sexp.new(:call, Sexp.new(:self),:class), Sexp.new(:const, self_name))
+        end
+        case ast.node_type
+        when :hash #name, value, name, value, ...
+          if ast[1].is_a?(Sexp) && ast[1].node_type == :kwsplat
+            ast[1..-1].map { |i| collapse_ast(i) }
+          else
+            Hash[*ast[1..-1].map { |i| collapse_ast(i) }]
+          end
+        when :array
+          ast[1..-1].map {|node| collapse_ast(node)}
+        when :lit, :lvar, :const, :str, :ivar, :cvar
+          ast[1]
+        when :true
+          true
+        when :false
+          false
+        when :nil
+          nil
+        when :self
+          ast[0]
+        when :call
+          if ast[2] == :[]
+            "#{method_name_from_ast(ast[1..1]).join('.')}[#{collapse_ast(ast[3])}]"
+          else
+            "#{method_name_from_ast(ast[1..2]).join('.')}#{'(...)' if ast.length > 3}"
+          end
+        when :evstr
+          "#"+"{#{collapse_asts(ast[1..-1]).join}}"
+        when :colon2
+          "#{method_name_from_ast(ast[1..-1]).join('::')}"
+        when :dot2
+          "#{collapse_ast(ast[1])}..#{collapse_ast(ast[2])}"
+        when :colon3
+          "::#{collapse_asts(ast[1..-1]).join}"
+        when :[]
+          "[#{collapse_asts(ast[1..-1]).join}]"
+        when :dstr
+          "#{collapse_asts(ast[1..-1]).join}"
+        #backref?
+        else
+          if max > 0
+            ast.map {|node| collapse_ast(node, max-1)}
+          else
+            "#{ast.node_type}[]"
+          end
+        end
+      elsif ast.nil?
+        nil
+      else
+        ast
+      end
+    end
+
+    def collapse_asts(ast, max=20)
+      ast.map {|node| collapse_ast(node)}
+    end
+
+    def parse(file_name, file_data=nil, required_string=nil)
+      #may make more sense to get this into cli (and an option for absolute path)
+      file_name = File.realpath(file_name)
+      file_data ||= File.binread(file_name)
+      begin
+        if required_string.nil? || file_data.include?(required_string)
+          in_context file_name do
+            traverse RubyParser.new.process(file_data, file_name)
+          end
+        end
+        @file_count += 1
+      rescue => e
+        STDERR.puts("#{e}: [#{file_data.size}] #{file_name}")
+      end
+    end
+
+    private
+
+    # where in the source are we?
+    def src
+      "#{@cur_method.first.first} | #{@cur_method.map(&:first)[1..-1].join('.')}"
+    end
+
+    # return nil if we haven't hit a class yet
+    def self_name
+      #cm[1] == true for module/class definitions
+      node=@cur_method.select {|cm| cm[1] == true}.last
+      node.first unless node.nil?
+    end
+
+    def static?
+      @cur_method.last.last
+    end
+
+    # mark the context of the method call.
+    # optionally indents output as well
+    # @param name [String] name of the block - file, module, class, method, 'yield'
+    # @param indent [boolean] (false) indent this block (pass :static if this is a static method)
+    # @param class_def [boolean] (false) true if this is a class definition
+    def in_context name, indent=false, class_def=false
+      name = collapse_ast(name) #split("::").last
+      @cur_method << [ name, class_def, indent == :static]
+      puts ">> #{'self.' if static?}#{src}" if debug? && indent
+      @indent += 1 if indent
+      ret = yield
+      @indent -= 1 if indent
+      @cur_method.pop
+      ret
+    end
+
+    #print appropriate # of spaces
+    def spaces
+      SPACES[@indent]
+    end
+  end
+end

data/lib/code_web/html_report.rb

@@ -0,0 +1,157 @@
+require 'set'
+require 'erb'
+
+module CodeWeb
+  class HtmlReport
+    # @!attribute :method_calls [r]
+    #   list of all the method_Calls
+    #   @return [Array<MethodCall>]
+    attr_accessor :method_calls
+    attr_accessor :arg_regex
+    def arg_regex? ; ! arg_regex.nil? ; end
+
+    # @!attribute :class_map [rw]
+    #   map from regex to class name
+    #   if the filename that has the method matches the regex, the classname
+    #     will get assigned to the link (to emphasize certain files/directories)
+    #   @return [Map<Regexp,color>] regex expressing name of main file
+    attr_accessor :class_map
+
+    def initialize(method_calls, class_map={}, arg_regex=nil, out=STDOUT)
+      @method_calls = method_calls
+      @class_map = class_map
+      @arg_regex = arg_regex
+      @out = out
+    end
+
+    TEMPLATE=%{
+<html>
+<head><style>
+table {border-collapse:collapse;}
+table, td, th { border:1px solid black;  }
+<%- @class_map.each_with_index do |(pattern, color), i| -%>
+.f<%=i%>, a.f<%=i%> { color: <%=color%>; }
+<%- end -%>
+</style>
+</head>
+<body>
+<%- methods_by_name.each do |methods| -%>
+  <h2><%=methods.name%></h2>
+  <%- methods.group_by(:hash_args?).each do |methods_with_hash| -%>
+    <%- if methods_with_hash.hash_args? -%>
+      <%- methods_with_hash.group_by(:method_types).each do |methods_with_type| -%>
+        <%- display_yield_column = methods_with_type.detect(&:yields?) -%>
+        <table>
+        <thead><tr>
+          <%- methods_with_type.arg_keys.each do |arg| -%>
+            <td><%=arg%></td>
+          <%- end -%>
+          <%- if display_yield_column -%>
+          <td>yield?</td>
+          <%- end -%>
+          <td>ref</td>
+        </tr></thead>
+        <tbody>
+        <%- methods_with_type.group_by(:signature, arg_regex).each do |methods_by_signature| -%>
+          <tr>
+          <%- methods_with_type.arg_keys.each do |arg| -%>
+            <td><%= simplified_argument(methods_by_signature.hash_arg[arg]) %></td>
+          <%- end -%>
+            <%- if display_yield_column -%>
+            <td><%= methods_by_signature.f.yields? %></td>
+            <%- end -%>
+            <td><%- methods_by_signature.each_with_index do |method, i| -%>
+                <%= method_link(method, i+1) %>
+            <%- end -%></td>
+          </tr>
+        <%- end -%>
+        </tbody>
+        </table>
+      <%- end -%>
+    <%- else -%>
+      <table>
+      <tbody>
+      <%- methods_with_hash.group_by(:method_types).each do |methods_with_type| -%>
+        <%- display_yield_column = methods_with_type.detect(&:yields?) -%>
+        <%- methods_with_type.group_by(:signature, nil, :small_signature).each do |methods_by_signature| -%>
+          <tr>
+          <%- methods_by_signature.f.args.each do |arg| -%>
+            <td><%= arg.inspect %></td>
+          <%- end -%>
+          <%- if display_yield_column -%>
+            <td><%= methods_by_signature.f.yields? ? 'yields' : 'no yield'%></td>
+          <%- end -%>
+            <td><%- methods_by_signature.each_with_index do |method, i| -%>
+                <%= method_link(method, i+1) %>
+            <%- end -%></td>
+          </tr>
+        <%- end -%>
+      <%- end -%>
+      </tbody>
+      </table>
+    <%- end -%>
+  <%- end -%>
+
+<%- end -%>
+</body>
+</html>
+}
+
+    def report
+      template = ERB.new(TEMPLATE, nil, "-")
+      @out.puts template.result(binding)
+    rescue => e
+      e.backtrace.detect { |l| l =~ /\(erb\):([0-9]+)/ }
+      line_no=$1.to_i
+      raise RuntimeError, "error in #{__FILE__}:#{line_no+28} #{e}\n\n #{TEMPLATE.split(/\n/)[line_no-1]}\n\n ",
+        e.backtrace
+    end
+
+    # helpers
+
+    def methods_by_name
+      MethodList.group_by(method_calls, :short_method_name)
+    end
+
+    private
+
+    # shorten the argument
+    def simplified_argument(arg)
+      short_arg = case arg
+      when nil
+        nil
+      when String
+        arg.split("::").last[0..12]
+      else
+        arg.to_s[0..12]
+      end
+      %{<span title="#{html_safe(arg)}">#{short_arg}</span>}
+    end
+
+    def html_safe(str)
+      str.to_s.gsub('"','&quot;')
+    end
+
+    # @param collection [Array<Method>] methods (with a hash first argument)
+    # @return [Array<String>] list of all keys for all hashes
+    def all_hash_names(collection)
+      collection.inject(Set.new) {|acc, m| m.arg_keys.each {|k| acc << k} ; acc}.sort_by {|n| n}
+    end
+
+    # create a link to a method
+    # add a class if the method is in a particular file
+
+    def method_link(m, count=nil)
+      name = count ? "[#{count}]" : m.signature
+      class_name = nil
+      class_map.each_with_index do |(pattern, color), i|
+        if m.filename =~ pattern
+          class_name = "f#{i}"
+          break
+        end
+      end
+      #NOTE: may want to CGI::escape(m.filename)
+      %{<a href="subl://open?url=file://#{m.filename}&amp;line=#{m.line}" title="#{html_safe(m.signature)}"#{" class=\"#{class_name}\"" if class_name}>#{name}</a>}
+    end
+  end
+end