pronto-clang_format 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da6b480040bfb881723b002a3c288b16bbff3a65ed6553f24cc7774722fa0f77
-  data.tar.gz: 780c8d7b5754c41502acbcd2eda9ec7adabc85fc1fb8958c97934225487d7fd8
+  metadata.gz: 302624fd634c66b617e65dd0a978245587d65bfd95b3f4cd078c8e7e09f7002d
+  data.tar.gz: 66453b07b07ea23b48050bf9d3081f1489155c526bf53eee7ad7a091e0424169
 SHA512:
-  metadata.gz: 50ac0304347960daf2d12cf5860ea23ff428f592d63f60edd796b12db076c76758d34a0bd50a03210c029337f6acef21943e83b1900d8c32b9c60c085bdc2ab9
-  data.tar.gz: 14ba65662a824f97ee0e3150524803d04b5261ad1848dec97b33796d8ff442e1dcecce1858277dd49a0726174c822a67750fcd5f417ad967ce97e98b4a76e5d6
+  metadata.gz: d5599a978450406787d148dc45d4948e9e20d392209cc912906a6b60bcb2a4b5a3b6a1f33899d140a6168b136edf2f61e216183d9ada36826498495e0d60a368
+  data.tar.gz: 4e1b9c2e129c7be2ab0026ebba925e97b10df3585bc659c2060e7e8adad3a535deca9a9931bec8709132e389eb619e5027bb232c94fd003243b4a48334d3227a

data/lib/pronto/clang_format/offence.rb

@@ -0,0 +1,42 @@
+require_relative 'offence_categorizer/factory'
+
+module Pronto
+  module ClangFormat
+    class Offence
+      attr_reader :offset, :line_no, :column, :length, :replacement,
+                  :affected_lines_before
+      def initialize(offset, line_no, column, length, replacement,
+                     affected_lines)
+        @offset = offset.freeze
+        @line_no = line_no.freeze
+        @column = column.freeze
+        @length = length.freeze
+        @replacement = replacement.freeze
+        @affected_lines_before = affected_lines.freeze
+      end
+
+      # generates a user-friendly message that describes this offence. This is
+      # done by using OffenceCategorizer's chain of responsibility classes
+      def msg
+        OffenceCategorizer::Factory.create_categorizers.handle self
+      end
+
+      # the exact portion of text that is to be replaced by this offence
+      def replaced_text
+        affected_lines_before[column..(column + length - 1)]
+      end
+
+      # returns the range of line numbers affected by this offence
+      def affected_lines_range
+        (line_no..line_no + replaced_text.count("\n"))
+      end
+
+      # returns affected lines after fixing this offence
+      def affected_lines_after
+        affected_lines = String.new(affected_lines_before)
+        affected_lines[column..(column + length - 1)] = replacement
+        affected_lines
+      end
+    end
+  end
+end

data/lib/pronto/clang_format/offence_categorizer/abstract_categorizer.rb

@@ -0,0 +1,28 @@
+module Pronto
+  module ClangFormat
+    module OffenceCategorizer
+      # base class to implement a chain of responsibility
+      class AbstractCategorizer
+        def initialize(successor = nil)
+          @successor = successor
+        end
+
+        def handle(offence)
+          current_result = handle_current offence
+          if !current_result.nil?
+            current_result
+          elsif !@successor.nil?
+            @successor.handle offence
+          else # unahndled offence
+            "This should be rewritten as: \n#{offence.affected_lines_after}"
+          end
+        end
+
+        def handle_current(_offence)
+          raise NotImplementedError, 'this method needs to be implemented in '\
+                                     'subclasses'
+        end
+      end
+    end
+  end
+end

data/lib/pronto/clang_format/offence_categorizer/factory.rb

@@ -0,0 +1,14 @@
+require_relative 'indentation_categorizer'
+require_relative 'includes_order_categorizer'
+
+module Pronto
+  module ClangFormat
+    module OffenceCategorizer
+      class Factory
+        def self.create_categorizers
+          IncludesOrderCategorizer.new IndentationCategorizer.new
+        end
+      end
+    end
+  end
+end

data/lib/pronto/clang_format/offence_categorizer/includes_order_categorizer.rb

@@ -0,0 +1,16 @@
+require_relative 'abstract_categorizer'
+
+module Pronto
+  module ClangFormat
+    module OffenceCategorizer
+      class IncludesOrderCategorizer < AbstractCategorizer
+        def handle_current(offence)
+          return unless offence.replaced_text.include? 'include'
+
+          "Include statements are not ordered alphabetically. "\
+          "They should be rewritten as:\n#{offence.affected_lines_after}"
+        end
+      end
+    end
+  end
+end

