peeky 0.0.33 → 0.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f39a9477e701fff31e203e1d90fb479cd8898662499edf4c4722673e7c0da20
-  data.tar.gz: d7a743fc208c5dbfe640c687833e3cc69b663654630cad0d15a582033f3f39f8
+  metadata.gz: a5ace1c867116904f98e261077b746cd8d2621f657a391e79c80f3f57edf4583
+  data.tar.gz: 195ab81abb7ab1198c19613c4fe2f4e730fd2b6a6c2654938396ad191dde8e25
 SHA512:
-  metadata.gz: dd1a24d91ef1fef5b72fc90f2c041112462cc842009ed68f9499f9a94cc3218ff0e2a0bc46ba4b5564487891b54d2bff023cf4deaa8af64a607f207b4f6a8e6f
-  data.tar.gz: 8fe132fffb24332d7b28b92a288b799ed51dac71df7bcfb8887bec7c6433c3b58bda9a6af05cb81dc006322b5991b6b05735760756dcef4c8919575e16155bd8
+  metadata.gz: db4dd2ec06b1722637d716611c9d6ae6080f1b52ffa2da6129e8a421e0a034ea5923f56ea041869d69e7bd0fe48656a759f01c29d8067ec64cbd5e7ee7956c24
+  data.tar.gz: 56982a728fc581b06080ede29139b2245770affe03d9ce97633d18ac7d56341536740d4b15b52e1264ff26bc4b7e27ad4f7548489b0d0879f1c9569c34c1dd90

data/.github/workflows/ruby.yml

@@ -1,6 +1,5 @@
 # This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
 # For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
-
 name: Ruby
 
 on:
@@ -19,10 +18,10 @@ jobs:
     - name: Set up Ruby
     # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
     # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@ec106b438a1ff6ff109590de34ddc62c540232e0
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: 2.6
+        # bundler-cache: true # runs 'bundle install' and caches installed gems automatically
     - name: Install dependencies
       run: bundle install
     - name: Run tests

data/.rubocop.yml

@@ -1,12 +1,15 @@
 AllCops:
+  TargetRubyVersion: 2.5
   DisplayCopNames: true
   ExtraDetails: true
   NewCops: enable
   Exclude:
     - "_/**/*"
-    - "lib/peeky/example/yard_sample.rb"
+    - "spec/sample/**/*"
 
 # My Preferences - Start
+Metrics/ClassLength:
+  Enabled: false
 Naming/MemoizedInstanceVariableName:
   Enabled: false
 Naming/VariableNumber:
@@ -35,9 +38,9 @@ Layout/SpaceBeforeComma:
   
 Metrics/BlockLength:
   Exclude:
-    - "**/spec/*"
+    - "**/spec/**/*"
     - "*.gemspec"
-  ExcludedMethods:
+  IgnoredMethods:
     - configure
     - context
     - define

data/Gemfile

@@ -5,19 +5,25 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in poc_github_ap.gemspec
 gemspec
 
-# group :development do
-#   # pry on steroids
-#   gem 'pry-coolline', github: 'owst/pry-coolline', branch: 'support_new_pry_config_api'
-#   gem 'jazz_fingers'
-# end
+group :development do
+  # pry on steroids
+  # gem 'pry-coolline', github: 'owst/pry-coolline', branch: 'support_new_pry_config_api'
+  # gem 'jazz_fingers'
+end
 
 group :development, :test do
-  gem 'guard-bundler'
-  gem 'guard-rspec'
-  gem 'guard-rubocop'
+  gem 'guard-bundler', '~> 3.0'
+  gem 'guard-rspec', '~> 4.0'
+  gem 'guard-rubocop', '~> 1.2'
   gem 'rake', '~> 12.0'
   # this is used for cmdlets 'self-executing gems'
   gem 'rake-compiler'
   gem 'rspec', '~> 3.0'
-  gem 'rubocop'
+  gem 'rubocop', '~> 1.9'
+  gem 'rubocop-rake', require: false
+  gem 'rubocop-rspec', require: false
 end
+
+# group :test do
+#   gem 'k_usecases', path: '~/dev/kgems/k_usecases'
+# end

data/Guardfile

