peeky 0.0.28 → 0.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5bfa72308dbaa677a774831ef7323b1a6b7756589714b068edab839232e96c1
-  data.tar.gz: c20a0d04a9ef69d8f77d7c506ddd45560294a4e9b0b7ec7ffeb33c6665b6a3f6
+  metadata.gz: edb80ec928d5d4495d464467e28bbb6b16638a14773eca16891ddbea915335a5
+  data.tar.gz: febac36ff7fa54d618d0ef6f3ef20da522b5918904c76550b823f11e1eb6ffde
 SHA512:
-  metadata.gz: '0070992885f6a7a5a19acb3d62fef9e5ce3d116b35c0436185fe3304293c7831bb6c9652704c43985842854bba7472733bb10b2cd26f055b9893dedecae27604'
-  data.tar.gz: 2312202e390a5ad6478aa124f94634627b65d7a69f0e0b725091907d7bddc10040a524b7eaf784e0bf37c74ab030228a74a8d1a319f810516308c7dc83c985ea
+  metadata.gz: 4c984b3df997d970c6da34e654495802f54ce67c18bf7a057e22b56ab6f0c7b9e68579834715b09288059ac389662d5c3504ebe1aa42eee7675978b8010cb1b3
+  data.tar.gz: c2e45fbfda42652aeec5334edc8a5d596948eba45ecaa91d3a3f8522e603c39284deff97a78abc519edc0be675e29811624b7c51a2e17d48a3fe501acd9ca669

data/README.md

@@ -30,17 +30,82 @@ gem install peeky
 
 As a Ruby Developer, I should be able to Reverse engineer classes and methods, so that I can document and understand them
 
-See all [stories](./file.STORIES.html)
+See all [stories](./STORIES.md)
 
 ### Featured Stories
 
 - As a Developer, I should be able to interrogate class instance information, so that I can reverse engineer a ruby class
-- As a Developer, I can render method with minimal parameter calls, So that I know the minimum parameters when calling a method
+- As a Developer, I can render a method with minimal parameter calls, So that I know the minimum parameters when calling a method
 - As a Developer, I can render a class with instance attributes and methods, So that I can quickly mock out an entire class
 
 ## Usage
 
-TODO: Write usage instructions here
+See all [usages](./USAGE.md)
+
+### Basic Example
+
+This example assumes you have this simple class
+
+
+
+```ruby
+module Sample
+  class SimpleClass
+    attr_accessor :read_write
+
+    def position_and_optional(aaa, bbb = 1)
+    end
+  end
+end      
+```
+
+
+### Rendering Examples
+
+Here a list of example renderers for the simple class
+
+#### Class interface
+Render simple class using class_interface renderer with compact formatting
+
+```ruby
+puts api.render_class(:class_interface, instance: Sample::SimpleClass.new)
+```
+
+
+
+```ruby
+class SimpleClass
+  attr_accessor :read_write
+
+  def position_and_optional(aaa, bbb = nil);                                      end
+end
+```
+
+#### Documented class interface
+Render simple class using class_interface_yard renderer to product YARD compatible documentation
+
+```ruby
+puts api.render_class(:class_interface_yard, instance: Sample::SimpleClass.new)
+```
+
+
+
+```ruby
+class SimpleClass
+  # Read write
+  attr_accessor :read_write
+
+  # Position and optional
+  #
+  # @param aaa [String] aaa (required)
+  # @param bbb [String] bbb (optional)
+  def position_and_optional(aaa, bbb = nil)
+  end
+end
+```
+
+
+
 
 ## Development
 
@@ -58,7 +123,7 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Peeky project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the.
+Everyone interacting in the Peeky project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/peeky/blob/master/CODE_OF_CONDUCT.md).
 
 ## Copyright
 

data/STORIES.md

@@ -4,17 +4,12 @@
 
 As a Ruby Developer, I should be able to Reverse engineer classes and methods, so that I can document and understand them
 
-## Development rader
+## Development radar
 
 
 ### Tasks next on list
 
-As a Developer, I can render a class with RDoc documentation, so that I do not have to manually type RDoc references
-
-- Add simplified API with examples
-- Start documenting usage instructions
-
-As a Developer, I can use Peeky with a simple API, so that I use this GEM quickly
+As a Developer, I can use Peeky with a simple API, so that I use Peeky quickly
 
 - Add simplified API with examples
 - Start documenting usage instructions
@@ -30,12 +25,6 @@ As a Developer, I can quickly build requirements, so that I can document project
 
 ### Stories - completed
 
-As a David, I can edify Karin, because she is cool
-
-- karin_is_awesome
-- i_am_very_grateful_for_karin
-- karin_the_beautiful
-
 As a Developer, I can render a class with instance attributes and methods, So that I can quickly mock out an entire class
 
 - Render: Class Interface
