churn_vs_complexity 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2efc73253aa94e1fe4de49723e2d7238857aa1a1f0b37fa6c39cb3e6cd1a133a
+  data.tar.gz: '09be5e6af924ce5d32cc81e918f88e943f13e3c80e78bffaeb799c957d300c78'
+SHA512:
+  metadata.gz: 72fb9a5556e813e7999ca5134e91566e9c2b64e9050076c170578db470cb98c68bd53c440fb2b15b68db60abddab9af40026723deb543cf44b6a83acaeeed83e
+  data.tar.gz: 17adf306ab68cf12ed73b733f2810df28761f726077cd6825ddb393fa89cf1fa264c66fd98eccd8c7bdfafb24af953e04f8b05a276615a2c0ae8b6c59be1c02b

data/.devcontainer/devcontainer.json

@@ -0,0 +1,26 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-dockerfile
+{
+	"name": "Existing Dockerfile",
+	"build": {
+		// Sets the run context to one level up instead of the .devcontainer folder.
+		"context": "..",
+		// Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
+		"dockerfile": "../Dockerfile.dev"
+	}
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Uncomment the next line to run commands after the container is created.
+	// "postCreateCommand": "cat /etc/os-release",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as an existing user other than the container default. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "devcontainer"
+}

data/.rubocop.yml

@@ -0,0 +1,22 @@
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+
+Layout/LineLength:
+  Max: 120
+
+
+Style/Documentation:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArguments:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.10
+before_install: gem install bundler -v 1.17.2

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## [1.0.0] - 2024-06-07
+
+- Initial release

data/Dockerfile

@@ -0,0 +1,34 @@
+# Create a build image with wget and unzip
+FROM ubuntu:latest as pmd_builder
+# Install wget and unzip
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+      wget unzip
+
+RUN wget https://github.com/pmd/pmd/releases/download/pmd_releases%2F7.0.0/pmd-dist-7.0.0-bin.zip --no-check-certificate
+RUN unzip pmd-dist-7.0.0-bin.zip
+
+FROM ruby:3.3-bullseye
+# Install git and java JDK
+
+RUN apt-get update; \
+	  apt-get install -y --no-install-recommends \
+      git openjdk-17-jdk
+
+# copy PMD from build image
+COPY --from=pmd_builder /pmd-bin-7.0.0 /usr/local/bin/pmd-bin-7.0.0
+# make pmd available in the PATH
+RUN ln -s /usr/local/bin/pmd-bin-7.0.0/bin/pmd /usr/local/bin/pmd
+
+COPY *.gemspec Gemfile* /app/
+COPY lib /app/lib
+
+WORKDIR /app
+
+RUN bundle install
+
+COPY bin /app/bin
+COPY tmp/pmd-support /app/tmp/pmd-support
+COPY tmp/template /app/tmp/template
+
+CMD ["/bin/sh", "-c", "echo 'It works!'"]

data/Dockerfile.dev

