peeky 0.0.19 → 0.0.33

data/lib/peeky/parameter_info.rb

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

data/lib/peeky/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_debug_render.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Peeky
+  module Renderer
+    # Class Debug Render
+    class ClassDebugRender
+      attr_reader :class_info
+
+      def initialize(class_info)
+        @key_width = 30
+        @class_info = class_info
+      end
+
+      # Render the class interface
+      # rubocop:disable Metrics/AbcSize
+      def render
+        output = []
+        output.push class_details
+        attributes = render_accessors + render_readers + render_writers
+
+        if attributes.length.positive?
+          output.push("-- Attributes #{'-' * 56}")
+          output.push(*attributes)
+          output.push('')
+        end
+
+        methods = render_methods
+
+        if methods.length.positive?
+          output.push("-- Public Methods #{'-' * 52}")
+          output.push(*methods)
+          output.push('')
+        end
+
+        output.pop if output.last == ''
+
+        output.join("\n")
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def lj(value, size = 20)
+        value.to_s.ljust(size)
+      end
+
+      def kv(key, value)
+        "#{key.to_s.ljust(@key_width)}: #{value}"
+      end
+
+      def class_details
+        [
+          '-' * 70,
+          kv('class name', @class_info.class_name),
+          kv('module name', @class_info.module_name),
+          kv('class full name', @class_info.class_full_name),
+          ''
+        ]
+      end
+
+      def render_accessors
+        @class_info.accessors.map { |attr| kv('attr_accessor', attr.name) }
+      end
+
+      def render_readers
+        @class_info.readers.map { |attr| kv('attr_reader', attr.name) }
+      end
+
+      def render_writers
+        @class_info.writers.map { |attr| kv('attr_writer', attr.name) }
+      end
+
+      def render_methods
+        @class_info.methods.flat_map do |method|
+          [
+            "#{method.name}::",
+            *render_paramaters(method.parameters),
+            ''
+          ]
+        end
+      end
+
+      def render_paramaters(parameters)
+        result = [
+          "#{lj('name')} #{lj('param format')} #{lj('type')}",
+          '-' * 70
+        ]
+
+        result + parameters.map do |param|
+          "#{lj(param.name)} #{lj(param.signature_format)} #{lj(param.type)}"
+        end
+      end
+    end
+  end
+end

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,141 @@
+# frozen_string_literal: true
+
+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 + render_readers + render_writers + 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
+
+          if method_signature.name.to_s.end_with?('?')
+            result.push ''
+            result.push "#{@indent}# @return [Boolean] true when #{method_signature.name.to_s.humanize.downcase}"
+          end
+
+          render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
+          render_signature.indent = @indent
+          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