@@ -48,7 +37,7 @@ As a Developer, I can see the method signature of a method, So that I understand
 
 - Render: Method Signature in compact format
 
-As a Developer, I can render method with minimal parameter calls, So that I know the minimum parameters when calling a method
+As a Developer, I can render a method with minimal parameter calls, So that I know the minimum parameters when calling a method
 
 - Render: Simple instance method calls with minimum parameters
 
@@ -65,7 +54,14 @@ As a Developer, I should be able to interrogate class instance information, so t
 - ClassInfo stores information about a ruby class. Only support instance methods
 
 
-##$ Tasks - completed
+### Tasks - completed
+
+As a Developer, I can render a class with RDoc documentation, so that I do not have to manually type RDoc references
+
+
+As a Developer, I can read detailed API documentation on Peaky, so that I use Peeky quickly
+
+- Acid Test: Use the YARD renderer to document Peaky the GEM
 
 Setup GitHub Action (test and lint)
 

data/USAGE.md

@@ -0,0 +1,322 @@
+# Peeky
+
+> Peeky is a Ruby GEM for peaking into ruby classes and extracting meta
+
+As a Ruby Developer, I should be able to Reverse engineer classes and methods, so that I can document and understand them
+
+## Usage
+
+### Sample Classes
+
+The usage examples listed below will work with these sample classes
+
+#### Simple example
+
+
+```ruby
+module Sample
+  class SimpleClass
+    attr_accessor :read_write
+
+    def position_and_optional(aaa, bbb = 1)
+    end
+  end
+end      
+```
+
+#### Complex example
+
+
+```ruby
+module Sample
+  class ComplexClass
+    attr_accessor :a_read_write1, :a_read_write2
+    attr_reader   :b_reader, :b_another_reader
+    attr_writer   :c_writer, :c_another_writer
+
+    def do_something_method
+    end
+
+    def looks_like_an_attr_reader
+      @looks_like_an_attr_reader ||= 5
+    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); end
+
+    def method_08(aaa, *bbb, **ccc, &ddd); end
+
+    def method_09(aaa:); end
+
+    def method_10(aaa:, bbb: 1); end
+
+    def questionable?; end
+
+    def destructive!; end
+
+    def method_with_every_type_of_paramater(aaa, bbb = 1, *ccc, ddd:, eee: 1, **fff, &ggg); end
+
+    # Check that methods are sorted
+    def alpha_sort2;                                        end
+    def alpha_sort1;                                        end
+  end
+end      
+```
+
+
+### Build Class Information
+
+Use build_class_info to extract meta data from a ruby class
+
+#### Build ClassInfo
+By default information is lazy loaded only when accessed
+
+
+```ruby
+class_info = api.build_class_info(Sample::SimpleClass.new)
+
+puts class_info
+```
+
+
+
+```shell
+Sample::SimpleClass
+```
+
+#### Build ClassInfo - pre-loaded
+Pre-load will ensure that methods and parameters are loaded straight away.
+
+
+```ruby
+class_info = api.build_class_info(Sample::ComplexClass.new, lazy: false)
+
+puts class_info
+```
+
+
+
+```shell
+Sample::ComplexClass
+```
+
+
+### Render Class
+
+Render a class using a pre-defined class renderer that can be referenced by key
+
+#### Render class interface using class_info
+Render a basic class interface in compact format "One line per method".
+
+Note: Modules are not yet supported in Peeky
+
+
+```ruby
+class_info = api.build_class_info(Sample::SimpleClass.new)
+
+puts api.render_class(:class_interface, class_info: class_info)
+```
+
+#### Render class interface using an instance of the intended class
+
+
+```ruby
+puts api.render_class(:class_interface, instance: Sample::SimpleClass.new)
+```
+
+
+### Render Class Examples
+
+Here a list of example renderers for the complex class
+
+#### Class interface
+Render simple class using class_interface renderer
+
+```ruby
+puts api.render_class(:class_interface, instance: Sample::SimpleClass.new)
+```
+
+
+
+```ruby
+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 = nil);                                                  end
+  def method_03(aaa, bbb = nil, ccc = nil);                                       end
+  def method_04(*aaa);                                                            end
+  def method_05(aaa, bbb = nil, *ccc);                                            end
+  def method_06(**aaa);                                                           end
+  def method_07(aaa, *bbb, **ccc);                                                end
+  def method_08(aaa, *bbb, **ccc, &ddd);                                          end
+  def method_09(aaa:);                                                            end
+  def method_10(aaa:, bbb: nil);                                                  end
+  def method_with_every_type_of_paramater(aaa, bbb = nil, *ccc, ddd:, eee: nil, **fff, &ggg);end
+  def questionable?;                                                              end
+end
+```
+
+#### Class interface - YARD
+Render complex class using class_interface_yard renderer
+
+```ruby
+puts api.render_class(:class_interface_yard, instance: Sample::ComplexClass.new)
+```
+
+
+
+```ruby
+class ComplexClass
+  # A read write1
+  attr_accessor :a_read_write1
+
+  # A read write2
+  attr_accessor :a_read_write2
+
+  # B another reader
+  attr_reader :b_another_reader
+
+  # B reader
+  attr_reader :b_reader
+
+  # Looks like an attr reader
+  attr_reader :looks_like_an_attr_reader
+
+  # C another writer
+  attr_writer :c_another_writer
+
+  # C writer
+  attr_writer :c_writer
+
+  # Alpha sort1
+  def alpha_sort1
+  end
+
+  # Alpha sort2
+  def alpha_sort2
+  end
+
+  # Destructive!
+  def destructive!
+  end
+
+  # Do something method
+  def do_something_method
+  end
+
+  # Method 01
+  #
+  # @param aaa [String] aaa (required)
+  def method_01(aaa)
+  end
+
+  # Method 02
+  #
+  # @param aaa [String] aaa (required)
+  # @param bbb [String] bbb (optional)
+  def method_02(aaa, bbb = nil)
+  end
+
+  # Method 03
+  #
+  # @param aaa [String] aaa (required)
+  # @param bbb [String] bbb (optional)
+  # @param ccc [String] ccc (optional)
+  def method_03(aaa, bbb = nil, ccc = nil)
+  end
+
+  # Method 04
+  #
+  # @param aaa [Array<Object>] *aaa - list of aaa
+  def method_04(*aaa)
+  end
+
+  # Method 05
+  #
+  # @param aaa [String] aaa (required)
+  # @param bbb [String] bbb (optional)
+  # @param ccc [Array<Object>] *ccc - list of ccc
+  def method_05(aaa, bbb = nil, *ccc)
+  end
+
+  # Method 06
+  #
+  # @param aaa [<key: value>...] **aaa - list of key/values
+  def method_06(**aaa)
+  end
+
+  # Method 07
+  #
+  # @param aaa [String] aaa (required)
+  # @param bbb [Array<Object>] *bbb - list of bbb
+  # @param ccc [<key: value>...] **ccc - list of key/values
+  def method_07(aaa, *bbb, **ccc)
+  end
+
+  # Method 08
+  #
+  # @param aaa [String] aaa (required)
+  # @param bbb [Array<Object>] *bbb - list of bbb
+  # @param ccc [<key: value>...] **ccc - list of key/values
+  # @param ddd [Block] &ddd
+  def method_08(aaa, *bbb, **ccc, &ddd)
+  end
+
+  # Method 09
+  #
+  # @param aaa [String] aaa: <value for aaa> (required)
+  def method_09(aaa:)
+  end
+
+  # Method 10
+  #
+  # @param aaa [String] aaa: <value for aaa> (required)
+  # @param bbb [String] bbb: <value for bbb> (optional)
+  def method_10(aaa:, bbb: nil)
+  end
+
+  # Method with every type of paramater
+  #
+  # @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 method_with_every_type_of_paramater(aaa, bbb = nil, *ccc, ddd:, eee: nil, **fff, &ggg)
+  end
+
+  # Questionable?
+  #
+  # @return [Boolean] true when questionable?
+  def questionable?
+  end
+end
+```
+
+#### Debug class info

