objenealogist 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca90d0b5901aa3b2d3d517d772c715b926545530421ea695646a80f4c10e432c
-  data.tar.gz: 7f4f3f5a7aa8b5b1f24855e7b8fa68c258dbbc42686ff29ddc5767105d35782d
+  metadata.gz: 3bf00f425eca6902d2ab65a19c0b125f6a3a7462534f7aca0451097d6598f71e
+  data.tar.gz: 6c70cd4562686b12755f94bc0c4d40f702a6ee787eecc3b73c051a8b4a653bfd
 SHA512:
-  metadata.gz: e406e9f86b6708851d5d56a2340001ec1d6574a8f36481bf1b388103f14712d24f38886d12529860d3b5f84b7673621b78d945f8a93a10d3cd24285e9673c586
-  data.tar.gz: 9718d6c0482ee0e89799c75afb6d86a6e4b90824cae2ff09033da119e0dae326db491b4d9c5cf2fa6cce0620403453302c430c4a6cc60b6cfd92f5ebdfa0231e
+  metadata.gz: 200cb4292920be6f24f1d15cb18b6e4eeab114534e9654968fc22c5892aefc5ba2704ff64534897928850f24d980be2615e710860130c0f4001b586887801852
+  data.tar.gz: f65b8678119db27c0b9747ac2b9a2df749da48e3701516db6a9ec5cafd6bca1633ab2789199198491d45912f3e3f5e9d6c41c2080a573dedfbece00ac63e1220

data/README.md

@@ -1,39 +1,71 @@
 # Objenealogist
 
-TODO: Delete this and the text below, and describe your gem
+> object + genealogist -> objenealogist
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/objenealogist`. To experiment with that code, run `bin/console` for an interactive prompt.
+A Ruby gem that visualizes class inheritance hierarchy and included modules in a tree format.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
-Install the gem and add to the application's Gemfile by executing:
-
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install objenealogist
 ```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+## Usage
 
