peeky 0.0.40 → 0.0.47

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08eb3e66afafe6b6af1896abb030457b6bd417ddaed97311f174b30458805146'
-  data.tar.gz: 587f9afee745e58ee2783aa80d23c482a096ad8f96b8d50cbe9a1683b5f23188
+  metadata.gz: bd2714ca018026119c093e7920cd6de4202f809add8780595dc1bc2d77fa4c33
+  data.tar.gz: dfd1dfc025023e32c2b2892b3880c2be63a54bbc347d269cee0e19533a72fa4b
 SHA512:
-  metadata.gz: 2cf0854c592886fc801068f7bf3bb310bcbb8db1b343be375e1b4ad82ab574fba783697bdce642358747784a247ba4b1ee49885a6737662866568f1e550e71f8
-  data.tar.gz: 6a77ec688a91339da22a3f7c7c58e2ea7b9f8f7c99ec19e1998673484c4e197a2291d207c34fc42ab64d288055cc3b50e827a32659a39c1ee48aa7b758cb0e9c
+  metadata.gz: 359c0c49597ed2154c73d6db25c5a0b6c6d33dc1f6a3f464d594558ef31143a278f1428c58f0319c1205b8bbe6eb703300ff17daa9f1d89df8613e041d08a80a
+  data.tar.gz: c1b259ebbd335fdb71e907dd9bef8c8fb1dd63bbfd1ca767be83e7a2879aebb7485d3ec18b4cc067e074ebf4a4407ccefdaf33670fe4231b09b8cee4fbbae6e0

data/.rubocop.yml

@@ -5,7 +5,7 @@ AllCops:
   NewCops: enable
   Exclude:
     - "_/**/*"
-    - "lib/peeky/example/yard_sample.rb"
+    - "spec/sample/**/*"
 
 # My Preferences - Start
 Metrics/ClassLength:

data/Guardfile

@@ -23,7 +23,7 @@ group :green_pass_then_cop, halt_on_fail: true do
     watch(%r{^lib/peeky/commands/(.+)\.rb$}) { |m| "spec/unit/commands/#{m[1]}_spec.rb" }
   end
 
-  guard :rubocop, all_on_start: false, cli: ['--format', 'clang'] do
+  guard :rubocop, all_on_start: false, cli: ['--format', 'clang', '-a'] do
     watch(%r{.+\.rb$})
     watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
   end

data/README.md

@@ -4,6 +4,10 @@
 
 When using the source code for this gem, start by running `bin/setup` to install locally or `bundle install`
 
+## TODO
+
+@klueless-io - look at [show-source](https://stackoverflow.com/questions/13012109/get-class-location-from-class-object)
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/peeky/class_info.rb

@@ -17,6 +17,20 @@ module Peeky
       @instance = instance
     end
 
+    def to_h
+      {
+        class_name: class_name,
+        module_name: module_name,
+        class_full_name: class_full_name,
+        attr_accessor: accessors.map(&:name),
+        attr_reader: readers.map(&:name),
+        attr_writer: writers.map(&:name),
+        klass: methods_to_h(class_methods),
+        instance_public: methods_to_h(public_methods),
+        instance_private: methods_to_h(private_methods)
+      }
+    end
+
     # rubocop:disable Metrics/AbcSize
     def to_s
       result = []
@@ -26,16 +40,23 @@ module Peeky
       else
         result.push kv('# of instance methods', '')
       end
-      if defined?(@_signatures)
+      if defined?(@signatures)
         result.push kv('# of accessors', accessors.length)
         result.push kv('# of readers', readers.length)
         result.push kv('# of writers', writers.length)
-        result.push kv('# of methods', methods.length)
+        result.push kv('# of methods', all_methods.length)
+        result.push kv('# of methods - public', public_methods.length)
+        result.push kv('# of methods - private', private_methods.length)
+        result.push kv('# of class methods', class_methods.length)
+
       else
-        result.push kv('# of accessors', '')
-        result.push kv('# of readers', '')
-        result.push kv('# of writers', '')
-        result.push kv('# of methods', '')
+        result.push 'Not Loaded'
+        # result.push kv('# of accessors', '')
+        # result.push kv('# of readers', '')
+        # result.push kv('# of writers', '')
+        # result.push kv('# of methods', '')
+        # result.push kv('# of methods - public', '')
+        # result.push kv('# of methods - private', '')
       end
       result.join("\n")
     end
@@ -49,8 +70,6 @@ module Peeky
     # At times during debug or other edge cases, it may be useful to
     # pre-load this information early.
     def load
-      ruby_instance_methods
-      ruby_instance_method_names
       signatures
     end
 
@@ -61,19 +80,19 @@ module Peeky
 
     # Class name
     def class_name
-      @_class_name ||= class_full_name.to_s.gsub(/^.*::/, '')
+      @class_name ||= class_full_name.to_s.gsub(/^.*::/, '')
       # instance.class.name.split('::').last
     end
 
     # Module name
     def module_name
-      @_module_name ||= class_full_name.to_s.gsub(/(.*)::.*/, '\1')
+      @module_name ||= class_full_name.to_s.gsub(/(.*)::.*/, '\1')
     end
 
     # Get a list of :attr_accessor on the class
     # @return [Array<AttrInfo>] list of AttrInfo where type is :attr_accessor
     def accessors
-      @_accessors ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_accessor }
+      @accessors ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_accessor }
     end
 
     # Get a list of :attr_accessors ordered the way they are in the source code
