overrides_tracker 0.1.9 → 0.1.12

data/lib/overrides_tracker/methods_collector.rb

@@ -1,4 +1,6 @@
 class OverridesTracker::MethodsCollector
+  require 'active_support/core_ext/string/inflections'
+
   require 'json'
   @instance = new
 
@@ -6,51 +8,44 @@ class OverridesTracker::MethodsCollector
   @overridden_methods_collection = {}
 
   private_class_method :new
-  def self.instance
-    @instance
-  end
 
-  def add_instance_method_for_class(class_name, method_name, method_hash)
-    add_method_for_class(:instance_methods, class_name, method_name, method_hash)
+  class << self
+    attr_reader :instance
   end
 
-  def add_singleton_method_for_class(class_name, method_name, method_hash)
-    add_method_for_class(:singleton_methods, class_name, method_name, method_hash)
-  end 
-  
   def add_method_for_class(method_type, class_name, method_name, method_hash)
     methods_collection(class_name)
     @methods_collection[class_name][method_type][method_name] = method_hash
-  end
-
-  def mark_method_as_instance_override(class_name, method_name, overriding_method, method_hash)
-    mark_method_as_override(:instance_methods, class_name, method_name, overriding_method, method_hash)
-  end
-
-  def mark_method_as_singleton_override(class_name, method_name, overriding_method, method_hash)
-    mark_method_as_override(:singleton_methods, class_name, method_name, overriding_method, method_hash)
+    if !@methods_collection[class_name][:is_part_of_app] && @methods_collection[class_name][method_type][method_name][:is_part_of_app]
+      @methods_collection[class_name][:is_part_of_app] = true
+    end
   end
 
   def mark_method_as_override(method_type, class_name, method_name, overriding_method, method_hash)
     overridden_methods_collection(class_name)
-    @overridden_methods_collection[class_name][method_type][method_name] = @methods_collection[class_name][method_type][method_name]
-    @overridden_methods_collection[class_name][method_type][method_name][:overriding_location] = overriding_method.source_location
+    @overridden_methods_collection[class_name][method_type][method_name] =
+@methods_collection[class_name][method_type][method_name]
+    @overridden_methods_collection[class_name][method_type][method_name][:overriding_location] =
+overriding_method.source_location
     @overridden_methods_collection[class_name][method_type][method_name][:overriding_body] = method_hash[:body]
     @overridden_methods_collection[class_name][method_type][method_name][:overriding_sha] = method_hash[:sha]
-  end
-
-  def mark_method_as_added_instance(class_name, method_name, overriding_method, method_hash)
-    mark_method_as_added(:added_instance_methods, class_name, method_name, overriding_method, method_hash)
-  end
-
-  def mark_method_as_added_singleton(class_name, method_name, overriding_method, method_hash)
-    mark_method_as_added(:added_singleton_methods, class_name, method_name, overriding_method, method_hash)
+    if @overridden_methods_collection[class_name][method_type][method_name][:overriding_location][0].include? Dir.pwd
+      @overridden_methods_collection[class_name][method_type][method_name][:overriding_is_part_of_app] = true
+    else
+      @overridden_methods_collection[class_name][method_type][method_name][:overriding_is_part_of_app] = false
+    end
   end
 
   def mark_method_as_added(method_type, class_name, method_name, overriding_method, method_hash)
     overridden_methods_collection(class_name)
-    @overridden_methods_collection[class_name][method_type][method_name] =  method_hash
-    @overridden_methods_collection[class_name][method_type][method_name][:overriding_location] = overriding_method.source_location
+    @overridden_methods_collection[class_name][method_type][method_name] = method_hash
+    @overridden_methods_collection[class_name][method_type][method_name][:overriding_location] =
+overriding_method.source_location
+    if @overridden_methods_collection[class_name][method_type][method_name][:overriding_location][0].include? Dir.pwd
+      @overridden_methods_collection[class_name][method_type][method_name][:overriding_is_part_of_app] = true
+    else
+      @overridden_methods_collection[class_name][method_type][method_name][:overriding_is_part_of_app] = false
+    end
   end
 
   def build_overrides_hash_for_method_type(clazz, class_methods, methods_type, working_directory)
@@ -58,49 +53,51 @@ class OverridesTracker::MethodsCollector
     if methods_type == :instance_methods
       methods = clazz.instance_methods(false)
       clazz.ancestors.each do |ancestor|
-        if ancestor.class == Class
-          break
-        end
-        methods = methods + ancestor.instance_methods(false)
+        break if ancestor.instance_of?(Class)
+
+        methods += ancestor.instance_methods(false)
       end
     else
       methods = clazz.singleton_methods(false)
       clazz.ancestors.each do |ancestor|
-        if ancestor.class == Class
-          break
-        end
-        methods = methods + ancestor.singleton_methods(false)
+        break if ancestor.instance_of?(Class)
+
+        methods += ancestor.singleton_methods(false)
+      end
+      clazz.singleton_class.ancestors.each do |ancestor|
+        break if ancestor.instance_of?(Class)
+        methods += ancestor.instance_methods(false)
       end
     end
 
     methods.each do |method_name|
-      if method_name != nil && method_name != :overrides_tracker_finished_file
-        method_hash = class_methods[methods_type][method_name]
-        begin
-          if methods_type == :instance_methods
-            method_to_check = clazz.instance_method(method_name)
-          else
-            method_to_check = clazz.singleton_method(method_name)
-          end
+      next unless !method_name.nil? && method_name != :overrides_tracker_finished_file
+
+      method_hash = class_methods[methods_type][method_name]
+
+      begin
+        method_to_check = if methods_type == :instance_methods
+                            clazz.instance_method(method_name)
+                          else
+                            clazz.singleton_class.instance_method(method_name) || clazz.singleton_method(method_name)
+                          end
 
-          method_to_check_hash = OverridesTracker::Util.method_hash(method_to_check)
-        
-          if method_to_check_hash[:location] != nil 
-            if method_hash != nil
-              if method_to_check_hash[:location] != method_hash[:location]
-                mark_method_as_override(methods_type, clazz.name, method_name, method_to_check, method_to_check_hash)
-                puts "#{method_name} of class #{clazz.name} was overridden".green
-              end
-            else
-              if (method_to_check_hash[:location][0].include? working_directory)
-                mark_method_as_added("added_#{methods_type}".to_sym, clazz.name, method_name, method_to_check, method_to_check_hash)
-                puts "#{method_name} of class #{clazz.name} was added".green
-              end
+        method_to_check_hash = OverridesTracker::Util.method_hash(method_to_check)
+
+        unless method_to_check_hash[:location].nil?
+          if !method_hash.nil?
+            if method_to_check_hash[:location] != method_hash[:location]
+              mark_method_as_override(methods_type, clazz.name, method_name, method_to_check, method_to_check_hash)
+              puts "#{method_name} of class #{clazz.name} was overridden".green
             end
+          elsif method_to_check_hash[:location][0].include? working_directory
+            mark_method_as_added("added_#{methods_type}".to_sym, clazz.name, method_name, method_to_check,
+                                 method_to_check_hash)
+            puts "#{method_name} of class #{clazz.name} was added".green
           end
-        rescue Exception => e
-          #puts "Error processing #{method_name} of class #{clazz.name}".red
         end
+      rescue Exception => e
+        # puts "Error processing #{method_name} of class #{clazz.name}".red
       end
     end
   end
@@ -109,13 +106,18 @@ class OverridesTracker::MethodsCollector
     total_classes = @methods_collection.size
     count = 0
     working_directory = Dir.pwd
+
     @methods_collection.each do |class_name, class_methods|
-      if class_name != nil
-        clazz = class_name.constantize
-        build_overrides_hash_for_method_type(clazz, class_methods, :instance_methods, working_directory)
-        build_overrides_hash_for_method_type(clazz, class_methods, :singleton_methods, working_directory)
+      unless class_name.nil?
+        begin
+          clazz = class_name.constantize
+          build_overrides_hash_for_method_type(clazz, class_methods, :instance_methods, working_directory)
+          build_overrides_hash_for_method_type(clazz, class_methods, :singleton_methods, working_directory)
+        rescue Exception => e
+          puts "Error processing #{class_name}".red
+        end
       end
-      count = count+1
+      count += 1
       puts "Processed #{class_name} #{count} / #{total_classes}"
     end
   end
@@ -130,28 +132,48 @@ class OverridesTracker::MethodsCollector
     begin
       File.open(file_path) do |f|
         file_data = JSON.parse(f.read)
-        data = file_data['overridden_methods'] != nil ?  file_data['overridden_methods'] : file_data
+        data = file_data
       end
-    rescue
+    rescue StandardError
       puts "Error processing #{file_path}"
     end
     data
   end
 
   def save_to_file
-    
     file_data = {}
     file_data[:version] = OverridesTracker::VERSION
     file_data[:branch_name] = branch_name
+    file_data[:author_name] = author_name
+    file_data[:committer_name] = committer_name
     file_data[:branch_name_to_report] = branch_name_to_report
     file_data[:last_commit_id] = last_commit_id
     file_data[:last_commit_name] = last_commit_name
     file_data[:last_commit_name_to_report] = last_commit_name_to_report
     file_data[:working_directory] = Dir.pwd
     file_data[:bundle_path] = Bundler.bundle_path.to_s
-    file_data[:overridden_methods] = @overridden_methods_collection
+    file_data[:methods_collection] = @overridden_methods_collection
 
-    File.open(path_to_report_file, "w") do |f|
+    classes_with_overrides = @methods_collection.select do |_key, val|
+      !val[:instance_methods].nil? || !val[:singleton_methods].nil?
+    end
+    classes_with_overrides_transformed = classes_with_overrides.map do |k, v|
+      [k, v[:instance_methods], v[:singleton_methods]]
+    end
+
+    file_data[:number_of_methods] = classes_with_overrides_transformed.sum { |a| a[1].size + a[2].size }
+    file_data[:number_of_methods_in_app_path] = classes_with_overrides_transformed.sum do |a|
+      a[1].sum do |b|
+        (b[1][:is_part_of_app] || b[1][:overriding_is_part_of_app]) ? 1 : 0 
+      end + a[2].sum do |b|
+        (b[1][:is_part_of_app] || b[1][:overriding_is_part_of_app]) ? 1 : 0
+      end
+    end
+
+    file_data[:number_of_classes] = @methods_collection.size
+    file_data[:number_of_classes_in_app_path] = @methods_collection.select { |_k, v| v[:is_part_of_app] }.size
+
+    File.open(path_to_report_file, 'w') do |f|
       f << file_data.to_json
     end
     puts '  '
@@ -170,7 +192,7 @@ class OverridesTracker::MethodsCollector
     @methods_collection[class_name] ||= {}
     @methods_collection[class_name][:instance_methods] ||= {}
     @methods_collection[class_name][:singleton_methods] ||= {}
-    @methods_collection[class_name][:closed] ||= 'no'
+    @methods_collection[class_name][:is_part_of_app] ||= false
   end
 
   def overridden_methods_collection(class_name)
@@ -184,34 +206,43 @@ class OverridesTracker::MethodsCollector
 
   def branch_name
     branch = `git rev-parse --abbrev-ref HEAD`
-    branch.downcase.gsub('/','_').gsub(/\s+/, "")
+    branch.downcase.gsub('/', '_').gsub(/\s+/, '').chomp
   end
 
   def branch_name_to_report
-    branch = `git rev-parse --abbrev-ref HEAD`
-    branch.gsub(/\s+/, "")
+    branch = `git rev-parse --abbrev-ref HEAD`.chomp
+    branch.gsub(/\s+/, '')
   end
 
   def last_commit_id
-    commit_id = `git log --format="%H" -n 1`
-    commit_id.gsub(/\s+/, "")
+    commit_id = `git log --format="%H" -n 1`.chomp
+    commit_id.gsub(/\s+/, '')
   end
 
   def last_commit_name
-    commit_name = `git log --format="%s" -n 1`
-    commit_name.gsub(/\s+/, "")
+    commit_name = `git log --format="%s" -n 1`.chomp
+    commit_name.gsub(/\s+/, '')
   end
 
   def last_commit_name_to_report
-    commit_name = `git log --format="%s" -n 1`
+    commit_name = `git log --format="%s" -n 1`.chomp
+    commit_name
+  end
+
+  def author_name
+    author_name = `git show -s --format='%an'`.chomp
+  end
+
+  def committer_name
+    committer_name = `git show -s --format='%cn'`.chomp
   end
 
   def path_to_report_file
     file_name = "#{branch_name}##{last_commit_id}.otf"
 
-    directory_name = File.join(Dir.pwd, "/overrides_tracker")
-    Dir.mkdir(directory_name) unless File.exists?(directory_name)
+    directory_name = File.join(Dir.pwd, '/overrides_tracker')
+    Dir.mkdir(directory_name) unless File.exist?(directory_name)
 
-    directory_name+"/#{file_name}"
+    directory_name + "/#{file_name}"
   end
-end
+end

data/lib/overrides_tracker/string_colorizer.rb

@@ -30,12 +30,10 @@ module OverridesTracker::StringColorizer
   def bold
     "\e[1m#{self}\e[22m"
   end
-  
+
   def italic
-    "\e[3m#{self}\e[23m" 
+    "\e[3m#{self}\e[23m"
   end
-
-
 end
 
-String.prepend(OverridesTracker::StringColorizer)
+String.prepend(OverridesTracker::StringColorizer)

data/lib/overrides_tracker/util.rb

@@ -2,33 +2,30 @@ require 'digest/sha1'
 
 module OverridesTracker
   class Util
-    class << self
-
-      def method_hash method
-          begin
-              {
-                  :sha => method_sha(method),
-                  :location => method.source_location,
-                  :body => outdented_method_body(method),
-              }
-          rescue
-              {
-                  :sha => method.hash,
-                  :location => nil,
-                  :body => nil,
-              }
-          end
-      end
+    def self.method_hash(method)
+      {
+        sha: method_sha(method),
+        location: method.source_location,
+        body: outdented_method_body(method),
+        is_part_of_app: method.source_location[0].include?(Dir.pwd)
+      }
+    rescue StandardError
+      {
+        sha: nil,
+        location: nil,
+        body: nil,
+        is_part_of_app: false
+      }
+    end
 
-      def outdented_method_body method
-        body = method.source
-        indent = body.match(/^\W+/).to_s
-        body.lines.map{|l| l.sub(indent, '')}.join
-      end
+    def self.outdented_method_body(method)
+      body = method.source
+      indent = body.match(/^\W+/).to_s
+      body.lines.map { |l| l.sub(indent, '') }.join
+    end
 
-      def method_sha method
-        Digest::SHA1.hexdigest(method.source.gsub(/\s+/, ' '))
-      end
+    def self.method_sha(method)
+      Digest::SHA1.hexdigest(method.source.gsub(/\s+/, ' '))
     end
   end
 end

data/lib/overrides_tracker/version.rb

@@ -1,3 +1,3 @@
 module OverridesTracker
-  VERSION = "0.1.9"
+  VERSION = '0.1.12'
 end

data/lib/overrides_tracker.rb

@@ -1,19 +1,18 @@
-require "overrides_tracker/version"
+require 'overrides_tracker/version'
 
 # dependency for extracting method bodies and comments
 require 'method_source'
 
-require "overrides_tracker/version"
-require "overrides_tracker/methods_collector"
-require "overrides_tracker/file_observer"
-require "overrides_tracker/string_colorizer"
-require "overrides_tracker/util"
-require "overrides_tracker/comparer"
-require "overrides_tracker/api"
-
+require 'overrides_tracker/version'
+require 'overrides_tracker/methods_collector'
+require 'overrides_tracker/file_observer'
+require 'overrides_tracker/string_colorizer'
+require 'overrides_tracker/util'
+require 'overrides_tracker/comparer'
+require 'overrides_tracker/api'
+require 'overrides_tracker/hash_decorator'
 
 module OverridesTracker
-
 end
 
 # We only want to do this core ruby monkey patching when using cli
@@ -37,39 +36,19 @@ if defined? OVERRIDES_TRACKER_TRACKING_ENABLED
         inst_methods.each do |inst_method|
           method = clazz.instance_method(inst_method)
           method_hash = OverridesTracker::Util.method_hash(method)
-          OverridesTracker::MethodsCollector.instance.add_instance_method_for_class(clazz.name, inst_method, method_hash)
+          OverridesTracker::MethodsCollector.instance.add_method_for_class(:instance_methods, clazz.name, inst_method,
+                                                                           method_hash)
         end
 
         single_methods = clazz.singleton_methods(false)
         single_methods.each do |single_method|
-          if single_method != :overrides_tracker_finished_file
-            method = clazz.singleton_method(single_method)
-            method_hash = OverridesTracker::Util.method_hash(method)
-            OverridesTracker::MethodsCollector.instance.add_singleton_method_for_class(clazz.name, single_method, method_hash)
-          end
-        end
-      end
-    end
-  end
-end
+          next unless single_method != :overrides_tracker_finished_file
 
-
-
-
-#Adding deep merge functionality
-Hash.class_eval do
-  def deep_merge(other_hash, &block)
-    dup.deep_merge!(other_hash, &block)
-  end
-
-  def deep_merge!(other_hash, &block)
-    merge!(other_hash) do |key, this_val, other_val|
-      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-        this_val.deep_merge(other_val, &block)
-      elsif block_given?
-        block.call(key, this_val, other_val)
-      else
-        other_val
+          method = clazz.singleton_method(single_method)
+          method_hash = OverridesTracker::Util.method_hash(method)
+          OverridesTracker::MethodsCollector.instance.add_method_for_class(:singleton_methods, clazz.name,
+                                                                           single_method, method_hash)
+        end
       end
     end
   end

data/overrides_tracker.gemspec

@@ -1,42 +1,42 @@
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "overrides_tracker/version"
+require 'overrides_tracker/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "overrides_tracker"
+  spec.name          = 'overrides_tracker'
   spec.version       = OverridesTracker::VERSION
-  spec.authors       = ["Simon Meyborg"]
-  spec.email         = ["meyborg@syborgstudios.com"]
+  spec.authors       = ['Simon Meyborg']
+  spec.email         = ['meyborg@syborgstudios.com']
 
   spec.summary       = 'Overrides Tracker monitors methods you override for changes and allows for comparison across branches.'
   spec.description   = 'Overrides Tracker monitors methods you override for changes and allows for comparison across branches.'
-  spec.homepage      = "https://github.com/SyborgStudios/overrides_tracker"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/SyborgStudios/overrides_tracker'
+  spec.license       = 'MIT'
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
-    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
 
-    spec.metadata["homepage_uri"] = spec.homepage
-    spec.metadata["source_code_uri"] = spec.homepage 
-    spec.metadata["changelog_uri"] = "https://github.com/SyborgStudios/overrides_tracker/CHANGELOG.md"
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = spec.homepage
+    spec.metadata['changelog_uri'] = 'https://github.com/SyborgStudios/overrides_tracker/CHANGELOG.md'
   else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
   end
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
 
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-   `git ls-files -z`.split("\x0")
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0")
   end
 
-  spec.bindir        = "bin"
+  spec.bindir        = 'bin'
   spec.executables   = ['overrides_tracker']
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "method_source"
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'method_source'
 end

data/spec/overrides_tracker_spec.rb

@@ -1,9 +1,5 @@
 RSpec.describe OverridesTracker do
-  it "has a version number" do
+  it 'has a version number' do
     expect(OverridesTracker::VERSION).not_to be nil
   end
-
-  it "does something useful" do
-    expect(false).to eq(true)
-  end
 end

data/spec/spec_helper.rb

@@ -1,12 +1,28 @@
-require "bundler/setup"
-require "overrides_tracker"
+require 'simplecov'
+require 'coveralls'
+require 'simplecov-lcov'
+
+SimpleCov::Formatter::LcovFormatter.config.report_with_single_file = true
+SimpleCov.formatter = SimpleCov::Formatter::LcovFormatter
+
+SimpleCov.start 'rails' do # <============= 2
+  add_filter 'spec/'
+  add_filter 'lib/external/require_all.rb'
+  add_filter 'lib/overrides_tracker/version.rb'
+  add_filter 'lib/overrides_tracker.rb'
+end
+
+Coveralls.wear!
+
+require 'bundler/setup'
+require 'overrides_tracker'
+require 'rspec'
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = ".rspec_status"
-
+  config.mock_with :rspec
   # Disable RSpec exposing methods globally on `Module` and `main`
-  config.disable_monkey_patching!
+  # config.disable_monkey_patching!
 
   config.expect_with :rspec do |c|
     c.syntax = :expect

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: overrides_tracker
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.12
 platform: ruby
 authors:
 - Simon Meyborg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-13 00:00:00.000000000 Z
+date: 2023-01-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: method_source
   requirement: !ruby/object:Gem::Requirement