-```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```ruby
+require 'objenealogist'
+
+puts MyClass.to_tree
 ```
 
-## Usage
+### Options
 
-TODO: Write usage instructions here
+- `show_methods`: Show public methods for each class/module (default: `true`)
+- `show_locations`: Show source file locations (default: `true`). You can also pass a `Regexp` to show locations only for matching class/module names.
 
-## Development
+### Example
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```ruby
+MyClass.to_tree(show_locations: false)
+```
 
-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).
+```
+C MyClass
+│ ├ c
+│ └ singleton_c
+│
+├── M M2
+│ └ m2
+│
+├── M M1
+│ └ m1
+│
+└── C NS::C2
+    │ └ c2
+    │
+    ├── M M4
+    │ └ m4
+    │
+    ├── M M3
+    │ └ m3
+    │
+    └── C C1
+        │ └ c1
+        │
+        ├── M M5
+        │ └ m5
+        │
+        └── C Object
+            ├── M Kernel
+            └── C BasicObject
+```
 
-## Contributing
+### Output to file
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/objenealogist.
+```ruby
+MyClass.to_tree >> "out.txt"
+```
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+MIT License

data/lib/objenealogist/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Objenealogist
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/objenealogist.rb

@@ -4,7 +4,8 @@ require "prism"
 
 require_relative "objenealogist/version"
 
-class Objenealogist
+class Objenealogist # rubocop:disable Style/Documentation
+  # `class` and `module` node visitor
   class ClassVisitor < Prism::Visitor
     attr_reader :found
 
@@ -12,6 +13,7 @@ class Objenealogist
       @target_class_names = target_class_names.map(&:to_s).map(&:to_sym)
       @found = []
       @stack = []
+      super()
     end
 
     def visit_class_node(node)
@@ -26,40 +28,45 @@ class Objenealogist
   end
 
   class << self
-    def to_tree(clazz, show_methods: true, show_locations: true)
-      # ruby -r./lib/objenealogist -e 'puts Objenealogist.to_tree(Objenealogist)'
-      process_one(clazz, show_methods:, show_locations:).join("\n")
+    def to_tree(clazz = self, show_methods: true, show_locations: true)
+      # ruby -r./lib/objenealogist -r./test/my_class -e "puts Objenealogist.to_tree(MyClass)"
+      Objenealogist::String.new(process_one(clazz, show_methods:, show_locations:).join("\n"))
     end
 
-    def process_one(clazz, result = [], location_map = create_location_map(clazz), indent = "", show_methods: true,
+    def process_one(clazz, result = [], location_map = create_location_map(clazz), indent = "", show_methods: true, # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/ParameterLists
                     show_locations: true)
       locations = location_map[clazz.to_s.to_sym]
 
       result << "#{indent}C #{clazz}#{format_locations(locations, show_locations:, target: clazz.to_s)}" if indent == ""
-      if locations && locations[:methods] && show_methods
-        locations[:methods].sort do |a, b|
-          a[2] == b[2] ? a[0] <=> b[0] : a[2] <=> b[2]
-        end.each_with_index do |method, index|
-          m, path, line = method
-          mark = locations[:methods].size - 1 == index ? "└" : "├"
-          result << "#{indent}│ #{mark} #{m}#{format_locations("#{path}:#{line}", show_locations:, target: clazz.to_s)}"
+      if show_methods
+        methods = class << clazz; public_instance_methods(false).map { |m| instance_method(m) }; end
+        methods += clazz.public_instance_methods(false).map do |m|
+          clazz.instance_method(m)
         end
-        result << "#{indent}│"
+        methods.compact.sort { |a, b| a.name <=> b.name }.each_with_index do |method, index|
+          path, line = method.source_location
+          mark = methods.size - 1 == index ? "└" : "├"
+          result << "#{indent}│ #{mark} #{method.name}#{format_locations("#{path}:#{line}", show_locations:,
+                                                                                            target: clazz.to_s)}"
+        end
+        result << "#{indent}│" if methods.any?
       end
 
       (clazz.included_modules - (clazz.superclass&.included_modules || [])).each do |mod|
         locations = location_map[mod.to_s.to_sym]
         result << "#{indent}├── M #{mod}#{format_locations(locations, show_locations:, target: mod.to_s)}"
-        if locations && locations[:methods] && show_methods # rubocop:disable Style/Next
-          locations[:methods].sort do |a, b|
-            a[2] == b[2] ? a[0] <=> b[0] : a[2] <=> b[2]
-          end.each_with_index do |method, index|
-            m, path, line = method
-            mark = locations[:methods].size - 1 == index ? "└" : "├"
-            result << "#{indent}|     #{mark} #{m}#{format_locations("#{path}:#{line}", show_locations:,
-                                                                                        target: mod.to_s)}"
+        if show_methods && mod != ::Kernel # rubocop:disable Style/Next
+          methods = class << mod; public_instance_methods(false).map { |m| instance_method(m) }; end
+          methods += mod.public_instance_methods(false).map do |m|
+            clazz.instance_method(m)
+          end
+          methods.compact.sort { |a, b| a.name <=> b.name }.each_with_index do |method, index|
+            path, line = method.source_location
+            mark = methods.size - 1 == index ? "└" : "├"
+            result << "#{indent}│ #{mark} #{method.name}#{format_locations("#{path}:#{line}", show_locations:,
+                                                                                              target: mod.to_s)}"
           end
-          result << "#{indent}|"
+          result << "#{indent}│" if methods.any?
         end
       end
 
@@ -67,107 +74,69 @@ class Objenealogist
         locations = location_map[clazz.superclass.to_s.to_sym]
         result << "#{indent}└── C #{clazz.superclass}#{format_locations(locations, show_locations:,
                                                                                    target: clazz.superclass.to_s)}"
-        process_one(clazz.superclass, result, location_map, "    #{indent}", show_methods:, show_locations:)
+        if clazz.superclass == ::BasicObject
+          result
+        else
+          process_one(clazz.superclass, result, location_map, "    #{indent}", show_methods:, show_locations:)
+        end
       else
         result
       end
     end
 
-    def format_locations(locations, show_locations: true, target: "")
+    def format_locations(locations, show_locations: true, target: "") # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       return "" unless show_locations
       return "" if show_locations.is_a?(Regexp) && show_locations !~ target
 
-      if locations.is_a?(String)
-        if locations != ":0" && show_locations
+      if locations.is_a?(::String)
+        if locations != ":" && show_locations
           " (location: #{locations})"
         else
           ""
         end
-      elsif locations && locations[:locations]&.any? && show_locations
-        " (location: #{locations[:locations].map { |path, loc| "#{path}:#{loc.start_line}" }.join(", ")})"
+      elsif locations&.any? && show_locations
+        " (location: #{locations.map { |path, loc| "#{path}:#{loc.start_line}" }.join(", ")})"
       else
         ""
       end
     end
 
-    def create_location_map(clazz)
+    def create_location_map(clazz) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       instance = clazz.allocate
       methods = clazz.methods + instance.methods
-      source_locations = methods.map do |m|
+      location_map = {}
+      methods.map do |m|
         if clazz.respond_to?(m) && clazz.method(m).source_location
-          [m] + clazz.method(m).source_location
+          clazz.method(m).source_location[0]
         elsif instance.respond_to?(m) && instance.method(m).source_location
-          [m] + instance.method(m).source_location
+          instance.method(m).source_location[0]
         end
-      end.compact
-      location_map = {}
-      source_locations.uniq { |_, path,| path }.each do |method, path, line|
+      end.compact.uniq.each do |path| # rubocop:disable Style/MultilineBlockChain
         next unless File.exist?(path)
 
-        source = File.open(path).read
+        source = File.read(path)
         visitor = ClassVisitor.new(clazz.ancestors)
         Prism.parse(source).value.accept(visitor)
         visitor.found.each do |name, def_location|
-          (location_map[name] ||= { name: name, locations: [], methods: [] })[:locations] << [path, def_location]
+          (location_map[name] ||= []) << [path, def_location]
         end
       end
-      source_locations.uniq(&:join).each do |m, method_path, line|
-        locations = location_map.values.find do |location|
-          location[:locations].any? do |source_path, loc|
-            method_path == source_path && loc.start_line <= line && line <= loc.end_line
-          end
-        end
-        if locations
-          locations[:methods] << [m, method_path, line]
-        else
-          location_map[clazz.to_s.to_sym]&.[](:methods)&.<< [m, nil, 0]
-        end
-      end
-      # {M1:
-      #   {name: :M1,
-      #    locations: [["objenealogist.rb", (122,0)-(124,3)]],
-      #    methods: [[:m1, "objenealogist.rb", 123]]}}
+      # {M1: [["objenealogist.rb", (122,0)-(124,3)]]}
       location_map
     end
   end
-end
 
-module M1
-  def m1 = :m1
-end
+  class String < ::String # rubocop:disable Style/Documentation
+    def >>(other)
+      raise "A file already exists!" if File.exist?(other)
 
-module M2
-  def m2 = :m2
-end
-
-module M3
-  def m3 = :m3
-end
-
-module M4
-  include M3
-  def m4 = :m4
-end
-
-module M5
-  def m5 = :m5
-end
-
-class C1
-  include M5
-  def c1 = :c1
-end
-
-module NS
-  class C2 < C1
-    include M4
-    def c2 = :c2
+      File.write(other, to_s)
+    end
   end
 end
 
-class MyClass < NS::C2
-  include M1
-  include M2
-  def c = :c
-  def self.singleton_c = :singleton_c
+class Class # rubocop:disable Style/Documentation
+  def to_tree(show_methods: true, show_locations: true)
+    Objenealogist.to_tree(self, show_methods:, show_locations:)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: objenealogist
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Koji NAKAMURA