churn_vs_complexity 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d748bfb7d21087a5fbcb360dbc05dcd46b5ec05bf2c2fcc542e2e25368084d78
-  data.tar.gz: 0d160c582aee2696823061dd7623cf17e9b537d798ae31502eb30b065a61391d
+  metadata.gz: de43228c387df735f0bd01eff8f53cfac5bf752474be0f4e901d29d5847781f5
+  data.tar.gz: d78475fd751dff01f1aafb45e995cdeabd2d0561348e86de5cf5f951dcc7b6f0
 SHA512:
-  metadata.gz: f521d39fddad8e8adf05ab0f21d8b8adcc2460f9a57c553b90c73eb60451aafed19ab11977768d494987ff72838c856dd04c3910781ec0da34f53d82d18d9d4e
-  data.tar.gz: 3ab17db013540128bd428edb54cf0615f47ce50caa19d1ad418261c20efde494bb36ea8e84408e0ca330f7721013a9e8958f3cd5a16565636186508e59bf7360
+  metadata.gz: 4297b81854c54d4b60672f89156977299549cc012519b178ce206f3108e3e7dc65b9a9d0341b0f218945b9be580f9cc46fb8b5d049a3e5508f4fb4d026e23f5f
+  data.tar.gz: 1338de4b39496a4af2f9485c14178112558399ab308b03d76ad18294e8a5cb6f87f55f5a0990ea0963ae63d3e6a5c49758c5aed072390e2610e2f0e5b52c2723

data/CHANGELOG.md

@@ -12,3 +12,8 @@
 - Fix bug in CLI where new flags and `--since` would not be recognized
 - Improve selection of observations included in the output
 - Fixed calculation of churn that would never be zero
+
+## [1.3.0] - 2024-09-26
+
+- Add support for javascript and typescript complexity calculation using eslint
+- Fixed behavior when --since or short-hand flags were not provided

data/README.md

@@ -34,6 +34,8 @@ Execute the `churn_vs_complexity` with the applicable arguments. Output in the r
 Usage: churn_vs_complexity [options] folder
         --java                       Check complexity of java classes
         --ruby                       Check complexity of ruby files
+        --js, --ts, --javascript, --typescript
+                                     Check complexity of javascript and typescript files
         --csv                        Format output as CSV
         --graph                      Format output as HTML page with Churn vs Complexity graph
         --summary                    Output summary statistics (mean and median) for churn and complexity
@@ -42,6 +44,7 @@ Usage: churn_vs_complexity [options] folder
     -m, --month                      Calculate churn for the month leading up to the most recent commit
     -q, --quarter                    Calculate churn for the quarter leading up to the most recent commit
     -y, --year                       Calculate churn for the year leading up to the most recent commit
+        --dry-run                    Echo the chosen options from the CLI
     -h, --help                       Display help
 ```
 

data/lib/churn_vs_complexity/churn.rb

@@ -8,7 +8,8 @@ module ChurnVsComplexity
       class << self
         def calculate(folder:, file:, since:)
           git_dir = File.join(folder, '.git')
-          formatted_date = since.strftime('%Y-%m-%d')
+          earliest_date = [date_of_first_commit(folder:), since].max
+          formatted_date = earliest_date.strftime('%Y-%m-%d')
           cmd = %Q(git --git-dir #{git_dir} --work-tree #{folder} log --format="%H" --follow --since="#{formatted_date}" -- #{file} | wc -l)
           `#{cmd}`.to_i
         end
@@ -19,6 +20,10 @@ module ChurnVsComplexity
 
         private
 
+        def date_of_first_commit(folder:)
+          repo(folder).log.last&.date&.to_date || Time.at(0).to_date
+        end
+
         def repo(folder)
           repos[folder] ||= Git.open(folder)
         end

data/lib/churn_vs_complexity/cli.rb

@@ -22,6 +22,10 @@ module ChurnVsComplexity
           options[:language] = :ruby
         end
 
+        opts.on('--js', '--ts', '--javascript', '--typescript', 'Check complexity of javascript and typescript files') do
+          options[:language] = :javascript
+        end
+
         opts.on('--csv', 'Format output as CSV') do
           options[:serializer] = :csv
         end

data/lib/churn_vs_complexity/complexity/eslint_calculator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Complexity
+    module ESLintCalculator
+      class << self
+        def folder_based? = false
+          
+        def calculate(files:)
+          dir_path = File.join(gem_root, 'tmp', 'eslint-support')
+          script_path = File.join(dir_path, 'complexity-calculator.js')
+          install_command = "npm install --prefix '#{dir_path}'"
+          `#{install_command}`
+
+
+          command = "node #{script_path} '#{files.to_json}'"
+          complexity = `#{command}`
+
+          if complexity.empty?
+            raise Error, "Failed to calculate complexity"
+          end
+          all = JSON.parse(complexity)
+          all.to_h do |abc|
+            [abc['file'], abc['complexity']]
+          end
+        end
+
+        private
+
+        def gem_root
+          File.expand_path('../../..', __dir__)
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/complexity/flog_calculator.rb

