called_uncalled 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ac7eebb19754d8b3bb7ad38973a96b99b313be1f437fdc04bf4c4606f12310b5
+  data.tar.gz: d8d10dc05f2be835da6cc2185433d0a3820980ed730a3699dc3c731e242fcec6
+SHA512:
+  metadata.gz: 9001b8c62228958774720026d769c3b68d051288190c402a2c268c5af51aee4063594d0920b84154dc9e6cd4cff9c5ecb25fa981e732756e1424a2100fc42f9d
+  data.tar.gz: 7ccff283ac786867c9dad05f6235411369a32bcf3bbf5d50abd2e7f28f0a3b69e6026939408f89a84632c5cf700aeff5c0cd588fa4025957a2e1efca577dbcc0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [1.0.0] - 2026-05-02
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"called_uncalled" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["ChapterHouse.Dune@gmail.com"](mailto:"ChapterHouse.Dune@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Frank Hall
+
+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,158 @@
+# CalledUncalled
+
+Identify which methods for a class are being used and which are not.
+
+### Supports
+- Directly defined methods
+- Inherited methods
+- Singleton methods
+- Methods included from Modules
+- Methods dynamically added
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add called_uncalled
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install called_uncalled
+```
+
+## Usage
+
+Include called_uncalled in your Class at any location.
+Execute your code as normal.
+When you are interested in what methods have been called or not called use the class methods 'called_methods' and 'uncalled_methods'.
+The class methods accept an array of classes or modules in the class hierarchy to filter by. The default filter is the class itself.
+To list the singleton methods, pass in the results of #singleton_class. Additionally you can pass in an instance of your class to get 
+both the class and singleton methods combined.
+
+Please note that 
+
+### Example
+```ruby
+module Baz
+
+  def included_called
+    puts 'in included_called'
+  end
+
+  def included_uncalled
+    puts 'in included_uncalled'
+  end
+
+end
+
+class Bar
+
+  def inherited_called
+    puts 'in inherited_called'
+  end
+
+  def inherited_uncalled
+    puts 'in inherited_uncalled'
+  end
+
+end
+
+class Foo < Bar
+
+  include Baz
+
+  def before_called
+    puts 'in before_called'
+  end
+
+  def before_uncalled
+    puts 'in before_uncalled'
+  end
+
+  include CalledUncalled
+
+  def after_called
+    puts 'in after_called'
+  end
+
+  def after_uncalled
+    puts 'in after_uncalled'
+  end
+
+end
+
+a = Foo.new
+b = Foo.new
+def a.singleton_called
+  puts 'in singleton_called'
+end
+
+def b.singleton_uncalled
+  puts 'in singleton_uncalled'
+end
+
+a.before_called
+a.after_called
+a.singleton_called
+a.included_called
+a.inherited_called
+
+uts "\nInstance methods on #{a.class} that were called: #{Foo.called_methods}"
+puts "Instance methods on #{a.class} that were not called: #{Foo.uncalled_methods}\n\n"
+
+puts "Singleton methods on 'a' that were called: #{Foo.called_methods(a.singleton_class)}"
+puts "Combined instance and singleton methods called: #{Foo.called_methods(a)}\n\n"
+
+puts "Uncalled singleton methods on 'a': #{Foo.uncalled_methods(a.singleton_class)}"
+puts "Uncalled singleton methods on 'b': #{Foo.uncalled_methods(b.singleton_class)}\n\n"
+
+puts "Methods from Foo and Bar that were called: #{Foo.called_methods(Foo, Bar)}\n\n"
+puts "All methods called #{Foo.called_methods(:all)}\n\n"
+```
+
+Gives the following output
+```text
+in before_called
+in after_called
+in singleton_called
+in included_called
+in inherited_called
+
+Instance methods on Foo that were called: [:before_called, :after_called]
+Instance methods on Foo that were not called: [:before_uncalled, :after_uncalled]
+
+Singleton methods on 'a' that were called: [:singleton_called]
+Combined instance and singleton methods called: [:before_called, :after_called, :singleton_called]
+
+Uncalled singleton methods on 'a': []
+Uncalled singleton methods on 'b': [:singleton_uncalled]
+
+Methods from Foo and Bar that were called: [:before_called, :after_called, :inherited_called]
+
+All methods called [:singleton_method, :singleton_class, :before_called, :after_called, :singleton_called, :included_called, :inherited_called, :class, :respond_to?, :is_a?]
+```
+
+## Limitations
+
+Identically names singleton methods on multiple instances of the same class are not currently tracked separately.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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 the created tag, 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/[USERNAME]/called_uncalled. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/called_uncalled/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the CalledUncalled project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/called_uncalled/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/called_uncalled/version.rb

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

data/lib/called_uncalled.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "called_uncalled/version"
+
+module CalledUncalled
+
+  def self.included(base)
+
+    base.define_singleton_method(:called_methods) do |*sources|
+      # Default to the class itself if no sources are given
+      sources.push(base) if sources.empty?
+      # If an instance is given, change it to be both the class and the singleton class
+      sources = sources.flatten.map { |source| source.is_a?(base) ? [source.class, source.singleton_class] : source }.flatten
+      # Select all methods that come from the given sources
+      base.class_variable_get(:@@called_methods).select { |m| sources.include?(:all) || sources.include?(m.owner) }.map(&:name)
+    end
+
+    base.define_singleton_method(:uncalled_methods) do |*sources|
+      # Default to the class itself if no sources are given
+      sources.push(base) if sources.empty?
+      # If an instance is given, change it to be both the class and the singleton class
+      sources = sources.flatten.map { |source| source.is_a?(base) ? [source.class, source.singleton_class] : source }.flatten
+      # Select all methods that come from the given sources
+      base.class_variable_get(:@@uncalled_methods).select { |m| sources.include?(:all) || sources.include?(m.owner) }.map(&:name)
+    end
+
+    observe = ->(base, klass,  mthd) do
+      method_name = mthd.name
+      # Add the method name to uncalled methods
+      klass.class_variable_get(:@@uncalled_methods) << mthd
+      # Define a wrapping method
+      base.define_method(method_name) do |*args, **kwargs, &block|
+        # Remove ourselves from the uncalled list and add to the called list
+        newly_called = klass.class_variable_get(:@@uncalled_methods).find { |x| x.name == method_name }
+        if newly_called
+          klass.class_variable_get(:@@uncalled_methods).delete(newly_called)
+          # Add ourselves to the called list if this is the first time we were called
+          klass.class_variable_get(:@@called_methods).push(newly_called)
+        end
+
+        # Make the original call
+        super(*args, **kwargs, &block)
+      end
+    end
+
+    singleton_method_wrapper = Module.new
+
+    method_wrapper = Module.new do
+      # Track called and uncalled methods
+      base.class_variable_set(:@@called_methods, [])
+      base.class_variable_set(:@@uncalled_methods, [])
+
+      # Add the existing methods to the method wrapper
+      method_names = base.instance_methods
+      method_names.each { |method_name|
+        mthd = base.instance_method(method_name)
+        observe.call(self, base, mthd)
+      }
+
+      define_method(:singleton_method_added) do |method_name|
+        mthd = singleton_method(method_name)
+        # Add the new method to the existing singleton method wrapper
+        singleton_method_wrapper.module_eval { observe.call(self, base, mthd) }
+        singleton_class.prepend(singleton_method_wrapper) unless singleton_class < singleton_method_wrapper
+        # Special case deletion as we may be overriding the observer we added on the existing methods
+        newly_called = base.class_variable_get(:@@uncalled_methods).find { |x| x.name == :singleton_method_added }
+        if newly_called
+          base.class_variable_get(:@@uncalled_methods).delete(newly_called)
+          base.class_variable_get(:@@called_methods).push(newly_called)
+        end
+        # Call the original singleton_method_added
+        super(method_name)
+      end
+    end
+
+    method_added_wrapper = Module.new do
+      define_method(:method_added) do |method_name|
+        mthd = base.instance_method(method_name)
+        # Add the new method to the existing method wrapper
+        method_wrapper.module_eval { observe.call(self, base, mthd) }
+        # Call the original method_added
+        super(method_name)
+      end
+    end
+    # Start watching for new methods
+    base.singleton_class.prepend(method_added_wrapper)
+    # Watch all existing new singleton methods
+    base.prepend(method_wrapper)
+  end
+
+end

data/sig/called_uncalled.rbs

@@ -0,0 +1,4 @@
+module CalledUncalled
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: called_uncalled
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Frank Hall
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Track which instance and singleton methods were called and not called
+  including those added dynamically from other sources
+email:
+- ChapterHouse.Dune@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/called_uncalled.rb
+- lib/called_uncalled/version.rb
+- sig/called_uncalled.rbs
+homepage: https://github.com/ChapterHouse/called_uncalled
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ChapterHouse/called_uncalled
+  source_code_uri: https://github.com/ChapterHouse/called_uncalled
+  changelog_uri: https://github.com/ChapterHouse/as_ruby/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Identify methods that were called and not called
+test_files: []