data/lib/pronto/clang_format/offence_categorizer/indentation_categorizer.rb

@@ -0,0 +1,13 @@
+require_relative 'abstract_categorizer'
+
+module Pronto
+  module ClangFormat
+    module OffenceCategorizer
+      class IndentationCategorizer < AbstractCategorizer
+        def handle_current(offence)
+          "Incorrect indentation" if offence.column <= 1
+        end
+      end
+    end
+  end
+end

data/lib/pronto/clang_format/version.rb

@@ -1,5 +1,5 @@
 module Pronto
   module ClangFormat
-    VERSION = '0.1.0'.freeze
+    VERSION = '0.1.1'.freeze
   end
 end

data/lib/pronto/clang_format/wrapper.rb

@@ -1,8 +1,8 @@
 require 'open3'
 require 'rexml/document'
 require 'shellwords'
+require_relative 'offence'
 
-# TODO: make sure clang-format returns its output sorted by offset. If this is always true, switch to using .each_with_index.to_a.reverse.bsearch { |n, i| n < clang_offset }
 module Pronto
   module ClangFormat
     class Wrapper
@@ -10,53 +10,90 @@ module Pronto
         @clang_format_path = ENV['PRONTO_CLANG_FORMAT_PATH'] || 'clang-format'
       end
 
-      def run(filepath)
-        # TODO: add environment variable for style file
+      # runs clang-format for the provided file and returns an array of
+      # offence objects
+      # Params:
+      # - file_path: path to the file to be examined by clang-format
+      def run(file_path)
         stdout, stderr, = Open3.capture3("#{@clang_format_path} "\
-                                         "-output-replacements-xml #{filepath}")
+                                         "-style=#{style} "\
+                                         "-output-replacements-xml "\
+                                         "#{file_path}")
         if stderr && !stderr.empty?
-          puts "WARN: pronto-clang_format: #{filepath}: #{stderr}"
+          puts "WARN: pronto-clang_format: #{file_path}: #{stderr}"
         end
         return [] if stdout.nil? || stdout == 0
-        parse_output(filepath, stdout)
+        parse_output(file_path, stdout)
       end
 
-      def parse_output(filepath, output)
+      private
+
+      def style
+        ENV['PRONTO_CLANG_FORMAT_STYLE'] || 'file'
+      end
+
+      # parses clang-format output for a given file and returns an array of
+      # offence objects
+      # Params:
+      # - file_path: file path for which clang-format generated the output
+      # - output: clang-format standard output for the given file path
+      def parse_output(file_path, output)
+        file_contents = File.read(file_path, mode: 'r')
+        newlines_array = newline_offsets_in(file_contents)
         doc = REXML::Document.new output
         doc.root.elements.map do |element|
           offset = element.attributes['offset'].to_i
           length = element.attributes['length'].to_i
-          line_no, column = ln_col_for(offset, filepath)
-          {
-            offset: offset,
-            line_no: line_no, column: column, length: length,
-            replacement: element.get_text.value
-          }
+          line_no, column = ln_col_from_offset(newlines_array, offset)
+          replacement = element.get_text ? element.get_text.value : ''
+          # remove non-changed new lines from the beginning of the replacement
+          while replacement.start_with?("\n") && column.zero? && length > 0
+            offset += 1
+            length -= 1
+            line_no, column = ln_col_from_offset(newlines_array, offset)
+            replacement = replacement[1..-1]
+          end
+          # calculate number of the last line affected by the replacement
+          end_line_no, = ln_col_from_offset(newlines_array, offset + length)
+          # extract relevant lines and pass to offence
+          start_offset = offset_from_ln_col(newlines_array, line_no, 1)
+          end_offset = offset_from_ln_col(newlines_array, end_line_no + 1, 0)
+          old_lines_text = file_contents[start_offset..end_offset]
+                           .prepend("\n")
+          Offence.new(offset, line_no, column, length, replacement,
+                      old_lines_text)
         end
       end
 
-      private
-
-      # a function that returns line no and column given byte offset in a file
-      def ln_col_for(offset, filepath)
-        preceding_newlines = newline_offsets_in(filepath)
-                             .select { |newline| newline < offset }
+      # returns line no and column given byte offset in a text file
+      # Params:
+      # - newlines_array: an array that contains offsets of newline
+      #   characters in the text file (can be obtained by calling
+      #   newline_offsets_in(file_contents)
+      # - offset: offset to be converted
+      def ln_col_from_offset(newlines_array, offset)
+        preceding_newlines = newlines_array
+                             .select { |newline| newline <= offset }
         ln = preceding_newlines.length + 1
