calltally 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 500a5c27806a402198ff657275586756c3a3d004f01b03cdad133b13b119c1bf
+  data.tar.gz: 1f479fe7061ad208fb22d376519a6040d85bf93d80a92672e4ab01db51fdac59
+SHA512:
+  metadata.gz: eaa590ed4f0c510b262597e1b89fd08f8e01940a4abc35a6dc768018b1c1ee2220cb8f4ca141e9190f1e09be956368ab8b7b9be8ec316b1ced685e2e9548ff9d
+  data.tar.gz: b9390cb686dbeb010039999fc4c93d53f2e0508468b3a4df2cb3a2fdeb06e0abbf7f8bb3da9948349ae82203ec9919cbfe21cce5792b2bba61762c1f4ea0d8c4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+https://github.com/nsgc/calltally/issues.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Naoki Nishiguchi
+
+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,216 @@
+# Calltally
+
+> Tally your method calls.
+
+A simple yet powerful tool to analyze method usage in Ruby/Rails codebases. Quickly identify your most-used methods, understand code patterns, and make informed refactoring decisions.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'calltally', group: :development
+```
+
+Or install globally:
+
+```bash
+gem install calltally
+```
+
+## Quick Start
+
+```bash
+# Analyze current directory
+calltally
+
+# Analyze specific directory
+calltally app/models
+
+# Show top 20 results
+calltally --top 20
+
+# Focus on specific classes
+calltally --receivers User,Post --top 10
+```
+
+## Usage Examples
+
+### Rails Projects
+
+Calltally automatically detects Rails projects and scans the right directories:
+
+```bash
+# Auto-detects Rails and scans app/, lib/, config/
+calltally
+
+# Include ERB templates
+calltally --erb
+
+# Focus on ActiveRecord methods
+calltally --methods where,find,joins --mode pairs
+```
+
+### Output Formats
+
+```bash
+# Default table format
+calltally
+
+# JSON format for further processing
+calltally --format json > analysis.json
+
+# CSV for spreadsheet analysis
+calltally --format csv -o results.csv
+```
+
+### Filtering and Analysis
+
+```bash
+# Show only method names (no receivers)
+calltally --mode methods
+
+# Show only receivers (classes being called)
+calltally --mode receivers
+
+# Show receiver-method pairs (default)
+calltally --mode pairs
+
+# Include methods called without explicit receivers
+calltally --include-nil-receiver
+```
+
+## Configuration
+
+Create `.calltally.yml` in your project root for persistent settings:
+
+```yaml
+# .calltally.yml
+profile: rails          # auto|rails|default
+dirs:                   # Directories to scan
+  - app
+  - lib
+exclude:                # Patterns to exclude
+  - spec
+  - test
+  - vendor
+top: 50                 # Number of results to show
+include_erb: true       # Process ERB files
+mode: pairs            # pairs|methods|receivers
+skip_operators: true    # Skip operators like +, -, ==
+```
+
+You can also use a custom config file:
+
+```bash
+calltally --config config/calltally-production.yml
+```
+
+## Advanced Usage
+
+<details>
+<summary>Filter by Variable Types</summary>
+
+```bash
+# Only local variables
+calltally --only-locals
+
+# Only instance variables
+calltally --only-ivars
+
+# Only class/module constants
+calltally --only-constants
+
+# Class variables
+calltally --only-cvars
+
+# Global variables
+calltally --only-gvars
+
+# Combine filters
+calltally --only-locals --only-constants
+
+# Show variable names instead of grouping
+calltally --split-variables
+# Shows: (var:user).name instead of (var).name
+```
+</details>
+
+<details>
+<summary>All CLI Options</summary>
+
+```
+calltally [PATH] [options]
+
+Options:
+  --profile PROFILE        auto|rails|default (default: auto)
+  -d, --dirs x,y           Directories to include
+  -x, --exclude x,y        Path parts to exclude
+  -n, --top N              Show top N results (default: 100)
+  -v, --verbose            Verbose output
+  --erb                    Include .erb files (requires erubi gem)
+
+  --mode MODE              Output mode:
+                           - pairs: receiver-method pairs (default)
+                           - methods: method names only
+                           - receivers: receiver names only
+
+  --receivers x,y          Filter by receiver constants (e.g. User,Post)
+  --methods x,y            Filter by method names (e.g. where,find)
+
+  --include-nil-receiver   Count calls without explicit receiver
+  --split-variables        Show variable names (e.g. '(var:user)' vs '(var)')
+
+  --only-locals            Show only local variable receivers
+  --only-ivars             Show only instance variable receivers
+  --only-cvars             Show only class variable receivers
+  --only-gvars             Show only global variable receivers
+  --only-constants         Show only constant receivers
+
+  --[no-]skip-operators    Skip operator methods like +, -, ==, [] (default: true)
+
+  --format FORMAT          Output format: table|json|csv (default: table)
+  -o, --output PATH        Write result to file instead of STDOUT
+  --config PATH            Use a specific config file
+  -h, --help               Show help
+```
+</details>
+
+## Understanding the Output
+
+Calltally shows method calls in your codebase with their receivers:
+
+```
+10  User.where          # User class, where method, called 10 times
+ 5  (var).each          # Local variable, each method, called 5 times
+ 3  (ivar).save         # Instance variable, save method
+ 2  Post#.validate      # validate called within Post class (implicit receiver)
+```
+
+### Receiver Types
+
+- `User` - Class or module constant
+- `(var)` - Local variable (use `--split-variables` to see names)
+- `(ivar)` - Instance variable
+- `(cvar)` - Class variable
+- `(gvar)` - Global variable
+- `(self)` - Explicit self receiver
+- `(result)` - Method calls on results (e.g., `user.posts.first` → `(var).posts` + `(result).first`)
+- `#` - Implicit receiver (when using `--include-nil-receiver`)
+
+## Use Cases
+
+1. **Find most-used methods** - Identify candidates for optimization
+2. **Understand code patterns** - See how your team uses APIs
+3. **Refactoring decisions** - Know what methods are heavily depended upon
+4. **API design** - Understand which methods are actually used
+5. **Code reviews** - Quickly analyze unfamiliar codebases
+6. **Gem development** - See how your gem's methods are used
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nsgc/calltally.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/exe/calltally

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "calltally"
+
+Calltally::CLI.start(ARGV)

data/lib/calltally/cli.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "yaml"
+
+module Calltally
+  class CLI
+    def self.start(argv) = new.run(argv)
+
+    def run(argv)
+      sub = argv.first
+      return print_help if %w[-h --help help].include?(sub)
+
+      case sub
+      when "scan" then run_scan(argv.drop(1))
+      when nil then run_scan(argv)  # Default to scan when no command specified
+      else
+        # If first arg doesn't look like a command, treat as scan with path
+        if sub.start_with?("-") || File.exist?(sub) || sub == "."
+          run_scan(argv)
+        else
+          warn "Unknown command: #{sub}"
+          print_help
+
+          exit 1
+        end
+      end
+    end
+
+    def print_help
+      puts <<~USAGE
+        calltally #{Calltally::VERSION}
+        Usage:
+          calltally [PATH] [options]  # Defaults to scan command
+          calltally scan [PATH] [options]
+
+        Commands:
+          scan    Scan a directory (default PATH='.') and summarize method usage. (default)
+
+        Options (scan):
+          --profile PROFILE        auto(default)|rails|default
+          -d, --dirs x,y           Directories to include
+          -x, --exclude x,y        Path parts to exclude
+          -n, --top N              Show top N (default: 100)
+          -v, --verbose
+          --erb                    Include .erb (requires 'erubi' gem)
+          --mode MODE              Output mode:
+                                   - pairs (default): receiver-method pairs
+                                   - methods: method names only
+                                   - receivers: receiver names only
+          --receivers x,y          Filter by receiver constants (e.g. User,Group)
+          --methods x,y            Filter by method names (e.g. where,find)
+          --include-nil-receiver   Count calls without constant receiver (as '(no recv)')
+          --split-variables        Show variable names (e.g. '(var:user)' instead of '(var)')
+          --only-locals            Show only local variable receivers
+          --only-ivars             Show only instance variable receivers
+          --only-cvars             Show only class variable receivers
+          --only-gvars             Show only global variable receivers
+          --only-constants         Show only constant receivers
+          --only-results           Show only method results receivers
+          --[no-]skip-operators    Skip operator methods like +, -, ==, [] (default: true)
+          --format F               table(default)|json|csv
+          -o, --output PATH        Write result to file instead of STDOUT
+          --config PATH            Use a specific .calltally.yml
+          -h, --help
+      USAGE
+    end
+
+    def run_scan(argv)
+      base_dir = "."
+      cli_opts = {}
+      config_override = nil
+
+      opts = OptionParser.new do |opt|
+        opt.on("--profile PROFILE") { |v| cli_opts["profile"] = v }
+        opt.on("-d x,y", "--dirs x,y", Array) { |v| cli_opts["dirs"] = v }
+        opt.on("-x x,y", "--exclude x,y", Array) { |v| cli_opts["exclude"] = v }
+        opt.on("-n N", "--top N", Integer) { |v| cli_opts["top"] = v }
+        opt.on("-v", "--verbose") { cli_opts["verbose"] = true }
+        opt.on("--erb") { cli_opts["include_erb"] = true }
+        opt.on("--mode MODE", [:pairs, :methods, :receivers]) { |v| cli_opts["mode"] = v.to_s }
+        opt.on("--receivers x,y", Array) { |v| cli_opts["receivers"] = v }
+        opt.on("--methods x,y", Array) { |v| cli_opts["methods"] = v }
+        opt.on("--include-nil-receiver") { cli_opts["include_nil_receiver"] = true }
+        opt.on("--split-variables") { cli_opts["split_variables"] = true }
+        opt.on("--only-locals") { (cli_opts["receiver_types"] ||= []) << "locals" }
+        opt.on("--only-ivars") { (cli_opts["receiver_types"] ||= []) << "ivars" }
+        opt.on("--only-cvars") { (cli_opts["receiver_types"] ||= []) << "cvars" }
+        opt.on("--only-gvars") { (cli_opts["receiver_types"] ||= []) << "gvars" }
+        opt.on("--only-constants") { (cli_opts["receiver_types"] ||= []) << "constants" }
+        opt.on("--only-results") { (cli_opts["receiver_types"] ||= []) << "results" }
+        opt.on("--[no-]skip-operators") { |v| cli_opts["skip_operators"] = v }
+        opt.on("--format F", [:table, :json, :csv]) { |v| cli_opts["format"] = v.to_s }
+        opt.on("-o PATH", "--output PATH") { |v| cli_opts["output"] = v }
+        opt.on("--config PATH") { |v| config_override = v }
+        opt.on("-h", "--help") { puts opt; exit }
+      end
+
+      if argv.first && !argv.first.start_with?("-")
+        base_dir = argv.shift
+      end
+
+      opts.parse!(argv)
+
+      if config_override && File.file?(config_override)
+        yaml = YAML.load_file(config_override) || {}
+        yaml.each { |k, v| cli_opts[k.to_s] = v unless cli_opts.key?(k.to_s) }
+      end
+
+      config = Calltally::Config.load(base_dir: base_dir, cli_opts: cli_opts)
+
+      if config["profile"] == "rails" && config["include_erb"] && !Calltally::Config.erubi_available?
+        warn "[calltally] Rails profile detected but 'erubi' not found. ERB will be skipped. Install 'erubi' to include ERB."
+        config["include_erb"] = false
+      end
+
+      mode, rows = Calltally::Scanner.new(base_dir: base_dir, config: config).scan
+
+      out = config["output"] ? File.open(config["output"], "w") : $stdout
+      begin
+        case config["format"]
+        when "json" then Calltally::Formatter.print_json(mode: mode, data: rows, io: out)
+        when "csv"  then Calltally::Formatter.print_csv(mode: mode, data: rows, io: out)
+        else             Calltally::Formatter.print_table(mode: mode, data: rows, io: out)
+        end
+      ensure
+        out.close if out.is_a?(File)
+      end
+    end
+  end
+end

data/lib/calltally/config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "set"
+
+module Calltally
+  class Config
+    DEFAULTS = {
+      "profile" => "auto",              # auto|rails|default
+      "dirs" => %w[.],
+      "exclude" => %w[spec test vendor node_modules tmp log .git .bundle],
+      "top" => 100,
+      "verbose" => false,
+      "include_erb" => false,
+      "mode" => "pairs",                # pairs|methods|receivers
+      "receivers" => nil,               # ["User","Group"]
+      "methods" => nil,                 # ["where","find"]
+      "include_nil_receiver" => false,
+      "split_variables" => false,      # Show variable names vs grouping
+      "receiver_types" => nil,          # ["locals", "ivars", "constants"] etc.
+      "skip_operators" => true,
+      "format" => "table",              # table|json|csv
+      "output" => nil
+    }.freeze
+
+    RAILS_DIR_PRESET = %w[app lib config].freeze
+
+    def self.load(base_dir:, cli_opts:)
+      config = DEFAULTS.dup
+
+      path = File.join(base_dir, ".calltally.yml")
+      if File.file?(path)
+        yaml = YAML.load_file(path) || {}
+        yaml.each { |k, v| config[k.to_s] = v }
+      end
+
+      cli_opts.compact.each { |k, v| config[k.to_s] = v }
+
+      config["profile"] = resolve_profile(base_dir, config["profile"])
+
+      if config["profile"] == "rails"
+        config["dirs"] = RAILS_DIR_PRESET if config["dirs"] == DEFAULTS["dirs"]
+        config["include_erb"] = config["include_erb"] || erubi_available?
+      end
+
+      config["receivers"] = to_set_or_nil(config["receivers"])
+      config["methods"]   = to_set_or_nil(config["methods"]&.map(&:to_s))
+      config
+    end
+
+    def self.resolve_profile(base_dir, desired)
+      return desired unless desired == "auto"
+
+      gemfile_path = File.join(base_dir, "Gemfile")
+      if File.file?(gemfile_path) && File.read(gemfile_path).include?("rails")
+        "rails"
+      else
+        "default"
+      end
+    end
+
+    def self.erubi_available?
+      require "erubi"
+      true
+    rescue LoadError
+      false
+    end
+
+    def self.to_set_or_nil(v)
+      case v
+      when nil then nil
+      when Set then v
+      when Array then Set.new(v)
+      else Set.new([v])
+      end
+    end
+  end
+end

data/lib/calltally/formatter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "json"
+begin
+  require "csv"
+rescue LoadError
+  # CSV is optional for Ruby 3.4+
+end
+
+module Calltally
+  module Formatter
+    module_function
+
+    def print_table(mode:, data:, io: $stdout)
+      case mode
+      when :pairs
+        name_w  = (data.map { |receiver, method, _| "#{receiver}.#{method}".length }.max || 0)
+        count_w = (data.map { |_, _, count| count.to_s.length }.max || 1)
+
+        data.each { |receiver, method, count|
+          io.puts "#{count.to_s.rjust(count_w)}  #{(receiver + "." + method).ljust(name_w)}"
+        }
+      when :methods, :receivers
+        name_w  = (data.map { |name, _| name.to_s.length }.max || 0)
+        count_w = (data.map { |_, count| count.to_s.length }.max || 1)
+
+        data.each { |name, count|
+          io.puts "#{count.to_s.rjust(count_w)}  #{name.to_s.ljust(name_w)}"
+        }
+      end
+    end
+
+    def print_json(mode:, data:, io: $stdout)
+      payload =
+        case mode
+        when :pairs
+          { mode: "pairs", rows: data.map { |receiver, method, count| { receiver:, method:, count: } } }
+        when :methods
+          { mode: "methods", rows: data.map { |method, count| { method:, count: } } }
+        when :receivers
+          { mode: "receivers", rows: data.map { |receiver, count| { receiver:, count: } } }
+        end
+
+      io.puts JSON.pretty_generate(payload)
+    end
+
+    def print_csv(mode:, data:, io: $stdout)
+      case mode
+      when :pairs
+        io.puts CSV.generate_line(%w[receiver method count])
+        data.each { |receiver, method, count| io.puts CSV.generate_line([receiver, method, count]) }
+      when :methods
+        io.puts CSV.generate_line(%w[method count])
+        data.each { |method, count| io.puts CSV.generate_line([method, count]) }
+      when :receivers
+        io.puts CSV.generate_line(%w[receiver count])
+        data.each { |receiver, count| io.puts CSV.generate_line([receiver, count]) }
+      end
+    end
+  end
+end