@@ -86,7 +105,7 @@ module Peeky
 
     # Attribute infos
     def attribute_infos
-      @_attribute_infos ||= begin
+      @attribute_infos ||= begin
         grouped_method_infos = signatures.select { |signature| signature.readable? || signature.writable? }.group_by(&:clean_name)
 
         grouped_method_infos.keys.map { |key| AttrInfo.create(*grouped_method_infos[key]) }
@@ -102,8 +121,26 @@ module Peeky
 
     # Get a list methods
     # @return [Array<MethodInfo>] list of MethodInfo where type is :method
-    def methods
-      @_methods ||= signatures.select { |signature| signature.implementation_type == :method }
+    def all_methods
+      @all_methods ||= signatures.select { |signature| signature.implementation_type == :method }
+    end
+
+    # Get a list of private methods
+    # @return [Array<MethodInfo>] list of MethodInfo where type is :method
+    def private_methods
+      @private_methods ||= signatures.select { |signature| signature.implementation_type == :method && signature.access_control == :private }
+    end
+
+    # Get a list of public methods
+    # @return [Array<MethodInfo>] list of MethodInfo where type is :method
+    def public_methods
+      @public_methods ||= signatures.select { |signature| signature.implementation_type == :method && signature.access_control == :public }
+    end
+
+    # Get a list of class methods
+    # @return [Array<MethodInfo>] list of MethodInfo where type is :method
+    def class_methods
+      @class_methods ||= signatures.select { |signature| signature.implementation_type == :class_method }
     end
 
     # Get a list methods ordered the way they are in the source code
@@ -111,7 +148,7 @@ module Peeky
     def methods_source_order
       # TODO: This feature is required
       # May be best to have a sort object that can be created for each type of ordering that is needed
-      methods
+      all_methods
     end
 
     # Reader by name
@@ -124,7 +161,7 @@ module Peeky
     # Get a list of :attr_reader on the class
     # @return [Array<AttrInfo>] list of AttrInfo where type is :attr_accessor
     def readers
-      @_readers ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_reader }
+      @readers ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_reader }
     end
 
     # Get a list of :attr_reader ordered the way they are in the source code
@@ -138,7 +175,7 @@ module Peeky
     # Get a list of :attr_writer on the class
     # @return [Array<AttrInfo>] list of AttrInfo where type is :attr_writer
     def writers
-      @_writers ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_writer }
+      @writers ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_writer }
     end
 
     # Get a list of :attr_writer ordered the way they are in the source code
@@ -161,7 +198,14 @@ module Peeky
     #         such as static, private vs public
     #         deep, deep_to_level, this_instance.
     def signatures
-      @_signatures ||= ruby_instance_methods.map { |im| MethodInfo.new(im, @instance) }
+      return @signatures if defined? @signatures
+
+      @signatures = begin
+        instance_methods  = ruby_instance_methods.map { |im| MethodInfo.new(im, @instance) }
+        private_methods   = ruby_private_methods.map  { |im| MethodInfo.new(im, @instance, access_control: :private) }
+        class_methods     = ruby_class_methods.map    { |im| MethodInfo.new(im, @instance, implementation_type: :class_method) }
+        instance_methods + private_methods + class_methods
+      end
     end
 
     # Signatures by clean name
