let_it_go 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e07c3bf2d1c860ea3942429f6b70a9e0fff08e5
+  data.tar.gz: 331e78ae77329a8b96c32a38038f40e972a8b96c
+SHA512:
+  metadata.gz: 4971320b95a2fd1fe09c37c1aa095d4090b9db878fb013ccf895bac610d6b76568a1c06dd4ab5ecc2c39b445fbd7df2a8262fd153bbf701f460ef46685ac4cb5
+  data.tar.gz: 79cb35ec9297cb9692a1cb33f5bb7f26351fefa8fb6f7e1aaad227fe1ed6b7ecd4dcb4740ed2433f08bc954f9759b2bb66c868df0943f2e7f676fb02f9b13b49

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

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

data/.travis.yml

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

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 schneems
+
+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,148 @@
+# Let It Go
+
+Frozen string literals can save time and memory when used correctly. This library looks for common places that can easily accept frozen string literals and lets you know if a non-frozen string is being used instead so you can speed up your programs.
+
+For more info on the relationship betwen speed, objects, and memory in Ruby Check out [How Ruby Uses Memory](http://www.schneems.com/2015/05/11/how-ruby-uses-memory.html).
+
+Note: This library only works with Ruby files on disk, and not with interactive sessions like `irb`. Why? Because intercepting arguments to c defined methods isn't possible [Attempt 1](http://stackoverflow.com/questions/30512945/programmatically-alias-method-that-uses-global-variable) [Attempt 2](http://stackoverflow.com/questions/30584454/get-method-arguments-using-rubys-tracepoint).
+
+## What is a Frozen String Literal?
+
+This is a frozen string literal:
+
+```ruby
+"foo".freeze
+```
+
+The `freeze` method is a way to tell  the Ruby interpreter that we will not modify that string in the future. When we do this, the Ruby interpreter only ever has to create one object that can be re-used instead of having to create a new string each time. This is how we save CPU cycles. Passing frozen strings to methods like `String#gsub` that do not modify their arguments is best practice when possible:
+
+```ruby
+matchdata.captures.map do |e|
+  e.gsub(/_|,/, '-'.freeze)
+end
+```
+
+## Installation
+
+Requires Ruby 2.0+
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'let_it_go', group: :development
+```
+
+And then execute:
+
+    $ bundle
+
+It's really important you don't run this in production, it would really slow stuff down.
+
+
+## Middleware Use
+
+You can profile method calls during a request by using a middleware.
+
+
+```ruby
+# config/initializers/let_it_go.rb
+
+if defined?(LetItGo::Middleware::Olaf)
+  Rails.application.config.middleware.insert(0, LetItGo::Middleware::Olaf)
+end
+```
+
+Now every time a page is rendered, you'll get a list of un-frozen methods in your standard out.
+
+## Direct Use
+
+Anywhere you want to check for non-frozen string use call:
+
+```ruby
+LetItGo.record do
+  "foo".gsub(/f/, "")
+end.print
+
+## Un-Fozen Hotspots
+#  1: Method: String#gsub [(irb):2:in `block in irb_binding']
+```
+
+Each time the same method is called it is counted
+
+```ruby
+LetItGo.record do
+  99.times { "foo".gsub(/f/, "") }
+end.print
+
+## Un-Fozen Hotspots
+#  99: Method: String#gsub [(irb):6:in `block (2 levels) in irb_binding']
+```
+
+When you're running this against a file, `LetItGo` will try to parse the calling line to determine if a string literal was used.
+
+```
+$ cat <<  EOF > foo.rb
+  require 'let_it_go'
+
+  LetItGo.record do
+    "foo".gsub(/f/, "")
+  end.print
+EOF
+$ ruby foo.rb
+## Un-Fozen Hotspots
+  1: Method: String#gsub [foo.rb:4:in `block in <main>']
+```
+
+If you try again with a string variable or a modified string (anything not a string literal) it will be ignored
+
+```
+$ cat <<  EOF > foo.rb
+  require 'let_it_go'
+
+  LetItGo.record do
+    "foo".gsub(/f/, "".downcase) # freezing downcase would not help with memory or speed here
+  end.print
+EOF
+$ ruby foo.rb
+## Un-Fozen Hotspots
+  (none)
+```
+
+## Watching Frozen (methods)
+
+For a list of all methods that are watched check in lib/let_it_go/core_ext. You can manually add your own by using `LetItGo.watch_frozen`. For example `[].join("")` is a potential hotspot. To watch this method we would call
+
+```ruby
+LetItGo.watch_frozen(Array, :join, positions: [0])
+```
+
+The positions named argument is an array containing the indexes of the method arguments you want to watch. In this case `join` only takes one method argument, so we are only watching the first one (index of 0). If there are other common method invocations that can ALWAYS take in a frozen string (i.e. they NEVER modify the string argument) then please submit a PR to this library by adding it to `lib/let_it_go/core_ext`. Please add a test to the corresponding spec file.
+
+## How
+
+This extremely convoluted library works by watching all method calls using [TracePoint](http://ruby-doc.org/core-2.2.2/TracePoint.html) to see when a method we are watching is called. Since we [cannot use TracePoint to get all method arguments](http://stackoverflow.com/questions/30584454/get-method-arguments-using-rubys-tracepoint) we instead resort to parsing Ruby code on disk to see if a string literal is used. The parsing functionality is achieved by reading in the line of the caller and parsing it with [Ripper](http://ruby-doc.org/stdlib-2.2.2/libdoc/ripper/rdoc/Ripper.html) which is then translated by lib/let_it_go/wtf_parser.rb. It probably has bugs, and it won't work with weirly formatted or multi line code.
+
+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).
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/let_it_go/fork )
+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 a new Pull Request
+
+
+## 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

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "let_it_go"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/let_it_go.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'let_it_go/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "let_it_go"
+  spec.version       = LetItGo::VERSION
+  spec.authors       = ["schneems"]
+  spec.email         = ["richard.schneeman@gmail.com"]
+
+  spec.summary       = %q{ Finds un-frozen string literals in your program }
+  spec.description   = %q{ Finds un-frozen string literals in your program }
+  spec.homepage      = "https://github.com/schneems/let_it_go"
+  spec.license       = "MIT"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/let_it_go.rb

@@ -0,0 +1,200 @@
+require 'ripper'
+require 'pp'
+require 'thread'
+
+require "let_it_go/version"
+
+module LetItGo
+end
+
+require 'let_it_go/wtf_parser'
+
+module LetItGo
+  @mutex    = Mutex.new
+  @watching = {}
+
+  def self.watching_positions(klass, method)
+    @watching[klass] && @watching[klass][method]
+  end
+
+  # Main method, wrap code you want to check for frozen violations in
+  # a `let_it_go` block.
+  #
+  # By default it will try to parse source of the method call to determine
+  # if a string literal or variable was used. We only care about string literals.
+  def self.record
+    @mutex.synchronize do
+      Thread.current[:let_it_go_recording]    = :on
+      Thread.current[:let_it_go_records]      = {} # nil => never checked, 0 => checked, no string literals, positive => checked, positive literals detected
+    end
+    yield
+    records = Thread.current[:let_it_go_records]
+    report  = Report.new(records)
+    return report
+  ensure
+    @mutex.synchronize do
+      Thread.current[:let_it_go_recording]    = nil
+      Thread.current[:let_it_go_records]      = nil
+    end
+  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 :the_cold_never_bothered_me_anyway :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:)
+    @watching[klass] ||= {}
+    @watching[klass][method_name] = positions
+  end
+
+
+  # If we are tracking it
+  #   If it has positive counter
+  #     Increment Counter
+  #   If not
+  #     do nothing
+  # else we are not tracking it
+  #   If it has a frozen string literal
+  #     Set counter to 1
+  #   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
+    end
+  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]
+  end
+
+  # Records when a method has been called without passing in a frozen object
+  def self.store(key, increment = 0)
+    @mutex.synchronize do
+      Thread.current[:let_it_go_records][key] ||= 0
+      Thread.current[:let_it_go_records][key] += increment
+    end
+  end
+
+  def self.increment(key)
+    store(key, 1)
+  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
+
+    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
+
+    def print
+      puts report
+    end
+
+  end
+end
+
+require 'let_it_go/middleware/olaf'
+
+Dir[File.expand_path("../let_it_go/core_ext/*.rb", __FILE__)].each do |file|
+  require file
+end
+

data/lib/let_it_go/core_ext/array.rb

@@ -0,0 +1,13 @@
+# positions: 0
+LetItGo.watch_frozen(Array, :join,       positions: [0])
+LetItGo.watch_frozen(Array, :include?,   positions: [0])
+LetItGo.watch_frozen(Array, :assoc,      positions: [0])
+LetItGo.watch_frozen(Array, :count,      positions: [0])
+LetItGo.watch_frozen(Array, :delete,     positions: [0])
+LetItGo.watch_frozen(Array, :fill,       positions: [0])
+LetItGo.watch_frozen(Array, :index,      positions: [0])
+LetItGo.watch_frozen(Array, :find_index, positions: [0])
+LetItGo.watch_frozen(Array, :rindex,     positions: [0])
+
+# positions: 1
+LetItGo.watch_frozen(Array, :fetch,      positions: [1])

data/lib/let_it_go/core_ext/pathname.rb

@@ -0,0 +1 @@
+LetItGo.watch_frozen(Pathname, :new, positions: [0])

data/lib/let_it_go/core_ext/string.rb

@@ -0,0 +1,49 @@
+# Needs parser fixing to work
+LetItGo.watch_frozen(String, :+,       positions: [0])
+LetItGo.watch_frozen(String, :<<,      positions: [0])
+LetItGo.watch_frozen(String, :'<=>',     positions: [0])
+
+# Positions: 0
+
+LetItGo.watch_frozen(String, :split,        positions: [0])
+LetItGo.watch_frozen(String, :concat,       positions: [0])
+LetItGo.watch_frozen(String, :casecmp,      positions: [0])
+LetItGo.watch_frozen(String, :chomp,        positions: [0])
+LetItGo.watch_frozen(String, :count,        positions: [0])
+LetItGo.watch_frozen(String, :crypt,        positions: [0])
+LetItGo.watch_frozen(String, :delete,       positions: [0])
+LetItGo.watch_frozen(String, :delete!,      positions: [0])
+LetItGo.watch_frozen(String, :each_line,    positions: [0])
+LetItGo.watch_frozen(String, :lines,        positions: [0])
+LetItGo.watch_frozen(String, :include?,     positions: [0])
+LetItGo.watch_frozen(String, :index,        positions: [0])
+LetItGo.watch_frozen(String, :rindex,       positions: [0])
+LetItGo.watch_frozen(String, :replace,      positions: [0])
+LetItGo.watch_frozen(String, :match,        positions: [0])
+LetItGo.watch_frozen(String, :partition,    positions: [0])
+LetItGo.watch_frozen(String, :rpartition,   positions: [0])
+LetItGo.watch_frozen(String, :prepend,      positions: [0])
+LetItGo.watch_frozen(String, :scan,         positions: [0])
+LetItGo.watch_frozen(String, :slice,        positions: [0])
+LetItGo.watch_frozen(String, :slice!,       positions: [0])
+LetItGo.watch_frozen(String, :squeeze,      positions: [0])
+LetItGo.watch_frozen(String, :start_with?,  positions: [0])
+LetItGo.watch_frozen(String, :unpack,       positions: [0])
+LetItGo.watch_frozen(String, :upto,         positions: [0])
+
+
+# Positions; 0, 1
+
+LetItGo.watch_frozen(String, :gsub,    positions: [0, 1])
+LetItGo.watch_frozen(String, :gsub!,   positions: [0, 1])
+LetItGo.watch_frozen(String, :sub,     positions: [0, 1])
+LetItGo.watch_frozen(String, :sub!,    positions: [0, 1])
+LetItGo.watch_frozen(String, :tr,      positions: [0, 1])
+LetItGo.watch_frozen(String, :tr!,     positions: [0, 1])
+
+
+# Positions: 1
+
+LetItGo.watch_frozen(String, :insert,   positions: [1])
+LetItGo.watch_frozen(String, :ljust,    positions: [1])
+LetItGo.watch_frozen(String, :rjust,    positions: [1])

data/lib/let_it_go/middleware/olaf.rb

@@ -0,0 +1,31 @@
+module LetItGo
+  module Middleware
+    class Olaf
+      def initialize(app)
+        @app          = app
+      end
+
+      def asset_request?(path)
+        path.match(/^\/assets\/|favicon.ico$/i)
+      end
+
+      def not_asset_request?(path)
+        !asset_request?(path)
+      end
+
+      def call(env)
+        result = nil
+        report = LetItGo.record do
+          result = @app.call(env)
+        end
+        puts ""
+        report.print if not_asset_request?(env["REQUEST_PATH".freeze])
+        result
+      end
+    end
+
+    # Pick your favorite character!
+    Elsa = Olaf
+    Anna = Olaf
+  end
+end

data/lib/let_it_go/version.rb

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

data/lib/let_it_go/wtf_parser.rb

@@ -0,0 +1,200 @@
+
+module LetItGo
+  # Used for parsing the output of Ripper from a single line of Ruby.
+  #
+  # Pulls out method calls, and arguments to those method calls.
+  # We only care about when a string literal isn't frozen
+  class WTFParser
+
+    # Holds the "MethodAdd" components of parsed Ripper output
+    # Capable of pulling out `method_name`, and argument types such as
+    # :string_literal
+    class MethodAdd
+      # @raw =
+      #   [
+      #    [:string_literal, [:string_content, [:@tstring_content, "foo", [1, 7]]]],
+      #    :".",
+      #    [:@ident, "gsub", [1, 12]]],
+      #   [:arg_paren,
+      #    [:args_add_block,
+      #     [[:regexp_literal, [], [:@regexp_end, "/", [1, 18]]],
+      #      [:string_literal,
+      #       [:string_content, [:@tstring_content, "blerg", [1, 22]]]]],
+      #     false]]
+      def initialize(ripped_code)
+        ripped_code = ripped_code.dup
+        raise "Wrong node" unless ripped_code.shift == :method_add_arg
+        @raw = ripped_code
+      end
+
+      # [
+      #  :call,
+      #  [:string_literal, [:string_content, [:@tstring_content, "foo", [1, 7]]]],
+      #  :".",
+      #  [:@ident, "gsub", [1, 12]]
+      # ]
+      def call
+        @raw.find {|x| x.first == :call || x.first == :fcall}
+      end
+
+      # For gsub we want to pull from [:@ident, "gsub", [1, 12]] from `call`
+      def method_name
+        call.find {|x| x.is_a?(Array) && x.first == :@ident }[1]
+      end
+
+      # [:arg_paren,
+      #   [
+      #     :args_add_block,
+      #     # ..
+      #   ]
+      def args_paren
+        @raw.find {|x| x.first == :arg_paren } || []
+      end
+
+      # [:args_add_block,
+      #  [[:regexp_literal, [], [:@regexp_end, "/", [1, 18]]],
+      #   [:string_literal, [:string_content, [:@tstring_content, "blerg", [1, 22]]]]],
+      #  false]
+      #
+      # or
+      #
+      # [:args_add_block,
+       #    [[:regexp_literal, [], [:@regexp_end, "/", [1, 18]]],
+       #     [[:call,
+       #       [:string_literal,
+       #        [:string_content, [:@tstring_content, "bar", [1, 22]]]],
+       #       :".",
+       #       [:@ident, "gsub!", [1, 27]]],
+       #      [:arg_paren,
+       #       [:args_add_block,
+       #        [[:regexp_literal, [], [:@regexp_end, "/", [1, 34]]],
+       #         [:string_literal,
+       #          [:string_content, [:@tstring_content, "zoo", [1, 38]]]]],
+       #        false]]]],
+       #    false]]]
+      def args_add_block
+        args_paren.last || @raw.find {|x| x.first == :args_add_block }
+      end
+
+      def args
+        args_add_block.first(2).last || []
+      end
+
+      # 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 }
+      end
+    end
+
+    # I think "command calls" are method invocations without parens
+    # Like `puts "hello world"`. For some unholy reason, their structure
+    # is different than regular method calls?
+    class CommandCall < MethodAdd
+      # @raw =
+      # [
+      #  [:string_literal, [:string_content, [:@tstring_content, "foo", [1, 7]]]],
+      #  :".",
+      #  [:@ident, "gsub", [1, 12]],
+      #  [:args_add_block,
+      #   [[:regexp_literal, [], [:@regexp_end, "/", [1, 18]]],
+      #    [:call,
+      #     [:string_literal,
+      #      [:string_content, [:@tstring_content, "blerg", [1, 22]]]],
+      #     :".",
+      #     [:@ident, "downcase", [1, 29]]]],
+      #   false]]
+      def initialize(ripped_code)
+        ripped_code = ripped_code.dup
+        raise "Wrong node" unless ripped_code.shift == :command_call
+        @raw = ripped_code
+      end
+
+      def method_name
+        @raw.find {|x| x.is_a?(Array) ? x.first == :@ident : false }[1]
+      end
+
+      def args_add_block
+        @raw.find {|x| x.is_a?(Array) ? x.first == :args_add_block : false }
+      end
+
+      def args
+        args_add_block.first(2).last || []
+      end
+
+      # 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 }
+      end
+    end
+
+    # These are calls to operators that take 1 argument such as `1 + 1` or `[] << 1`
+    class BinaryCall
+      # @raw =
+      # [
+      #   [:string_literal, [:string_content, [:@tstring_content, "hello", [1, 7]]]],
+      #   :+,
+      #   [:string_literal,
+      #    [:string_content, [:@tstring_content, "there", [1, 17]]]]]
+      def initialize(ripped_code)
+        ripped_code = ripped_code.dup
+        raise "Wrong node" unless ripped_code.shift == :binary
+        @raw = ripped_code
+      end
+
+      # For `1 + 1` we want to pull "+"
+      def method_name
+        @raw[1].to_s
+      end
+
+      def args
+        [@raw.last]
+      end
+
+      def arg_types
+        args.map(&:first).map {|x| x.is_a?(Array) ? x.first : x }
+      end
+    end
+
+    def initialize(ripped_code)
+      @raw = ripped_code
+    end
+
+    # Parses raw input recursively looking for :method_add_arg blocks
+    def find_method_add_from_raw(ripped_code, array = [])
+      return false unless ripped_code.is_a?(Array)
+
+      case ripped_code.first
+      when :method_add_arg
+        array << MethodAdd.new(ripped_code)
+        ripped_code.shift
+      when :command_call
+        array << CommandCall.new(ripped_code)
+        ripped_code.shift
+      when :binary
+        array << BinaryCall.new(ripped_code)
+        ripped_code.shift
+      end
+      ripped_code.each do |code|
+        find_method_add_from_raw(code, array) unless ripped_code.empty?
+      end
+    end
+
+    def method_add
+      @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
+        end
+      else
+        enum_for(:each_method)
+      end
+    end
+  end
+end

data/lib/untitled.rb

@@ -0,0 +1,78 @@
+require 'ripper'
+require 'pp'
+
+# code = <<-CODE
+#   "foo".gsub(//, "blerg".downcase)
+# CODE
+
+# ripped_code = Ripper.sexp(code)
+
+code = <<-CODE
+  "foo".gsub //, "blerg".downcase
+CODE
+
+ripped_code = Ripper.sexp(code)
+# pp ripped_code
+
+puts "============="
+
+
+# code = <<-CODE
+#   ["hello"] << "there"
+# CODE
+
+# ripped_code = Ripper.sexp(code)
+# pp ripped_code
+
+
+code = <<-CODE
+  ps.find_all { |l| followpos(l).include?(DUMMY) }
+CODE
+ripped_code = Ripper.sexp(code)
+pp ripped_code
+
+def find_method_adds(ripped_code, array = [])
+  return false unless ripped_code.is_a?(Array)
+  case ripped_code.first
+  when :method_add_arg, :command_call, :binary
+    array << ripped_code
+    ripped_code.shift
+    ripped_code.each do |code|
+      find_method_adds(code, array)
+    end
+  else
+    ripped_code.each do |code|
+      find_method_adds(code, array) unless ripped_code.empty?
+    end
+  end
+end
+
+array = []
+find_method_adds(ripped_code, array)
+
+array.uniq!
+
+puts array.count
+pp array
+
+
+
+def foo
+end
+
+# trace = TracePoint.trace(:call, :c_call) do |tp|
+#   tp.disable
+#   puts "=="
+#   puts tp.defined_class
+#   puts tp.method_id.inspect
+#   tp.enable
+# end
+
+# trace.enable
+
+# a = rand
+# "blahblah" << "blah #{a}"
+
+foo()
+
+

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: let_it_go
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- schneems
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: " Finds un-frozen string literals in your program "
+email:
+- richard.schneeman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- let_it_go.gemspec
+- lib/let_it_go.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/middleware/olaf.rb
+- lib/let_it_go/version.rb
+- lib/let_it_go/wtf_parser.rb
+- lib/untitled.rb
+homepage: https://github.com/schneems/let_it_go
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Finds un-frozen string literals in your program
+test_files: []
+has_rdoc: