domesticate_monkeys 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2b075af4113a94ea0fa6dc9bdbf085b0cad3d0d15b37badffaca05ed77e656d1
+  data.tar.gz: 2f391f15f8044dec6df881f9e81ff5ebd9a034a5ee1b555898a9e240e300070b
+SHA512:
+  metadata.gz: 152653bfd024299e8ce20aadda9ded6d8124c754925ba4a532ba30929ec3c8f586c00d5a61227969de12954e4bb4faa16591ec39420d3d2d97370519ce1d9758
+  data.tar.gz: 2cab94b24d90eaa77f9122dbdf7206dbdd5e45bd04e3e4a638a5ce9d651c853927cb2935f3e7631bdb70f661d6a367f7589f35d7ddb26be03bc6d8c45ff4ca1f

data/Gemfile

@@ -0,0 +1,5 @@
+
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    domesticate_monkeys (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.3)
+    method_source (1.0.0)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.0.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  domesticate_monkeys!
+  pry
+  rake
+
+BUNDLED WITH
+   2.1.4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Jurriaan Schrofer
+
+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,3 @@
+# Domesticate Monkeys
+
+Domesticating monkeys, yay!

data/bin/domesticate_monkeys

@@ -0,0 +1,45 @@
+require 'optparse'
+require 'domesticate_monkeys'
+require 'pry'
+
+module DomesticateMonkeys
+
+  options  = {}
+
+  # parse task options
+  OptionParser.new do |parser|
+    
+    parser.banner = <<~BANNER
+      
+      domesticate_monkeys shows you all the method redefinitions within your application and its gems.
+
+      Options:
+    BANNER
+
+    parser.on("-s [SHOW]", "--show [SHOW]", "show view [app, all, overview]") { |view| options[:view] = view }
+    parser.on("-t [COUNT]", "--top [COUNT", "show top x redefinitions") { |top| options[:top] = top }
+    parser.on("-h", "--help", "show option") { puts parser; exit }
+    parser.on("-v", "--version", "show version") { puts VERSION; exit }
+  end.parse!
+
+  # set default arguments
+  view = options[:view]&.to_sym || :app
+  top  = options[:top].to_i     || 3
+
+  # validate task
+  abort "Aborted: invalid view argument" unless %i( app all overview ).include?(view&.to_sym)
+  abort "Aborted: too many arguments"    unless ARGV.empty?
+
+  # load application
+  load MainApp
+
+  # show results
+  dm_view = View.new
+  dm_view.send(view)
+
+  # show reports
+  dm_report = Report.new
+  dm_report.boot_information
+  dm_report.top_redefinitions(top)
+
+end

data/lib/domesticate_monkeys/boot/main_app.rb

@@ -0,0 +1,20 @@
+
+# Set boot flag
+$BOOTING_MAIN_APP = true
+
+# Load required domesticate_monkeys framework
+require 'bundler'
+
+# Start boot time counter
+boot_start = `date`
+
+# Boot the main application
+require './config/environment'
+
+# Finalize boot time counter
+boot_start = Time.parse(boot_start)
+boot_end   = Time.now
+$BOOT_TIME = (boot_end.to_f - boot_start.to_f).round(3)
+
+# Reset boot flag
+$BOOTING_MAIN_APP = false

data/lib/domesticate_monkeys/constants/report.rb

@@ -0,0 +1,38 @@
+
+module DomesticateMonkeys
+  class Report
+
+    attr_reader :snapshot, :all_tracks, :multi_tracks, :method_count, :redefined_method_count
+
+    def initialize
+      @snapshot     = Snapshot.new
+      @all_tracks   = @snapshot.all_tracks
+      @multi_tracks = @snapshot.multi_tracks
+
+      @method_count           = @all_tracks.size
+      @redefined_method_count = @multi_tracks.size
+    end
+
+    def top_redefinitions(top_amount = 3)
+      puts "Showing top #{top_amount} redefinitions:"
+      tracks = @multi_tracks.first(top_amount).to_h.values
+      tracks.each(&:print)
+      nil
+    end
+
+    def boot_information
+      plain_text   = "It took domesticate_monkeys #{$BOOT_TIME} seconds to analyse your application,"\
+                     " which defined #{$DOMESTICATE_MONKEYS_COUNT} methods."
+      colored_text = "\e[#{35}m#{plain_text}\e[0m"
+      puts colored_text   
+    end
+
+    def inspect
+      # Overwrite default behaviour, which returns – and thus often prints –
+      # the values of the object's set instance variables, which is enormous
+      # in the case of @all_tracks and @multi_tracks. 
+      to_s
+    end
+
+  end
+end

data/lib/domesticate_monkeys/constants/snapshot.rb

@@ -0,0 +1,42 @@
+
+module DomesticateMonkeys
+  class Snapshot
+
+    # The Snapshot class serves as a data storage, which contains, and compartmentalizes,
+    # all current Track instances.
+
+    # The Snapshot's data storage serves as a basis for other classes, such as View (which
+    # provides insight into the data storage), Report (which provides aggregate information
+    # about your application) and TrackExport (which generates a JSON file).
+
+    attr_reader :all_tracks, :filtered_tracks, :multi_tracks
+
+    def initialize
+      @all_tracks      = $DOMESTICATE_MONKEYS_TRACKS
+      @filtered_tracks = filter_no_methods
+      @multi_tracks    = select_multi_tracks
+    end
+
+    def filter_no_methods
+      @all_tracks.filter { _1.include?(".") || _1.include?("#") }
+    end
+
+    def select_multi_tracks
+      multis = @filtered_tracks.select { |_method, track| track.count > 1 }
+      sort_tracks(multis)
+    end
+
+    def sort_tracks(tracks)
+      sorted_array = tracks.sort_by   { |_method, track| -track.count }
+      sorted_hash  = sorted_array.map { |_method, track| { _method => track } }.inject(&:merge)
+    end
+
+    def inspect
+      # Overwrite default behaviour, which returns – and thus often prints –
+      # the values of the object's set instance variables, which is enormous
+      # in the case of @all_tracks and @multi_tracks. 
+      to_s
+    end
+
+  end
+end

data/lib/domesticate_monkeys/constants/track.rb

@@ -0,0 +1,114 @@
+require "pry"
+module DomesticateMonkeys
+  class Track
+
+    # The Track class serves as the main class for tracking all method definitions:
+    # each method, for each object, that gets defined during the initialization 
+    # process, gets it's own track with a uniquely identifying key, such as:
+    # 'Nokogiri.scrape', or: 'User#format_name'.
+
+    # The Track instance keeps track of the amount of definitions, the chronological
+    # sequence of the source of the definitions, and potentially other information
+    # which we will deem valuable in the future.
+
+    attr_accessor :method, :count, :sources
+
+    class << self
+
+      def add(unbound_method)
+        
+        name   = format_method_name(unbound_method)
+        source = read_method_source(unbound_method)
+        return unless name && source
+
+        # Find the existing track for the given method, or create a new track
+        # if the given method is defined for the first time, through the 
+        # default value of:
+        #   $DOMESTICATE_MONKEYS_TRACKS ||= Hash.new(Track.new)
+
+        # Also, duplicate the found / new record, in order to avoid the same
+        # track being updated all the time and being assigned to all different 
+        # keys.
+
+        track = $DOMESTICATE_MONKEYS_TRACKS[name].dup
+        track.add_source(name, source)
+        
+        rescue
+          return
+      end
+
+      def format_method_name(unbound_method)
+        
+        # The formatted method name serves as the uniquely identifying key for
+        # all operations, with a distinguishing '#' for instance methods and a
+        # '.' for singleton methods.
+
+        name = unbound_method.to_s
+
+        return format_instance_method(name)  if name.include?('UnboundMethod')
+        return format_singleton_method(name) if name.include?('Method')
+      end
+
+      def format_instance_method(name)
+        name.slice(/(?<=#<UnboundMethod: )[^(]*/)
+            .gsub(/\(.*\)/,'')
+            .delete('>')
+      end
+
+      def format_singleton_method(name)
+        name.slice(/(?<=#<Method: )[^(]*/)
+            .gsub(/\(.*\)/,'')
+            .delete('>')
+      end
+
+      def read_method_source(unbound_method)
+        unbound_method.source_location&.join(':')
+      end
+
+    end
+
+    def initialize
+      @method  = nil
+      @count   = 0
+      @sources = []
+    end
+
+    def add_source(method_name, source)
+      
+      $DOMESTICATE_MONKEYS_COUNT += 1
+      printf("\r   Methods defined: #{$DOMESTICATE_MONKEYS_COUNT}\r") if $BOOTING_MAIN_APP
+
+      @method ||= method_name
+      
+      # Duplicate the retrieved self.sources, in order to avoid the instance variable
+      # from hanging and being stacked with every new source – shared between multiple
+      # instances.
+      dupped_sources = @sources.dup
+
+      # Only add a source to the sources variable if the method is being redefined, i.e.
+      # being defined by source code that differs from the previously held definition.
+      # If a file is being read for a second time, the method is technically defined again
+      # but not redefined, since all behaviour is still the same. Therefore we should not
+      # track such cases.
+      dupped_sources << source unless dupped_sources.last == source
+
+      # Update the tracker's state, and add it to our global $DOMESTICATE_MONKEYS_TRACKS dictionary afterwards. 
+      @sources = dupped_sources
+      @count   = dupped_sources.size
+
+      $DOMESTICATE_MONKEYS_TRACKS[self.method] = self
+    end
+
+    def print
+      view = <<~EOL
+      
+      #{@count} definitions for: 
+      #{@method}
+      #{@sources.map.with_index { |source, i| "#{i}: #{source}"}.join("\n")}
+      EOL
+
+      puts view
+    end
+
+  end
+end

data/lib/domesticate_monkeys/constants/view.rb

@@ -0,0 +1,73 @@
+
+module DomesticateMonkeys
+  class View
+
+    attr_reader :snapshot
+
+    def initialize(snapshot = nil)
+      @snapshot = snapshot || Snapshot.new
+    end
+
+    # parsed CLI option methods
+
+    def all(path_filter = nil)
+      tracks = @snapshot.multi_tracks
+      tracks = filter_tracks_by_path(tracks, path_filter) if path_filter
+
+      tracks.values.each { |track| track.print }
+
+      # Return nil in order to avoid a lengthy print of the @snapshot.
+      return nil
+    end
+
+    def app
+      all(app_name)
+    end
+
+    def overview
+      app_header = header_text("#{app_monkeys_count} Monkeys within our own application").red
+      puts app_header
+      app
+
+      all_header = header_text("#{all_monkeys_count} Monkeys through the whole application, including third party software").yellow
+      puts all_header
+      all
+    end
+
+    private
+
+    # Helper methods
+
+    def filter_tracks_by_path(tracks, path_filter)
+      tracks.select do |_method, track|
+        track.sources.any? { |source| source.snakecase.include?(path_filter.snakecase) }
+      end
+    end
+
+    def app_name
+      app_class = Rails.application.class
+      # Support both the new Module#module_parent and the deprecated Module#parent methods (Rails 6.1)
+      top_class = app_class.respond_to?(:module_parent) ? app_class.module_parent : app_class.parent
+      app_name  = top_class.name.snakecase
+    end
+    
+    def app_monkeys_count
+      filter_tracks_by_path(@snapshot.multi_tracks, app_name).count
+    end
+
+    def all_monkeys_count
+      @snapshot.multi_tracks.count
+    end
+
+    def header_text(text)
+      <<~EOL
+        
+
+        #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
+        #{text}
+        #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
+      EOL
+    end
+
+  end
+end

data/lib/domesticate_monkeys/initializers/global_variables.rb

@@ -0,0 +1,3 @@
+
+$DOMESTICATE_MONKEYS_TRACKS ||= Hash.new(DomesticateMonkeys::Track.new)
+$DOMESTICATE_MONKEYS_COUNT  ||= 0

data/lib/domesticate_monkeys/initializers/module.rb

@@ -0,0 +1,28 @@
+
+class Module
+
+  # We can keep track of all methods through the two patches below, which are
+  # provided by ruby as useful callbacks.
+
+  # In order to track as much methods and redefinitions as possible, and thus
+  # giving the best representation of your application's method defining
+  # process, we should initialize all tracker relevant classes AND the below
+  # callbacks as early on in the initialization process as possible.
+
+  # Although 'the earlier, the better' does definitely apply, this should, in
+  # any case, happen BEFORE the initialization of Rails and all other gems.
+  # The reason being that we can only track redefinitions of methods defined in
+  # gems, such as Rails, if we first are able to built a Track for that method's
+  # orignal definition.
+
+  def method_added(_method)
+    unbound_method = instance_method(_method)
+    DomesticateMonkeys::Track.add(unbound_method)
+  end
+
+  def self.singleton_method_added(_method)
+    unbound_method = singleton_method(_method)
+    DomesticateMonkeys::Track.add(unbound_method)
+  end
+
+end

data/lib/domesticate_monkeys/tasks/dm.rake

@@ -0,0 +1,10 @@
+
+namespace :dm do
+
+  task :run do
+    
+    # binding.pry
+    puts "hihihi, I'm a monkey!"
+  end
+
+end

data/lib/domesticate_monkeys/version.rb

@@ -0,0 +1,6 @@
+
+module DomesticateMonkeys
+
+  VERSION = '0.0.1'
+
+end

data/lib/domesticate_monkeys.rb

@@ -0,0 +1,17 @@
+
+require "domesticate_monkeys/version"
+
+module DomesticateMonkeys
+
+  Root    = File.expand_path('../', __dir__)
+  MainApp = Root + "/lib/domesticate_monkeys/boot/main_app.rb"
+
+  autoload :Track,    "domesticate_monkeys/constants/track"
+  autoload :View,     "domesticate_monkeys/constants/view"
+  autoload :Snapshot, "domesticate_monkeys/constants/snapshot"
+  autoload :Report,   "domesticate_monkeys/constants/report"
+
+  require "domesticate_monkeys/initializers/global_variables"
+  require "domesticate_monkeys/initializers/module" 
+
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: domesticate_monkeys
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jurriaan Schrofer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Monkey patches make your application great yet dangerous, therefore you
+  ought to domesticate them!
+email:
+- jschrofer@gmail.com
+executables:
+- domesticate_monkeys
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- bin/domesticate_monkeys
+- lib/domesticate_monkeys.rb
+- lib/domesticate_monkeys/boot/main_app.rb
+- lib/domesticate_monkeys/constants/report.rb
+- lib/domesticate_monkeys/constants/snapshot.rb
+- lib/domesticate_monkeys/constants/track.rb
+- lib/domesticate_monkeys/constants/view.rb
+- lib/domesticate_monkeys/initializers/global_variables.rb
+- lib/domesticate_monkeys/initializers/module.rb
+- lib/domesticate_monkeys/tasks/dm.rake
+- lib/domesticate_monkeys/version.rb
+homepage: https://github.com/jurriaanschrofer/domesticate_monkeys
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jurriaanschrofer/domesticate_monkeys
+  source_code_uri: https://github.com/jurriaanschrofer/domesticate_monkeys
+  changelog_uri: https://github.com/jurriaanschrofer/domesticate_monkeys
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Monkey patches make your application great yet dangerous, therefore you ought
+  to domesticate them!
+test_files: []