let_it_go 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e07c3bf2d1c860ea3942429f6b70a9e0fff08e5
-  data.tar.gz: 331e78ae77329a8b96c32a38038f40e972a8b96c
+  metadata.gz: 42a5bb8aaa66d8aff49ee60864cb68e81acd8789
+  data.tar.gz: 762339fb4d4aa69b3b39d862cd1cb932244d021e
 SHA512:
-  metadata.gz: 4971320b95a2fd1fe09c37c1aa095d4090b9db878fb013ccf895bac610d6b76568a1c06dd4ab5ecc2c39b445fbd7df2a8262fd153bbf701f460ef46685ac4cb5
-  data.tar.gz: 79cb35ec9297cb9692a1cb33f5bb7f26351fefa8fb6f7e1aaad227fe1ed6b7ecd4dcb4740ed2433f08bc954f9759b2bb66c868df0943f2e7f676fb02f9b13b49
+  metadata.gz: c1145f8bd66dd5a0a8897d80467c0947f0cd7f2ef2f886f97d0660be6b65a6e72d4a02355070fa7fdb2b07844f8cd459fddd29265e01cdb1aea37f726e076dc9
+  data.tar.gz: 4640afbfe44d014fccefbabd2821bb7126ba9800c456b65f3ee95a47b0db4c18ac34684a0750c706b4e78726fb38af5a7ab3e7e5e9552bd79657a0a1454965d2

data/README.md

