peeky 0.0.14 → 0.0.28

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

@@ -3,7 +3,8 @@
 require 'forwardable'
 
 module Peeky
-  # Method Info
+  # Method info store a list of instance methods and attr_* for
+  # a ruby class.
   class MethodInfo
     extend Forwardable
 
@@ -11,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

@@ -2,7 +2,7 @@
 
 module Peeky
   module Renderer
-    # Class Interface Render
+    # Render: Class Interface
     #
     # Example output:
     # class SampleClassClassInterfaceRender
@@ -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