exercism-analysis 0.1.1

data/lib/exercism-analysis/analyzers/ruby/iter_mutation.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../../../templates/each_to_map', __FILE__)
+require File.expand_path('../../../templates/each_to_select', __FILE__)
+
+class Exercism
+  module Analyzers
+
+    class IterMutation < Analyzer
+
+      processor Processors::IterMutationProcessor
+
+      def call
+        feedback = processor.result.map do |mutation|
+          Feedback.from_src(:iter_mutation, mutation.iter.src_extract, mutation_replacement(mutation)) unless mutation.mutators.empty?
+        end
+        Result.new(:iter_mutation, feedback.compact)
+      end
+
+      private
+
+      def mutation_replacement(mutation)
+        if filter?(mutation)
+          Templates::EachToSelect.render(mutation)
+        else
+          Templates::EachToMap.render(mutation)
+        end
+      end
+
+      def filter?(mutation)
+        mutation.iter.block.params.each_param.any? do |param|
+          mutation.mutators.map { |m| m.exp.body.value }.include?(param.value)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/analyzers/ruby/output.rb

@@ -0,0 +1,20 @@
+class Exercism
+  module Analyzers
+
+    class Output < Analyzer
+
+      STDOUT_METHODS = %w(p puts print)
+
+      processor Processors::CallProcessor.partial(STDOUT_METHODS)
+
+      def call
+        feedback = processor.result.map do |exp|
+          Feedback.from_src(:print, exp.src_extract)
+        end
+        Result.new(:output, feedback)
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/analyzers/ruby/range.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../../templates/range_exclusive', __FILE__)
+
+class Exercism
+  module Analyzers
+
+    class Range < Analyzer
+
+      processor Processors::RangeProcessor
+
+      def call
+        feedback = processor.result.map do |range_exp|
+          if range_exp.inclusive? && decrement_one?(range_exp.right)
+            Feedback.from_src(:range, range_exp.src_extract, Templates::RangeExclusive.render(range_exp))
+          end
+        end.compact
+        Result.new(:range_inclusive, feedback)
+      end
+
+      private
+
+      def decrement_one?(exp)
+        exp.value == '-' && exp.right.value == '1'
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/analyzers/ruby/roodi.rb

@@ -0,0 +1,19 @@
+require 'roodi'
+
+class Exercism
+  module Analyzers
+
+    class Roodi < Analyzer
+
+      def call
+        roodi = ::Roodi::Core::Runner.new
+        roodi.check_content(adapter.code)
+        roodi.errors.map do |error|
+          ThirdPartyResult.new(error.message, error.line_number)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/analyzers/ruby/send.rb

@@ -0,0 +1,25 @@
+class Exercism
+  module Analyzers
+
+    class Send < Analyzer
+
+      processor Processors::SendProcessor
+
+      def call
+        feedback = processor.result.map do |exp|
+          Feedback.from_src(:send, exp.src_extract, public_send_template(exp))
+        end
+        Result.new(:send, feedback)
+      end
+
+      private
+
+      def public_send_template(exp)
+        receiver = [exp.receiver.src, '.'].join if exp.receiver
+        [padding(exp), receiver, 'public_send', exp.args.src].compact.join
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/analyzers/ruby/shebang.rb

@@ -0,0 +1,23 @@
+class Exercism
+  module Analyzers
+
+    class Shebang < Analyzer
+
+      def call
+        Result.new(:shebang, feedback)
+      end
+
+      def feedback
+        shebang.map do |(line, line_no)|
+          Feedback.from_line(:shebang, line.chomp, line_no)
+        end
+      end
+
+      def shebang
+        adapter.code.lines.zip(1..Float::INFINITY).select { |(l, _)| l.start_with?('#!') }.take(1)
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/analyzers/ruby/tab.rb

@@ -0,0 +1,38 @@
+class Exercism
+  module Analyzers
+
+    class Tab < Analyzer
+
+      TAB_REGEX = /\A\s*\t+\s*\b/
+      SPACE_REGEX = /\A\t* \t*\b/
+
+      def call
+        Result.new(:indentation, feedback)
+      end
+
+      def feedback
+        feedback_lines_with_type.take(1).map do |(line, line_no), type|
+          Feedback.from_line(type, line.chomp, line_no)
+        end
+      end
+
+      def feedback_lines_with_type
+        lines_with_tabs_and_spaces.zip([:tab_and_space]) + lines_with_tabs.zip([:tab])
+      end
+
+      def lines_with_tabs
+        lines.select do |line, _|
+          line =~ TAB_REGEX
+        end
+      end
+
+      def lines_with_tabs_and_spaces
+        lines_with_tabs.select do |line, _|
+          line =~ SPACE_REGEX
+        end
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/processors/call_processor.rb

@@ -0,0 +1,39 @@
+class Exercism
+  module Processors
+
+    class CallProcessor < Processor
+
+      class Partial
+        def initialize(method_names)
+          @method_names = method_names
+        end
+
+        def new
+          CallProcessor.new(@method_names)
+        end
+      end
+
+      def self.partial(method_names)
+        Partial.new(method_names)
+      end
+
+      def initialize(method_names)
+        @method_names = method_names
+        @calls = []
+      end
+
+      def process_command(exp)
+        @calls << exp if @method_names.include?(exp.value)
+      end
+
+      alias process_call process_command
+      alias process_fcall process_command
+
+      def result
+        @calls
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/processors/control_flow_processor.rb

@@ -0,0 +1,27 @@
+class Exercism
+  module Processors
+
+    class ControlFlowProcessor < Processor
+
+      CONTROL_FLOW = %w(and or)
+
+      def initialize
+        @control_flow = []
+      end
+
+      def process_binary(exp)
+        if CONTROL_FLOW.include?(exp.value)
+          @control_flow << exp
+        end
+      end
+
+      alias process_unary process_binary
+
+      def result
+        @control_flow
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/processors/enumerable_condition_processor.rb

