code_web 0.0.4

data/lib/code_web/method_cache.rb

@@ -0,0 +1,29 @@
+module CodeWeb
+  class MethodCache
+    # Map<String,Array<MethodCall>>
+    attr_accessor :method_calls
+
+    # only store the information on these methods
+    attr_accessor :method_regex
+    attr_accessor :arg_regex
+
+    def initialize(method_regex = nil)
+      @method_calls=[]
+      @method_regex = method_regex
+    end
+
+    def <<(mc)
+      @method_calls << mc if detect?(mc)
+    end
+
+    def detect?(mc)
+      (method_regex.nil? || mc.full_method_name =~ method_regex) &&
+        (
+          arg_regex.nil? || (
+            mc.hash_args? &&
+            mc.arg_keys.detect {|key| key =~ arg_regex }
+          )
+        )
+    end
+  end
+end

data/lib/code_web/method_call.rb

@@ -0,0 +1,116 @@
+module CodeWeb
+  # method call reference
+  class MethodCall
+    # file that has this method call
+    attr_accessor :filename
+    # line number that has this method
+    attr_accessor :line
+    # method name
+    attr_accessor :name
+    # what arguments are passed in
+    attr_accessor :args
+    alias :arguments :args
+    # is this calling a yield block
+    attr_accessor :is_yielding
+
+    def initialize(filename, line, name=nil, args=[], is_yielding=false)
+      @filename = filename
+      @line = line
+      @name = name
+      @args = sorted_hash(args)
+      @is_yielding = !! is_yielding
+    end
+
+    def args?
+      args && !args.empty?
+    end
+
+    def yields?
+      is_yielding
+    end
+
+    def method_types
+      args.map { |arg| arg_type(arg) }
+    end
+
+    def small_signature
+      [arg_type(args.first), args.size]
+    end
+
+    def signature
+      "#{full_method_name}(#{sorted_args.to_s})#{" yields" if is_yielding}"
+    end
+
+    def short_method_name
+      Array(name).last
+    end
+
+    def full_method_name
+      Array(name).compact.join(".")
+    end
+
+    def short_filename
+      filename.split("/").last if filename
+    end
+
+    def sorted_args(hash=@args)
+      hash.map {|arg| sorted_hash(arg) }.join(", ")
+    end
+
+    def sorted_hash(args)
+      case args
+      when Hash
+        args.each_pair.sort_by {|n,v| n }.inject({}) {|h, (n,v)| h[n]=sorted_hash(v); h}
+      when Array
+        args
+      else
+        args
+      end
+    end
+
+    def hash_args?
+      args.first.class == Hash
+    end
+
+    def args_size
+      args.size
+    end
+
+    def hash_arg
+      args.first
+    end
+
+    def arg_keys
+      args.first.keys
+    end
+
+    def ==(other)
+      other &&
+        other.name == @name &&
+        other.args == @args &&
+        other.is_yielding == @is_yielding
+    end
+
+    # used by debugging (not sure if this should be signature)
+    def to_s(spaces = '')
+      "#{spaces}#{full_method_name}(#{args.map{|arg|arg.inspect}.join(", ")})#{" do" if is_yielding}"
+    end
+
+    private
+
+    def arg_type(arg)
+      case arg
+      when Array
+        '[]'
+      when Hash
+        '{}'
+      when nil
+        "nil"
+      when Symbol
+        ':'
+      else
+        'str'
+      end
+    end
+  end
+end

data/lib/code_web/method_list.rb

@@ -0,0 +1,60 @@
+require 'forwardable'
+#collection of similar method calls
+module CodeWeb
+  class MethodList
+    extend Forwardable
+    include Enumerable
+
+    # what was used in the group by
+    attr_accessor :name
+    # the collection (actually [[k,[v1,v2]],[k2,[v1,v2]]])
+    attr_accessor :collection
+
+    def initialize(name, collection)
+      @name = name
+      @collection = collection
+    end
+
+    def group_by(name, arg_regex=nil, sort_by = nil, &block)
+      if block.nil?
+        if arg_regex.nil?
+          block = Proc.new { |m| m.send(name).to_s }
+        else
+          block = Proc.new {|m|
+            if m.hash_args?
+              m.hash_arg.collect {|n,v| v if n =~ arg_regex}.compact.join(" ")
+            else
+              m.signature
+            end
+          }
+        end
+      end
+      MethodList.new(name, collection.group_by(&block).sort_by {|n, ms| sort_by ? ms.first.send(sort_by) : n })
+    end
+
+    def f
+      collection.first
+    end
+
+    delegate [:detect, :each_with_index, :count] => :collection
+    delegate [:args_size, :hash_arg, :hash_args?] => :f
+
+    def detect(&block)
+      collection.detect(&block)
+    end
+
+    def each(&block)
+      collection.each do |n, c|
+        yield MethodList.new(n,c)
+      end
+    end
+
+    def arg_keys
+      @arg_keys ||= collection.inject(Set.new) {|acc, m| m.arg_keys.each {|k| acc << k} ; acc}.sort_by {|n| n}
+    end
+
+    def self.group_by(collection, name)
+      MethodList.new(nil, collection).group_by(name)
+    end
+  end
+end