-        line_start_offset = preceding_newlines.last || 0
+        line_start_offset = preceding_newlines.last || -1
         col = offset - line_start_offset
         [ln, col]
       end
 
-      # a memoized function that returns offsets of newline characters
-      # in a file. used in ln_col_for
-      def newline_offsets_in(filepath)
-        @newline_offsets_in ||= Hash.new do |h, key|
-          # reading as binary to support CRLF and LF
-          text = File.read(key, mode: 'rb')
-          h[key] = (0..(text.length - 1))
-                   .select { |i| text[i] == "\n" }
-        end
-        @newline_offsets_in[filepath]
+      # returns byte offset given line no and a column in a text file
+      # Params:
+      # - newlines_array: an array that contains offsets of newline
+      #   characters in the text file (can be obtained by calling
+      #   newline_offsets_in(file_contents)
+      # - offset: offset to be converted
+      def offset_from_ln_col(newlines_array, ln, col)
+        (ln >= 2 ? newlines_array[ln - 2] : -1) + col
+      end
+
+      # returns an array that contains offsets of newline characters in given
+      # text
+      def newline_offsets_in(text)
+        (0..(text.length - 1)).select { |i| text[i] == "\n" }
       end
     end
   end

data/lib/pronto/clang_format_runner.rb

@@ -6,43 +6,46 @@ module Pronto
     def initialize(_, __ = nil)
       super
       @inspector = ::Pronto::ClangFormat::Wrapper.new
+      comma_separated_exts = ENV['PRONTO_CLANG_FORMAT_FILE_EXTS']
+      if comma_separated_exts.nil? # load default cpp files extensions
+        @cpp_extensions = %w[c h cpp cc cxx c++ hh hxx hpp h++ icc inl tcc tpp
+                             ipp]
+      else # load desired extensions from environment variable
+        @cpp_extensions = comma_separated_exts.split(',').map(&:strip)
+      end
     end
 
     def run
       return [] if !@patches || @patches.count.zero?
       @patches
-        .select { |p| valid_patch(p) }
+        .select { |p| valid_patch?(p) }
         .map { |p| inspect(p) }
         .flatten.compact
     end
-    
-    def valid_patch(patch)
-      #TODO: file should be a cpp or c or a header file (make sure we aren't missing anything)
-      #TODO: should we consider patches with added lines only?
-      true
+
+    def valid_patch?(patch)
+      return false if patch.additions < 1
+      cpp_file?(patch.new_file_full_path)
+    end
+
+    def cpp_file?(file_path)
+      @cpp_extensions.include? file_path.extname[1..-1]
     end
 
     def inspect(patch)
-      puts 'inspecting patch'
-      filename = patch.new_file_full_path
-      offences = @inspector.run(filename)
+      file_path = patch.new_file_full_path
+      offences = @inspector.run(file_path)
       offences.map do |offence|
-        patch.added_lines
-          .select { |line| line.new_lineno == offence[:line_no] }
-          .map { |line| new_message(offence, line) }
+        line = patch.added_lines.find do |added_line|
+          offence.affected_lines_range.cover? added_line.new_lineno
+        end
+        new_message(offence, line) unless line.nil?
       end
     end
-    
+
     def new_message(offence, line)
       path = line.patch.delta.new_file[:path]
-      Message.new(path, line, :warning, msg_for_offence(offence), nil, self.class)
-    end
-    
-    #TODO: correct line numbers for indentation errors (clang outputs the replacement to start from the preceding line)
-    #TODO: better messages, maybe have categories? (e.g. indentation, missing space, superfluous space, missine newline, superfluous newline, ...)
-    
-    def msg_for_offence(offence)
-      "col: #{offence[:column]}, len: #{offence[:length]}, offset: #{offence[:offset]}, replace with: #{offence[:replacement].dump}"
+      Message.new(path, line, :warning, offence.msg, nil, self.class)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pronto-clang_format
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Michael Jabbour
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-24 00:00:00.000000000 Z
+date: 2018-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pronto
@@ -67,6 +67,11 @@ files:
 - README.md
 - Rakefile
 - lib/pronto/clang_format.rb
+- lib/pronto/clang_format/offence.rb
+- lib/pronto/clang_format/offence_categorizer/abstract_categorizer.rb
+- lib/pronto/clang_format/offence_categorizer/factory.rb
+- lib/pronto/clang_format/offence_categorizer/includes_order_categorizer.rb
+- lib/pronto/clang_format/offence_categorizer/indentation_categorizer.rb
 - lib/pronto/clang_format/version.rb
 - lib/pronto/clang_format/wrapper.rb
 - lib/pronto/clang_format_runner.rb