@@ -124,6 +124,23 @@ This extremely convoluted library works by watching all method calls using [Trac
 
 If you can think of a better way, please open up an issue and send me a proof of concept. I know what you're thinking and no, [programatically aliasing methods won't work for 100% of the time](http://stackoverflow.com/questions/30512945/programmatically-alias-method-that-uses-global-variable).
 
+Note: This method fails for any Ruby code that can't be parsed in 1 line. For example:
+
+```
+query = <<-SQL % known_coder_types.join(", ")
+```
+
+and
+
+```
+(attr[0] == :html && attr[1] == :attr && options[:hyphen_attrs].include?(attr[2]) &&
+```
+
+Are not valid, complete Ruby instructions. That being said this lib is still relevant. To see what you're not able to parse, run with `ENV['LET_IT_GO_RECORD_FAILED_CODE']`
+
+
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -141,8 +158,5 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## TODO
 
-- Count number of string literals * method calls instead of just method calls for methods that can take multiple string literals.
-- Display counts grouped by file then by line/method
-- Implicit methods i.e. 1 + 1 and [1] << 2
-- Global operators != && ==
-- Subclass support. Hook into a class created TracePoint to see if a class is a subclass and add it to the list
+- Global operators != && == (maybe it's good enough to only track calls to string)
+- Watch receivers such as "foo".eq(variable)

data/lib/let_it_go/caller_line.rb

@@ -0,0 +1,31 @@
+module LetItGo
+  # Given a single line from `caller` retrieves line_number, file_name
+  # and can read the contents of the file
+  class CallerLine
+    attr_accessor :line_number, :file_name
+    def initialize(string)
+      file_line       = string.split(":in `".freeze).first
+      file_line_array = file_line.split(":".freeze)
+
+      @line_number = file_line_array.pop
+      @file_name   = file_line_array.join(":".freeze) # name may have `:` in it
+    end
+
+    def contents
+      @contents ||= read || ""
+    end
+
+  private
+    def read
+      contents = ""
+      File.open(file_name).each_with_index do |line, index|
+        next unless index == Integer(line_number).pred
+        contents = line
+        break
+      end
+      contents
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/let_it_go/core_ext/string.rb

@@ -2,6 +2,7 @@
 LetItGo.watch_frozen(String, :+,       positions: [0])
 LetItGo.watch_frozen(String, :<<,      positions: [0])
 LetItGo.watch_frozen(String, :'<=>',     positions: [0])
+LetItGo.watch_frozen(String, :'==',     positions: [0])
 
 # Positions: 0
 

data/lib/let_it_go/method_call.rb

@@ -0,0 +1,85 @@
+require 'let_it_go/wtf_parser'
+
+module LetItGo
+  # Wraps logic that require knowledge of the method call
+  # can parse original method call's source and determine if a string literal
+  # was passed into the method.
+  class MethodCall
+    attr_accessor :klass, :method_name, :positions, :line_number, :file_name, :call_count
+
+    def initialize(klass: , method_name: , kaller:, positions: )
+      @klass        = klass
+      @method_name  = method_name.to_s
+      # Subclasses report method definition as caller.first via TracePoint
+      @key          = "Method: #{klass}##{method_name} [#{kaller.first(2).inspect}]"
+      @caller_lines = kaller.first(2).map {|kaller_line| CallerLine.new(kaller_line) }
+      @positions    = positions
+      @call_count   = 0
+    end
+
+    def count
+      call_count * string_allocation_count
+    end
+
+    def zero?
+      count.zero?
+    end
+
+    # Loop through each line in the caller and see if the method we're watching is being called
+    # This is needed due to the way TracePoint deals with inheritance
+    def method_array
+      @parser = nil
+      @caller_lines.each do |kaller|
+        code   = Ripper.sexp(kaller.contents)
+        code  ||= Ripper.sexp(kaller.contents.sub(/^\W*(if|unless)/, ''.freeze)) # if and unless "block" statements aren't valid one line ruby code
+        code  ||= Ripper.sexp(kaller.contents.sub(/do \|.*\|$/, ''.freeze)) # remove trailing do |thing| to make valid code
+        code  ||= Ripper.sexp(kaller.contents.sub(/(and|or)\W*$/, ''.freeze))# trailing and || or
+        code  ||= Ripper.sexp(kaller.contents.sub(/:\W*$/, ''.freeze)) # multi line ternary statements
+        code  ||= Ripper.sexp(kaller.contents.sub(/(^\W*)|({ \|?.*\|?)}/, ''.freeze)) # multi line blocks using {}
+
+        puts "LetItGoFailed parse (#{kaller.file_name}:#{kaller.line_number}: \n  \033[0;31m"+ kaller.contents.strip + "\e[0m".freeze if ENV['LET_IT_GO_RECORD_FAILED_CODE'] && code.nil? && kaller.contents.match(/"|'/)
+
+        parser = ::LetItGo::WTFParser.new(code, contents: kaller.contents)
+
+        if parser.each_method.any? { |m| m.method_name == method_name }
+          @line_number = kaller.line_number
+          @file_name   = kaller.file_name
+
+          @parser = parser
+          parser.each_method.each(&:arg_types)
+          break
+        else
+          next
+        end
+      end
+      @parser || []
+    end
+
+    def line_to_s
+      @line_to_s ||= contents_from_file_line(file_name, line_number)
+    end
+
+    def optimizable?
+      @optimizable ||= called_with_string_literal?
+    end
+
+    def string_allocation_count
+      @string_allocation_count
+    end
+
+    # Parses original method call location
+    # Determines if a string literal was used or not
+    def called_with_string_literal?
+      @string_allocation_count = 0
+      method_array.each do |m|
+        positions.each {|position| @string_allocation_count += 1 if m.arg_types[position] == :string_literal }
+      end
+      !@string_allocation_count.zero?
+    end
+
+    # Needs to be very low cost, cannot incur disk read
+    def key
+      @key
+    end
+  end
+end

data/lib/let_it_go/report.rb

@@ -0,0 +1,45 @@
+module LetItGo
+
+  # Turns hash of keys into a semi-inteligable sorted result
+  class Report
+    def initialize(hash_of_reports)
+      @hash = hash_of_reports.reject {|k, obj| obj.zero? }
+    end
+
+    def count
+      @hash.inject(0) {|count, (k, obj)| count + obj.count; }
+    end
+
+    def report
+      @report = "## Un-Fozen Hotspots (#{count} total)\n\n"
+
+      file_names = @hash.values.map(&:file_name).uniq
+      file_name_hash = Hash.new { [] }
+      file_names.each do |name|
+        file_name_hash[name] = @hash.select {|_, obj| obj.file_name == name}.values.sort {|obj1, obj2| obj1.count <=> obj2.count }.reverse
+      end
+
+      file_name_hash = file_name_hash.sort {|(_, objects1), (_, objects2) |
+        count1 = objects1.inject(0) {|count, obj| count + obj.count }
+        count2 = objects2.inject(0) {|count, obj| count + obj.count }
+        count1 <=> count2
+        }.reverse
+
+      file_name_hash.each do |file_name, objects|
+        count = objects.inject(0) {|count, obj| count + obj.count }
+        @report << "  #{count}) #{file_name}\n"
+        objects.each do |obj|
+          @report << "    - #{obj.count}) #{obj.klass}##{obj.method_name} on line #{ obj.line_number }\n"
+        end
+      end
+
+      @report << "  (none)" if @hash.empty?
+      @report << "\n"
+      @report
+    end
+
+    def print
+      puts report
+    end
+  end
+end

data/lib/let_it_go/version.rb

@@ -1,3 +1,3 @@
 module LetItGo
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/let_it_go/wtf_parser.rb

@@ -73,16 +73,29 @@ module LetItGo
        #        false]]]],
        #    false]]]
       def args_add_block
-        args_paren.last || @raw.find {|x| x.first == :args_add_block }
+        args_paren.last || @raw.find {|x| x.first == :args_add_block } || []
       end
 
       def args
-        args_add_block.first(2).last || []
+        args = (args_add_block.first(2).last || [])
+        case args.first
+        when :args_add_star
+          args.shift
+          args
+        else
+          args
+        end
       end
 
+    # [:fcall, [:@ident, "foo", [1, 6]]],
+    #    [:arg_paren,
+    #     [:args_add_block, [:args_add_star, [], [:array, nil]], false]]
+
+    # [:args_add_star, [], [:array, nil]], false]
+
       # Returns argument types as an array of symbols [:regexp_literal, :string_literal]
       def arg_types
-        args.map(&:first).map {|x| x.is_a?(Array) ? x.first : x }
+        args.map(&:first).map {|x| x.is_a?(Array) ? x.first : x }.compact
       end
     end
 
@@ -114,7 +127,7 @@ module LetItGo
       end
 
       def args_add_block
-        @raw.find {|x| x.is_a?(Array) ? x.first == :args_add_block : false }
+        @raw.find {|x| x.is_a?(Array) ? x.first == :args_add_block : false } || []
       end
 
       def args
@@ -123,7 +136,7 @@ module LetItGo
 
       # Returns argument types as an array of symbols [:regexp_literal, :string_literal]
       def arg_types
-        args.map(&:first).map {|x| x.is_a?(Array) ? x.first : x }
+        args.map(&:first).map {|x| x.is_a?(Array) ? x.first : x }.compact
       end
     end
 
@@ -151,12 +164,15 @@ module LetItGo
       end
 
       def arg_types
-        args.map(&:first).map {|x| x.is_a?(Array) ? x.first : x }
+        args.map(&:first).map {|x| x.is_a?(Array) ? x.first : x }.compact
       end
     end
 
-    def initialize(ripped_code)
-      @raw = ripped_code
+    attr_accessor :contents
+
+    def initialize(ripped_code, contents: "")
+      @contents   = contents
+      @raw = ripped_code || []
     end
 
     # Parses raw input recursively looking for :method_add_arg blocks
@@ -179,22 +195,36 @@ module LetItGo
       end
     end
 
-    def method_add
+    def all_methods
       @method_add_array ||= begin
         method_add_array = []
         find_method_add_from_raw(@raw.dup, method_add_array)
         method_add_array
       end
     end
-
-    def each_method
-      if block_given?
-        method_add.each do |obj|
-          yield obj
+    alias :method_add :all_methods
+
+    def each
+      begin
+        if block_given?
+          all_methods.each do |obj|
+            begin
+              yield obj
+            rescue => e
+            end
+          end
+        else
+          enum_for(:each)
         end
-      else
-        enum_for(:each_method)
+      rescue => e
+        msg = "Could not parse seemingly valid Ruby code:\n\n"
+        msg << "    #{ parser.contents.inspect }\n\n"
+        msg << e.message
+        raise e, msg
       end
     end
+    alias :each_method :each
+
+    include Enumerable
   end
 end

data/lib/let_it_go.rb

@@ -7,12 +7,19 @@ require "let_it_go/version"
 module LetItGo
 end
 
-require 'let_it_go/wtf_parser'
-
 module LetItGo
   @mutex    = Mutex.new
   @watching = {}
 
+  def self.watching_klasses
+    @watching.keys
+  end
+
+  def self.method_hash_for_klass(klass)
+    @watching[klass]
+  end
+
+
   def self.watching_positions(klass, method)
     @watching[klass] && @watching[klass][method]
   end
@@ -39,68 +46,17 @@ module LetItGo
   end
 
   class << self
-    alias :cant_hold_it_back_anymore :record
-    alias :do_you_want_to_build_a_snowman :record
-    alias :turn_away_and_slam_the_door :record
+    alias :cant_hold_it_back_anymore         :record
+    alias :do_you_want_to_build_a_snowman    :record
+    alias :turn_away_and_slam_the_door       :record
     alias :the_cold_never_bothered_me_anyway :record
-    alias :let_it_go :record
+    alias :let_it_go                         :record
   end
 
   def self.recording?
     Thread.current[:let_it_go_recording] == :on
   end
 
-  # Wraps logic that require knowledge of the method call
-  # can parse original method call's source and determine if a string literal
-  # was passed into the method.
-  class MethodCall
-    attr_accessor :line_number, :file_name, :klass, :method_name, :kaller, :positions
-
-    def initialize(klass: , method_name: , kaller:, positions: )
-      @klass        = klass
-      @method_name  = method_name
-      @kaller       = kaller
-      @positions    = positions
-
-      file_line       = kaller.split(":in `".freeze).first # can't use gsub, because global variables get messed up
-      file_line_array = file_line.split(":".freeze)
-
-      @line_number = file_line_array.pop
-      @file_name   = file_line_array.join(":".freeze)
-    end
-
-    def line_to_s
-      @line_to_s ||= begin
-        contents = ""
-        File.open(file_name).each_with_index do |line, index|
-          next unless index == Integer(line_number).pred
-          contents = line
-          break
-        end
-        contents
-      rescue Errno::ENOENT
-        nil
-      end
-    end
-
-    # Parses original method call location
-    # Determines if a string literal was used or not
-    def called_with_string_literal?(parser_klass = ::LetItGo::WTFParser)
-      return true if line_to_s.nil?
-
-      if parsed_code = Ripper.sexp(line_to_s)
-        parser_klass.new(parsed_code).each_method.any? do |m|
-          m.method_name == method_name.to_s && positions.any? {|position| m.arg_types[position] == :string_literal }
-        end
-      end
-    end
-
-    def key
-      "Method: #{klass}##{method_name} [#{kaller}]"
-    end
-  end
-
-
 
   # Call to begin watching method for frozen violations
   def self.watch_frozen(klass, method_name, positions:)
@@ -108,7 +64,6 @@ module LetItGo
     @watching[klass][method_name] = positions
   end
 
-
   # If we are tracking it
   #   If it has positive counter
   #     Increment Counter
@@ -120,34 +75,13 @@ module LetItGo
   #   If it does not
   #     Set counter to
   def self.watched_method_was_called(meth)
-    if LetItGo.record_exists?(meth.key)
-      if Thread.current[:let_it_go_records][meth.key] > 0
-        LetItGo.increment(meth.key)
-      end
-    else
-      if meth.called_with_string_literal?
-        LetItGo.store(meth.key, 1)
-      else
-        LetItGo.store(meth.key, 0)
-      end
+    unless method = Thread.current[:let_it_go_records][meth.key]
+      Thread.current[:let_it_go_records][meth.key] = method = meth
     end
+    method.call_count += 1 if method.optimizable?
   end
 
 
-  trace = TracePoint.trace(:call, :c_call) do |tp|
-    tp.disable
-    if LetItGo.recording?
-      if positions = watching_positions(tp.defined_class, tp.method_id)
-        meth = MethodCall.new(klass: tp.defined_class, method_name: tp.method_id, kaller: caller.first, positions: positions)
-        LetItGo.watched_method_was_called(meth)
-      end
-    end
-    tp.enable
-  end
-
-  trace.enable
-
-
   # Prevent looking
   def self.record_exists?(key)
     Thread.current[:let_it_go_records][key]
@@ -164,37 +98,29 @@ module LetItGo
   def self.increment(key)
     store(key, 1)
   end
+end
 
-  # Turns hash of keys into a semi-inteligable sorted result
-  class Report
-    def initialize(hash_of_reports)
-      @hash = hash_of_reports.reject {|k, v| v.zero? }.sort {|(k1, v1), (k2, v2)| v1 <=> v2 }.reverse
-    end
+require 'let_it_go/middleware/olaf'
+require 'let_it_go/caller_line'
+require 'let_it_go/method_call'
+require 'let_it_go/report'
 
-    def count
-      @hash.inject(0) {|count, (k, v)| count + v }
-    end
 
-    def report
-      @report = "## Un-Fozen Hotspots (#{count} total)\n"
-      @hash.each do |name_location, count|
-        @report << "  #{count}: #{name_location}\n"
-      end
-      @report << "  (none)" if @hash.empty?
-      @report << "\n"
-      @report
-    end
+Dir[File.expand_path("../let_it_go/core_ext/*.rb", __FILE__)].each do |file|
+  require file
+end
 
-    def print
-      puts report
-    end
+RubyVM::InstructionSequence.compile_option = { specialized_instruction: false }
 
+TracePoint.trace(:call, :c_call) do |tp|
+  tp.disable
+  if LetItGo.recording?
+    if positions = LetItGo.watching_positions(tp.defined_class, tp.method_id)
+      meth = LetItGo::MethodCall.new(klass: tp.defined_class, method_name: tp.method_id, kaller: caller, positions: positions)
+      LetItGo.watched_method_was_called(meth)
+    end
   end
+  tp.enable
 end
 
-require 'let_it_go/middleware/olaf'
-
-Dir[File.expand_path("../let_it_go/core_ext/*.rb", __FILE__)].each do |file|
-  require file
-end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: let_it_go
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - schneems
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-07-19 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,10 +71,13 @@ files:
 - bin/setup
 - let_it_go.gemspec
 - lib/let_it_go.rb
+- lib/let_it_go/caller_line.rb
 - lib/let_it_go/core_ext/array.rb
 - lib/let_it_go/core_ext/pathname.rb
 - lib/let_it_go/core_ext/string.rb
+- lib/let_it_go/method_call.rb
 - lib/let_it_go/middleware/olaf.rb
+- lib/let_it_go/report.rb
 - lib/let_it_go/version.rb
 - lib/let_it_go/wtf_parser.rb
 - lib/untitled.rb