@@ -5,15 +5,16 @@ require 'flog'
 module ChurnVsComplexity
   module Complexity
     module FlogCalculator
-      CONCURRENCY = Etc.nprocessors
-
       class << self
         def folder_based? = false
 
-        def calculate(file:)
+        def calculate(files:)
           flog = Flog.new
-          flog.flog(file)
-          { file => flog.total_score }
+          # TODO: Run this concurrently
+          files.to_h do |file|
+            flog.flog(file)
+            [file, flog.total_score]
+          end
         end
       end
     end

data/lib/churn_vs_complexity/complexity.rb

@@ -2,6 +2,7 @@
 
 require_relative 'complexity/pmd_calculator'
 require_relative 'complexity/flog_calculator'
+require_relative 'complexity/eslint_calculator'
 
 module ChurnVsComplexity
   module Complexity

data/lib/churn_vs_complexity/concurrent_calculator.rb

@@ -30,9 +30,7 @@ module ChurnVsComplexity
           files[:explicitly_excluded].each { |file| result.delete(file) }
           result
         else
-          files[:included].each_with_object({}) do |file, acc|
-            acc.merge!(@complexity.calculate(file:))
-          end
+          @complexity.calculate(files: files[:included])
         end
     end
 

data/lib/churn_vs_complexity/config.rb

@@ -19,7 +19,7 @@ module ChurnVsComplexity
     end
 
     def validate!
-      raise Error, "Unsupported language: #{@language}" unless %i[java ruby].include?(@language)
+      raise Error, "Unsupported language: #{@language}" unless %i[java ruby javascript].include?(@language)
       raise Error, "Unsupported serializer: #{@serializer}" unless %i[none csv graph summary].include?(@serializer)
 
       @since_validator.validate!(@since)
@@ -44,6 +44,14 @@ module ChurnVsComplexity
           serializer:,
           since: @since,
         )
+      when :javascript
+        Engine.concurrent(
+          complexity: Complexity::ESLintCalculator,
+          churn:,
+          file_selector: FileSelector::JavaScript.excluding(@excluded),
+          serializer:,
+          since: @since,
+        )
       end
     end
 

data/lib/churn_vs_complexity/file_selector.rb

@@ -10,9 +10,10 @@ module ChurnVsComplexity
     end
 
     class Excluding
-      def initialize(extensions, excluded)
+      def initialize(extensions, excluded, convert_to_absolute_path = false)
         @extensions = extensions
         @excluded = excluded
+        @convert_to_absolute_path = convert_to_absolute_path
       end
 
       def select_files(folder)
@@ -25,6 +26,10 @@ module ChurnVsComplexity
             were_included << f
           end
         end
+        if @convert_to_absolute_path
+          were_excluded.map! { |f| File.absolute_path(f) }
+          were_included.map! { |f| File.absolute_path(f) }
+        end
         { explicitly_excluded: were_excluded, included: were_included }
       end
 
@@ -50,5 +55,11 @@ module ChurnVsComplexity
         Excluding.new(['.rb'], excluded)
       end
     end
+
+    module JavaScript
+      def self.excluding(excluded)
+        Excluding.new(['.js', '.jsx', '.ts', '.tsx'], excluded, true)
+      end
+    end
   end
 end

data/lib/churn_vs_complexity/git_date.rb

@@ -22,7 +22,7 @@ module ChurnVsComplexity
         @end_date = end_date
       end
 
-      def effective_start_date = Time.at(0)
+      def effective_start_date = Time.at(0).to_date
 
       def requested_start_date = nil
     end

data/lib/churn_vs_complexity/version.rb

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

data/package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "churn_vs_complexity",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

data/tmp/eslint-support/complexity-calculator.js

@@ -0,0 +1,51 @@
+import { ESLint } from 'eslint';
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+async function analyzeComplexity(files) {
+    const overrideConfig = tseslint.config(
+        eslint.configs.recommended,
+        ...tseslint.configs.recommended,
+        {
+            rules: {
+                'complexity': ['warn', 0],
+            },
+                        
+        }
+    );
+
+    const linter = new ESLint({
+        overrideConfigFile: true,
+        overrideConfig,
+        cwd: '/',
+    });
+
+    try {
+        const results = await linter.lintFiles(files);
+        const complexityResults = results.map(result => {
+            const messages = result.messages.filter(msg => msg.ruleId === 'complexity');
+            const complexity = messages.reduce((sum, msg) => {
+                const complexityValue = parseInt(msg.message.match(/\d+/)[0], 10);
+                return sum + complexityValue;
+            }, 0);
+            
+            if (complexity === 0) {
+                console.error("File has no complexity", result);
+            }
+
+            return {
+                file: result.filePath,
+                complexity,
+            };
+        });
+
+        console.log(JSON.stringify(complexityResults));
+    } catch (error) {
+        console.error('Error during analysis:', error);
+        process.exit(1);
+    }
+}
+
+const files = JSON.parse(process.argv[2]);
+analyzeComplexity(files);