data/lib/code_web/text_report.rb

@@ -0,0 +1,41 @@
+module CodeWeb
+  class TextReport
+    # @!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
+
+    def initialize(method_calls, class_map=nil, arg_regex=nil, out=STDOUT)
+      @method_calls = method_calls
+      @arg_regex = arg_regex
+      @out = out
+    end
+    
+    def report
+      methods_by_name.each do |methods|
+        @out.puts "---- #{methods.name} ----"
+        methods.group_by(:signature, arg_regex).each do |methods_with_signature|
+          if arg_regex?
+            @out.puts " --> #{arg_regex.inspect}=#{methods_with_signature.name}"
+          else
+            @out.puts " --> #{methods_with_signature.name}"
+          end
+          methods_with_signature.each_with_index do |method, i|
+            @out.puts
+            @out.puts method.signature
+            @out.puts "#{method.filename}:#{method.line}"
+          end
+          @out.puts
+          @out.puts
+        end
+        @out.puts
+      end
+    end
+
+    def methods_by_name
+      MethodList.group_by(method_calls, :short_method_name)
+    end
+  end
+end

data/lib/code_web/version.rb

@@ -0,0 +1,3 @@
+module CodeWeb
+  VERSION = "0.0.4"
+end

data/lib/code_web.rb

@@ -0,0 +1,11 @@
+require "code_web/version"
+
+module CodeWeb
+end
+
+require 'code_web/method_call'
+require 'code_web/method_list'
+require 'code_web/method_cache'
+require 'code_web/code_parser'
+require 'code_web/text_report'
+require 'code_web/html_report'