@@ -23,8 +23,8 @@ 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
-  #   watch(%r{.+\.rb$})
-  #   watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
-  # end
+  guard :rubocop, all_on_start: false, cli: ['--format', 'clang'] do
+    watch(%r{.+\.rb$})
+    watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
+  end
 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/Rakefile

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+GEM_NAME = 'peeky'
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
@@ -14,3 +16,16 @@ Rake::ExtensionTask.new('peeky') do |ext|
 end
 
 task default: %i[clobber compile spec]
+
+desc 'Publish the gem to RubyGems.org'
+task :publish do
+  system 'gem build'
+  system "gem push #{GEM_NAME}-#{Peeky::VERSION}.gem"
+end
+
+desc 'Remove old *.gem files'
+task :clean do
+  system 'rm *.gem'
+end
+
+task default: %i[clobber compile spec]

data/USAGE2.md

@@ -0,0 +1,5 @@
+# Peeky
+
+This document will show you how to use Peeky.
+
+Peeky is a Ruby GEM for peaking into ruby classes and extracting meta

data/lib/peeky/api.rb

@@ -16,6 +16,9 @@ module Peeky
     # ClassInfo stores information about the instance of a
     # class that is passed in including methods, attr_accessors
     # attr_readers and attr_writers.
+    #
+    # @param instance [Object] instance of class to gather information about (required)
+    # @param lazy [TrueClass] lazy load method and parameter information, laze: is optional, defaults to true
     def build_class_info(instance, lazy: true)
       ci = Peeky::ClassInfo.new(instance)
       ci.load unless lazy
@@ -23,6 +26,14 @@ module Peeky
     end
 
     # Render a class using a predefined class renderer
+    #
+    # ^1: One of class_info and instance must supplied, they are mutually
+    # exclusive to each other.
+    #
+    # @param render_key [Symbol] class render key (required)
+    # @param class_info [Object] class_info: is optional^1, defaults to nil
+    # @param instance [Object] instance: is optional^1, defaults to nil
+    # @param _opts [<key: value>...] **_opts - list of key/values that can help configure render
     def render_class(render_key, class_info: nil, instance: nil, **_opts)
       raise 'Call render_class with class_info OR instance.' if class_info.nil? && instance.nil?
       raise 'Call render_class with class_info OR instance, these parameters are mutually exclusive' if !class_info.nil? && !instance.nil?
@@ -37,6 +48,7 @@ module Peeky
     # Get a method renderer by :key
     #
     # TODO: Refactor to a configurable system
+    # @param key [String] key is a shortcut to a specific Peeky::Render that handles method_info (required)
     def method_renderer(key)
       case key
       when :signature
@@ -53,6 +65,7 @@ module Peeky
     # Get a class renderer by :key
     #
     # TODO: Refactor to a configurable system
+    # @param key [String] key is a shortcut to a specific Peeky::Renderer that handles class_info (required)
     def class_renderer(key)
       case key
       when :class_debug

data/lib/peeky/attr_info.rb

@@ -6,7 +6,9 @@ module Peeky
   # Attr Info is a container that holds read, write or read/write
   # attributes in the form of MethodInfo objects
   class AttrInfo
+    # reader stores a MethodInfo for a matching reader, nil if readable style method_info not found
     attr_reader :reader
+    # writer stores a MethodInfo for a matching writer, nil if writable style method_info not found
     attr_reader :writer
 
     def initialize(reader: nil, writer: nil)
@@ -16,6 +18,7 @@ module Peeky
       @writer = writer
     end
 
+    # Type of the attribute [:attr_writer, :attr_reader or :attr_accessor]
     def type
       @type ||= if @reader.nil?
                   :attr_writer
@@ -24,6 +27,7 @@ module Peeky
                 end
     end
 
+    # Name of the attribute
     def name
       @name ||= @reader.nil? ? @writer.clean_name : @reader.clean_name
     end

data/lib/peeky/class_info.rb

@@ -17,9 +17,33 @@ module Peeky
       @instance = instance
     end
 
+    # rubocop:disable Metrics/AbcSize
     def to_s
-      class_full_name
+      result = []
+      result.push kv('class', class_full_name)
+      if defined?(@_ruby_instance_method_names)
+        result.push kv('# of instance methods', @_ruby_instance_method_names.join(', '))
+      else
+        result.push kv('# of instance methods', '')
+      end
+      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', all_methods.length)
+        result.push kv('# of methods - public', public_methods.length)
+        result.push kv('# of methods - private', private_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 kv('# of methods - public', '')
+        result.push kv('# of methods - private', '')
+      end
+      result.join("\n")
     end
+    # rubocop:enable Metrics/AbcSize
 
     # Load class_info
     #
@@ -29,8 +53,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
 
@@ -41,19 +63,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
@@ -66,7 +88,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]) }
@@ -82,8 +104,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
@@ -91,7 +131,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
@@ -104,7 +144,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
@@ -118,7 +158,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
@@ -141,7 +181,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
@@ -161,41 +208,42 @@ module Peeky
       signatures.select { |im| im.name == name && im.implementation_type == filter_type }
     end
 
-    # Debug
-    #
-    # Refact: PATTERN: Come up it an debug inclusion system so that
-    # so that debug helpers can be included for development and excluded
-    # for production
-    # @param format [String] format: <value for format> (optional)
-    def debug(format: [:signatures])
-      debug_method_names if format.include?(:method_names)
-
-      return unless format.include?(:signatures)
-
-      puts '-' * 70
-      puts 'Methods'
-      puts '-' * 70
-      signatures.each(&:debug)
-    end
-
-    def debug_method_names
-      puts '-' * 70
-      puts 'Method Names'
-      puts '-' * 70
-      ruby_instance_method_names.each do |method_name|
-        puts method_name
-      end
+    private
+
+    def kv(key, value)
+      "#{key.to_s.ljust(25)}: #{value}"
     end
 
-    private
+    def ruby_class_method_names
+      @ruby_class_method_names ||= instance.class.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
   end

data/lib/peeky/method_info.rb

@@ -14,28 +14,40 @@ 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
+    ## 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
 
-    # TODO: target_instance is required...
-    def initialize(method, target_instance = nil)
+    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
-      @implementation_type = infer_implementation_type(target_instance)
+      infer_implementation_type
+      infer_default_paramaters
     end
 
     # Stage 2 (working out) attr_accessor
+    #
+
     # Name of method minus writer annotations
-    # Example :writable_attribute= becomes :writable_attribute
+    # Example
+    #   :writable_attribute=
+    #   # becomes
+    #   :writable_attribute
     def clean_name
       @clean_name ||= begin
         n = name.to_s
@@ -43,43 +55,112 @@ module Peeky
       end
     end
 
-    def infer_implementation_type(target_instance)
-      if target_instance.nil?
-        :method
-      elsif match(target_instance, Peeky::Predicates::AttrReaderPredicate)
-        :attr_reader
-      elsif match(target_instance, Peeky::Predicates::AttrWriterPredicate)
-        :attr_writer
-      else
-        :method
+    # Infer implementation type [:class_method, :method, :attr_reader or :attr_writer]
+    def infer_implementation_type
+      return unless @implementation_type == :method
+
+      @implementation_type = :attr_reader if match(Peeky::Predicates::AttrReaderPredicate)
+      @implementation_type = :attr_writer if match(Peeky::Predicates::AttrWriterPredicate)
+    end
+
+    # Get parameter by name
+    #
+    # @param name [String] name (required)
+    def get_parameter(name)
+      name = name.to_s
+      parameters.find { |p| p.name == name }
+    end
+
+    # Has any optional paramaters?
+
+    # @return [Boolean] true when any parameter is optional?
+    def optional?
+      parameters.any?(&:optional?)
+    end
+
+    # Infer default paramater values
+    #
+    # WARNING: Unit test coverage went from .1 seconds to 30-40 seconds
+    # when I first introduced this method.
+    #
+    # I now only call TracePoint if I have optional parameters to be inferred.
+    #
+    # 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
+
+      return if minimalist_method.end_with?('=')
+      return unless optional?
+
+      tracer.enable do
+        if @implementation_type == :method
+          @target_instance.instance_eval(minimalist_method)
+        end
+        if @implementation_type == :class_method
+          minimalist_method = "#{@target_instance.class.name}.#{minimalist_method}"
+          @target_instance.class.instance_eval(minimalist_method)
+        end
+      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
+        # not be re-raised
+        puts e.message
+      end
+    end
+
+    def tracer
+      TracePoint.trace(:call, :c_call) do |tp|
+        next unless tp.self.is_a?(@target_instance.class)
+        next unless tp.method_id == name
+
+        tp.parameters.each do |_type, param_name|
+          method_paramater = get_parameter(param_name)
+
+          if method_paramater.optional?
+            value = tp.binding.local_variable_get(param_name)
+            method_paramater.default_value = value
+          end
+        end
       end
     end
 
