peeky 0.0.15 → 0.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ca022f75a0c8100cb747acf3be51f77abf2ebedd092b6f235fbe717ea001dc4
-  data.tar.gz: 43250493a0da5114f6d685445a8b189d335df8dc74f3596c3d7395b4e1dd0a3a
+  metadata.gz: edb80ec928d5d4495d464467e28bbb6b16638a14773eca16891ddbea915335a5
+  data.tar.gz: febac36ff7fa54d618d0ef6f3ef20da522b5918904c76550b823f11e1eb6ffde
 SHA512:
-  metadata.gz: bbfa5087d3653aa6aee52ce37138883205e5b8ee1c3cef4419a0619c81e97f3f577c8f8482ff7c399d9a454fe07530857b8f16863129547f954cfcd45b7ddda9
-  data.tar.gz: 71738fcef6e04171391b2863f480468f3e34ed249fcee9dfd6188fbf2fdfab0b655ebe07d82170e058dcadfef2b76e4c06bd22617b78d200608478cb35e06a95
+  metadata.gz: 4c984b3df997d970c6da34e654495802f54ce67c18bf7a057e22b56ab6f0c7b9e68579834715b09288059ac389662d5c3504ebe1aa42eee7675978b8010cb1b3
+  data.tar.gz: c2e45fbfda42652aeec5334edc8a5d596948eba45ecaa91d3a3f8522e603c39284deff97a78abc519edc0be675e29811624b7c51a2e17d48a3fe501acd9ca669

data/.github/workflows/ruby.yml

@@ -0,0 +1,31 @@
+# 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:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - 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
+      with:
+        ruby-version: 2.6
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: bundle exec rspec
+    - name: Run rubocop
+      run: bundle exec rubocop

data/.rubocop.yml

@@ -4,8 +4,26 @@ AllCops:
   NewCops: enable
   Exclude:
     - "_/**/*"
+    - "lib/peeky/example/yard_sample.rb"
 
 # My Preferences - Start
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
+Style/EmptyMethod:    
+  Exclude:
+    - "**/spec/**/*"
+Metrics/ParameterLists:
+  Exclude:
+    - "**/spec/**/*"
+Layout/EmptyLineBetweenDefs:
+  Exclude:
+    - "**/spec/**/*"
+
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - "**/spec/**/*"
+
 Style/AccessorGrouping:
   Enabled: false
 
@@ -16,6 +34,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/CODE_OF_CONDUCT.md

@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at david.cruwys@bugcrowd.com. All
+reported by contacting the project team at david@ideasmne.com.au. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.

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

@@ -1,40 +1,9 @@
-# ToDo
-
-* Manually create each file using the template system
-  - Models
-    - [Done] ParameterInfo
-    - [Done] AttrInfo
-    - [Done] ClassInfo
-    - [Done] MethodInfo
-  - Create predicates
-    - [Done] attr_reader_predicate
-    - [Done] attr_writer_predicate
-  - Create renderers
-    - [Done] method_call_minimum_params_render
-    - [Done] method_signature_render
-    - [Done] method_signature_with_debug_render
-    - [Done] class_interface_render
-- [Done] Recreate peeky
-- [Done] Symlink KlueLess files
-- [Done] Hot fix after each section
-- [Done] Make sure the klueless files follow a natural structure
-- [Done] Push peeky to Ruby Gems
-- Build out the readme file
-- Build out the stories
-- Back compare templates vis definitions
-- Auto create .template folder with copied definitions
-
-
 # Peeky
 
 > 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:
@@ -57,10 +26,86 @@ gem install peeky
 
 ## Stories
 
+### Main Story
+
+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](./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 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
 

data/STORIES.md

@@ -0,0 +1,79 @@
+# 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
+
+## Development radar
+
+
+### Tasks next on list
+
+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
+
+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 Developer, I can render a class with instance attributes and methods, So that I can quickly mock out an entire class
+
+- Render: Class Interface
+
+As a Developer, I can render method signature with debug code, So that mock out a method with parameter logging
+
+- Render: Method signature with debug code
+
+As a Developer, I can see the method signature of a method, So that I understand it's parameters
+
+- Render: Method Signature in compact format
+
+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
+
+As a Developer, I can tell if a method is attr_*, so that I can format methods using attr_* notation
+
+- Attr Writer Predicate will match true if the method info could be considered a valid attr_writer
+- Attr Writer Predicate will match true if the method info could be considered a valid attr_writer
+
+As a Developer, I should be able to interrogate class instance information, so that I can reverse engineer a ruby class
+
+- ParameterInfo model to store information about parameters on a method
+- MethodInfo model to store signature of a ruby instance method
+- AttrInfo is a container that represents attr_reader, attr_writer or attr_accessor by storying 1 or 2 MethodInfo
+- ClassInfo stores information about a ruby class. Only support instance methods
+
+
+### 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)
+
+- Setup Rspec action
+- Setup RuboCop action
+
+Setup new Ruby GEM
+
+- Build out a standard GEM structure
+- Add semantic versioning
+- Add Rspec unit testing framework
+- Add RuboCop linting
+- Add Guard for automatic watch and test
+- Add GitFlow support
+- Add GitHub Repository

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