churnalizer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 121e0c4906c450169d97de281a8642791ac17b5e
+  data.tar.gz: d13666dd80e932cee1d1556b4cb208a888ae383b
+SHA512:
+  metadata.gz: c757caeedbc38724192ddf613faf96baf3de26b37e8efd1b6fa79f4c7680321973ee9e46737a4979f9cc9a62a9d74def9ac048d3dd6ba2a1e5cf7a3ae2d06e17
+  data.tar.gz: 02c79cb372325593c507009f805c54ddcd4c73ff22acff093c273536cbe64646b34f5840dbb22fc9918bea9ccc8e6e425649a29bc740a744699f4d9e6e03704e

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+*.swp
+.DS_Store
+.byebug_history
+chart.html

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.0
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in churnalizer.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    churnalizer (0.1.0)
+      flog
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (10.0.0)
+    diff-lcs (1.3)
+    flog (4.6.2)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.8)
+    path_expander (1.0.2)
+    rake (10.5.0)
+    rb-readline (0.5.5)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    ruby_parser (3.11.0)
+      sexp_processor (~> 4.9)
+    sexp_processor (4.10.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  byebug
+  churnalizer!
+  rake (~> 10.0)
+  rb-readline
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Federico Ramirez
+
+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,72 @@
+# Churnalizer
+
+Churnalizer helps you analyze the churn vs complexity of your Ruby application.
+
+![Graph Screenshot](screenshot.png?raw=true)
+
+What is churn vs complexity? Sandi Metz explains it nicely in her blog post
+[Breaking up the
+Behemot](https://www.sandimetz.com/blog/2017/9/13/breaking-up-the-behemoth).
+
+Basically, it shows you which files need to be refactored first -- top-right
+corner of the graph. Churn is how many times a file has been changed, so you
+want files which change a lot to be simple. Files which are never touched are
+fine with being complex for a while.
+
+## Installation
+
+    $ gem install churnalizer
+
+## Usage
+
+    $ churnalizer my-app-directory/
+
+This was only tested on MacOS. It uses the `open` command to make things easier,
+so when the gem is done analyzing your app, it will open the generated chart
+with your default browser. 
+
+That functionality would not work on Linux so the chart would need to be opened
+manually.
+
+Don't think it works on Windows at all, given the churn counter uses the
+following command: `cd $(dirname #{file}) && git log --oneline -- #{file} | wc -l`
+
+### Ignoring Files
+
+By default, Churnalizer will ignore specs and Rails files like `schema.rb` and
+`routes.rb`.
+
+For custom ignore rules, in the base directory you are analyzing, create a file
+named `.churnignore`, in that file, add a regular expression per-line to run
+against file paths. If a regex returns true, it will be ignored.
+
+For example, this is the default `.churnignore` file:
+
+    /test/
+    /spec/
+    /db/
+    /config/
+    /bin/
+    /vendor/
+    /public/
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake spec` to run the tests. You can also 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`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+### Playing with the CLI
+
+To locally run the CLI use `ruby -Ilib exe/churnalizer`
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/gosukiwi/churnalizer.

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "churnalizer"
+
+# 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(__FILE__)

data/bin/setup

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

data/churnalizer.gemspec

@@ -0,0 +1,36 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "churnalizer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "churnalizer"
+  spec.version       = Churnalizer::VERSION
+  spec.authors       = ["Federico Ramirez"]
+  spec.email         = ["federico_r@beezwax.net"]
+
+  spec.summary       = %q{Analyze your Ruby application for Churn vs Complexity}
+  spec.homepage      = "http://github.com/gosukiwi/churnalizer"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "rb-readline"
+
+  spec.add_dependency "flog"
+end

data/exe/churnalizer

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "churnalizer/cli"
+Churnalizer::CLI.new

data/lib/churn_analyzers/git.rb

@@ -0,0 +1,22 @@
+module ChurnAnalyzers
+  # This class uses Git to analyze the churn (how many times it was changed) of
+  # a file.
+  #
+  class Git
+    def analyze(file)
+      as_integer run_command(file)
+    end
+
+    private
+
+    # Trim string and cast to integer
+    def as_integer(string)
+      string.gsub(/[\n ]+/, "").to_i
+    end
+
+    # NOTE: This only works on *NIX systems
+    def run_command(file)
+      `cd $(dirname #{file}) && git log --oneline -- #{file} | wc -l`
+    end
+  end
+end

data/lib/churnalizer/analyzer.rb

@@ -0,0 +1,65 @@
+require "file_scanners/ruby"
+require "churn_analyzers/git"
+require "complexity_analyzers/ruby"
+require "graph_builders/google_charts"
+
+module Churnalizer
+  class Analyzer
+    attr_reader :path
+    def initialize(path)
+      @path = path
+    end
+
+    def run
+      build_graph analyzed_files
+    end
+
+    private
+
+    def analyzed_files
+      files.map do |file|
+        [display_name_for(file), analyze(file)]
+      end.to_h
+    end
+
+    def display_name_for(file)
+      file.gsub(path, ".")
+    end
+
+    def analyze(file)
+      { churn: churn_for(file), complexity: complexity_for(file) }
+    end
+
+    def files
+      file_scanner.scan
+    end
+
+    def file_scanner
+      @file_scanner ||= FileScanners::Ruby.new(path)
+    end
+
+    def churn_analyzer
+      @churn_analyzer ||= ChurnAnalyzers::Git.new
+    end
+
+    def churn_for(file)
+      churn_analyzer.analyze(file)
+    end
+
+    def complexity_analyzer
+      @complexity_analyzer ||= ComplexityAnalyzers::Ruby.new
+    end
+
+    def complexity_for(file)
+      complexity_analyzer.analyze(file)
+    end
+
+    def graph_builder
+      @graph_builder ||= GraphBuilders::GoogleCharts.new
+    end
+
+    def build_graph(graph_data)
+      graph_builder.build(graph_data, save_to: "chart.html")
+    end
+  end
+end

data/lib/churnalizer/cli.rb

@@ -0,0 +1,34 @@
+require "churnalizer/analyzer"
+
+module Churnalizer
+  class CLI
+    attr_accessor :path
+
+    def initialize
+      @path = path
+      analyze
+    end
+
+    def analyze
+      return help if path.nil?
+      puts churnalizer.run
+    end
+
+    def churnalizer
+      @churnalizer ||= Churnalizer::Analyzer.new(path)
+    end
+
+    def help
+      puts """This is Churnalizer, a churn vs complexity analyzer for your Ruby
+application.
+
+Usage:
+churnalizer my-app/
+      """
+    end
+
+    def path
+      ARGV[0]
+    end
+  end
+end

data/lib/churnalizer/version.rb

@@ -0,0 +1,3 @@
+module Churnalizer
+  VERSION = "0.1.0"
+end

data/lib/churnalizer.rb

@@ -0,0 +1,5 @@
+require "churnalizer/version"
+
+module Churnalizer
+  # Silence is beautiful
+end

data/lib/complexity_analyzers/ruby.rb

@@ -0,0 +1,18 @@
+require "flog"
+
+module ComplexityAnalyzers
+  # This class uses Flog <https://github.com/seattlerb/flog> to check the
+  # complexity of a Ruby file.
+  #
+  class Ruby
+    def analyze(file)
+      flog.reset
+      flog.flog(file)
+      flog.total_score
+    end
+
+    def flog
+      @flog ||= Flog.new
+    end
+  end
+end

data/lib/file_scanners/ignorer.rb

@@ -0,0 +1,47 @@
+module FileScanners
+  # Takes a list of files and ignores them appropriately
+  #
+  class Ignorer
+    DEFAULT_IGNORES = %w[/test/ /spec/ /db/ /config/ /bin/ /vendor/ /public/].freeze
+
+    attr_reader :path
+    def initialize(path)
+      @path = path
+    end
+
+    def ignore?(file)
+      ignore_rules.each do |rule|
+        return true if rule === file
+      end
+      false
+    end
+
+    private
+
+    def ignore_rules
+      @ignore_rules ||= churnignore.map { |regex| Regexp.new(regex) }
+    end
+
+    def churnignore
+      if churnignore_contents.empty?
+        DEFAULT_IGNORES
+      else
+        churnignore_as_array
+      end
+    end
+
+    def churnignore_as_array
+      churnignore_contents.split("\n").compact
+    end
+
+    def churnignore_contents
+      @churnignore_contents ||= File.read(churnignore_path)
+    rescue Errno::ENOENT
+      ""
+    end
+
+    def churnignore_path
+      "#{path}/.churnignore"
+    end
+  end
+end

data/lib/file_scanners/ruby.rb

@@ -0,0 +1,33 @@
+require "file_scanners/ignorer"
+
+module FileScanners
+  # FileScanners are in charge of finding files to be analyzed. This one in
+  # particular finds Ruby files.
+  #
+  class Ruby
+    attr_reader :path
+    def initialize(path)
+      @path = path
+    end
+
+    def scan
+      files.reject do |file|
+        ignore? file
+      end
+    end
+
+    private
+
+    def files
+      Dir.glob("#{path}/**/*.rb")
+    end
+
+    def ignorer
+      @ignorer ||= Ignorer.new(path)
+    end
+
+    def ignore?(file)
+      ignorer.ignore? file
+    end
+  end
+end

data/lib/graph_builders/google_charts.rb

@@ -0,0 +1,36 @@
+require "json"
+
+module GraphBuilders
+  # Generate an HTML chart using Google Charts
+  #
+  class GoogleCharts
+    def build(graph_data, save_to:)
+      write_chart graph_data, to_file: save_to
+      open_with_default_browser save_to
+      File.expand_path save_to
+    end
+
+    private
+
+    def open_with_default_browser(file)
+      `open #{file}` if `which open` == "/usr/bin/open\n"
+    end
+
+    def write_chart(graph_data, to_file:)
+      contents = compile_template graph_data
+      File.write(to_file, contents)
+    end
+
+    def compile_template(graph_data)
+      template.gsub("{{graph_data}}", graph_data.to_json)
+    end
+
+    def template
+      File.read view_path("google_chart.html")
+    end
+
+    def view_path(name)
+      "#{__dir__}/views/#{name}"
+    end
+  end
+end

data/lib/graph_builders/views/google_chart.html

@@ -0,0 +1,75 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Churnalizer: Churn vs Complexity</title>
+  <style>
+body {
+  font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol"
+}
+h1,
+h2 {
+  text-align: center;
+}
+
+p {
+  text-align: center;
+  margin: 0 auto 1.25em;
+  max-width: 780px;
+  line-height: 1.2;
+}
+  </style>
+</head>
+<body>
+  <h1>Churn vs Complexity</h1>
+
+  <div id="churnalizer-chart"></div>
+
+  <h2>How to read this chart?</h2>
+  <p>
+    Basically, you want to minimize the amount of files which show up at the
+    top-right of the chart. Those are files which are complex and also change
+    a lot.
+  </p>
+  <p>
+    Ideally, you don't want to have complex files, but if you do, at least make
+    sure they don't change often. The files at the top-right are good candidates
+    for refactoring.
+  </p>
+
+  <script src="https://www.gstatic.com/charts/loader.js"></script>
+  <script>
+    google.charts.load('current', {'packages':['corechart']});
+    google.charts.setOnLoadCallback(drawChart);
+
+    var graph_data = {{graph_data}};
+    
+    function drawChart() {
+        var data = new google.visualization.DataTable();
+        data.addColumn('number', 'Churn');
+        data.addColumn('number', 'Complexity');
+        data.addColumn({ type: 'string', role: 'tooltip' });
+
+        for(var file in graph_data) {
+          file_data = graph_data[file]
+          data.addRow([
+            file_data.churn,
+            file_data.complexity,
+            file + "\nComplexity: " + Math.round(file_data.complexity) + "\nChurn: " + file_data.churn
+          ]);
+        }
+
+        var options = {
+          hAxis: {title: 'Churn', minValue: 0, maxValue: 50},
+          vAxis: {title: 'Complexity', minValue: 0, maxValue: 200},
+          legend: 'none',
+          crosshair: { trigger: 'both' }
+        };
+
+        var chart = new google.visualization.ScatterChart(document.getElementById('churnalizer-chart'));
+
+        chart.draw(data, options);
+      }
+  </script>
+</body>
+</html>