data/tmp/eslint-support/package.json

@@ -0,0 +1,11 @@
+{
+  "type": "module",
+  "dependencies": {
+    "eslint-plugin-complexity": "^1.0.2",
+    "@eslint/js": "^9.11.1",
+    "@types/eslint__js": "^8.42.3",
+    "eslint": "^9.11.1",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.7.0"
+  }
+}

data/tmp/test-support/javascript/complex.js

@@ -0,0 +1,43 @@
+function analyzeNumber(num) {
+    let result = '';
+
+    if (num < 0) {
+        result += 'negative ';
+    } else if (num > 0) {
+        result += 'positive ';
+    } else {
+        return 'zero';
+    }
+
+    if (num % 2 === 0) {
+        result += 'even ';
+    } else {
+        result += 'odd ';
+    }
+
+    if (num % 3 === 0) {
+        result += 'divisible by 3 ';
+    }
+
+    if (num % 5 === 0) {
+        result += 'divisible by 5 ';
+    }
+
+    if (isPrime(num)) {
+        result += 'prime ';
+    }
+
+    return result.trim();
+}
+
+function isPrime(num) {
+    if (num <= 1) return false;
+    for (let i = 2; i <= Math.sqrt(num); i++) {
+        if (num % i === 0) return false;
+    }
+    return true;
+}
+
+console.log(analyzeNumber(17));
+console.log(analyzeNumber(30));
+console.log(analyzeNumber(-7));

data/tmp/test-support/javascript/moderate.js

@@ -0,0 +1,12 @@
+function fibonacci(n) {
+    if (n <= 1) return n;
+    return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+function printFibonacciSequence(length) {
+    for (let i = 0; i < length; i++) {
+        console.log(fibonacci(i));
+    }
+}
+
+printFibonacciSequence(10);

data/tmp/test-support/javascript/simple.js

@@ -0,0 +1,5 @@
+function greet(name) {
+    return `Hello, ${name}!`;
+}
+
+console.log(greet('World'));

data/tmp/test-support/javascript/typescript-example.ts

@@ -0,0 +1,26 @@
+interface Person {
+    name: string;
+    age: number;
+}
+
+function createGreeting(person: Person): string {
+    let greeting = `Hello, ${person.name}!`;
+
+    if (person.age < 18) {
+        greeting += " You're still a minor.";
+    } else if (person.age >= 18 && person.age < 65) {
+        greeting += " You're an adult.";
+    } else {
+        greeting += " You're a senior citizen.";
+    }
+
+    return greeting;
+}
+
+const alice: Person = { name: 'Alice', age: 30 };
+const bob: Person = { name: 'Bob', age: 17 };
+const charlie: Person = { name: 'Charlie', age: 70 };
+
+console.log(createGreeting(alice));
+console.log(createGreeting(bob));
+console.log(createGreeting(charlie));

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: churn_vs_complexity
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Erik T. Madsen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-20 00:00:00.000000000 Z
+date: 2024-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: flog
@@ -62,6 +62,7 @@ files:
 - lib/churn_vs_complexity/churn.rb
 - lib/churn_vs_complexity/cli.rb
 - lib/churn_vs_complexity/complexity.rb
+- lib/churn_vs_complexity/complexity/eslint_calculator.rb
 - lib/churn_vs_complexity/complexity/flog_calculator.rb
 - lib/churn_vs_complexity/complexity/pmd_calculator.rb
 - lib/churn_vs_complexity/concurrent_calculator.rb
@@ -71,10 +72,17 @@ files:
 - lib/churn_vs_complexity/git_date.rb
 - lib/churn_vs_complexity/serializer.rb
 - lib/churn_vs_complexity/version.rb
+- package-lock.json
+- tmp/eslint-support/complexity-calculator.js
+- tmp/eslint-support/package.json
 - 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/javascript/complex.js
+- tmp/test-support/javascript/moderate.js
+- tmp/test-support/javascript/simple.js
+- tmp/test-support/javascript/typescript-example.ts
 - tmp/test-support/txt/abc.txt
 - tmp/test-support/txt/d.txt
 - tmp/test-support/txt/ef.txt