@@ -187,14 +231,52 @@ module Peeky
       "#{key.to_s.ljust(25)}: #{value}"
     end
 
+    def ruby_class_method_names
+      @ruby_class_method_names ||= instance.class.methods(false).sort # singleton_class.instance_methods(false).sort
+    end
+
     def ruby_instance_method_names
-      @_ruby_instance_method_names ||= instance.class.instance_methods(false).sort
+      @ruby_instance_method_names ||= instance.class.instance_methods(false).sort
+    end
+
+    def ruby_private_method_names
+      @ruby_private_method_names ||= instance.private_methods(false).sort
+    end
+
+    def ruby_class_methods
+      @ruby_class_methods ||= ruby_class_method_names.map { |method_name| instance.class.method(method_name) }
+    rescue StandardError => e
+      # puts 'ruby_class_methods'
+      puts e
+    end
+
+    def ruby_private_methods
+      @ruby_private_methods ||= ruby_private_method_names.map { |method_name| instance.method(method_name) }
+    rescue StandardError => e
+      # puts 'ruby_private_methods'
+      puts e
     end
 
     def ruby_instance_methods
-      @_ruby_instance_methods ||= ruby_instance_method_names.map { |method_name| instance.method(method_name) }
+      @ruby_instance_methods ||= ruby_instance_method_names.map { |method_name| instance.method(method_name) }
     rescue StandardError => e
+      # puts 'ruby_instance_methods'
       puts e
     end
+
+    def methods_to_h(methods)
+      methods.map do |m|
+        {
+          name: m.name,
+          paramaters: m.parameters.map do |p|
+            {
+              name: p.name,
+              type: p.type,
+              default_value: p.default_value
+            }
+          end
+        }
+      end
+    end
   end
 end

data/lib/peeky/method_info.rb

@@ -14,26 +14,29 @@ module Peeky
     # MethodInfo delegates to the underlying ruby method object
     attr_reader :focal_method
 
+    attr_reader :access_control
+
     def_delegators :focal_method, :name, :receiver, :arity, :super_method
 
     ## Stage 2 is the method likely to be an attribute reader or writer
     #
 
     # Implementation type indicates the probable representation of this
-    # method in ruby, was it `def method` or `attr_reader` / `attr_writer`
+    # method in ruby, was it
+    # instance method         `def method`
+    # instance method reader  `attr_reader`
+    # instance method writer  `attr_writer`
+    # class method            `def self.method`
     attr_reader :implementation_type
 
-    def initialize(method, target_instance)
+    def initialize(method, target_instance, implementation_type: :method, access_control: :public)
       @focal_method = method
       @target_instance = target_instance
+      @access_control = access_control
+      @implementation_type = implementation_type
       @parameters = ParameterInfo.from_method(method)
-      # stage 1
-      # @implementation_type = :method
 
-      # stage 2
       infer_implementation_type
-
-      # stage 3
       infer_default_paramaters
     end
 
@@ -52,20 +55,13 @@ module Peeky
       end
     end
 
-    # Infer implementation type [:method, :attr_reader or :attr_writer]
-    # rubocop:disable Lint/DuplicateBranch
+    # Infer implementation type [:class_method, :method, :attr_reader or :attr_writer]
     def infer_implementation_type
-      @implementation_type = if @target_instance.nil?
-                               :method
-                             elsif match(Peeky::Predicates::AttrReaderPredicate)
-                               :attr_reader
-                             elsif match(Peeky::Predicates::AttrWriterPredicate)
-                               :attr_writer
-                             else
-                               :method
-                             end
+      return unless @implementation_type == :method
+
+      @implementation_type = :attr_reader if match(Peeky::Predicates::AttrReaderPredicate)
+      @implementation_type = :attr_writer if match(Peeky::Predicates::AttrWriterPredicate)
     end
-    # rubocop:enable Lint/DuplicateBranch
 
     # Get parameter by name
     #
@@ -92,13 +88,16 @@ module Peeky
     # The tests are now down to 5 seconds, but it highlights the cost of use
     # TracePoint.
     def infer_default_paramaters
-      minimalist_method = Peeky::Renderer::MethodCallMinimumParamsRender.new(self).render
+      class_name = @implementation_type == :class_method ? @target_instance.class.name : nil
+      minimalist_method = Peeky::Renderer::MethodCallMinimumParamsRender.new(self, class_name: class_name).render
 
       return if minimalist_method.end_with?('=')
       return unless optional?
 
       tracer.enable do
-        @target_instance.instance_eval(minimalist_method)
+        # TODO: minimalist method should be able to handle class methods
+        @target_instance.instance_eval(minimalist_method)       if @implementation_type == :method
+        @target_instance.class.instance_eval(minimalist_method) if @implementation_type == :class_method
       rescue StandardError => e
         # just print the error for now, we are only attempting to capture the
         # first call, any errors inside the call cannot be dealt with and should

data/lib/peeky/predicates/attr_reader_predicate.rb

@@ -32,7 +32,12 @@ module Peeky
         cloned = instance.clone
 
         cloned.instance_eval(code)
-        current_value = cloned.send(method_name)
+        begin
+          current_value = cloned.send(method_name)
+        rescue StandardError #=> exception
+          current_value = nil
+        end
+
         current_value == new_value
       end
 

data/lib/peeky/renderer/class_debug_render.rb

@@ -24,13 +24,9 @@ module Peeky
           output.push('')
         end
 
-        methods = render_methods
-
-        if methods.length.positive?
-          output.push("-- Public Methods #{'-' * 82}")
-          output.push(*methods)
-          output.push('')
-        end
+        render_methods_with_heading(output, @class_info.public_methods, 'Public Methods')
+        render_methods_with_heading(output, @class_info.class_methods, 'Class Methods')
+        render_methods_with_heading(output, @class_info.private_methods, 'Private Methods')
 
         output.pop if output.last == ''
 
@@ -70,10 +66,20 @@ module Peeky
         @class_info.writers.map { |attr| kv('attr_writer', attr.name) }
       end
 
-      def render_methods
-        @class_info.methods.flat_map do |method|
+      def render_methods_with_heading(output, method_list, heading)
+        methods = render_methods(method_list)
+
+        return unless methods.length.positive?
+
+        output.push("-- #{heading} #{'-' * 82}")
+        output.push(*methods)
+        output.push('')
+      end
+
+      def render_methods(method_list)
+        method_list.flat_map do |method|
           [
-            "#{method.name}::",
+            "[ #{method.name} ]",
             *render_paramaters(method.parameters),
             ''
           ]

data/lib/peeky/renderer/class_interface_render.rb

@@ -2,32 +2,44 @@
 
 module Peeky
   module Renderer
-    # Render: Class Interface
+    # Render: Class Interface Example
     #
-    # Example output:
-    # class SampleClassClassInterfaceRender
-    #   attr_accessor :a
+    # class ComplexClass
+    #   attr_accessor :a_read_write1
+    #   attr_accessor :a_read_write2
+
+    #   attr_reader :b_another_reader
+    #   attr_reader :b_reader
+    #   attr_reader :looks_like_an_attr_reader
+
+    #   attr_writer :c_another_writer
+    #   attr_writer :c_writer
+
+    #   def alpha_sort1;                                                                end
+    #   def alpha_sort2;                                                                end
+    #   def destructive!;                                                               end
+    #   def do_something_method;                                                        end
+    #   def method_01(aaa);                                                             end
+    #   def method_02(aaa, bbb = 1);                                                    end
+    #   def method_03(aaa, bbb = 1, ccc = 2);                                           end
+    #   def method_04(*aaa);                                                            end
+    #   def method_05(aaa, bbb = 1, *ccc);                                              end
+    #   def method_06(**aaa);                                                           end
+    #   def method_07(aaa, *bbb, ccc: 'string1', **ddd);                                end
+    #   def method_08(aaa, *bbb, **ccc, &ddd);                                          end
+    #   def method_09(aaa:);                                                            end
+    #   def method_10(aaa:, bbb: 1);                                                    end
+    #   def method_with_every_type_of_paramater(aaa, bbb = 1, *ccc, ddd:, eee: 1, **fff, &ggg);end
+    #   def questionable?;                                                              end
     #
-    #   attr_reader :b
+    #   class << self
+    #     def klass_complex(aaa, bbb = nil, *ccc, ddd:, eee: , **fff, &ggg);              end
+    #     def klass_simple(first_param);                                                  end
+    #   end
     #
-    #   attr_writer :c
+    #   private
     #