@@ -0,0 +1,27 @@
+# Create a build image with wget and unzip
+FROM ubuntu:latest as pmd_builder
+# Install wget and unzip
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+      wget unzip
+
+RUN wget https://github.com/pmd/pmd/releases/download/pmd_releases%2F7.0.0/pmd-dist-7.0.0-bin.zip --no-check-certificate
+RUN unzip pmd-dist-7.0.0-bin.zip
+
+FROM ruby:3.3-bullseye
+# Install git and java JDK
+
+RUN apt-get update; \
+	  apt-get install -y --no-install-recommends \
+      git openjdk-17-jdk
+
+# copy PMD from build image
+COPY --from=pmd_builder /pmd-bin-7.0.0 /usr/local/bin/pmd-bin-7.0.0
+# make pmd available in the PATH
+RUN ln -s /usr/local/bin/pmd-bin-7.0.0/bin/pmd /usr/local/bin/pmd
+
+COPY *.gemspec Gemfile* ./
+COPY lib/churn_vs_complexity/version.rb lib/churn_vs_complexity/version.rb
+RUN bundle install
+
+CMD ["/bin/sh", "-c", "echo 'It works!'"]

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Erik T. Madsen
+
+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,64 @@
+# ChurnVsComplexity
+
+A tool to visualise code complexity in a project and help direct refactoring efforts.
+
+Inspired by [Michael Feathers' article "Getting Empirical about Refactoring"](https://www.agileconnection.com/article/getting-empirical-about-refactoring) and the gem [turbulence](https://rubygems.org/gems/turbulence) by Chad Fowler and others.
+
+This gem was built primarily to support analysis of Java and Ruby repositories, but it can easily be extended.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'churn_vs_complexity'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install churn_vs_complexity
+
+This gem depends on git for churn analysis and [PMD](https://pmd.github.io) for complexity analysis of JVM based languages.
+
+In order to use the `--java` flag, you must first install PMD manually, and the gem assumes it is available on the search path as `pmd`. On macOS, for example, you can install it using homebrew with `brew install pmd`.
+
+## Usage
+
+Execute the `churn_vs_complexity` with the applicable arguments. Output in the requested format will be directed to stdout.
+
+```
+churn_vs_complexity [options] folder
+        --java                       Check complexity of java classes
+        --ruby                       Check complexity of ruby files
+        --csv                        Format output as CSV
+        --graph                      Format output as HTML page with Churn vs Complexity graph
+        --excluded PATTERN           Exclude file paths including this string. Can be used multiple times.
+        --since YYYY-MM-DD           Calculate churn after this date
+    -h, --help                       Display help
+```
+
+## Examples
+
+`churn_vs_complexity --ruby --csv my_ruby_project > ~/Desktop/ruby-demo.csv`
+
+`churn_vs_complexity --java --graph --exclude generated-sources --exclude generated-test-sources --since 2023-01-01 my_java_project > ~/Desktop/java-demo.html`
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/beatmadsen/churn_vs_complexity.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'tldr/rake'
+
+task default: :tldr

data/bin/churn_vs_complexity

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'churn_vs_complexity'
+
+begin
+  ChurnVsComplexity::CLI.run!
+rescue StandardError => e
+  warn e.message
+end

data/lib/churn_vs_complexity/churn.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'git'
+
+module ChurnVsComplexity
+  module Churn
+    module GitCalculator
+      class << self
+        def calculate(folder:, file:, since:)
+          with_follow = calculate_with_follow(folder, file, since)
+          with_follow.zero? ? repo(folder).log.path(file).size : with_follow
+        end
+
+        private
+
+        def calculate_with_follow(folder, file, since)
+          # Format the date as "YYYY-MM-DD"
+          formatted_date = since.strftime('%Y-%m-%d')
+          # git log --follow --oneline --since="YYYY-MM-DD" <file_path> | wc -l
+          `git --git-dir #{File.join(folder,
+                                     '.git',)} --work-tree #{folder} log --follow --oneline --since=#{formatted_date} #{file} | wc -l`.to_i
+        end
+
+        def repo(folder)
+          repos[folder] ||= Git.open(folder)
+        end
+
+        def repos
+          @repos ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/cli.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'time'
+require 'optparse'
+
+module ChurnVsComplexity
+  class CLI
+    def self.run!
+      # Create an options hash to store parsed options
+      options = { excluded: [] }
+      since = nil
+
+      # Initialize OptionParser
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: churn_vs_complexity [options] folder'
+
+        opts.on('--java', 'Check complexity of java classes') do
+          options[:language] = :java
+        end
+
+        opts.on('--ruby', 'Check complexity of ruby files') do
+          options[:language] = :ruby
+        end
+
+        opts.on('--csv', 'Format output as CSV') do
+          options[:serializer] = :csv
+        end
+
+        opts.on('--graph', 'Format output as HTML page with Churn vs Complexity graph') do
+          options[:serializer] = :graph
+        end
+
+        opts.on('--excluded PATTERN',
+                'Exclude file paths including this string. Can be used multiple times.',) do |value|
+          options[:excluded] << value
+        end
+
+        opts.on('--since YYYY-MM-DD', 'Calculate churn after this date') do |value|
+          since = value
+        end
+
+        opts.on('-h', '--help', 'Display help') do
+          puts opts
+          exit
+        end
+      end.parse!
+
+      # First argument that is not an option is the folder
+      folder = ARGV.first
+
+      raise Error, 'No folder selected. Use --help for usage information.' if folder.nil? || folder.empty?
+
+      #  Verify that folder exists
+      raise Error, "Folder #{folder} does not exist" unless File.directory?(folder)
+
+      raise Error, 'No options selected. Use --help for usage information.' if options.empty?
+
+      begin
+        if since.nil?
+          since = Time.at(0).to_date
+          options[:graph_title] = 'Churn vs Complexity'
+        else
+          date_string = since
+          since = Date.strptime(since, '%Y-%m-%d')
+          options[:graph_title] = "Churn vs Complexity since #{date_string}"
+        end
+      rescue StandardError
+        raise Error, "Invalid date #{since}, please use correct format, YYYY-MM-DD"
+      end
+
+      config = Config.new(**options)
+
+      config.validate!
+
+      puts config.to_engine.check(folder:, since:)
+    end
+  end
+end

data/lib/churn_vs_complexity/complexity/flog_calculator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'flog'
+
+module ChurnVsComplexity
+  module Complexity
+    module FlogCalculator
+      CONCURRENCY = Etc.nprocessors
+
+      class << self
+        def folder_based? = false
+
+        def calculate(file:)
+          flog = Flog.new
+          flog.flog(file)
+          { file => flog.total_score }
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/complexity/pmd_calculator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Complexity
+    module PMDCalculator
+      CONCURRENCY = Etc.nprocessors
+
+      class << self
+        def folder_based? = true
+
+        def calculate(folder:)
+          output = `pmd check -d #{folder} -R #{resolve_ruleset_path} -f json -t #{CONCURRENCY}  --cache #{resolve_cache_path}`
+          Parser.new.parse(output)
+        end
+
+        def check_dependencies!
+          `pmd --help`
+        rescue StandardError
+          raise Error, 'Could not execute PMD using command pmd'
+        end
+
+        private
+
+        def resolve_ruleset_path
+          ruleset_path = File.join(gem_root, 'tmp', 'pmd-support', 'ruleset.xml')
+          raise "ruleset.xml not found in #{ruleset_path}" unless File.exist?(ruleset_path)
+
+          ruleset_path
+        end
+
+        def resolve_cache_path
+          File.join(gem_root, 'tmp', 'pmd-support', 'pmd-cache')
+        end
+
+        def gem_root
+          File.expand_path('../../..', __dir__)
+        end
+      end
+
+      class Parser
+        def parse(output)
+          doc = JSON.parse(output)
+          doc['files'].each_with_object({}) do |file, result|
+            result[file['filename']] =
+              file['violations'].sum { |violation| extract_complexity(violation) }
+          end
+        end
+
+        private
+
+        def extract_complexity(violation)
+          # Find text 'total cyclomatic complexity of <number>'
+          violation['description'].match(/total cyclomatic complexity of (\d+)/)[1].to_i
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/complexity.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'complexity/pmd_calculator'
+require_relative 'complexity/flog_calculator'
+
+module ChurnVsComplexity
+  module Complexity
+  end
+end

data/lib/churn_vs_complexity/concurrent_calculator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  class ConcurrentCalculator
+    CONCURRENCY = Etc.nprocessors
+
+    def initialize(complexity:, churn:)
+      @complexity = complexity
+      @churn = churn
+      @churn_results = {}
+    end
+
+    def calculate(folder:, files:, since:)
+      schedule_churn_calculation(folder, files, since)
+      calculate_complexity(folder, files)
+      await_results
+      combine_results
+    end
+
+    private
+
+    def calculate_complexity(folder, files)
+      @complexity_results =
+        if @complexity.folder_based?
+          @complexity.calculate(folder:)
+        else
+          files.each_with_object({}) do |file, acc|
+            acc.merge!(@complexity.calculate(file:))
+          end
+        end
+    end
+
+    def schedule_churn_calculation(folder, files, since)
+      f = files.dup
+      @threads = CONCURRENCY.times.map do
+        t = Thread.new do
+          until f.empty?
+            next_file = f.pop
+            @churn_results[next_file] = @churn.calculate(folder:, file: next_file, since:)
+          end
+        end
+        t.report_on_exception = false
+        t
+      end
+    end
+
+    def await_results
+      @threads.each(&:join)
+    rescue StandardError => e
+      raise Error, "Failed to caculate churn: #{e.message}"
+    end
+
+    def combine_results
+      @churn_results.to_h do |file, churn|
+        complexity = @complexity_results[file] || -1
+        [file, [churn, complexity]]
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/config.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  class Config
+    def initialize(
+      language:,
+      serializer:,
+      excluded: [],
+      graph_title: nil,
+      complexity_validator: ComplexityValidator
+    )
+      @language = language
+      @serializer = serializer
+      @excluded = excluded
+      @complexity_validator = complexity_validator
+      @graph_title = graph_title
+    end
+
+    def validate!
+      raise Error, "Unsupported language: #{@language}" unless %i[java ruby].include?(@language)
+      raise Error, "Unsupported serializer: #{@serializer}" unless %i[none csv graph].include?(@serializer)
+      raise Error, 'Please provide a title for the graph' if @serializer == :graph && @graph_title.nil?
+
+      @complexity_validator.validate!(@language)
+    end
+
+    def to_engine
+      case @language
+      when :java
+        Engine.concurrent(
+          complexity: Complexity::PMDCalculator,
+          churn:,
+          file_selector: FileSelector::Java.excluding(@excluded),
+          serializer:,
+        )
+      when :ruby
+        Engine.concurrent(
+          complexity: Complexity::FlogCalculator,
+          churn:,
+          file_selector: FileSelector::Ruby.excluding(@excluded),
+          serializer:,
+        )
+      end
+    end
+
+    private
+
+    def churn = Churn::GitCalculator
+
+    def serializer
+      case @serializer
+      when :none
+        Serializer::None
+      when :csv
+        Serializer::CSV
+      when :graph
+        Serializer::Graph.new(title: @graph_title)
+      end
+    end
+
+    module ComplexityValidator
+      def self.validate!(language)
+        case language
+        when :java
+          Complexity::PMDCalculator.check_dependencies!
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/engine.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  class Engine
+    def initialize(file_selector:, calculator:, serializer:)
+      @file_selector = file_selector
+      @calculator = calculator
+      @serializer = serializer
+    end
+
+    def check(folder:, since:)
+      files = @file_selector.select_files(folder)
+      result = @calculator.calculate(folder:, files:, since:)
+      @serializer.serialize(result)
+    end
+
+    def self.concurrent(complexity:, churn:, serializer: Serializer::None, file_selector: FileSelector::Any)
+      Engine.new(file_selector:, serializer:, calculator: ConcurrentCalculator.new(complexity:, churn:))
+    end
+  end
+end

data/lib/churn_vs_complexity/file_selector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module FileSelector
+    module Any
+      def self.select_files(folder)
+        Dir.glob("#{folder}/**/*").select { |f| File.file?(f) }
+      end
+    end
+
+    class Excluding
+      def initialize(extensions, excluded)
+        @extensions = extensions
+        @excluded = excluded
+      end
+
+      def select_files(folder)
+        Dir.glob("#{folder}/**/*").select do |f|
+          !has_excluded_pattern?(f) && has_correct_extension?(f) && File.file?(f)
+        end
+      end
+
+      private
+
+      def has_correct_extension?(file_path)
+        @extensions.any? { |e| file_path.end_with?(e) }
+      end
+
+      def has_excluded_pattern?(file_path)
+        @excluded.any? { |e| file_path.include?(e) }
+      end
+    end
+
+    module Java
+      def self.excluding(excluded)
+        Excluding.new(['.java'], excluded)
+      end
+    end
+
+    module Ruby
+      def self.excluding(excluded)
+        Excluding.new(['.rb'], excluded)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/serializer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Serializer
+    module None
+      def self.serialize(values_by_file) = values_by_file
+    end
+
+    module CSV
+      def self.serialize(values_by_file)
+        values_by_file.map do |file, values|
+          "#{file},#{values[0]},#{values[1]}\n"
+        end.join
+      end
+    end
+
+    class Graph
+      def initialize(title:, template: Graph.load_template_file)
+        @template = template
+        @title = title
+      end
+
+      def serialize(values_by_file)
+        data = values_by_file.map do |file, values|
+          "{ file_path: '#{file}', churn: #{values[0]}, complexity: #{values[1]} }"
+        end.join(",\n") + "\n"
+        @template.gsub("// INSERT DATA\n", data).gsub('INSERT TITLE', @title)
+      end
+
+      def self.load_template_file
+        file_path = File.expand_path('../../tmp/template/graph.html', __dir__)
+        File.read(file_path)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  VERSION = '1.0.0'
+end

data/lib/churn_vs_complexity.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'etc'
+
+require_relative 'churn_vs_complexity/version'
+require_relative 'churn_vs_complexity/engine'
+require_relative 'churn_vs_complexity/concurrent_calculator'
+require_relative 'churn_vs_complexity/file_selector'
+require_relative 'churn_vs_complexity/complexity'
+require_relative 'churn_vs_complexity/churn'
+require_relative 'churn_vs_complexity/cli'
+require_relative 'churn_vs_complexity/config'
+require_relative 'churn_vs_complexity/serializer'
+
+module ChurnVsComplexity
+  class Error < StandardError; end
+end

data/tmp/pmd-support/ruleset.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0"?>
+
+<ruleset name="Rules for churn vs complexity"
+         xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 https://pmd.sourceforge.io/ruleset_2_0_0.xsd">
+
+    <description>
+        Find cyclomatic complexity in java files
+    </description>
+
+    <rule ref="category/java/design.xml/CyclomaticComplexity">
+        <properties>
+            <property name="classReportLevel" value="1"/>
+            <!-- We only want one report pr class -->
+            <property name="methodReportLevel" value="1000000"/>
+            <property name="cycloOptions" value=""/>
+        </properties>
+    </rule>
+
+</ruleset>

data/tmp/template/graph.html

@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>INSERT TITLE</title>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+</head>
+<body>
+  <canvas id="churnComplexityChart" width="800" height="400"></canvas>
+
+  <script>
+    // Example data points from your Ruby gem
+    const dataPoints = [
+      // INSERT DATA
+    ];
+
+    // Extract data for Chart.js
+    const labels = dataPoints.map(point => point.file_path);
+    const churnData = dataPoints.map(point => point.churn);
+    const complexityData = dataPoints.map(point => point.complexity);
+
+    // Prepare data in Chart.js format
+    const data = {
+      labels: labels,
+      datasets: [{
+        label: 'INSERT TITLE',
+        data: dataPoints.map(point => ({ x: point.churn, y: point.complexity })),
+        backgroundColor: 'rgba(75, 192, 192, 0.2)',
+        borderColor: 'rgba(75, 192, 192, 1)',
+        borderWidth: 1,
+        pointRadius: 5,
+        pointHoverRadius: 10
+      }]
+    };
+
+    // Configure and render the chart
+    const config = {
+      type: 'scatter',
+      data: data,
+      options: {
+        scales: {
+          x: {
+            type: 'linear',
+            position: 'bottom',
+            title: {
+              display: true,
+              text: 'Churn'
+            }
+          },
+          y: {
+            title: {
+              display: true,
+              text: 'Complexity'
+            }
+          }
+        },
+        plugins: {
+          tooltip: {
+            callbacks: {
+              label: function(context) {
+                const index = context.dataIndex;
+                return `${labels[index]}: Churn(${context.raw.x}), Complexity(${context.raw.y})`;
+              }
+            }
+          }
+        }
+      }
+    };
+
+    const myChart = new Chart(
+      document.getElementById('churnComplexityChart'),
+      config
+    );
+  </script>
+</body>
+</html>

data/tmp/test-support/java/small-example/src/main/java/org/example/Main.java

@@ -0,0 +1,10 @@
+package org.example;
+
+import org.example.spice.Checker;
+
+public class Main {
+    public static void main(String[] args) {
+        new Checker().check();
+    }
+
+}

data/tmp/test-support/java/small-example/src/main/java/org/example/spice/Checker.java

@@ -0,0 +1,28 @@
+package org.example.spice;
+
+import java.util.Iterator;
+import java.util.PrimitiveIterator;
+import java.util.Random;
+
+public class Checker {
+    public void check() {
+        for (int j = 0; j < 3; j++) {
+            var iter = tenRandomInts();
+            while (iter.hasNext()) {
+                var i = iter.nextInt();
+                if (i < 100) {
+                    System.out.println("Bongo");
+                } else if (i > 200) {
+                    System.out.println("Dingo");
+                } else {
+                    System.out.println("Zapp");
+                }
+            }
+        }
+    }
+
+    private static PrimitiveIterator.OfInt tenRandomInts() {
+        var randomInts = new Random().ints();
+        return randomInts.limit(10).iterator();
+    }
+}

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: churn_vs_complexity
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Erik T. Madsen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: flog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: Inspired by Michael Feathers' article "Getting Empirical about Refactoring"
+  and the gem 'turbulence' by Chad Fowler and others. This gem was built primarily
+  to support analysis of Java and Ruby repositories, but it can easily be extended.
+email:
+- beatmadsen@gmail.com
+executables:
+- churn_vs_complexity
+extensions: []
+extra_rdoc_files: []
+files:
+- ".devcontainer/devcontainer.json"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Dockerfile
+- Dockerfile.dev
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/churn_vs_complexity
+- lib/churn_vs_complexity.rb
+- lib/churn_vs_complexity/churn.rb
+- lib/churn_vs_complexity/cli.rb
+- lib/churn_vs_complexity/complexity.rb
+- lib/churn_vs_complexity/complexity/flog_calculator.rb
+- lib/churn_vs_complexity/complexity/pmd_calculator.rb
+- lib/churn_vs_complexity/concurrent_calculator.rb
+- lib/churn_vs_complexity/config.rb
+- lib/churn_vs_complexity/engine.rb
+- lib/churn_vs_complexity/file_selector.rb
+- lib/churn_vs_complexity/serializer.rb
+- lib/churn_vs_complexity/version.rb
+- tmp/pmd-support/ruleset.xml
+- tmp/template/graph.html
+- tmp/test-support/java/small-example/src/main/java/org/example/Main.java
+- tmp/test-support/java/small-example/src/main/java/org/example/spice/Checker.java
+- tmp/test-support/txt/abc.txt
+- tmp/test-support/txt/d.txt
+- tmp/test-support/txt/ef.txt
+- tmp/test-support/txt/ghij.txt
+- tmp/test-support/txt/klm.txt
+- tmp/test-support/txt/nopq.txt
+- tmp/test-support/txt/r.txt
+- tmp/test-support/txt/st.txt
+- tmp/test-support/txt/uvx.txt
+- tmp/test-support/txt/yz.txt
+homepage: https://github.com/beatmadsen/churn_vs_complexity
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/beatmadsen/churn_vs_complexity
+  changelog_uri: https://github.com/beatmadsen/churn_vs_complexity/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: A tool to visualise code complexity in projects and help direct refactoring
+  efforts.
+test_files: []