Merge pull request #6 from exercism/helpers

Extract sa methods into helpers

Author: iHiD

Gemfile

@@ -13,7 +13,6 @@ gem 'activesupport'
 gem 'parser'
 gem 'rubocop'
 
-
 group :test do
   gem 'minitest', '~> 5.10', '!= 5.10.2'
   gem 'minitest-stub-const'

lib/analyzer.rb

@@ -12,6 +12,7 @@
 require 'parser/current'
 require 'active_support/inflector'
 
+require_relative "generic/helpers"
 require_relative "generic/extract_class_method"
 require_relative "generic/extract_instance_method"
 require_relative "generic/extract_module_or_class"

lib/analyzers/two_fer/analyze.rb

@@ -61,8 +61,8 @@ def analyze!
     def check_structure!
       # First we check that there is a two-fer class or module
       # and that it contains a method called two-fer
-      disapprove!(:no_module) unless two_fer_module
-      disapprove!(:no_method) unless main_method
+      disapprove!(:no_module) unless target_module
+      disapprove!(:no_method) unless target_method
     end
 
     def check_method_signature!
@@ -71,11 +71,11 @@ def check_method_signature!
       disapprove!(:missing_default_param) if parameters.size != 1
 
       # If they provide a splat, the tests can pass but we
-      # should suggest they use a real paramater
-      disapprove!(:splat_args, first_paramater_name) if first_paramater.restarg_type?
+      # should suggest they use a real parameter
+      disapprove!(:splat_args, first_parameter_name) if first_parameter.restarg_type?
 
       # If they don't provide an optional argument the tests will fail
-      disapprove!(:missing_default_param) unless first_paramater.optarg_type?
+      disapprove!(:missing_default_param) unless first_parameter.optarg_type?
     end
 
     def check_for_optimal_solution!
@@ -106,7 +106,7 @@ def check_for_correct_solution_without_string_interpolaton!
       return unless default_argument_is_optimal?
       return unless one_line_solution?
 
-      loc = first_line_in_method(main_method)
+      loc = SA::Helpers.extract_first_line_from_method(target_method)
 
       # In the case of:
       # "One for " + name + ", one for me."
@@ -138,7 +138,7 @@ def check_for_correct_solution_without_string_interpolaton!
     end
 
     def check_for_conditional_on_default_argument!
-      loc = first_line_in_method(main_method)
+      loc = SA::Helpers.extract_first_line_from_method(target_method)
 
       # If we don't have a conditional, then let's get out of here.
       #
@@ -147,17 +147,17 @@ def check_for_conditional_on_default_argument!
       return unless loc.type == :if
 
       # Get the clause of the conditional (i.e. the bit after the "if" keyword)
-      conditional = extract_conditional_clause(loc)
+      conditional = SA::Helpers.extract_conditional_clause(loc)
 
       # Let's warn about using a better default if they `if name == nil`
-      if is_lvar?(conditional.receiver, :name) &&
+      if SA::Helpers.lvar?(conditional.receiver, :name) &&
          conditional.first_argument == default_argument
         disapprove!(:incorrect_default_param)
       end
 
       # Same thing but if they do it the other way round, i.e. `if nil == name`
       if conditional.receiver == default_argument &&
-         is_lvar?(conditional.first_argument, :name)
+         SA::Helpers.lvar?(conditional.first_argument, :name)
         disapprove!(:incorrect_default_param)
       end
     end
@@ -170,70 +170,44 @@ def default_argument_is_optimal?
     end
 
     def one_line_solution?
-      main_method.body.line_count == 1
+      target_method.body.line_count == 1
     end
 
     def using_string_interpolation?
-      main_method.body.dstr_type?
+      target_method.body.dstr_type?
     end
 
     def string_interpolation_has_three_components?
-      #main_method.body.pry
-      main_method.body.children.size == 3
-    end
-
-    # ###
-    # Static analysis helpers
-    # ###
-    def num_lines_in_method(method)
-      method.body.child_nodes.size
-    end
-
-    def first_line_in_method(method)
-      # A begin block signifies multiple lines
-      # so we return the first line.
-      method.body.children.first if main_method.body.type == :begin
-
-      # Without a begin block we just have one line,
-      # so we return the method body, which *is* the first line
-      method.body
-    end
-
-    # Is this an lvar (local variable) with a given name?
-    def is_lvar?(node, name)
-      node.lvar_type? && node.children[0] == name
-    end
-
-    def extract_conditional_clause(loc)
-      loc.children[0]
+      #target_method.body.pry
+      target_method.body.children.size == 3
     end
 
     memoize
-    def two_fer_module
-      ExtractModuleOrClass.(root_node, "TwoFer")
+    def target_module
+      SA::Helpers.extract_module_or_class(root_node, "TwoFer")
     end
 
     memoize
-    def main_method
-      ExtractClassMethod.(two_fer_module, "two_fer")
+    def target_method
+      SA::Helpers.extract_class_method(target_module, "two_fer")
     end
 
     memoize
-    def paramaters
-      main_method.arguments
+    def parameters
+      target_method.arguments
     end
 
     memoize