-    #   def alpha_sort1;                                                                end
-    #   def alpha_sort2;                                                                end
-    #   def d;                                                                          end
-    #   def e(aaa);                                                                     end
-    #   def f(aaa, bbb = nil);                                                          end
-    #   def g(aaa, bbb = nil, ccc = nil);                                               end
-    #   def h(*aaa);                                                                    end
-    #   def i(aaa, bbb, *ccc);                                                          end
-    #   def j(**aaa);                                                                   end
-    #   def k(aaa, *bbb, **ccc);                                                        end
-    #   def l(aaa, *bbb, **ccc, &ddd);                                                  end
-    #   def m(aaa:);                                                                    end
-    #   def n(aaa:, bbb: nil);                                                          end
-    #   def p?;                                                                         end
-    #   def q!;                                                                         end
-    #   def z(aaa, bbb = nil, *ccc, ddd:, eee: nil, **fff, &ggg);                       end
+    #   def keep_me_private;                                                            end
     # end
     class ClassInterfaceRender
       # ClassInfo with information about the class instance to be rendered.
@@ -40,19 +52,24 @@ module Peeky
       # Render the class interface
       def render
         @indent = ''
-        output = []
-        output.push render_start
+        @output = []
+        @output.push render_start
         @indent = '  '
-        output += render_accessors
-        output += render_readers
-        output += render_writers
-        output += render_methods
-        output.pop if output.last == ''
+
+        render_accessors
+        render_readers
+        render_writers
+
+        render_methods(@class_info.public_methods)
+        render_class_methods(@class_info.class_methods)
+        render_private_methods(@class_info.private_methods)
+
+        @output.pop if @output.last == ''
 
         @indent = ''
-        output.push render_end
+        @output.push render_end
 
-        output.join("\n")
+        @output.join("\n")
       end
 
       private
@@ -64,28 +81,46 @@ module Peeky
       def render_accessors
         result = @class_info.accessors.map { |attr| "#{@indent}attr_accessor :#{attr.name}" }
         result.push '' unless result.length.zero?
-        result
+        @output += result
       end
 
       def render_readers
         result = @class_info.readers.map { |attr| "#{@indent}attr_reader :#{attr.name}" }
         result.push '' unless result.length.zero?
-        result
+        @output += result
       end
 
       def render_writers
         result = @class_info.writers.map { |attr| "#{@indent}attr_writer :#{attr.name}" }
         result.push '' unless result.length.zero?
-        result
+        @output += result
       end
 
-      def render_methods
-        result = @class_info.methods.map do |method_signature|
+      def render_methods(method_list)
+        result = method_list.map do |method_signature|
           render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
           "#{@indent}#{render_signature.render}"
         end
         result.push '' unless result.length.zero?
-        result
+        @output += result
+      end
+
+      def render_class_methods(methods)
+        return if methods.length.zero?
+
+        @output += ["#{@indent}class << self"]
+        @indent += '  '
+        @output += render_methods(methods)
+        @indent.delete_suffix!('  ')
+        @output.pop if @output.last == ''
+        @output += ["#{@indent}end", '']
+      end
+
+      def render_private_methods(methods)
+        return if methods.length.zero?
+
+        @output += ["#{@indent}private", '']
+        @output += render_methods(methods)
       end
 
       def render_end

data/lib/peeky/renderer/class_interface_yard_render.rb

@@ -33,26 +33,33 @@ module Peeky
 
       # Render the class interface with YARD documentation
       def render
-        output = []
-        output.push render_start
+        @output = []
+
+        render_start
         @indent += '  '
-        output += (render_accessors + render_readers + render_writers + render_methods)
-        output.pop if output.last == ''
+
+        render_accessors
+        render_readers
+        render_writers
+
+        render_public_methods
+        render_class_methods
+        render_private_methods
+
+        @output.pop if @output.last == ''
 
         @indent = @indent[0..-3]
 
-        output.push render_end
+        @output.push render_end
 
-        output.join("\n")
+        @output.join("\n")
       end
 
       private
 
       def render_start
-        [
-          "#{@indent}# #{@class_info.class_name.titleize.humanize}",
-          "#{@indent}class #{@class_info.class_name}"
-        ]
+        @output.push "#{@indent}# #{@class_info.class_name.titleize.humanize}"
+        @output.push "#{@indent}class #{@class_info.class_name}"
       end
 
       def render_accessors
@@ -63,7 +70,7 @@ module Peeky
           result.push "#{@indent}attr_accessor :#{attr.name}"
         end
         result.push '' unless result.length.zero?
-        result
+        @output += result
       end
 
       def render_readers
@@ -74,7 +81,7 @@ module Peeky
           result.push "#{@indent}attr_reader :#{attr.name}"
         end
         result.push '' unless result.length.zero?
-        result
+        @output += result
       end
 
       def render_writers
@@ -85,54 +92,81 @@ module Peeky
           result.push "#{@indent}attr_writer :#{attr.name}"
         end
         result.push '' unless result.length.zero?
-        result
+        @output += result
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
-      def render_methods
+      def render_public_methods
         result = []
-        class_info.methods.map.with_index do |method_signature, index|
-          result.push '' if index.positive?
-          result.push "#{@indent}# #{method_signature.name.to_s.humanize}"
-
-          method_signature.parameters.each_with_index do |parameter, param_index|
-            result.push "#{@indent}#" if param_index.zero?
-
-            case parameter.type
-            when :splat
-              result.push "#{@indent}# @param #{parameter.name} [Array<#{default_splat_param_type}>] *#{parameter.name} - list of #{parameter.name.to_s.humanize.downcase}"
-            when :double_splat
-              result.push "#{@indent}# @param #{parameter.name} [<key: value>...] **#{parameter.name} - list of key/values"
-            when :block
-              result.push "#{@indent}# @param #{parameter.name} [Block] &#{parameter.name}"
-            when :key_required
-              result.push "#{@indent}# @param #{parameter.name} [#{default_param_type}] #{parameter.name}: <value for #{parameter.name.to_s.humanize.downcase}> (required)"
-            when :key_optional
-              result.push "#{@indent}# @param #{parameter.name} [#{parameter.default_value_type}] #{parameter.name}: is optional, defaults to #{parameter.wrap_default_value('nil')}"
-            when :param_required
-              result.push "#{@indent}# @param #{parameter.name} [#{default_param_type}] #{parameter.name.to_s.humanize.downcase} (required)"
-            when :param_optional
-              result.push "#{@indent}# @param #{parameter.name} [#{parameter.default_value_type}] #{parameter.name} is optional, defaults to #{parameter.wrap_default_value('nil')}"
-              # result.push "#{@indent}# @param #{parameter.name} [#{default_param_type}] #{parameter.name.to_s.humanize.downcase} (optional)"
-            else
-              result.push "#{@indent}# @param #{parameter.name} [#{default_param_type}] #{parameter.name.to_s.humanize.downcase}"
-            end
-          end
+        class_info.public_methods.map.with_index do |method_signature, index|
+          render_method(result, method_signature, index)
+        end
+        result.push '' unless result.length.zero?
+        @output += result
+      end
+
+      def render_class_methods
+        return if class_info.class_methods.length.zero?
+
+        result = ["#{@indent}# Class methods", "#{@indent}class << self"]
+        @indent += '  '
+        class_info.class_methods.map.with_index do |method_signature, index|
+          render_method(result, method_signature, index)
+        end
+        @indent.delete_suffix!('  ')
+        result.push "#{@indent}end"
+
+        @output += result
+      end
 
