peeky 0.0.14

data/lib/peeky/attr_info.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# require 'peeky/attr_info'
+
+module Peeky
+  # Attr Info is a container that holds read, write or read/write
+  # attributes in the form of MethodInfo objects
+  class AttrInfo
+    attr_reader :reader
+    attr_reader :writer
+
+    def initialize(reader: nil, writer: nil)
+      guard(reader, writer)
+
+      @reader = reader
+      @writer = writer
+    end
+
+    def type
+      @type ||= if @reader.nil?
+                  :attr_writer
+                else
+                  @writer.nil? ? :attr_reader : :attr_accessor
+                end
+    end
+
+    def name
+      @name ||= @reader.nil? ? @writer.clean_name : @reader.clean_name
+    end
+
+    # Factory method that will create an AttrInfo from a list of method_infos
+    #
+    # There is an expectation that the list will have 1 or 2 method_infos and
+    # that they will be of type :attr_reader and/or :attr_writer
+    # Currently there are some edge cases that I can see where this may not
+    # be true and in those cases we just ignore those cases
+    def self.create(*method_infos)
+      reader = method_infos.find(&:readable?)
+      writer = method_infos.find(&:writable?)
+
+      new(reader: reader, writer: writer)
+    end
+
+    private
+
+    def guard(reader, writer)
+      raise 'AttrInfo requires at least one read or write parameter' if reader.nil? && writer.nil?
+
+      guard_reader(reader) unless reader.nil?
+      guard_writer(writer) unless writer.nil?
+    end
+
+    def guard_reader(reader)
+      raise 'reader: parameter must be of type MethodInfo' unless reader.is_a?(Peeky::MethodInfo)
+      raise 'reader: method does not implement the :attr_reader signature' unless reader.implementation_type == :attr_reader
+    end
+
+    def guard_writer(writer)
+      raise 'writer: parameter must be of type MethodInfo' unless writer.is_a?(Peeky::MethodInfo)
+      raise 'writer: method does not implement the :attr_writer signature' unless writer.implementation_type == :attr_writer
+    end
+  end
+end

data/lib/peeky/class_info.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Peeky
+  # Class Info stores information about the
+  # class instance that you pass in.
+  #
+  # The information is collected into MethodInfo objects
+  # that live within the signatures accessor.
+  #
+  # This information is then separated out into
+  # :methods, :attr_accessors, :attr_readers and :attr_writers
+  class ClassInfo
+    attr_reader :instance
+
+    # Peak into class information
+    def initialize(instance)
+      @instance = instance
+    end
+
+    def class_name
+      instance.class.name
+    end
+
+    def accessors
+      @accessors ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_accessor }
+    end
+
+    def readers
+      @readers ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_reader }
+    end
+
+    def writers
+      @writers ||= attribute_infos.select { |attribute_info| attribute_info.type == :attr_writer }
+    end
+
+    def methods
+      @methods ||= signatures.select { |signature| signature.implementation_type == :method }
+    end
+
+    # def signatures(types = [:instance])
+    # REFACT: Support different types
+    #         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 }
+    end
+
+    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)
+
+        grouped_method_infos.keys.map { |key| AttrInfo.create(*grouped_method_infos[key]) }
+      end
+    end
+
+    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
+
+      return unless format == :signatures
+
+      puts '-' * 70
+      puts 'Methods'
+      puts '-' * 70
+      signatures.each(&:debug)
+    end
+
+    private
+
+    def ruby_instance_method_names
+      @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) }
+    end
+  end
+end

data/lib/peeky/method_info.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Peeky
+  # Method Info
+  class MethodInfo
+    extend Forwardable
+
+    # List of parameters for this method
+    attr_accessor :parameters
+
+    # MethodInfo delegates to the underlying ruby method object
+    attr_reader :method
+
+    def_delegators :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
+    # method in ruby, was it `def method` or `attr_reader` / `attr_writer`
+    attr_reader :implementation_type
+
+    def initialize(method, target_instance = nil)
+      @method = method
+      @parameters = ParameterInfo.from_method(method)
+      # stage 1
+      # @implementation_type = :method
+
+      # stage 2
+      @implementation_type = infer_implementation_type(target_instance)
+    end
+
+    # Stage 2 (working out) attr_accessor
+    # Name of method minus writer annotations
+    # Example :writable_attribute= becomes :writable_attribute
+    def clean_name
+      @clean_name ||= begin
+        n = name.to_s
+        n.end_with?('=') ? n.delete_suffix('=').to_sym : name
+      end
+    end
+
+    def infer_implementation_type(target_instance)
+      if target_instance.nil?
+        :method
+      elsif match(target_instance, Peeky::Predicates::AttrReaderPredicate)
+        :attr_reader
+      elsif match(target_instance, Peeky::Predicates::AttrWriterPredicate)
+        :attr_writer
+      else
+        :method
+      end
+    end
+
+    def match(target_instance, predicate)
+      predicate.new.match(target_instance, self)
+    end
+
+    def method?
+      @implementation_type == :method
+    end
+
+    # https://github.com/rubyide/vscode-ruby/issues/454
+    # if I prefix these methods with attr_ then will get an issue
+    # in the language server.
+    # Cannot read property 'namedChildren' of undefined
+    def readable?
+      @implementation_type == :attr_reader
+    end
+
+    def writable?
+      @implementation_type == :attr_writer
+    end
+
+    def debug
+      puts '-' * 70
+      puts name
+      puts '-' * 70
+      parameters.each(&:debug)
+    end
+  end
+end