@@ -0,0 +1,31 @@
+class Exercism
+  module Processors
+
+    class EnumerableConditionProcessor < Processor
+
+      ENUMERABLE_METHODS = %w(
+        all? any? chunk collect collect_concat count cycle detect drop_while each
+        each_cons each_entry each_slice each_with_index each_with_object
+        find find_all find_index flat_map grep group_by inject map max max_by
+        min min_by minmax minmax_by none? one? partition reduce reject reverse_each
+        select slice_after slice_before slice_when sort sort_by take_while zip
+      ).to_set
+
+      def initialize
+        @conditionals = []
+      end
+
+      def process_method_add_block(exp)
+        if ENUMERABLE_METHODS.include?(exp.value)
+          @conditionals += find_exps(exp.block, :condition)
+        end
+      end
+
+      def result
+        @conditionals
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/processors/for_loop_processor.rb

@@ -0,0 +1,21 @@
+class Exercism
+  module Processors
+
+    class ForLoopProcessor < Processor
+
+      def initialize
+        @fors = []
+      end
+
+      def process_for(exp)
+        @fors << exp
+      end
+
+      def result
+        @fors
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/processors/indentation_processor.rb

@@ -0,0 +1,69 @@
+class Exercism
+  module Processors
+
+    class IndentationProcessor < Processor
+
+      def self.inconsistent_end(*events)
+        events.each do |event|
+          define_method "process_#{event}" do |exp|
+            if inconsistent_end?(exp)
+              @inconsistent_nodes << exp
+            end
+          end
+        end
+      end
+
+      inconsistent_end :for, :class, :def, :defs, :until, :while
+
+      def initialize
+        @inconsistent_nodes = []
+      end
+
+      def result
+        @inconsistent_nodes.select(&method(:multiple_lines?))
+      end
+
+      def process_if(exp)
+        if inconsistent_end?(exp) || (exp.else_statement && inconsistent?(exp, exp.else_statement))
+          @inconsistent_nodes << exp
+        end
+      end
+
+      alias process_elsif process_if
+
+      def process_case(exp)
+        if inconsistent_end?(exp) || inconsistent_when?(exp)
+          @inconsistent_nodes << exp
+        end
+      end
+
+      def process_begin(exp)
+        if inconsistent_end?(exp) || [exp.rescue, exp.ensure].compact.any? {|e| inconsistent?(exp, e)}
+          @inconsistent_nodes << exp
+        end
+      end
+
+      private
+
+      def inconsistent?(a, b, offset=0)
+        a.column != b.column - offset
+      end
+
+      def inconsistent_end?(exp)
+        exp.column != (exp.end_column - 'end'.length)
+      end
+
+      def inconsistent_when?(exp)
+        expected_column = exp.whens.map(&:column).first
+        exp.whens.any?{|when_exp| when_exp.column != expected_column} ||
+            exp.whens.any? { |when_exp| (inconsistent?(exp, when_exp, 2) && inconsistent?(exp, when_exp)) }
+      end
+
+      def multiple_lines?(exp)
+        exp.line != exp.end_line
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/processors/iter_mutation_processor.rb

@@ -0,0 +1,50 @@
+class Exercism
+  module Processors
+
+    class IterMutationProcessor < Processor
+
+      Mutation = Struct.new(:iter, :variable, :mutators)
+      Mutator = Struct.new(:exp, :condition)
+
+      SIDE_EFFECTS = %w(<< push)
+
+      def initialize
+        @mutations = []
+      end
+
+      def process_def(exp)
+        assignment = find_exp(exp, :assign) {|e| e.body.type == :array }
+        call_to_each = find_exp(exp, :call) {|e| e.block }
+        if assignment && call_to_each
+          if mutating_exps = find_mutations_in_block(assignment, call_to_each)
+            mutators = mutating_exps.map do |exp|
+              Mutator.new(exp, condition_surrounding_mutation(exp, call_to_each.block))
+            end
+            mutation = Mutation.new(call_to_each, assignment, mutators)
+            @mutations << mutation
+          end
+        end
+      end
+
+      def result
+        @mutations
+      end
+
+      private
+
+      def condition_surrounding_mutation(mutation, block)
+        find_exp(block, :condition) do |exp|
+          [exp.consequence, exp.else_statement].compact.flat_map(&:each).include?(mutation)
+        end
+      end
+
+      def find_mutations_in_block(assignment, call_to_each)
+        find_exps(call_to_each.block, :binary, :command) do |e|
+          SIDE_EFFECTS.include?(e.value) && e.receiver.value == assignment.value
+        end
+      end
+
+    end
+
+  end
+end

data/lib/exercism-analysis/processors/processor.rb

@@ -0,0 +1,34 @@
+class Exercism
+  module Processors
+
+    class Processor
+
+      def find_exps(nodes, *types, &filter)
+        filter ||= -> * { true }
+        nodes.each.flat_map do |node|
+          if node.respond_to?(:type) && types.include?(node.type) && filter.call(node)
+            [node] + find_exps(node.each, *types, &filter)
+          elsif node.respond_to?(:each)
+            find_exps(node.each, *types, &filter)
+          else
+            []
+          end
+        end
+      end
+
+      def find_exp(exp, *types, &filter)
+        filter ||= -> * { true }
+        exp.each.find do |node|
+          if node.respond_to?(:type) && types.include?(node.type) && filter.call(node)
+            node
+          elsif node.respond_to?(:each)
+            result = find_exp(node.each, *types, &filter)
+            return result if result
+          end
+        end
+      end
+
+    end
+
+  end
+end