data/lib/calltally/prism_visitor.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+begin
+  require "prism"
+rescue LoadError
+  warn "[calltally] prism not found. Install 'prism' gem or use Ruby 3.3+."
+  raise
+end
+
+module Calltally
+  class PrismVisitor < ::Prism::Visitor
+    def initialize(config, pair_counts, method_counts, receiver_counts)
+      super()
+
+      @config          = config
+      @pair_counts     = pair_counts
+      @method_counts   = method_counts
+      @receiver_counts = receiver_counts
+      @class_stack     = []
+    end
+
+    def visit_class_node(node)
+      class_name = extract_class_name(node.constant_path)
+      @class_stack.push(class_name)
+
+      super
+    ensure
+      @class_stack.pop
+    end
+
+    def visit_module_node(node)
+      module_name = extract_class_name(node.constant_path)
+      @class_stack.push(module_name)
+
+      super
+    ensure
+      @class_stack.pop
+    end
+
+    def visit_call_node(node)
+      meth  = node.name&.to_s
+      rname = receiver_name(node.receiver)
+      tally(rname, meth)
+
+      super
+    end
+
+    def visit_block_argument_node(node)
+      expr = node.expression
+
+      if expr.is_a?(::Prism::SymbolNode)
+        tally(nil, expr.value.to_s)
+      end
+
+      super
+    end
+
+    private
+
+    def operator_like?(name)
+      name = name.to_s
+      !!(name =~ /\A(\[\]|\[\]=|[!~]|\*\*|===|==|!=|<=|>=|<<|>>|<|>|\+|-|\*|\/|%|\^|&|\|)\z/)
+    end
+
+    def tally(receiver_name, method_name)
+      return if method_name.nil?
+      return if @config["skip_operators"] && operator_like?(method_name)
+      return if @config["methods"] && !@config["methods"].include?(method_name)
+
+      # Filter by receiver type if specified
+      if @config["receiver_types"] && !@config["receiver_types"].empty?
+        return unless receiver_type_matches?(receiver_name, @config["receiver_types"])
+      end
+
+      if receiver_name.nil? && @config["include_nil_receiver"]
+        receiver_name = current_context_with_hash
+      end
+
+      case @config["mode"].to_s.downcase.to_sym
+      when :pairs
+        if receiver_name
+          return if @config["receivers"] && !@config["receivers"].include?(receiver_name)
+
+          @pair_counts[[receiver_name, method_name]] += 1
+          @receiver_counts[receiver_name] += 1
+        else
+          @method_counts[method_name] += 1
+        end
+      when :methods
+        @method_counts[method_name] += 1
+      when :receivers
+        @receiver_counts[receiver_name] += 1 if receiver_name
+      end
+    end
+
+    def receiver_name(node)
+      return nil if node.nil?
+
+      case node
+      when ::Prism::ConstantReadNode, ::Prism::ConstantPathNode
+        node.full_name.to_s if node.respond_to?(:full_name)
+      when ::Prism::LocalVariableReadNode
+        @config["split_variables"] ? "(var:#{node.name})" : "(var)"
+      when ::Prism::InstanceVariableReadNode
+        @config["split_variables"] ? "(ivar:#{node.name})" : "(ivar)"
+      when ::Prism::ClassVariableReadNode
+        @config["split_variables"] ? "(cvar:#{node.name})" : "(cvar)"
+      when ::Prism::GlobalVariableReadNode
+        @config["split_variables"] ? "(gvar:#{node.name})" : "(gvar)"
+      when ::Prism::SelfNode
+        "(self)"
+      when ::Prism::CallNode
+        "(result)"
+      else
+        nil
+      end
+    end
+
+    def const_full_name(node)
+      return nil if node.nil?
+      return node.full_name.to_s if node.respond_to?(:full_name)
+      nil
+    end
+
+    def extract_class_name(node)
+      case node
+      when ::Prism::ConstantReadNode
+        node.name.to_s
+      when ::Prism::ConstantPathNode
+        node.full_name.to_s if node.respond_to?(:full_name)
+      else
+        nil
+      end
+    end
+
+    def current_context_with_hash
+      if @class_stack.empty?
+        "#"
+      else
+        "#{@class_stack.join('::')}#"
+      end
+    end
+
+    def receiver_type_matches?(rname, allowed_types)
+      return false if rname.nil?
+
+      if rname.start_with?("(var")
+        allowed_types.include?("locals")
+      elsif rname.start_with?("(ivar")
+        allowed_types.include?("ivars")
+      elsif rname.start_with?("(cvar")
+        allowed_types.include?("cvars")
+      elsif rname.start_with?("(gvar")
+        allowed_types.include?("gvars")
+      elsif rname.start_with?("(result)")
+        allowed_types.include?("results")
+      elsif rname.start_with?("(self)")
+        # For future --only-self option
+        allowed_types.include?("self")
+      elsif rname.start_with?("#")
+        # For nil receivers with include_nil_receiver
+        allowed_types.include?("implicit")
+      else
+        # Constants like User, Post, etc.
+        allowed_types.include?("constants")
+      end
+    end
+  end
+end

