peeky 0.0.19 → 0.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17aca44d1863e4d7d811c2fdf09bbe4aec22c8aa5a2d0d09983a8d9c50f14430
-  data.tar.gz: ff605fe00998f4e7ca15725f20171180329edd882256c46eaa20c96d41491488
+  metadata.gz: 75fed761de619d444f8e84f4e08df5df41e9f12b89e95051b60dd0f60bafa57e
+  data.tar.gz: 05e1ba1ec76ffe0689f536e8e2c78c86fd16570051212ca9031ef3cf5f302e9b
 SHA512:
-  metadata.gz: e212ec6b8cb3e88e78e57f42d7a880aabf73e46cabd0b23e8d3ce93a0819a74d36f7dbf1d1af95f2677824aa885e277d003445c4d8bc656afd4e1245f8cd8d04
-  data.tar.gz: 3498282a3c71032ef6866783d06f642b7c834079d3cfae164d577a734ba5194c082b820b956bef116f7277fed19993f7833776e3fe97c1401d1485cf976e176c
+  metadata.gz: 19bb5a15dc9c0db1a5346632f448da2ff7396f247c474a89b1dee7c2097e1fdf824bce8227a35762bc85db49d4301463f613f78999a20f1656edb870e4eabb51
+  data.tar.gz: 89ae53bd7a7a840a92214337bc7a08c5e813eab892a94391cb69b2e27a0ad87546c7489f03c710f20328b770abafd3ccf45c92a5bdaf22ed0d5ffb2b93fcd2cf

data/.rubocop.yml

@@ -4,8 +4,23 @@ AllCops:
   NewCops: enable
   Exclude:
     - "_/**/*"
+    - "lib/peeky/example/yard_sample.rb"
 
 # My Preferences - Start
+Style/EmptyMethod:    
+  Exclude:
+    - "**/spec/**/*"
+Metrics/ParameterLists:
+  Exclude:
+    - "**/spec/**/*"
+Layout/EmptyLineBetweenDefs:
+  Exclude:
+    - "**/spec/**/*"
+
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - "**/spec/**/*"
+
 Style/AccessorGrouping:
   Enabled: false
 
@@ -16,6 +31,7 @@ Layout/SpaceBeforeComma:
 Metrics/BlockLength:
   Exclude:
     - "**/spec/*"
+    - "*.gemspec"
   ExcludedMethods:
     - configure
     - context

data/.rubocop_todo.yml

@@ -21,6 +21,10 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'peeky.gemspec'
 
+Metrics/BlockLength:
+  Exclude:
+    - 'peeky.gemspec'
+
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle.

data/Gemfile

@@ -5,13 +5,16 @@ 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, :test do
   gem 'guard-bundler'
   gem 'guard-rspec'
   gem 'guard-rubocop'
-  # pry on steroids
-  # gem 'pry-coolline', github: 'owst/pry-coolline', branch: 'support_new_pry_config_api'
-  gem 'jazz_fingers'
   gem 'rake', '~> 12.0'
   # this is used for cmdlets 'self-executing gems'
   gem 'rake-compiler'

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-stories.md

@@ -4,7 +4,37 @@
 
 As a Ruby Developer, I should be able to Reverse engineer classes and methods, so that I can document and understand them
 
-## Stories
+## Development rader
+
+
+### 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
+
+- Add simplified API with examples
+- Start documenting usage instructions
+
+As a Developer, I can quickly build requirements, so that I can document project features
+
+- Add support for backlog stories and tasks
+- Add usage instructions
+
+
+
+## Stories and tasks
+
+### 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
 
@@ -35,15 +65,13 @@ 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
-
+##$ Tasks - completed
 
 Setup GitHub Action (test and lint)
 
 - Setup Rspec action
 - Setup RuboCop action
 
-
 Setup new Ruby GEM
 
 - Build out a standard GEM structure

data/README.md

@@ -2,12 +2,8 @@
 
 > Peeky is a Ruby GEM for peaking into ruby classes and extracting meta
 
-Welcome to your new ruby gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/peeky`.
-
 When using the source code for this gem, start by running `bin/setup` to install locally or `bundle install`
 
-To experiment with that code, run `bin/console` for an interactive prompt or run `exe/peeky` to see a list of commands.
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -62,7 +58,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 [code of conduct](https://github.com/[USERNAME]/peeky/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Peeky project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the.
 
 ## Copyright
 

data/lib/peeky.rb

@@ -2,6 +2,8 @@
 
 require 'peeky/version'
 
+require 'peeky/api'
+
 require 'peeky/attr_info'
 require 'peeky/class_info'
 require 'peeky/method_info'
@@ -11,6 +13,7 @@ require 'peeky/predicates/attr_reader_predicate'
 require 'peeky/predicates/attr_writer_predicate'
 
 require 'peeky/renderer/class_interface_render'
+require 'peeky/renderer/class_interface_yard_render'
 require 'peeky/renderer/method_call_minimum_params_render'
 require 'peeky/renderer/method_signature_render'
 require 'peeky/renderer/method_signature_with_debug_render'

data/lib/peeky/api.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Peeky module provides access to the API via the
+# module method Peeky.api
+module Peeky
+  class << self
+    attr_accessor :api
+  end
+
+  # API has factory and creational patterns for easy usage
+  # of the Peeky reflection system
+  class Api
+    # Build a {Peeky::ClassInfo} structure based around a
+    # ruby class instance.
+    #
+    # 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)
+    end
+
+    # Render a class using a predefined class renderer
+    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?
+
+      renderer = class_renderer(render_key)
+
+      class_info = Peeky::ClassInfo.new(instance) if class_info.nil?
+
+      renderer.new(class_info).render
+    end
+
+    # Get a method renderer by :key
+    #
+    # TODO: Refactor to a configurable system
+    def method_renderer(key)
+      case key
+      when :signature
+        Peeky::Renderer::MethodSignatureRender
+      when :signature_with_debug
+        Peeky::Renderer::MethodSignatureWithDebugRender
+      when :call_minimum_params
+        Peeky::Renderer::MethodCallMinimumParamsRender
+      else
+        raise "Unknown method renderer: #{key}"
+      end
+    end
+
+    # Get a class renderer by :key
+    #
+    # TODO: Refactor to a configurable system
+    def class_renderer(key)
+      case key
+      when :class_interface
+        Peeky::Renderer::ClassInterfaceRender
+      when :class_interface_yard
+        Peeky::Renderer::ClassInterfaceYardRender
+      else
+        raise "Unknown class renderer: #{key}"
+      end
+    end
+
+    # def render_method()
+    # end
+  end
+end
+
+Peeky.api = Peeky::Api.new

data/lib/peeky/class_info.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module Peeky
-  # Class Info stores information about the
-  # class instance that you pass in.
+  # Class Info stores information about the class instance that is provided.
   #
   # The information is collected into MethodInfo objects
   # that live within the signatures accessor.
@@ -10,6 +9,7 @@ module Peeky
   # This information is then separated out into
   # :methods, :attr_accessors, :attr_readers and :attr_writers
   class ClassInfo
+    # Holds an instance to the class you are gathering information from
     attr_reader :instance
 
     # Peak into class information
@@ -17,24 +17,106 @@ module Peeky
       @instance = instance
     end
 
-    def class_name
+    # Class full name includes the module namespace
+    def class_full_name
       instance.class.name
     end
 
+    # Class name
+    def class_name
+      @_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')
+    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
+    # @return [Array<AttrInfo>] list of AttrInfo where type is :attr_accessor
+    def accessors_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
+      accessors
+    end
+
+    # Attribute infos
+    def attribute_infos
+      @_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]) }
+      end
+    end
+
+    # Method by name
+    #
+    # @param name [String] name (required)
+    def method_by_name(name)
+      signatures_by_name(name, filter_type: :method).first
+    end
+
+    # Get a list methods
+    # @return [Array<MethodInfo>] list of MethodInfo where type is :method
+    def methods
+      @_methods ||= signatures.select { |signature| signature.implementation_type == :method }
+    end
+
+    # Get a list methods ordered the way they are in the source code
+    # @return [Array<MethodInfo>] list of MethodInfo
+    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
+    end
+
+    # Reader by name
+    #
+    # @param name [String] name (required)
+    def reader_by_name(name)
+      signatures_by_name(name, filter_type: :attr_reader).first
     end
 
+    # 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
+    # @return [Array<AttrInfo>] list of AttrInfo where type is :attr_reader
+    def readers_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
+      readers
+    end
+
+    # 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
 
-    def methods
-      @methods ||= signatures.select { |signature| signature.implementation_type == :method }
+    # Get a list of :attr_writer ordered the way they are in the source code
+    # @return [Array<AttrInfo>] list of AttrInfo where type is :attr_writer
+    def writers_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
+      writers
+    end
+
+    # Writer by name
+    #
+    # @param name [String] name (required)
+    def writer_by_name(name)
+      signatures_by_name(name, filter_type: :attr_writer).first
     end
 
     # def signatures(types = [:instance])
@@ -42,27 +124,45 @@ 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) }
-    end
-
-    def signatures_by_name(name)
-      signatures.select { |im| im.name == name }
+      @_signatures ||= ruby_instance_methods.map { |im| MethodInfo.new(im, @instance) }
     end
 
+    # Signatures by clean name
+    #
+    # @param clean_name [String] clean name (required)
     def signatures_by_clean_name(clean_name)
       signatures.select { |im| im.clean_name == clean_name }
     end
 
-    def attribute_infos
-      @attribute_infos ||= begin
-        grouped_method_infos = signatures.select { |signature| signature.readable? || signature.writable? }.group_by(&:clean_name)
+    # Signatures by name
+    #
+    # @param name [String] name (required)
+    # @param filter_type [String] filter_type: <value for filter type> (optional)
+    def signatures_by_name(name, filter_type: :all)
+      return signatures.select { |im| im.name == name } if filter_type == :all
 
-        grouped_method_infos.keys.map { |key| AttrInfo.create(*grouped_method_infos[key]) }
-      end
+      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
+    # 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])
-      if format == :method_names
+      if format.include?(:method_names)
         puts '-' * 70
         puts 'Method Names'
         puts '-' * 70
@@ -71,7 +171,7 @@ module Peeky
         end
       end
 
-      return unless format == :signatures
+      return unless format.include?(:signatures)
 
       puts '-' * 70
       puts 'Methods'
@@ -82,11 +182,15 @@ module Peeky
     private
 
     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_instance_methods
-      @ruby_instance_methods ||= ruby_instance_method_names.map { |method_name| instance.method(method_name) }
+      begin
+        @_ruby_instance_methods ||= ruby_instance_method_names.map { |method_name| instance.method(method_name) }
+      rescue => exception
+        puts exception
+      end
     end
   end
 end

data/lib/peeky/example/yard_sample.rb

@@ -0,0 +1,123 @@
+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

data/lib/peeky/method_info.rb

@@ -12,18 +12,19 @@ module Peeky
     attr_accessor :parameters
 
     # MethodInfo delegates to the underlying ruby method object
-    attr_reader :method
+    attr_reader :focal_method
 
-    def_delegators :method, :name, :receiver, :arity, :super_method
+    def_delegators :focal_method, :name, :receiver, :arity, :super_method
 
     # Stage 2 is the method likely to be an attribute reader or writer
 
-    # Implemented As indicates the probable representation of this
+    # 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)
-      @method = method
+      @focal_method = method
       @parameters = ParameterInfo.from_method(method)
       # stage 1
       # @implementation_type = :method

data/lib/peeky/predicates/attr_reader_predicate.rb

@@ -7,27 +7,39 @@ module Peeky
     # Attr Reader Predicate will match true if the method info could be considered
     # a valid attr_reader
     class AttrReaderPredicate
+      # Match will return true if the method_info seems to be an :attr_reader
+      #
+      # @param instance [Object] instance the object that has this method (required)
+      # @param method_info [String] method info (required)
       def match(instance, method_info)
         return false unless prerequisites(instance, method_info)
 
-        variable_name = "@#{method_info.name}"
         method_name = method_info.name
 
         # Refactor: Fragile
         # Really need to handle exceptions and types better
         # old_value = instance.send(method_name)
+
+        # This code works by 
+        # 1. Set @name_of_method variable to random value
+        # 2. Call method name and see if it returns that value
+        # 3. Return match<true> if the values are equal
         new_value = SecureRandom.alphanumeric(20)
         code = <<-RUBY
-          #{variable_name} = '#{new_value}' # @variable = 'a3bj7a3bj7a3bj7a3bj7'
+          @#{method_name} = '#{new_value}' # eg. @variable = 'a3bj7a3bj7a3bj7a3bj7'
         RUBY
-        instance.instance_eval(code)
-        current_value = instance.send(method_name)
+
+        cloned = instance.clone
+
+        cloned.instance_eval(code)
+        current_value = cloned.send(method_name)
         current_value == new_value
       end
 
       private
 
       def prerequisites(instance, method_info)
+        # look for obvious NON :attr_reader patterns
         return false if %w[! ? =].include?(method_info.name.to_s[-1..-1])
         return false unless method_info.parameters.length.zero?
         return false unless instance.respond_to?(method_info.name)

data/lib/peeky/predicates/attr_writer_predicate.rb

@@ -7,16 +7,24 @@ module Peeky
     # Attr Writer Predicate will match true if the method info could be considered
     # a valid attr_writer
     class AttrWriterPredicate
+      # Match will return true if the method_info seems to be an :attr_writer
+      #
+      # @param instance [Object] instance the object that has this method (required)
+      # @param method_info [String] method info (required)
       def match(instance, method_info)
         return false unless prerequisites(instance, method_info)
 
         param = method_info.parameters.first
+        # Taking advantage of an odd reflection concept in ruby where by
+        # method.parameters returns this array value [:req] for :attr_writer
+        # while ordinary methods return [:req, some_param_name]
         param.type == :param_required && param.name.empty?
       end
 
       private
 
       def prerequisites(instance, method_info)
+        # look for obvious NON :attr_writer patterns
         return false if %w[! ?].include?(method_info.name.to_s[-1..-1])
         return false unless method_info.name.to_s.end_with?('=')
         return false unless instance.respond_to?(method_info.name)

data/lib/peeky/renderer/class_interface_render.rb

@@ -30,12 +30,14 @@ module Peeky
     #   def z(aaa, bbb = nil, *ccc, ddd:, eee: nil, **fff, &ggg);                       end
     # end
     class ClassInterfaceRender
+      # ClassInfo with information about the class instance to be rendered.
       attr_reader :class_info
 
       def initialize(class_info)
         @class_info = class_info
       end
 
+      # Render the class interface
       def render
         @indent = ''
         output = []
@@ -53,30 +55,32 @@ module Peeky
         output.join("\n")
       end
 
+      private
+
       def render_start
-        "#{@indent}class #{class_info.class_name}"
+        "#{@indent}class #{@class_info.class_name}"
       end
 
       def render_accessors
-        result = class_info.accessors.map { |attr| "#{@indent}attr_accessor :#{attr.name}" }
+        result = @class_info.accessors.map { |attr| "#{@indent}attr_accessor :#{attr.name}" }
         result.push '' unless result.length.zero?
         result
       end
 
       def render_readers
-        result = class_info.readers.map { |attr| "#{@indent}attr_reader :#{attr.name}" }
+        result = @class_info.readers.map { |attr| "#{@indent}attr_reader :#{attr.name}" }
         result.push '' unless result.length.zero?
         result
       end
 
       def render_writers
-        result = class_info.writers.map { |attr| "#{@indent}attr_writer :#{attr.name}" }
+        result = @class_info.writers.map { |attr| "#{@indent}attr_writer :#{attr.name}" }
         result.push '' unless result.length.zero?
         result
       end
 
       def render_methods
-        result = class_info.methods.map do |method_signature|
+        result = @class_info.methods.map do |method_signature|
           render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
           "#{@indent}#{render_signature.render}"
         end
@@ -87,10 +91,6 @@ module Peeky
       def render_end
         "#{@indent}end"
       end
-
-      def debug
-        puts render
-      end
     end
   end
 end

data/lib/peeky/renderer/class_interface_yard_render.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# require 'active_support/core_ext'
+require 'active_support/core_ext/string'
+
+module Peeky
+  module Renderer
+    # Render: Class Interface with YARD documentation
+    class ClassInterfaceYardRender
+      # Indentation prefix as a string, defaults to +''+
+      #
+      # If you were writing a class into a file with an existing
+      # module, you may set the indent to +'  '+ if you wanted this
+      # render to indent by two spaces
+      attr_accessor :indent
+
+      # Default param type when documenting positional and named parameters.
+      # Defaults to  <String>
+      attr_accessor :default_param_type
+
+      # Default param type when documenting splat *parameters.
+      # Defaults to  <Object>
+      attr_accessor :default_splat_param_type
+
+      # ClassInfo with information about the class instance to be rendered.
+      attr_reader :class_info
+
+      def initialize(class_info)
+        @class_info = class_info
+        @indent = ''
+        @default_param_type = 'String'
+        @default_splat_param_type = 'Object'
+      end
+
+      # Render the class interface with YARD documentation
+      def render
+        output = []
+        output.push render_start
+        @indent += '  '
+        output += render_accessors
+        output += render_readers
+        output += render_writers
+        output += render_methods
+        output.pop if output.last == ''
+
+        @indent = @indent[0..-3]
+
+        output.push render_end
+
+        output.join("\n")
+      end
+
+      private
+
+      def render_start
+        [
+          "#{@indent}# #{@class_info.class_name.titleize.humanize}",
+          "#{@indent}class #{@class_info.class_name}"
+        ]
+      end
+
+      def render_accessors
+        result = []
+        @class_info.accessors.map.with_index do |attr, index|
+          result.push '' if index.positive?
+          result.push "#{@indent}# #{attr.name.to_s.humanize}"
+          result.push "#{@indent}attr_accessor :#{attr.name}"
+        end
+        result.push '' unless result.length.zero?
+        result
+      end
+
+      def render_readers
+        result = []
+        @class_info.readers.map.with_index do |attr, index|
+          result.push '' if index.positive?
+          result.push "#{@indent}# #{attr.name.to_s.humanize}"
+          result.push "#{@indent}attr_reader :#{attr.name}"
+        end
+        result.push '' unless result.length.zero?
+        result
+      end
+
+      def render_writers
+        result = []
+        class_info.writers.map.with_index do |attr, index|
+          result.push '' if index.positive?
+          result.push "#{@indent}# #{attr.name.to_s.humanize}"
+          result.push "#{@indent}attr_writer :#{attr.name}"
+        end
+        result.push '' unless result.length.zero?
+        result
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      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
+
+          result.push "#{@indent}# @return [Boolean] true when #{method_signature.name.to_s.humanize.downcase}" if method_signature.name.to_s.end_with?('?')
+
+          render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
+          render_signature.indent = @indent
+          render_signature.style = :default
+          result.push render_signature.render
+        end
+        result.push '' unless result.length.zero?
+        result
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      def render_end
+        "#{@indent}end"
+      end
+    end
+  end
+end

data/lib/peeky/renderer/method_call_minimum_params_render.rb

@@ -8,13 +8,16 @@ module Peeky
     #   instance.simple('first_param')
     #   instance.complex('aaa', ddd: 'ddd')
     class MethodCallMinimumParamsRender
+      # Method signature stores a MethodInfo object
       attr_reader :method_signature
 
-      def initialize(method_signature, instance_name = 'instance')
+      def initialize(method_signature, **opts)
+        instance_name = opts[:instance_name] || 'instance'
         @instance_name = instance_name
         @method_signature = method_signature
       end
 
+      # Render the a method call with minimal parameters
       def render
         name = method_signature.name
 
@@ -28,10 +31,6 @@ module Peeky
 
         "#{@instance_name}.#{name}#{params}"
       end
-
-      def debug
-        puts render
-      end
     end
   end
 end

data/lib/peeky/renderer/method_signature_render.rb

@@ -4,14 +4,54 @@ module Peeky
   module Renderer
     # Render: Method Signature in compact format
     #
-    # Example output:
+    # === Example output (:default):
+    #   def simple(first_param)
+    #   end
+    #
+    #   def complex(aaa, bbb = nil, *ccc, ddd:, eee: nil, **fff, &ggg)
+    #   end
+    #
+    # === Example output (:compact):
     #   def simple(first_param);                                           end
     #   def complex(aaa, bbb = nil, *ccc, ddd:, eee: nil, **fff, &ggg);    end
     class MethodSignatureRender
+      # Indentation prefix as a string.
+      #
+      # Defaults to ''
+      #
+      # If you were writing a class into a file with an existing
+      # module, you may set the indent to '  ' if you wanted this
+      # render to indent by two spaces
+      attr_accessor :indent
+
+      # Style of method rendering [:default, :compact]
+      #
+      # default:: will render +def method_name+ and +end+ on separate lines
+      # compact:: will render +def method_name+ and +end+ on same line
+      # @return [Symbol] style
+      attr_accessor :style
+
+      # Method signature stores a MethodInfo object
       attr_reader :method_signature
 
-      def initialize(method_signature)
+      def initialize(method_signature, **_opts)
         @method_signature = method_signature
+        @indent = ''
+        @style = :compact
+      end
+
+      # Render the method signature in the selected style
+      def render
+        output = []
+        if @style == :compact
+          signature = "#{render_signature};"
+          output.push "#{signature.ljust(80)}#{render_end}"
+        end
+        if @style == :default
+          output.push render_signature
+          output.push render_end
+        end
+        output.join("\n")
       end
 
       def render_signature
@@ -19,20 +59,11 @@ module Peeky
 
         formatted_parameters = method_signature.parameters.map(&:signature_format).join(', ')
         params = formatted_parameters.length.zero? ? '' : "(#{formatted_parameters})"
-        "def #{name}#{params}"
+        "#{@indent}def #{name}#{params}"
       end
 
       def render_end
-        'end'
-      end
-
-      def render
-        signature = "#{render_signature};"
-        "#{signature.ljust(80)}#{render_end}"
-      end
-
-      def debug
-        puts render
+        "#{@indent}end"
       end
     end
   end

data/lib/peeky/renderer/method_signature_with_debug_render.rb

@@ -22,14 +22,22 @@ module Peeky
     #     puts ggg                            # &ggg is block with many calling options, example - instance_eval(&block) if block_given?
     #   end
     class MethodSignatureWithDebugRender
+      # Method signature stores a MethodInfo object
       attr_reader :method_signature
 
-      def initialize(method_signature)
+      def initialize(method_signature, **_opts)
         @method_signature = method_signature
 
         @render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
       end
 
+      # Render the method with debug statements for each parameter
+      def render
+        render_method
+      end
+
+      private
+
       def render_method
         name = method_signature.name
 
@@ -38,7 +46,7 @@ module Peeky
         indent = '  '
         output += "#{indent}puts 'method name: #{name}'\n"
 
-        output += render_logic(indent, 30)
+        output += render_debug_logic(indent, 30)
 
         indent = ''
         output += "#{indent}#{@render_signature.render_end}\n"
@@ -47,7 +55,7 @@ module Peeky
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      def render_logic(indent, size)
+      def render_debug_logic(indent, size)
         output = ''
         method_signature.parameters.each do |parameter|
           line = ''
@@ -73,14 +81,6 @@ module Peeky
         output
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
-
-      def render
-        render_method
-      end
-
-      def debug
-        puts render
-      end
     end
   end
 end

data/lib/peeky/tools/generate_yard_documentation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# 
+
+module Peeky
+  module Tools
+    # Generate Yard Documentation
+    class GenerateYardDocumentation
+      
+
+      def initialize
+      end
+
+      def debug
+      end
+
+    end
+  end
+end

data/lib/peeky/version.rb

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

data/peeky.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version  = '>= 2.5'
   spec.name                   = 'peeky'
   spec.version                = Peeky::VERSION
-  spec.authors                = ['David C']
+  spec.authors                = ['David Cruwys']
   spec.email                  = ['david@ideasmen.com.au']
 
   spec.summary                = 'Extracting meta data from ruby classes'
@@ -41,5 +41,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   # spec.extensions    = ['ext/peeky/extconf.rb']
 
+  spec.add_dependency 'activesupport'
   # spec.add_dependency 'tty-box',         '~> 0.5.0'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: peeky
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.25
 platform: ruby
 authors:
-- David C
+- David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-03 00:00:00.000000000 Z
-dependencies: []
+date: 2020-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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.
@@ -40,16 +54,20 @@ files:
 - hooks/pre-commit
 - hooks/update-version
 - lib/peeky.rb
+- 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
 - lib/peeky/predicates/attr_writer_predicate.rb
 - lib/peeky/renderer/class_interface_render.rb
+- lib/peeky/renderer/class_interface_yard_render.rb
 - lib/peeky/renderer/method_call_minimum_params_render.rb
 - lib/peeky/renderer/method_signature_render.rb
 - lib/peeky/renderer/method_signature_with_debug_render.rb
+- lib/peeky/tools/generate_yard_documentation.rb
 - lib/peeky/version.rb
 - peeky.gemspec
 homepage: http://appydave.com/gems/peeky