-    def first_paramater
-      paramaters.first
+    def first_parameter
+      parameters.first
     end
 
-    def first_paramater_name
-      first_paramater.children[0]
+    def first_parameter_name
+      first_parameter.children[0]
     end
 
     def default_argument
-      first_paramater.children[1]
+      first_parameter.children[1]
     end
 
     def default_argument_value

lib/generic/extract_class_method.rb

@@ -1,30 +1,32 @@
-class ExtractClassMethod < Parser::AST::Processor
-  include Mandate
+module SA
+  class ExtractClassMethod < Parser::AST::Processor
+    include Mandate
 
-  def initialize(node_to_search, name)
-    @node_to_search = node_to_search
-    @name = name.to_sym
-    @found_method = nil
-  end
+    def initialize(node_to_search, name)
+      @node_to_search = node_to_search
+      @name = name.to_sym
+      @found_method = nil
+    end
 
-  def call
-    process(node_to_search)
-    found_method
-  end
+    def call
+      process(node_to_search)
+      found_method
+    end
 
-  def on_sclass(node)
-    # If we're in a class << self context
-    if node.children[0].self_type?
-      @found_method = ExtractInstanceMethod.(node.children[1], name)
+    def on_sclass(node)
+      # If we're in a class << self context
+      if node.children[0].self_type?
+        @found_method = ExtractInstanceMethod.(node.children[1], name)
+      end
     end
-  end
 
-  def on_defs(node)
-    if node.method_name == name
-      @found_method = node
+    def on_defs(node)
+      if node.method_name == name
+        @found_method = node
+      end
     end
-  end
 
-  private
-  attr_reader :node_to_search, :name, :found_method
+    private
+    attr_reader :node_to_search, :name, :found_method
+  end
 end

lib/generic/extract_instance_method.rb

@@ -1,23 +1,25 @@
-class ExtractInstanceMethod < Parser::AST::Processor
-  include Mandate
+module SA
+  class ExtractInstanceMethod < Parser::AST::Processor
+    include Mandate
 
-  def initialize(node_to_search, name)
-    @node_to_search = node_to_search
-    @name = name.to_sym
-    @found_method = nil
-  end
+    def initialize(node_to_search, name)
+      @node_to_search = node_to_search
+      @name = name.to_sym
+      @found_method = nil
+    end
 
-  def call
-    process(node_to_search)
-    found_method
-  end
+    def call
+      process(node_to_search)
+      found_method
+    end
 
-  def on_def(node)
-    if node.method_name == name
-      @found_method = node
+    def on_def(node)
+      if node.method_name == name
+        @found_method = node
+      end
     end
-  end
 
-  private
-  attr_reader :node_to_search, :name, :found_method
+    private
+    attr_reader :node_to_search, :name, :found_method
+  end
 end

lib/generic/extract_module_or_class.rb

@@ -1,32 +1,33 @@
-class ExtractModuleOrClass < Parser::AST::Processor
-  include Mandate
+module SA
+  class ExtractModuleOrClass < Parser::AST::Processor
+    include Mandate
 
-  def initialize(node_to_search, name)
-    @node_to_search = node_to_search
-    @name = name
-    @found_constant = nil
-  end
+    def initialize(node_to_search, name)
+      @node_to_search = node_to_search
+      @name = name
+      @found_constant = nil
+    end
 
-  def call
-    process(node_to_search)
-    found_constant
-  end
+    def call
+      process(node_to_search)
+      found_constant
+    end
 
-  def on_module(node)
-    inspect_node(node)
-  end
+    def on_module(node)
+      inspect_node(node)
+    end
 
-  def on_class(node)
-    inspect_node(node)
-  end
+    def on_class(node)
+      inspect_node(node)
+    end
 
-  private
-  attr_reader :node_to_search, :name, :found_constant
+    private
+    attr_reader :node_to_search, :name, :found_constant
 
-  def inspect_node(node)
-    if node.children.first.const_name == name
-      @found_constant = node
+    def inspect_node(node)
+      if node.children.first.const_name == name
+        @found_constant = node
+      end
     end
   end
 end
-

lib/generic/helpers.rb

@@ -0,0 +1,34 @@
+module SA
+  module Helpers
+    def self.extract_module_or_class(*args)
+      ExtractModuleOrClass.(*args)
+    end
+
+    def self.extract_class_method(*args)
+      ExtractClassMethod.(*args)
+    end
+
+    def self.extract_first_line_from_method(method)
+      # A begin block signifies multiple lines
+      # so we return the first line.
+      return method.body.children.first if method.body.type == :begin
+
+      # Without a begin block we just have one line,
+      # so we return the method body, which *is* the first line
+      return method.body
+    end
+
+    def self.num_lines_in_method(method)
+      method.body.child_nodes.size
+    end
+
+    # Is this an lvar (local variable) with a given name?
+    def self.lvar?(node, name)
+      node.lvar_type? && node.children[0] == name
+    end
+
+    def self.extract_conditional_clause(loc)
+      loc.children[0]
+    end
+  end
+end