data/lib/calltally/scanner.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "find"
+require "calltally/prism_visitor"
+
+module Calltally
+  class Scanner
+    def initialize(base_dir:, config:)
+      @base_dir = File.expand_path(base_dir)
+      @config   = config
+    end
+
+    def scan
+      files = collect_paths
+      warn_verbose "Scan targets: #{files.size} files"
+      files.first(10).each { |file| warn_verbose " - #{file}" }
+
+      pair_counts     = Hash.new(0)
+      method_counts   = Hash.new(0)
+      receiver_counts = Hash.new(0)
+
+      visitor = PrismVisitor.new(@config, pair_counts, method_counts, receiver_counts)
+
+      files.each do |path|
+        begin
+          src    = read_source(path)
+          result = ::Prism.parse(src)
+          if (root = result.value)
+            visitor.visit(root)
+          else
+            warn_verbose "Prism.parse returned nil: #{path}"
+          end
+        rescue => e
+          warn "Error: #{path}: #{e.class}: #{e.message}"
+        end
+      end
+
+      top = Integer(@config["top"])
+      mode_sym = @config["mode"].to_s.downcase.to_sym
+
+      case mode_sym
+      when :pairs
+        rows = pair_counts.sort_by { |(_, _), c| -c }.first(top).map { |(r, m), c| [r, m, c] }
+      when :methods
+        rows = method_counts.sort_by { |_, c| -c }.first(top).map { |m, c| [m, c] }
+      when :receivers
+        rows = receiver_counts.sort_by { |_, c| -c }.first(top).map { |r, c| [r, c] }
+      else
+        raise ArgumentError, "Unknown mode: #{@config['mode']}"
+      end
+
+      [mode_sym, rows]
+    end
+
+    private
+
+    def warn_verbose(msg)
+      return unless @config && @config["verbose"]
+      warn(msg)
+    end
+
+    def collect_paths
+      exts = %w[.rb .ru .rake]
+      exts << ".erb" if @config["include_erb"]
+
+      files = []
+      @config["dirs"].each do |dir|
+        absolute_path = File.expand_path(dir, @base_dir)
+        next unless Dir.exist?(absolute_path)
+
+        Find.find(absolute_path) do |path|
+          next if File.directory?(path)
+          next unless exts.include?(File.extname(path))
+          next if excluded?(path)
+
+          files << path
+        end
+      end
+
+      files.uniq
+    end
+
+    def excluded?(path)
+      rel = path.sub(@base_dir + "/", "")
+      @config["exclude"].any? { |ex| rel.include?("/#{ex}/") || File.basename(rel).start_with?("#{ex}.") }
+    end
+
+    def read_source(path)
+      src = File.binread(path)
+      src = src.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "")
+
+      if @config["include_erb"] && File.extname(path) == ".erb"
+        begin
+          require "erubi"
+          src = Erubi::Engine.new(src).src
+        rescue LoadError
+          warn "ERB requested but 'erubi' not installed. Skipping ERB compilation for #{path}."
+        end
+      end
+
+      src
+    end
+  end
+end

data/lib/calltally/version.rb

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

data/lib/calltally.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "calltally/version"
+require_relative "calltally/version"
+require_relative "calltally/config"
+require_relative "calltally/formatter"
+require_relative "calltally/scanner"
+require_relative "calltally/cli"
+
+module Calltally
+end

data/sig/calltally.rbs

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

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: calltally
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Naoki Nishiguchi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: erubi
+  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: A simple yet powerful tool to analyze method usage in Ruby/Rails codebases.
+  Track which methods are called most frequently, filter by receivers or method names,
+  and export results in table, JSON, or CSV format. Perfect for understanding code
+  patterns, refactoring decisions, and identifying heavily-used APIs.
+executables:
+- calltally
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/calltally
+- lib/calltally.rb
+- lib/calltally/cli.rb
+- lib/calltally/config.rb
+- lib/calltally/formatter.rb
+- lib/calltally/prism_visitor.rb
+- lib/calltally/scanner.rb
+- lib/calltally/version.rb
+- sig/calltally.rbs
+homepage: https://github.com/nsgc/calltally
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nsgc/calltally
+  source_code_uri: https://github.com/nsgc/calltally.git
+  rubygems_mfa_required: 'true'
+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: 3.6.9
+specification_version: 4
+summary: Tally your method calls
+test_files: []