data/spec/code_parser_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+#$debug=true
+#$verbose=true
+describe CodeWeb::CodeParser do
+
+  context "method call" do
+    it 'should add a method' do
+      subject << CodeWeb::MethodCall.new(nil, "puts", ['"x"'], false )
+      expect(method_calls('puts')).to eq([
+        meth('puts',['"x"'])
+      ])
+    end
+
+    it 'should support basic method call' do
+      parse %{puts}
+      expect(method_calls('puts')).to eq([
+        meth('puts',[])
+      ])
+    end
+
+    it 'should support method call with arguments' do
+      parse %{puts "x", :y, true, false}
+      expect(method_calls('puts')).to eq([
+        meth('puts',['"x"', :y, :true, :false])
+      ])
+    end
+
+    it 'should support method calls with hash arguments' do
+      parse %{puts(a:5, "b" => 3)}
+      expect(method_calls('puts')).to eq([
+        meth('puts',{:a => 5, "b" => 3})
+        ])
+    end
+
+    it 'should support method call ob objects' do
+      parse %{y.puts "x"}
+      expect(method_calls('y.puts')).to eq([
+        meth('y.puts',['"x"'])
+      ])
+    end
+
+    #NOTE the chaining isn't perfect
+    it "should support method chaining" do
+      parse "x(a:5).y().z(5)"
+      expect(method_calls('x')).to eq([
+        meth('x', [{a:5}])
+      ])
+
+      expect(method_calls('x(...).y')).to eq([
+        meth('x(...).y')
+      ])
+
+      expect(method_calls('x(...).y.z')).to eq([
+        meth('x(...).y.z',[5])
+      ])
+    end
+
+    it 'should support method calls with method calls' do
+      parse "a(b(5))"
+      expect(method_calls('b')).to eq([
+        meth('b',[5])
+      ])
+      expect(method_calls('a')).to eq([
+        meth('a','b(...)')
+      ])
+    end
+  end
+
+  context 'blocks' do
+    it 'should support if blocks' do
+      parse "if a(5) ; b(5) ; else c(5) ; end"
+      expect(method_calls('a')).to eq([
+        meth('a',[5])
+      ])
+      expect(method_calls('b')).to eq([
+        meth('b',[5])
+      ])
+      expect(method_calls('c')).to eq([
+        meth('c',[5])
+      ])
+    end
+
+    it 'should support yield blocks' do
+      parse "a(5) { |x| b(x) }"
+      expect(method_calls('a')).to eq([
+        meth('a',[5], true)
+      ])
+      expect(method_calls('b')).to eq([
+        meth('b',[:x], false)
+      ])
+    end
+
+    it 'should support rescue blocks' do
+      parse %{
+        begin
+          a(5)
+        rescue => e
+          b(5)
+        ensure
+          c()
+        end
+      }
+      expect(method_calls('a')).to eq([
+        meth('a',[5])
+      ])
+      expect(method_calls('b')).to eq([
+        meth('b',[5])
+      ])
+      expect(method_calls('c')).to eq([
+        meth('c')
+      ])
+    end
+
+    it 'should support rescue blocks' do
+      parse "begin ; a(5) ; rescue ; b(5) ; end"
+      expect(method_calls('a')).to eq([
+        meth('a',[5])
+      ])
+      expect(method_calls('b')).to eq([
+        meth('b',[5])
+      ])
+    end
+
+    it 'should support rescue inline' do
+      parse "a(5) rescue b(5)"
+      expect(method_calls('a')).to eq([
+        meth('a',[5])
+      ])
+      expect(method_calls('b')).to eq([
+        meth('b',[5])
+      ])
+    end
+  end
+
+  context 'variables' do
+    it "should support global variables" do
+      parse %{$x=puts}
+      expect(method_calls('puts')).to eq([
+        meth('puts')
+        ])
+    end
+    it "should support global variable fetch" do
+      parse %{$x = puts}
+      expect(method_calls('puts')).to eq([
+        meth('puts')
+      ])
+    end
+    it "should support constants" do
+      parse %{
+        ABC=puts
+        Class::ABC.runx
+      }
+      expect(method_calls('puts')).to eq([
+        meth('puts')
+      ])
+      expect(method_calls('Class.ABC.runx')).to eq([
+        meth('Class.ABC.runx')
+      ])
+    end
+  end
+
+  it 'should parse modules' do
+    parse %{
+      module X
+        ABC=abc()
+        def method1
+          @module_var=mod1()
+        end
+        def method2
+          @@module_var=mod2()
+        end
+        def method3
+          return mod3()
+        end
+      end
+    }
+    expect(method_calls('abc')).to eq([
+      meth('abc')
+    ])
+    expect(method_calls('mod1')).to eq([
+      meth('mod1')
+    ])
+    expect(method_calls('mod2')).to eq([
+      meth('mod2')
+    ])
+    expect(method_calls('mod3')).to eq([
+      meth('mod3')
+    ])
+
+  end
+  it 'should support class' do
+    parse %{
+      module X
+        attr_accessor :var
+        class Class1
+          def method1
+            @var=m1(5)
+          end
+        end
+        class Class2 < Class1
+          def method2
+            var=m2()
+          end
+        end
+      end
+    }
+    expect(method_calls('m1')).to eq([
+      meth('m1',[5])
+    ])
+    expect(method_calls('m2')).to eq([
+      meth('m2')
+    ])
+  end
+
+  it "should interpolate strings" do
+    parse 'puts "abc#{subf()}"'
+    expect(method_calls('subf')).to eq([
+      meth('subf')
+    ])
+  end
+
+  it "should support logic" do
+    parse 'a() && b() || c() and d() or e()'
+    %w(a b c d e).each do |method_name|
+      expect(method_calls(method_name)).to eq([
+        meth(method_name)
+      ])
+    end
+  end
+
+  private
+
+  def method_calls(method_name=nil)
+    if method_name
+      subject.method_calls.select { |mc| mc.full_method_name =~ /#{method_name}/ }
+    else
+      subject.method_calls
+    end
+  end
+
+  def parse(body, require_string=nil)
+    test_method_name = caller[0].split(':').first #[0..1].join(':')
+    subject.parse(test_method_name, body, require_string)
+  end
+
+  def meth(name, args=[], is_yield=false, source = __FILE__)
+    name = [name.to_sym] if name.is_a?(String)
+    args = [args] unless args.is_a?(Array)
+    CodeWeb::MethodCall.new(source, 1, name, args, is_yield)
+  end
+end

data/spec/method_cache_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe CodeWeb::MethodCache do
+  describe "#<<" do
+    context "with default regex" do
+      it { expect(subject.method_calls).to be_empty }
+      context "with method" do
+        before { subject << methodcall }
+        it { expect(subject.method_calls.size).to eq(1) }
+      end
+    end
+
+    context "with regex" do
+      subject { described_class.new(/good/)}
+      context "with matching regex" do
+        before { subject << methodcall("goodone") }
+        it { expect(subject.method_calls.size).to eq(1) }
+      end
+      context "with non-matching regex" do
+        before { subject << methodcall("badone") }
+        it { expect(subject.method_calls.size).to eq(0) }
+      end
+    end
+  end
+
+  def methodcall(name = "method", args = [])
+    CodeWeb::MethodCall.new("file.rb", 5, name, args)
+  end
+end

data/spec/method_call_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe CodeWeb::MethodCall do
+  subject { described_class }
+  it "should compare" do
+    expect(meth('puts', ['a', 'b'])).to eq(meth('puts',['a','b'], false, ['sample.rb']))
+  end
+
+  describe "#args?" do
+    it { expect(meth("method", nil)).not_to be_args}
+    it { expect(meth("method", [])).not_to be_args}
+    it { expect(meth("method", [:a])).to be_args}
+    it { expect(meth("method", [:a => 'a'])).to be_args}
+  end
+
+  describe "#yields?" do
+    it { expect(meth("method", [], false)).not_to be_yield }
+    it { expect(meth("method", [], true)).to be_yield }
+  end
+
+  describe "#method_types" do
+    it { expect(meth("method", [%w(a b), {'a' => 'b'}, nil, :a, 'b']).method_types).to eq(%w([] {} nil : str)) }
+  end
+
+  describe "#small_signature" do
+    it { expect(meth("method", [%w(a b)]).small_signature).to eq(["[]", 1]) }
+    it { expect(meth("method", [[], [], []]).small_signature).to eq(["[]", 3]) }
+    it { expect(meth("method", [{}, []]).small_signature).to eq(["{}", 2]) }
+    it { expect(meth("method", []).small_signature).to eq(["nil", 0]) }
+  end
+
+  describe "#signature" do
+    it { expect(meth("method", [%w(a b)]).signature).to eq("method(a, b)") }
+    #it { expect(meth("method", [[], [], []]).signature).to eq("method([],[],[])")}
+    # it { expect(meth("method", [{}, []]).signature).to eq("method({})") }
+    # it { expect(meth("method", []).signature).to eq("method(nil)") }
+    # it { expect(meth("method", [%w(a b), :other, :a => b]).signature).to eq("method(a, b)") }
+  end
+
+  context "sorted_args" do
+    it "should not tack on [] to base args" do
+      expect(meth('name',['a','b']).sorted_args.to_s).to eq('a, b')
+    end
+
+    it "should handle sub arrays" do
+      expect(meth.sorted_hash(['b']).to_s).to eq('["b"]')
+    end
+
+    it "should handle hash" do
+      expect(meth.sorted_hash(b:5, a:3).to_s).to eq('{:a=>3, :b=>5}')
+    end
+  end
+
+  context "method_type" do
+    # a string, a constant - same thing
+    it "should handle strings" do
+      expect(meth('name',['a']).method_types).to eq(['str'])
+    end
+    it "should handle arrays and hashes" do
+      expect(meth('name',[['a','b'], {'a' => 5}, 'x']).method_types).to eq(['[]','{}','str'])
+    end
+  end
+
+  private
+
+  def meth(name = "method", args=[], is_yield=false, source = "file1", line = 5)
+    CodeWeb::MethodCall.new(source, line, name, args, is_yield)
+  end
+end

data/spec/method_list_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe CodeWeb::MethodList do
+  let(:four) { described_class.new(nil, [meth("a",%w(a b c)), meth("a",%w(a b)), meth("b",%w(a b)), meth("b",%w(a))]) }
+
+  describe "#group_by" do
+    subject { four.group_by(:name) }
+    it { expect(four.group_by(:name).count).to eq(2) }
+    it { expect(four.group_by(:name).map { |m| m.f.name }).to eq(%w(a b)) }
+    it { expect(four.group_by(:args_size).map { |m| m.args_size }).to eq([1, 2, 3]) }
+  end
+
+  # "#group_by"
+  #detect
+  #each
+  describe "#count" do
+    it { expect(ml([meth("a"), meth("b")]).count).to eq(2) }
+  end
+  describe "#arg_keys" do
+    it { expect(ml([meth("method", [{a:5, b:5, c:5}]), meth("method", [{d:5}])]).arg_keys).to eq([:a, :b, :c, :d]) }
+  end
+
+  private
+
+  def ml(methods, name=nil)
+    described_class.new(name, methods)
+  end
+
+  def meth(name = "method", args=[], is_yield=false, source = "file1", line = 5)
+    CodeWeb::MethodCall.new(source, line, name, args, is_yield)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'code_web'
+
+begin
+  require 'pry'
+rescue LoadError
+end