peeky 0.0.14 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28af40c7ccec4e9da59512a6fbac9a111768d5466c17a9a0fc0003928fa59191
-  data.tar.gz: '087aefb7db2766131766ab7cc9346449896cbec13ec14a583f96b3971da29df8'
+  metadata.gz: f5bfa72308dbaa677a774831ef7323b1a6b7756589714b068edab839232e96c1
+  data.tar.gz: c20a0d04a9ef69d8f77d7c506ddd45560294a4e9b0b7ec7ffeb33c6665b6a3f6
 SHA512:
-  metadata.gz: 6fd1164f74cd0f4b39a60b758372d771105147bd95e5032731d74c398862b60f748ea1b9b12ce4a92ff0857a0ae3d635db88781ce5390bc222156ca3625ed73e
-  data.tar.gz: 2c89b203b742301aa4834077bf56d60b6a412a753cff3d3c223dd2a86fb6a95d68aeff05f770d0b977760c94a6afea47f83fdd922796d6bb25046666a384a4ea
+  metadata.gz: '0070992885f6a7a5a19acb3d62fef9e5ce3d116b35c0436185fe3304293c7831bb6c9652704c43985842854bba7472733bb10b2cd26f055b9893dedecae27604'
+  data.tar.gz: 2312202e390a5ad6478aa124f94634627b65d7a69f0e0b725091907d7bddc10040a524b7eaf784e0bf37c74ab030228a74a8d1a319f810516308c7dc83c985ea

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/.gitignore

@@ -44,3 +44,5 @@ Gemfile.lock
 
 # ByeBug history
 .byebug_history
+
+*.gem

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,6 +26,17 @@ 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](./file.STORIES.html)
+
+### 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 class with instance attributes and methods, So that I can quickly mock out an entire class
 
 ## Usage
 
@@ -78,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/STORIES.md

@@ -0,0 +1,83 @@
+# 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 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
+
+- 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 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
+
+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/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,36 +124,47 @@ 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
-        puts '-' * 70
-        puts 'Method Names'
-        puts '-' * 70
-        ruby_instance_method_names.each do |method_name|
-          puts method_name
-        end
-      end
+      debug_method_names if format.include?(:method_names)
 
-      return unless format == :signatures
+      return unless format.include?(:signatures)
 
       puts '-' * 70
       puts 'Methods'
@@ -79,14 +172,25 @@ module Peeky
       signatures.each(&:debug)
     end
 
+    def debug_method_names
+      puts '-' * 70
+      puts 'Method Names'
+      puts '-' * 70
+      ruby_instance_method_names.each do |method_name|
+        puts method_name
+      end
+    end
+
     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) }
+      @_ruby_instance_methods ||= ruby_instance_method_names.map { |method_name| instance.method(method_name) }
+    rescue StandardError => e
+      puts e
     end
   end
 end