-          if method_signature.name.to_s.end_with?('?')
-            result.push ''
-            result.push "#{@indent}# @return [Boolean] true when #{method_signature.name.to_s.humanize.downcase}"
+      def render_private_methods
+        result = []
+        class_info.private_methods.map.with_index do |method_signature, index|
+          result.push "\n#{indent}private\n" if index.zero?
+          render_method(result, method_signature, index)
+        end
+        @output += result
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def render_method(result, method_signature, index)
+        result.push '' if index.positive?
+        result.push "#{@indent}# #{method_signature.name.to_s.humanize}"
+
+        method_signature.parameters.each_with_index do |parameter, param_index|
+          result.push "#{@indent}#" if param_index.zero?
+
+          case parameter.type
+          when :splat
+            result.push "#{@indent}# @param #{parameter.name} [Array<#{default_splat_param_type}>] *#{parameter.name} - list of #{parameter.name.to_s.humanize.downcase}"
+          when :double_splat
+            result.push "#{@indent}# @param #{parameter.name} [<key: value>...] **#{parameter.name} - list of key/values"
+          when :block
+            result.push "#{@indent}# @param #{parameter.name} [Block] &#{parameter.name}"
+          when :key_required
+            result.push "#{@indent}# @param #{parameter.name} [#{default_param_type}] #{parameter.name}: <value for #{parameter.name.to_s.humanize.downcase}> (required)"
+          when :key_optional
+            result.push "#{@indent}# @param #{parameter.name} [#{parameter.default_value_type}] #{parameter.name}: is optional, defaults to #{parameter.wrap_default_value('nil')}"
+          when :param_required
+            result.push "#{@indent}# @param #{parameter.name} [#{default_param_type}] #{parameter.name.to_s.humanize.downcase} (required)"
+          when :param_optional
+            result.push "#{@indent}# @param #{parameter.name} [#{parameter.default_value_type}] #{parameter.name} is optional, defaults to #{parameter.wrap_default_value('nil')}"
+            # result.push "#{@indent}# @param #{parameter.name} [#{default_param_type}] #{parameter.name.to_s.humanize.downcase} (optional)"
+          else
+            result.push "#{@indent}# @param #{parameter.name} [#{default_param_type}] #{parameter.name.to_s.humanize.downcase}"
           end
+        end
 
-          render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
-          render_signature.indent = @indent
-          render_signature.style = :default
-          result.push render_signature.render
+        if method_signature.name.to_s.end_with?('?')
+          result.push ''
+          result.push "#{@indent}# @return [Boolean] true when #{method_signature.name.to_s.humanize.downcase}"
         end
-        result.push '' unless result.length.zero?
-        result
+
+        render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
+        render_signature.indent = @indent
+        render_signature.style = :default
+        result.push render_signature.render
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       def render_end
         "#{@indent}end"

data/lib/peeky/renderer/method_call_minimum_params_render.rb

@@ -13,7 +13,8 @@ module Peeky
 
       def initialize(method_signature, **opts)
         # instance_name = opts[:instance_name] || 'instance'
-        @instance_name = opts[:instance_name]
+        @instance_name    = opts[:instance_name]
+        @class_name       = opts[:class_name]
         @method_signature = method_signature
       end
 
@@ -29,11 +30,10 @@ module Peeky
 
         params = minimal_call_parameters.length.zero? ? '' : "(#{minimal_call_parameters})"
 
-        if @instance_name.nil?
-          "#{name}#{params}"
-        else
-          "#{@instance_name}.#{name}#{params}"
-        end
+        return "#{@instance_name}.#{name}#{params}" unless @instance_name.nil?
+        return "#{@class_name}.#{name}#{params}" unless @class_name.nil?
+
+        "#{name}#{params}"
       end
     end
   end

data/lib/peeky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Peeky
-  VERSION = '0.0.40'
+  VERSION = '0.0.47'
 end

data/lib/peeky.rb

@@ -24,4 +24,9 @@ module Peeky
   # Your code goes here...
 end
 
-puts "Peeky::Version: #{Peeky::VERSION}" if ENV['KLUE_DEBUG']&.to_s&.downcase == 'true'
+if ENV['KLUE_DEBUG']&.to_s&.downcase == 'true'
+  namespace = 'Peeky::Version'
+  file_path = $LOADED_FEATURES.find { |f| f.include?('peeky/version') }
+  version   = Peeky::VERSION.ljust(9)
+  puts "#{namespace.ljust(35)} : #{version.ljust(9)} : #{file_path}"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: peeky
 version: !ruby/object:Gem::Version
-  version: 0.0.40
+  version: 0.0.47
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-01 00:00:00.000000000 Z
+date: 2021-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -59,7 +59,6 @@ files:
 - lib/peeky/api.rb
 - lib/peeky/attr_info.rb
 - lib/peeky/class_info.rb
-- lib/peeky/example/yard_sample.rb
 - lib/peeky/method_info.rb
 - lib/peeky/parameter_info.rb
 - lib/peeky/predicates/attr_reader_predicate.rb

data/lib/peeky/example/yard_sample.rb

@@ -1,146 +0,0 @@
-module Peeky
-  module Example
-    # Yard sample
-    class YardSample
-      # A read write1
-      attr_accessor :a_read_write1
-
-      # A read write2
-      attr_accessor :a_read_write2
-
-      # A read write3
-      attr_accessor :a_read_write3
-
-      # B reader1
-      attr_reader :b_reader1
-
-      # B reader2
-      attr_reader :b_reader2
-
-      # E looks like an attr reader
-      attr_reader :e_looks_like_an_attr_reader
-
-      # C writer1
-      attr_writer :c_writer1
-
-      # C writer2
-      attr_writer :c_writer2
-
-      # Alpha sort1
-      def alpha_sort1
-      end
-
-      # Alpha sort2
-      def alpha_sort2
-      end
-
-      # D do something method
-      def d_do_something_method
-      end
-
-      # E method with required param
-      #
-      # @param first_name [String] first name (required)
-      def e_method_with_required_param(first_name)
-      end
-
-      # F method with required param and optional param
-      #
-      # @param first_name [String] first name (required)
-      # @param last_name [String] last_name is optional, defaults to ''
-      def f_method_with_required_param_and_optional_param(first_name, last_name = '')
-      end
-
-      # G method with required param and two optional params
-      #
-      # @param first_name [String] first name (required)
-      # @param last_name [String] last_name is optional, defaults to ''
-      # @param age [Integer] age is optional, defaults to 21
-      def g_method_with_required_param_and_two_optional_params(first_name, last_name = '', age = 21)
-      end
-
-      # H list of optional parameters
-      #
-      # @param command_args [Array<Object>] *command_args - list of command args
-      def h_list_of_optional_parameters(*command_args)
-      end
-
-      # I method with two required params and list of optional params
-      #
-      # @param first_name [String] first name (required)
-      # @param last_name [String] last name (required)
-      # @param alias_names [Array<Object>] *alias_names - list of alias names
-      def i_method_with_two_required_params_and_list_of_optional_params(first_name, last_name, *alias_names)
-      end
-
-      # J method with list of named arguments
-      #
-      # @param options [<key: value>...] **options - list of key/values
-      def j_method_with_list_of_named_arguments(**options)
-      end
-
-      # Jin
-      #
-      # @param aaa [String] aaa (required)
-      def jin(aaa)
-      end
-
-      # K method with block
-      #
-      # @param code_block [Block] &code_block
-      def k_method_with_block(&code_block)
-      end
-
-      # L method with key value param required
-      #
-      # @param name [String] name: <value for name> (required)
-      def l_method_with_key_value_param_required(name:)
-      end
-
-      # N method with key value param required and optional key value
-      #
-      # @param last_name [String] last_name: <value for last name> (required)
-      # @param salutation [String] salutation: is optional, defaults to 'Mr'
-      def n_method_with_key_value_param_required_and_optional_key_value(last_name:, salutation: 'Mr')
-      end
-
-      # P available?
-
-      # @return [Boolean] true when p available?
-      def p_available?
-      end
-
-      # Q danger will robinson!
-      def q_danger_will_robinson!
-      end
-
-      # Z complex
-      #
-      # @param aaa [String] aaa (required)
-      # @param bbb [Integer] bbb is optional, defaults to 1
-      # @param ccc [Array<Object>] *ccc - list of ccc
-      # @param ddd [String] ddd: <value for ddd> (required)
-      # @param eee [Integer] eee: is optional, defaults to 1
-      # @param fff [<key: value>...] **fff - list of key/values
-      # @param ggg [Block] &ggg
-      def z_complex(aaa, bbb = 1, *ccc, ddd:, eee: 1, **fff, &ggg)
-      end
-
-      # Z optional styles
-      #
-      # @param aaa [String] aaa (required)
-      # @param bbb [Integer] bbb is optional, defaults to 123
-      # @param ccc [String] ccc is optional, defaults to 'abc'
-      # @param ddd [TrueClass] ddd is optional, defaults to true
-      # @param eee [FalseClass] eee is optional, defaults to false
-      # @param fff [Object] fff is optional, defaults to nil
-      # @param ggg [Integer] ggg: is optional, defaults to 123
-      # @param hhh [String] hhh: is optional, defaults to 'xyz'
-      # @param iii [TrueClass] iii: is optional, defaults to true
-      # @param jjj [FalseClass] jjj: is optional, defaults to false
-      # @param kkk [Object] kkk: is optional, defaults to nil
-      def z_optional_styles(aaa, bbb = 123, ccc = 'abc', ddd = true, eee = false, fff = nil, ggg: 123, hhh: 'xyz', iii: true, jjj: false, kkk: )
-      end
-    end
-  end
-end