data/lib/peeky/parameter_info.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Peeky
+  # Parameter Info takes a ruby paramater pair (*see below) and maps
+  # it to more readily usable properties
+  #
+  # Ruby parameter is an odd array format that with an array of 1 or 2 elements.
+  # Examples:
+  #  - [:req]
+  #  - [:req, 'aaa']
+  #  - [:opt, 'aaa']
+  #  - [:rest, 'aaa']
+  #  - [:keyreq, 'aaa']
+  #  - [:key, 'aaa']
+  #  - [:block, 'aaa']
+  class ParameterInfo
+    # name of the parameter
+    attr_accessor :name
+
+    # 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
+
+    def initialize(param)
+      map(param)
+    end
+
+    private_class_method :new
+
+    # Ruby parameter is an odd array format that with an array of 1 or 2 elements.
+    # Examples:
+    #  - [:req]
+    #  - [:req, 'aaa']
+    #  - [:opt, 'aaa']
+    #  - [:rest, 'aaa']
+    #  - [:keyreq, 'aaa']
+    #  - [:key, 'aaa']
+    #  - [:block, 'aaa']
+    def self.from_parameter(ruby_parameter)
+      new(ruby_parameter)
+    end
+
+    # Gets list of parameters fro ma ruby method and maps them to
+    # an array of ParameterInfo
+    def self.from_method(ruby_method)
+      ruby_method.parameters.map { |ruby_paramater| from_parameter(ruby_paramater) }
+    end
+
+    def debug
+      puts "name                          : #{name}"
+      puts "type                          : #{type}"
+      puts "signature_format              : #{signature_format}"
+      puts "minimal_call_format           : #{minimal_call_format}"
+    end
+
+    private
+
+    # Convert the limited information provided by ruby method.parameters
+    # to a richer structure.
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+    def map(param)
+      @name = param.length > 1 ? param[1].to_s : ''
+
+      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
+  end
+end

data/lib/peeky/predicates/attr_reader_predicate.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Peeky
+  module Predicates
+    # Attr Reader Predicate will match true if the method info could be considered
+    # a valid attr_reader
+    class AttrReaderPredicate
+      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)
+        new_value = SecureRandom.alphanumeric(20)
+        code = <<-RUBY
+          #{variable_name} = '#{new_value}' # @variable = 'a3bj7a3bj7a3bj7a3bj7'
+        RUBY
+        instance.instance_eval(code)
+        current_value = instance.send(method_name)
+        current_value == new_value
+      end
+
+      private
+
+      def prerequisites(instance, method_info)
+        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)
+
+        true
+      end
+    end
+  end
+end

data/lib/peeky/predicates/attr_writer_predicate.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Peeky
+  module Predicates
+    # Attr Writer Predicate will match true if the method info could be considered
+    # a valid attr_writer
+    class AttrWriterPredicate
+      def match(instance, method_info)
+        return false unless prerequisites(instance, method_info)
+
+        param = method_info.parameters.first
+        param.type == :param_required && param.name.empty?
+      end
+
+      private
+
+      def prerequisites(instance, method_info)
+        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)
+        return false unless method_info.parameters.length == 1
+
+        true
+      end
+    end
+  end
+end

data/lib/peeky/renderer/class_interface_render.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Peeky
+  module Renderer
+    # Class Interface Render
+    #
+    # Example output:
+    # class SampleClassClassInterfaceRender
+    #   attr_accessor :a
+    #
+    #   attr_reader :b
+    #
+    #   attr_writer :c
+    #
+    #   def alpha_sort1;                                                                end
+    #   def alpha_sort2;                                                                end
+    #   def d;                                                                          end
+    #   def e(aaa);                                                                     end
+    #   def f(aaa, bbb = nil);                                                          end
+    #   def g(aaa, bbb = nil, ccc = nil);                                               end
+    #   def h(*aaa);                                                                    end
+    #   def i(aaa, bbb, *ccc);                                                          end
+    #   def j(**aaa);                                                                   end
+    #   def k(aaa, *bbb, **ccc);                                                        end
+    #   def l(aaa, *bbb, **ccc, &ddd);                                                  end
+    #   def m(aaa:);                                                                    end
+    #   def n(aaa:, bbb: nil);                                                          end
+    #   def p?;                                                                         end
+    #   def q!;                                                                         end
+    #   def z(aaa, bbb = nil, *ccc, ddd:, eee: nil, **fff, &ggg);                       end
+    # end
+    class ClassInterfaceRender
+      attr_reader :class_info
+
+      def initialize(class_info)
+        @class_info = class_info
+      end
+
+      def render
+        @indent = ''
+        output = []
+        output.push render_start
+        @indent = '  '
+        output += render_accessors
+        output += render_readers
+        output += render_writers
+        output += render_methods
+        output.pop if output.last == ''
+
+        @indent = ''
+        output.push render_end
+
+        output.join("\n")
+      end
+
+      def render_start
+        "#{@indent}class #{class_info.class_name}"
+      end
+
+      def render_accessors
+        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.push '' unless result.length.zero?
+        result
+      end
+
+      def render_writers
+        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|
+          render_signature = Peeky::Renderer::MethodSignatureRender.new(method_signature)
+          "#{@indent}#{render_signature.render}"
+        end
+        result.push '' unless result.length.zero?
+        result
+      end
+
+      def render_end
+        "#{@indent}end"
+      end
+
+      def debug
+        puts render
+      end
+    end
+  end
+end