peeky 0.0.19 → 0.0.33

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

data/lib/peeky/api.rb

@@ -0,0 +1,74 @@
+# 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, lazy: true)
+      ci = Peeky::ClassInfo.new(instance)
+      ci.load unless lazy
+      ci
+    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_debug
+        Peeky::Renderer::ClassDebugRender
+      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,123 @@ module Peeky
       @instance = instance
     end
 
-    def class_name
+    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
     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 +141,36 @@ 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
 
+    # 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 +178,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

data/lib/peeky/example/yard_sample.rb

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