data/lib/peeky/api.rb

@@ -16,8 +16,10 @@ module Peeky
     # ClassInfo stores information about the instance of a
     # class that is passed in including methods, attr_accessors
     # attr_readers and attr_writers.
-    def build_class_info(instance)
-      Peeky::ClassInfo.new(instance)
+    def build_class_info(instance, lazy: true)
+      ci = Peeky::ClassInfo.new(instance)
+      ci.load unless lazy
+      ci
     end
 
     # Render a class using a predefined class renderer

data/lib/peeky/class_info.rb

@@ -17,6 +17,23 @@ module Peeky
       @instance = instance
     end
 
+    def to_s
+      class_full_name
+    end
+
+    # Load class_info
+    #
+    # Accessing information about methods and parameters is currently
+    # lazy-loaded via memoization.
+    #
+    # 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
+
     # Class full name includes the module namespace
     def class_full_name
       instance.class.name
@@ -144,17 +161,6 @@ module Peeky
       signatures.select { |im| im.name == name && im.implementation_type == filter_type }
     end
 
-    # Build (not sure where I am going with this yet)
-    # TODO: Refact: Currently the idea is to pre-load data
-    # this is slower when you are not accessing things, but
-    # it is easier to debug, so think about what I really want
-    # here
-    def build
-      ruby_instance_methods
-      ruby_instance_method_names
-      signatures
-    end
-
     # Debug
     #
     # Refact: PATTERN: Come up it an debug inclusion system so that

