code_keeper 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da70c28c42b1b848e40adb6145d25686ed8e8bea4dbf25adeb49bebbb82555a8
-  data.tar.gz: dcf7b9aebd57660ded6869224c87769d836c8518a19b46c74a8d1c86edd1e9b4
+  metadata.gz: 1d30fec72da618c4ce29c0c819fb0a912cb968d829182143337b537ec3a69dbc
+  data.tar.gz: f24e1bc9e08780f4e6c2f1943b4620671da06d1ff71026d8e81a00300137b352
 SHA512:
-  metadata.gz: e6dcab3c8280feb01e837e87025d5d71f6913f74b64c5afa22c36e126e8d69f8321c4445653088fc8fa82a4ee5c4bf2dffef825f92e6c5e5fbf4177a9ce725fd
-  data.tar.gz: 6d40b0fe93e685cbe3d982dd467dc843138686bdf08a95964b90da4187587fb9e4a3ffcab454dbc1b90ad086e9df6bf56d96cb2152dabf72450bc203790bde42
+  metadata.gz: ef7a1991ea72b93c1c47d6d07376008ca0d0e9b0da1156bdcedee4cd7efa96b9896912680c0520d8516a9a8486052d753b799fb836610787a794bc0b5001e5fe
+  data.tar.gz: 1c66dd84f996a705b93513bcd45b342cf1d3fba28d4773b84c882489b860c86024293096a0285580e38bde529e4dc53feb84b5cb719afe4ec0c8735ff078b7d5

data/.rubocop.yml

@@ -44,3 +44,16 @@ Style/Documentation:
 
 Metrics/AbcSize:
   Max: 25
+  Exclude:
+    # It's hard to control.
+    - lib/code_keeper/metrics/class_length.rb
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    # It's hard to control.
+    - lib/code_keeper/metrics/class_length.rb 
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    # It's hard to control.
+    - lib/code_keeper/metrics/class_length.rb 

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change log
+
+## Unrelease
+
+## 0.3.0 (2021-09-15)
+
+### New features
+- [#26](https://github.com/ebihara99999/code_keeper/pull/26): Support an ABC software metric.
+- [#27](https://github.com/ebihara99999/code_keeper/pull/27): Support a class length metric.
+### Bug fixes
+
+### Changes
+- [#25](https://github.com/ebihara99999/code_keeper/pull/25): Remove redundant codes.

data/README.md

@@ -3,7 +3,7 @@ The CodeKeeper measures metrics especially about complexity and size of Ruby fil
 
 Mesuring metrics leads to keep codebase simple and clean, and I name the gem CodeKeeper.
 
-Now CodeKeeper supports the cyclomatic complexity. The scores are output to stdout.
+Now CodeKeeper supports the cyclomatic complexity of a file, the ABC software metric of a file, and class length. The scores are output to stdout.
 
 ## Installation
 

data/lib/code_keeper/config.rb

@@ -6,7 +6,7 @@ module CodeKeeper
     attr_accessor :metrics, :number_of_threads
 
     def initialize
-      @metrics = [:cyclomatic_complexity]
+      @metrics = %i[cyclomatic_complexity class_length abc_metric]
       @number_of_threads = 2
     end
   end

data/lib/code_keeper/finder.rb

@@ -16,13 +16,7 @@ module CodeKeeper
     private
 
     def search_recursively(file_or_dir_paths)
-      checked = {}
-
       file_or_dir_paths.each do |edge|
-        next if checked[:"#{edge}"]
-
-        checked[:"#{edge}"] = true
-
         if FileTest.file?(edge)
           file_or_dir_paths << edge unless file_or_dir_paths.include?(edge)
         else

data/lib/code_keeper/formatter.rb

@@ -10,10 +10,16 @@ module CodeKeeper
 
         result.scores.each_key do |metric|
           result.scores[metric].each do |k, v|
+            klass_or_file_key = if metric == :class_length
+                                  'Class'
+                                else
+                                  'Filename'
+                                end
+
             formatted_result.concat(
               <<~EOS
                 Metric: #{metric}
-                Filename: #{k}
+                #{klass_or_file_key}: #{k}
                 Score: #{v}
                 ---
               EOS

data/lib/code_keeper/metrics/abc_metric.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CodeKeeper
+  module Metrics
+    # Caluculate cyclomatic complexity
+    class AbcMetric
+      include ::RuboCop::Cop::Metrics::Utils::IteratingBlock
+      include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
+
+      def initialize(file_path)
+        ps = Parser.parse(file_path)
+        @path = file_path
+        @body = ps.ast
+        @assignments = 0
+        @branches = 0
+        @conditionals = 0
+      end
+
+      def score
+        caluculator = ::RuboCop::Cop::Metrics::Utils::AbcSizeCalculator.new(@body)
+        caluculator.calculate
+        @assignments = caluculator.instance_variable_get('@assignment')
+        @conditionals = caluculator.instance_variable_get('@condition')
+        @branches = caluculator.instance_variable_get('@branch')
+
+        value = Math.sqrt(@assignments**2 + @branches**2 + @conditionals**2).round(4)
+        { "#{@path}": value }
+      end
+    end
+  end
+end

data/lib/code_keeper/metrics/class_length.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module CodeKeeper
+  module Metrics
+    # Caluculate Class Length.
+    class ClassLength
+      def initialize(file_path)
+        @ps = Parser.parse(file_path)
+        @body = @ps.ast
+        @score_hash = {}
+      end
+
+      # NOTE: This doesn't exclude foldale sources like Array, Hash and Heredoc.
+      def score
+        @body.each_node(:class, :casgn) do |node|
+          if node.class_type?
+            @score_hash.store(node.loc.name.source.to_sym, calculate(node))
+          elsif node.casgn_type?
+            parent = node.parent
+
+            if parent&.assignment?
+              block_node = node.children[2]
+            elsif parent&.parent&.masgn_type?
+              # In the case where `A, B = Struct.new(:a, :b)`,
+              # B is always nil.
+              assigned = parent.loc.expression.source.split(',').first
+              next unless node.loc.name.source == assigned
+
+              block_node = parent.parent.children[1]
+            else
+              _scope, klass, block_node = *node
+            end
+
+            # This is not to raise error on dynamic assignments like `X = Y = Z = Class.new`.
+            # the block node is as follows if node is X:
+            # `s(:casgn, nil, :Y, s(:casgn, nil, :Z, s(:block, ...`
+            # Similarly the block node is `:X` as follows if node is Y.
+            next unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
+
+            # if the parent is an assignment_type or the parent of the parent is a masgn_type,
+            klass ||= node.loc.name.source.to_sym
+
+            @score_hash.store(klass, calculate(block_node))
+          end
+        end
+        @score_hash
+      end
+
+      private
+
+      def calculate(node)
+        # node.body.line_count doesn't include comments after definition of a class.
+        count = node.nonempty_line_count - 2
+        count - line_count_of_inner_nodes(node) - comment_line_count(node)
+      end
+
+      def line_count_of_inner_nodes(node)
+        count = 0
+        node.each_descendant(:class, :module) do |klass_or_module_node|
+          count += klass_or_module_node.nonempty_line_count
+        end
+        count
+      end
+
+      def comment_line_count(node)
+        count = 0
+        @ps.comments.each do |comment|
+          count += 1 if (node.first_line...node.last_line).include? comment.loc.line
+        end
+        count
+      end
+    end
+  end
+end

data/lib/code_keeper/metrics/cyclomatic_complexity.rb

@@ -10,18 +10,20 @@ module CodeKeeper
       CONSIDERED_NODES = %i[if while until for csend block block_pass rescue when and or or_asgnand_asgn].freeze
 
       def initialize(file_path)
-        ps = Parser.parse(file_path)
+        @path = file_path
+        ps = Parser.parse(@path)
         @body = ps.ast
       end
 
       # returns score of cyclomatic complexity
       def score
-        @body.each_node(:lvasgn, *CONSIDERED_NODES).reduce(1) do |score, node|
+        final_score = @body.each_node(:lvasgn, *CONSIDERED_NODES).reduce(1) do |score, node|
           next score if !iterating_block?(node) || node.lvasgn_type?
           next score if node.csend_type? && discount_for_repeated_csend?(node)
 
           next 1 + score
         end
+        { "#{@path}": final_score }
       end
     end
   end

data/lib/code_keeper/metrics.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
+require 'code_keeper/metrics/abc_metric'
 require 'code_keeper/metrics/cyclomatic_complexity'
+require 'code_keeper/metrics/class_length'
 
 module CodeKeeper
   # Manage config values of metrics and the correspond classes
   module Metrics
-    MAPPINGS = { cyclomatic_complexity: CodeKeeper::Metrics::CyclomaticComplexity }.freeze
+    MAPPINGS = {
+      abc_metric: CodeKeeper::Metrics::AbcMetric,
+      cyclomatic_complexity: CodeKeeper::Metrics::CyclomaticComplexity,
+      class_length: CodeKeeper::Metrics::ClassLength
+    }.freeze
   end
 end

data/lib/code_keeper/result.rb

@@ -9,8 +9,8 @@ module CodeKeeper
       @scores = CodeKeeper.config.metrics.map { |key| [key, {}] }.to_h
     end
 
-    def add(metric, path, score)
-      scores[:"#{metric}"].store(path, score)
+    def add(metric, klass_or_path, score)
+      scores[:"#{metric}"].store(klass_or_path, score)
     end
   end
 end

data/lib/code_keeper/scorer.rb

@@ -14,20 +14,27 @@ module CodeKeeper
         # `in_threads: 1` makes 2 threads, a sleep_forever thread and the main thread.
         if num_threads == 1
           ruby_file_paths.each do |path|
-            metrics.each do |metric|
-              result.add(:cyclomatic_complexity, path, ::CodeKeeper::Metrics::MAPPINGS[metric].new(path).score)
-            end
+            metrics.each { |metric| calculate_score(metric, path, result) }
           end
         else
           Parallel.map(ruby_file_paths, in_threads: num_threads) do |path|
-            metrics.each do |metric|
-              result.add(:cyclomatic_complexity, path, ::CodeKeeper::Metrics::MAPPINGS[metric].new(path).score)
-            end
+            metrics.each { |metric| calculate_score(metric, path, result) }
           end
         end
 
         result
       end
+
+      private
+
+      def calculate_score(metric, path, result)
+        score = ::CodeKeeper::Metrics::MAPPINGS[metric].new(path).score
+
+        # The class length metric's score has multiple classes.
+        score.each do |k, v|
+          result.add(metric, k.to_s, v)
+        end
+      end
     end
   end
 end

data/lib/code_keeper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CodeKeeper
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/code_keeper.rb

@@ -10,7 +10,9 @@ require 'code_keeper/config'
 require 'code_keeper/scorer'
 require 'code_keeper/result'
 require 'code_keeper/metrics'
+require 'code_keeper/metrics/abc_metric'
 require 'code_keeper/metrics/cyclomatic_complexity'
+require 'code_keeper/metrics/class_length'
 
 module CodeKeeper
   class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_keeper
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yusuke Ebihara
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-08-18 00:00:00.000000000 Z
+date: 2021-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -65,6 +65,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -81,6 +82,8 @@ files:
 - lib/code_keeper/finder.rb
 - lib/code_keeper/formatter.rb
 - lib/code_keeper/metrics.rb
+- lib/code_keeper/metrics/abc_metric.rb
+- lib/code_keeper/metrics/class_length.rb
 - lib/code_keeper/metrics/cyclomatic_complexity.rb
 - lib/code_keeper/parser.rb
 - lib/code_keeper/result.rb