peeky 0.0.31 → 0.0.42

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`
     attr_reader :implementation_type
 
-    # TODO: target_instance is required...
-    def initialize(method, target_instance = nil)
+    def initialize(method, target_instance, access_control: :public)
       @focal_method = method
+      @target_instance = target_instance
+      @access_control = access_control
       @parameters = ParameterInfo.from_method(method)
       # stage 1
       # @implementation_type = :method
 
       # stage 2
-      @implementation_type = infer_implementation_type(target_instance)
+      infer_implementation_type
+
+      # stage 3
+      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,113 @@ 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 [:method, :attr_reader or :attr_writer]
+    # rubocop:disable Lint/DuplicateBranch
+    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
+    end
+    # rubocop:enable Lint/DuplicateBranch
+
+    # 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
+        @target_instance.instance_eval(minimalist_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
+        # not be re-raised
+        puts e.message
       end
     end
 
-    def match(target_instance, predicate)
-      predicate.new.match(target_instance, self)
+    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
 
+    # 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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Peeky
+  module Renderer
+    # Class Debug Render
+    class ClassDebugRender
+      attr_reader :class_info
+
+      def initialize(class_info)
+        @key_width = 30
+        @class_info = class_info
+      end
+
+      # Render the class interface
+      # rubocop:disable Metrics/AbcSize
+      def render
+        output = []
+        output.push class_details
+        attributes = render_accessors + render_readers + render_writers
+
+        if attributes.length.positive?
+          output.push("-- Attributes #{'-' * 86}")
+          output.push(*attributes)
+          output.push('')
+        end
+
+        methods = render_methods(@class_info.public_methods)
+
+        if methods.length.positive?
+          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
+
+        output.pop if output.last == ''
+
+        output.join("\n")
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def lj(value, size = 24)
+        value.to_s.ljust(size)
+      end
+
+      def kv(key, value)
+        "#{key.to_s.ljust(@key_width)}: #{value}"
+      end
+
+      def class_details
+        [
+          '-' * 100,
+          kv('class name', @class_info.class_name),
+          kv('module name', @class_info.module_name),
+          kv('class full name', @class_info.class_full_name),
+          ''
+        ]
+      end
+
+      def render_accessors
+        @class_info.accessors.map { |attr| kv('attr_accessor', attr.name) }
+      end
+
+      def render_readers
+        @class_info.readers.map { |attr| kv('attr_reader', attr.name) }
+      end
+
+      def render_writers
+        @class_info.writers.map { |attr| kv('attr_writer', attr.name) }
+      end
+
+      def render_methods(method_list)
+        method_list.flat_map do |method|
+          [
+            "[ #{method.name} ]",
+            *render_paramaters(method.parameters),
+            ''
+          ]
+        end
+      end
+
+      def render_paramaters(parameters)
+        result = [
+          "#{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.default_value)}"
+        end
+      end
+    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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# require 'active_support/core_ext'
 require 'active_support/core_ext/string'
 
 module Peeky
@@ -37,10 +36,7 @@ module Peeky
         output = []
         output.push render_start
         @indent += '  '
-        output += render_accessors
-        output += render_readers
-        output += render_writers
-        output += render_methods
+        output += (render_accessors + render_readers + render_writers + render_methods)
         output.pop if output.last == ''
 
         @indent = @indent[0..-3]
@@ -92,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.31'
+  VERSION = '0.0.42'
 end

data/lib/peeky.rb

@@ -12,6 +12,7 @@ require 'peeky/parameter_info'
 require 'peeky/predicates/attr_reader_predicate'
 require 'peeky/predicates/attr_writer_predicate'
 
+require 'peeky/renderer/class_debug_render'
 require 'peeky/renderer/class_interface_render'
 require 'peeky/renderer/class_interface_yard_render'
 require 'peeky/renderer/method_call_minimum_params_render'
@@ -22,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