-    def match(target_instance, predicate)
-      predicate.new.match(target_instance, self)
+    # Match
+    #
+    # @param predicate [String] use a predicate object with the signature match(instance, method_info)
+    def match(predicate)
+      predicate.new.match(@target_instance, self)
     end
 
+    # Method?
+
+    # @return [Boolean] true when implementation type is method?
     def method?
       @implementation_type == :method
     end
 
-    # https://github.com/rubyide/vscode-ruby/issues/454
-    # if I prefix these methods with attr_ then will get an issue
-    # in the language server.
-    # Cannot read property 'namedChildren' of undefined
+    # Readable?
+    #
+    # @return [Boolean] true when readable?
     def readable?
+      # Method naming issue: VSCode Ruby Language Server
+      #
+      # If this method is renamed to attr_readable, same for attr_writable.
+      #
+      # https://github.com/rubyide/vscode-ruby/issues/454
+      # if I prefix these methods with attr_ then will get an issue
+      # in the language server.
+      #
+      # Cannot read property 'namedChildren' of undefined
+
       @implementation_type == :attr_reader
     end
 
+    # Writable?
+
+    # @return [Boolean] true when implementation_type writable?
     def writable?
       @implementation_type == :attr_writer
     end
-
-    def debug
-      puts '-' * 70
-      puts name
-      puts '-' * 70
-      parameters.each(&:debug)
-    end
   end
 end

data/lib/peeky/parameter_info.rb

@@ -48,13 +48,6 @@ module Peeky
       ruby_method.parameters.map { |ruby_paramater| from_parameter(ruby_paramater) }
     end
 
-    def debug
-      puts "name                          : #{name}"
-      puts "type                          : #{type}"
-      puts "signature_format              : #{signature_format}"
-      puts "minimal_call_format           : #{minimal_call_format}"
-    end
-
     # ruby code formatted for use in a method signature
     def signature_format
       @_signature_format ||= begin
@@ -79,6 +72,34 @@ module Peeky
       end
     end
 
+    # Optional?
+
+    # @return [Boolean] true when parameter is one of the optional types?
+    def optional?
+      @_optional |= (@type == :param_optional || @type == :key_optional)
+    end
+
+    # Default value type will look at the default value and try to
+    # infer the class behind it. Will default to 'Object' fi nil
+    def default_value_type
+      if @default_value.nil?
+        'Object'
+      else
+        @default_value.class
+      end
+    end
+
+    # Wrap default value in quotes if string, or no wrapping otherwise
+    #
+    # @param value_for_nil [String] value for nil, generally '' or 'nil' (required)
+    def wrap_default_value(value_for_nil)
+      if @default_value.is_a?(String)
+        "'#{@default_value}'"
+      else
+        @default_value.nil? ? value_for_nil : @default_value
+      end
+    end
+
     private
 
     # Convert the limited information provided by ruby method.parameters
@@ -118,7 +139,7 @@ module Peeky
     end
 
     def signature_format_param_optional
-      "#{name} = nil" # signature format needs to be moved to a method
+      "#{name} = #{wrap_default_value('nil')}" # signature format needs to be moved to a method
     end
 
     def signature_format_splat
@@ -130,7 +151,7 @@ module Peeky
     end
 
     def signature_format_key_optional
-      "#{name}: nil"
+      "#{name}: #{wrap_default_value('')}"
     end
 
     def signature_format_double_splat
@@ -152,28 +173,8 @@ module Peeky
       "'#{@name}'"
     end
 
-    # def minimal_call_format_param_optional
-    #   ''
-    # end
-
-    # def minimal_call_format_splat
-    #   ''
-    # end
-
     def minimal_call_format_key_required
       "#{@name}: '#{@name}'"
     end
-
-    # def minimal_call_format_key_optional
-    #   ''
-    # end
-
-    # def minimal_call_format_double_splat
-    #   ''
-    # end
-
-    # def minimal_call_format_block
-    #   ''
-    # end
   end
 end

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

@@ -19,15 +19,23 @@ module Peeky
         attributes = render_accessors + render_readers + render_writers
 
         if attributes.length.positive?
-          output.push("-- Attributes #{'-' * 56}")
+          output.push("-- Attributes #{'-' * 86}")
           output.push(*attributes)
           output.push('')
         end
 
-        methods = render_methods
+        methods = render_methods(@class_info.public_methods)
 
         if methods.length.positive?
-          output.push("-- Public Methods #{'-' * 52}")
+          output.push("-- Public Methods #{'-' * 82}")
+          output.push(*methods)
+          output.push('')
+        end
+
+        methods = render_methods(@class_info.private_methods)
+
+        if methods.length.positive?
+          output.push("-- Private Methods #{'-' * 82}")
           output.push(*methods)
           output.push('')
         end
@@ -40,7 +48,7 @@ module Peeky
 
       private
 
-      def lj(value, size = 20)
+      def lj(value, size = 24)
         value.to_s.ljust(size)
       end
 
@@ -50,7 +58,7 @@ module Peeky
 
       def class_details
         [
-          '-' * 70,
+          '-' * 100,
           kv('class name', @class_info.class_name),
           kv('module name', @class_info.module_name),
           kv('class full name', @class_info.class_full_name),
@@ -70,10 +78,10 @@ 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(method_list)
+        method_list.flat_map do |method|
           [
-            "#{method.name}::",
+            "[ #{method.name} ]",
             *render_paramaters(method.parameters),
             ''
           ]
@@ -82,12 +90,12 @@ module Peeky
 
       def render_paramaters(parameters)
         result = [
-          "#{lj('name')} #{lj('param format')} #{lj('type')}",
-          '-' * 70
+          "#{lj('name')} #{lj('param format')} #{lj('type')} #{lj('default')}",
+          '-' * 100
         ]
 
         result + parameters.map do |param|
-          "#{lj(param.name)} #{lj(param.signature_format)} #{lj(param.type)}"
+          "#{lj(param.name)} #{lj(param.signature_format)} #{lj(param.type)} #{lj(param.default_value)}"
         end
       end
     end

data/lib/peeky/renderer/class_interface_render.rb

@@ -38,15 +38,20 @@ module Peeky
       end
 
       # Render the class interface
+      # rubocop:disable Metrics/AbcSize
       def render
         @indent = ''
-        output = []
+        output  = []
         output.push render_start
         @indent = '  '
         output += render_accessors
         output += render_readers
         output += render_writers
-        output += render_methods
+        output += render_methods(@class_info.public_methods)
+        unless @class_info.private_methods.length.zero?
+          output += ["#{@indent}private", '']
+          output += render_methods(@class_info.private_methods)
+        end
         output.pop if output.last == ''
 
         @indent = ''
@@ -54,6 +59,7 @@ module Peeky
 
         output.join("\n")
       end
+      # rubocop:enable Metrics/AbcSize
 
       private
 
@@ -79,8 +85,8 @@ module Peeky
         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

data/lib/peeky/renderer/class_interface_yard_render.rb

@@ -88,50 +88,61 @@ module Peeky
         result
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop:disable Metics/AbcSize
       def render_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} [#{default_param_type}] #{parameter.name}: <value for #{parameter.name.to_s.humanize.downcase}> (optional)"
-            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} [#{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
-
-          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
-
-          render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
-          render_signature.indent = @indent
-          render_signature.style = :default
-          result.push render_signature.render
+        class_info.public_methods.map.with_index do |method_signature, index|
+          render_method(result, method_signature, index)
+        end
+        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
         result.push '' unless result.length.zero?
         result
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop:enable Metics/AbcSize
+
+      # 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
+
+        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
+
+        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/CyclomaticComplexity, Metrics/MethodLength
 
       def render_end
         "#{@indent}end"

data/lib/peeky/renderer/method_call_minimum_params_render.rb

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

data/lib/peeky/version.rb

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

data/lib/peeky.rb

@@ -23,3 +23,10 @@ module Peeky
   class Error < StandardError; end
   # Your code goes here...
 end
+
+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

data/peeky.gemspec

@@ -3,26 +3,16 @@
 require_relative 'lib/peeky/version'
 
 Gem::Specification.new do |spec|
-  # https://piotrmurach.com/articles/writing-a-ruby-gem-specification/
-  spec.required_ruby_version  = '>= 2.5'
   spec.name                   = 'peeky'
   spec.version                = Peeky::VERSION
   spec.authors                = ['David Cruwys']
   spec.email                  = ['david@ideasmen.com.au']
 
   spec.summary                = 'Take a peek into your ruby classes and extract useful meta data'
-  spec.description            = <<-TEXT
-  Peeky is a Ruby GEM for peaking into ruby classes and extracting meta data.
-  You can use this meta data to recreate classes, interfaces, documentation etc.
-  or use it just to understand the internals of a class.
-  TEXT
-
+  spec.description            = 'peeky'
   spec.homepage               = 'http://appydave.com/gems/peeky'
   spec.license                = 'MIT'
-
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.' unless spec.respond_to?(:metadata)
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
 
   # spec.metadata['allowed_push_host'] = "Set to 'http://mygemserver.com'"
 
@@ -37,15 +27,14 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the RubyGem files that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|spec|features)/})
-    end
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
+
   # spec.extensions    = ['ext/peeky/extconf.rb']
-  spec.extra_rdoc_files = ['README.md', 'STORIES.md']
+  spec.extra_rdoc_files = ['README.md', 'STORIES.md', 'USAGE.md']
   spec.rdoc_options    += [
     '--title', 'peeky by appydave.com',
     '--main', 'README.md',
@@ -53,5 +42,4 @@ Gem::Specification.new do |spec|
   ]
 
   spec.add_dependency 'activesupport'
-  # spec.add_dependency 'tty-box',         '~> 0.5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: peeky
 version: !ruby/object:Gem::Version
-  version: 0.0.33
+  version: 0.0.43
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-08 00:00:00.000000000 Z
+date: 2021-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,10 +24,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: |2
-    Peeky is a Ruby GEM for peaking into ruby classes and extracting meta data.
-    You can use this meta data to recreate classes, interfaces, documentation etc.
-    or use it just to understand the internals of a class.
+description: peeky
 email:
 - david@ideasmen.com.au
 executables: []
@@ -35,6 +32,7 @@ extensions: []
 extra_rdoc_files:
 - README.md
 - STORIES.md
+- USAGE.md
 files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
@@ -49,6 +47,7 @@ files:
 - Rakefile
 - STORIES.md
 - USAGE.md
+- USAGE2.md
 - bin/console
 - bin/k
 - bin/kgitsync
@@ -60,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
@@ -94,14 +92,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.7
 signing_key:
 specification_version: 4
 summary: Take a peek into your ruby classes and extract useful meta data

data/lib/peeky/example/yard_sample.rb

@@ -1,124 +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 (optional)
-      def f_method_with_required_param_and_optional_param(first_name, last_name = nil)
-      end
-
-      # G method with required param and two optional params
-      #
-      # @param first_name [String] first name (required)
-      # @param last_name [String] last name (optional)
-      # @param age [String] age (optional)
-      def g_method_with_required_param_and_two_optional_params(first_name, last_name = nil, age = nil)
-      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
-
-      # 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: <value for salutation> (optional)
-      def n_method_with_key_value_param_required_and_optional_key_value(last_name:, salutation: nil)
-      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 [String] bbb (optional)
-      # @param ccc [Array<Object>] *ccc - list of ccc
-      # @param ddd [String] ddd: <value for ddd> (required)
-      # @param eee [String] eee: <value for eee> (optional)
-      # @param fff [<key: value>...] **fff - list of key/values
-      # @param ggg [Block] &ggg
-      def z_complex(aaa, bbb = nil, *ccc, ddd:, eee: nil, **fff, &ggg)
-      end
-    end
-  end
-end