data/lib/peeky/example/yard_sample.rb

@@ -99,6 +99,7 @@ module Peeky
       end
 
       # P available?
+
       # @return [Boolean] true when p available?
       def p_available?
       end

data/lib/peeky/parameter_info.rb

@@ -20,11 +20,8 @@ module Peeky
     # type of the parameter
     attr_accessor :type
 
-    # ruby code format when used in a signature
-    attr_accessor :signature_format
-
-    # minimal required usage in a call to the method with this paramater
-    attr_accessor :minimal_call_format
+    # default value for positional or keyed parameters
+    attr_accessor :default_value
 
     def initialize(param)
       map(param)
@@ -58,47 +55,125 @@ module Peeky
       puts "minimal_call_format           : #{minimal_call_format}"
     end
 
+    # ruby code formatted for use in a method signature
+    def signature_format
+      @_signature_format ||= begin
+        method_name = "signature_format_#{@type}".to_sym
+
+        m = method(method_name)
+        m.call
+      end
+    end
+
+    # minimal required usage in a call to the method with this paramater
+    def minimal_call_format
+      @_minimal_call_format ||= begin
+        method_name = "minimal_call_format_#{@type}".to_sym
+
+        if respond_to?(method_name, true)
+          m = method(method_name)
+          m.call
+        else
+          minimal_call_format_ignore
+        end
+      end
+    end
+
     private
 
     # Convert the limited information provided by ruby method.parameters
     # to a richer structure.
-    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
     def map(param)
       @name = param.length > 1 ? param[1].to_s : ''
 
+      @default_value = nil
+
       case param[0]
       when :req
         @type = :param_required
-        @signature_format = name.to_s
-        @minimal_call_format = "'#{name}'"
       when :opt
         @type = :param_optional
-        @signature_format = "#{name} = nil"
-        @minimal_call_format = ''
       when :rest
         @type = :splat
-        @signature_format = "*#{name}"
-        @minimal_call_format = ''
       when :keyreq
         @type = :key_required
-        @signature_format = "#{name}:"
-        @minimal_call_format = "#{name}: '#{name}'"
       when :key
         @type = :key_optional
-        @signature_format = "#{name}: nil"
-        @minimal_call_format = ''
       when :keyrest
         @type = :double_splat
-        @signature_format = "**#{name}"
-        @minimal_call_format = ''
       when :block
         @type = :block
-        @signature_format = "&#{name}"
-        @minimal_call_format = ''
       else
         raise 'unknown type'
       end
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # Signature format *: Is used to format a parameter when it is used
+    # inside of a method signature, eg. def my_method(p1, p2 = 'xyz', p3: :name_value)
+
+    def signature_format_param_required
+      name.to_s
+    end
+
+    def signature_format_param_optional
+      "#{name} = nil" # signature format needs to be moved to a method
+    end
+
+    def signature_format_splat
+      "*#{name}"
+    end
+
+    def signature_format_key_required
+      "#{name}:"
+    end
+
+    def signature_format_key_optional
+      "#{name}: nil"
+    end
+
+    def signature_format_double_splat
+      "**#{name}"
+    end
+
+    def signature_format_block
+      "&#{name}"
+    end
+
+    # Minimal call format *: Is used to format a call to a method with the least
+    # number of parameters needed to make it work.
+
+    def minimal_call_format_ignore
+      ''
+    end
+
+    def minimal_call_format_param_required
+      "'#{@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/renderer/class_interface_yard_render.rb

@@ -122,7 +122,10 @@ module Peeky
             end
           end
 
-          result.push "#{@indent}# @return [Boolean] true when #{method_signature.name.to_s.humanize.downcase}" if method_signature.name.to_s.end_with?('?')
+          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

data/lib/peeky/version.rb

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

data/peeky.gemspec

@@ -49,7 +49,7 @@ Gem::Specification.new do |spec|
   spec.rdoc_options    += [
     '--title', 'peeky by appydave.com',
     '--main', 'README.md',
-    '--files STORIES.MD'
+    '--files STORIES.MD USAGE.MD'
   ]
 
   spec.add_dependency 'activesupport'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: peeky
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.0.31
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-07 00:00:00.000000000 Z
+date: 2020-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -48,6 +48,7 @@ files:
 - README.md
 - Rakefile
 - STORIES.md
+- USAGE.md
 - bin/console
 - bin/k
 - bin/kgitsync
@@ -85,7 +86,7 @@ rdoc_options:
 - peeky by appydave.com
 - "--main"
 - README.md
-- "--files STORIES.MD"
+- "--files STORIES.MD USAGE.MD"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement