fastlane-plugin-code_static_analyzer 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f27b577db79a18a272cb128f635addb0ac1d4740
-  data.tar.gz: 292c5593392ca861eb7915ce1cbdd5bc52f45e8d
+  metadata.gz: 6530cd946311c49865759085970367cc7b80d49a
+  data.tar.gz: 1f25302307508f4869fd63ddb72ddac10a7c258a
 SHA512:
-  metadata.gz: be0c3524e9f856179ac50ef7116d22e1a9ca59e3eb6f7b223b789693d324c45e852d86f49d09c9950fa8c61bcdcc14d875adb668d2b10eb3aa9dcb551e306258
-  data.tar.gz: 11a075f75f5d5431ef10682cca0bb0f1ba8227f0f9e71a77af1dde540f5ae83bcc33fd8aaba73534a28bac8955d78d497aa456cb178bf274e199fdd200ee9472
+  metadata.gz: b4574eea5e4578a9ff8d74fa66efe10602073c8a22af0bcf33089c0ec6736ab3b16ff867fd269c720389dada66909106d182d0d498045e40408fee43daf0650f
+  data.tar.gz: 11d10144c2966570d7c946bcc8de252fe92a11ac54a3560a5d3596af1f46fdf80b4ceebbb02088ee7e688400da086ddb1f894b13edfc7b949c7178c45d316080

data/README.md

@@ -22,6 +22,7 @@ This plugin can be used in pair with CI static code analysis plugins. Check out
 ## Important
 - You can configure rubocop analyzer by creating configuration file `.rubocop.yml` in your project (more about rubocop configuration http://rubocop.readthedocs.io/en/latest/cops/)
 - All paths should be relative to work directory. 
+- Clang-format tool have to be installed on your machine to use clang analyzer
 
 ### Specific for copy paste analyzer (CPD)
 - PMD have to be installed on your machine (http://pmd.sourceforge.net/snapshot/usage/installing.html)
@@ -34,6 +35,7 @@ You may run each analyzer separate:<br />
 `cpd_analyzer` - finds copy paste in code (based on CPD from PMD package) <br />
 `ruby_analyzer` - checks your ruby files. Some offenses can be auto-corrected (if you want to save the changes do it manually) <br />
 `warning_analyzer` - this analyzer uses Xcode built-in analyzer mainly to detect warnings<br /> 
+`clang_analyzer` - this analyzer uses clang-format command to check and fix your code styling<br /> 
 
 ## Reference and Example
 
@@ -58,7 +60,12 @@ code_static_analyzer(
       xcode_workspace_name: 'path/to/testWorkspace',
       xcode_targets: ['TPClientTarget','TPServerTarget'],
       ruby_files: 'fastlane/Fastfile',
-      disable_junit: 'all' # don't create any results in JUnit format
+      disable_junit: 'all', # don't create any results in JUnit format
+      autocorrect: true,
+      clang_dir_to_inspect: %w('path/to/myFiles/' 'path/to/testFiles/'),
+      clang_dir_to_exclude: %w(Pods ThirdParty Build 'path/to/otherDir'),
+      files_extention: %w(h cpp),
+      basic_style: 'custom'
     )
 ````
 Parameter | Description
@@ -74,6 +81,11 @@ Parameter | Description
 `xcode_targets` | *(optional)* List of Xcode targets to inspect. By default used all targets which are available in project
 `ruby_files` | *(optional)* List of paths to ruby files to be inspected 
 `disable_junit` | *(optional)* List of analysers for which you want to disable results in JUnit format.<br />Supported analyzers: "xcodeWar", "rubocop", "CPD", "all"<br />By default all results will be created in JUnit format.
+`autocorrect` | *(optional)* If your code will be corrected basing on clang configuration.<br />Default value: false
+`clang_dir_to_inspect` | *(optional)* List of directories which include files you want to inspect.<br />Default value: your work directory
+`clang_dir_to_exclude` | *(optional)* List of directories which include files you don't want to inspect.
+`files_extention` | *(optional)* List of file extensions you use. [!] Each extension set without point.<br />Default value:[m h]
+`basic_style` | *(optional)* Basic Code Styling you want to use.<br />Supported styles: ['LLVM', 'Google', 'Chromium', 'Mozilla', 'WebKit', 'custom']. <br />By default analyzer uses custom (.clang-format) config file or create new one based on LLVM style in your work directory.<br />If you create configuration file based on one of the clang styling ('LLVM', 'Google', 'Chromium', 'Mozilla', 'WebKit') and change even one property than don't set this parameter or use 'custom'
 
 ### `code_static_analyzer` other examples (full configuration):
 CPD:
@@ -114,6 +126,38 @@ code_static_analyzer(
       xcode_targets: ['TPClientTarget','TPServerTarget'],
     )
 ````
+
+## Clang Format
+If you need to run clang_analyzer separately (for example as build step) you may call next:
+
+````ruby
+# minimum configuration
+clang_analyzer
+
+# minimum configuration
+clang_analyzer(
+      autocorrect: true,
+      clang_dir_to_inspect: %w(Classes/UI),
+      clang_dir_to_exclude: %w(Pods ThirdParty Build),
+      files_extention: %w(m h),
+      basic_style: 'custom'
+    )
+````
+All parameters are optional and described in previous part.
+Minimum configuration means that will be checked all files with extension *.m & *.h in work directory and it subdirectories by using custom (if exists) or llvm formatting rules.
+As result we get junit formatted file with failed tests (autocorrect = false) or skipped tests (autocorrect = true, + changed files).
+Each test message include: <br />
+
+Message parts | Description
+--------- | -----------
+`Code-fragment` | fragment of code (N lines) with clang format issue +- 5 lines (before /after line with clang issue)
+`Clang-fix` | clang replacement 
+`Code-fragment-after fix` | the same lines of code as for `Code-fragment` after clang made fix.<br /> Pay attention that this part not always show the current clang fix (due to clang fix the entire file).
+
+Recommendations: don't use autocorrect currently before making build due to some fixes can cause warnings.<br />
+For example Objective C method declaration `-(void)methodName:(type1)parameter1 :(type2)method2;`
+after fix will cause warnings due to this declaration is not under Objective C code convention (it should be `-(void)methodName:(type1)parameter1 withParamTwo:(type2)method2;`)
+
 ## Using CI plugins
 
 If you want to use CI static code analysis plugins pay attention on type of file which they use. 

data/lib/assets/formatter.rb

@@ -22,7 +22,12 @@ module Formatter
     puts 'format        : xml'
     puts "output_file   : #{result_file}"
   end
-
+  
+  def self.clang_format(file, count)
+    puts ">>>Made #{count} replacements in #{file}"
+  end
+ 
+       
   # String colorization
   # call UI.message Actions::FormatterAction.light_blue(text)
   def self.light_blue(mytext)

data/lib/assets/junit_parser.rb

@@ -5,10 +5,13 @@
 # 1. Parser 1. Xcode analyze result (.log)
 # 2. Parser 2. Rubocop result (.json)
 # 3. Parser 3. CPD result (.xml)
+# 4. Parser 4. Any result as required Hash (ruby hash)
 
 require 'crack'
 
 module JunitParser
+  SKIP_STR_IN_MATCH = ['*', '\n', '\\', '//']
+
   #####################################################
   # ================= For all parsers =================
   #####################################################
@@ -36,8 +39,14 @@ module JunitParser
     "#{failures}#{xml_level(2)}</testcase>"
   end
 
-  def self.add_success_testcase(name)
-    "#{xml_level(2)}<testcase name='#{name}' status='success'/>"
+  def self.add_success_testcase(name, assertions)
+    "#{xml_level(2)}<testcase name='#{name}' #{insert_attribute('assertions', assertions)} status='success'/>"
+  end
+
+  def self.add_skipped_testcase(name, assertions, message)
+    out = message == '' ? '' : add_system_output(message)
+    "#{xml_level(2)}<testcase #{insert_attribute('name', name)} #{insert_attribute('assertions', assertions)}>" \
+    "#{out}#{xml_level(3)}<skipped/>#{xml_level(2)}</testcase>"
   end
 
   def self.add_failure(message, type, text)
@@ -47,6 +56,10 @@ module JunitParser
   	"#{xml_level(3)}</failure>"
   end
 
+  def self.add_system_output(text)
+    "#{xml_level(3)}<system-out>#{text}#{xml_level(3)}</system-out>"
+  end
+
   def self.add_properties(property_array, value_array)
     properties = "#{xml_level(2)}<properties>"
     property_array.each_with_index do |property, index|
@@ -68,7 +81,7 @@ module JunitParser
   end
 
   def self.insert_attribute(attribute, value)
-    value == '' ? '' : "#{attribute}='#{value}'"
+    (value == '' or value.nil?) ? '' : "#{attribute}='#{value}'"
   end
 
   def self.add_code(codefragment)
@@ -106,55 +119,54 @@ module JunitParser
       error_text = ''
       temp_testcase = ''
       File.open(file).each do |line|
-        if line =~ /warning:|error:|BCEROR/
+        next unless line =~ /warning:|error:|BCEROR/
         failure_type = get_failure_type(line)
-          warning_params = line.split(':')
-          if warning_params.count == 5
-             error_text = construct_failure_mes(
-              ['Error ClassType', 'Error Message'],
-              [failure_type, warning_params[4].tr("\n", '')]
-            )
-            testcase_name = project+':'+warning_params[0].tr('<', '').tr('>', '')+
-               ":#{warning_params[1]}:#{warning_params[2]}"
-          else
-            error_text = construct_failure_mes(
-              ['Error ClassType', 'Error Message'],
-              [failure_type, line.tr("\n", '').gsub('warning:','')]
-            )
-            testcase_name = project
-            testcase_name += ':project configuration' if line =~ /BCEROR/
-            file_info = check_for_file_info(warning_params)
-            testcase_name += ":#{file_info[0]}" unless file_info[0]==nil
-            testcase_name += ":#{file_info[1]}" unless file_info[1]==nil
-          end
-          failures = add_failure('', '', error_text)
-          temp_testcase += add_failed_testcase(testcase_name, failures)
+        warning_params = line.split(':')
+        if warning_params.count == 5
+          error_text = construct_failure_mes(
+            ['Error ClassType', 'Error Message'],
+            [failure_type, warning_params[4].tr("\n", '')]
+          )
+          testcase_name = project + ':' + warning_params[0].tr('<', '').tr('>', '') +
+                          ":#{warning_params[1]}:#{warning_params[2]}"
+        else
+          error_text = construct_failure_mes(
+            ['Error ClassType', 'Error Message'],
+            [failure_type, line.tr("\n", '').gsub('warning:', '')]
+          )
+          testcase_name = project
+          testcase_name += ':project configuration' if line =~ /BCEROR/
+          file_info = check_for_file_info(warning_params)
+          testcase_name += ":#{file_info[0]}" unless file_info[0].nil?
+          testcase_name += ":#{file_info[1]}" unless file_info[1].nil?
         end
+        failures = add_failure('', '', error_text)
+        temp_testcase += add_failed_testcase(testcase_name, failures)
       end
       temp_testcase
     else
-      add_success_testcase(project)
+      add_success_testcase(project, '')
     end
   end
-  
+
   def self.check_for_file_info(text_list)
-    result =[]
+    result = []
     text_list.each_with_index do |text, i|
-      file = /([a-zA-Z0-9\.]*)?(\/[a-zA-Z0-9\._-]+)*(\.){1}[a-zA-Z0-9\._-]+/.match(text)
+      file = %r{([a-zA-Z0-9\.]*)?(/[a-zA-Z0-9\._-]+)*(\.){1}[a-zA-Z0-9\._-]+}.match(text)
       file = nil if file.to_s =~ /\.{2,}/
-      unless file==nil 
-        next_value=text_list.to_a[i.to_i+1].nil? ? '' : text_list.to_a[i.to_i+1]
-     	line = /[0-9]+/.match(next_value)
-     	if line ==nil
-     	  result=[file]
-     	else
-     	  result=[file, line]
-     	end
-     	break
-      end 
+      next if file.nil?
+      next_value = text_list.to_a[i.to_i + 1].nil? ? '' : text_list.to_a[i.to_i + 1]
+      line = /[0-9]+/.match(next_value)
+      if line.nil?
+        result = [file]
+      else
+        result = [file, line]
+      end
+      break
     end
     result
   end
+
   #####################################################
   # ============== Rubocop-json Parser ================
   #####################################################
@@ -179,7 +191,7 @@ module JunitParser
       error_text = ''
       errors = inspected_file['offenses']
       if errors.empty?
-        xml += add_success_testcase((inspected_file['path']).to_s)
+        xml += add_success_testcase((inspected_file['path']).to_s, '')
       else
         errors.each do |error|
           error_text += construct_failure_mes(
@@ -208,9 +220,9 @@ module JunitParser
     data_read = File.read(file)
     data_hash = Crack::XML.parse(data_read)
 
-    if data_hash.empty? or data_hash['pmd_cpd']==nil
+    if data_hash.empty? or data_hash['pmd_cpd'].nil?
       puts 'empty data_hash'
-      add_success_testcase('casino duplications')
+      add_success_testcase('casino duplications', '')
     else
       parse_code_duplications(data_hash)
     end
@@ -245,4 +257,170 @@ module JunitParser
     end
     file_list_info
   end
+
+  #####################################################
+  # =================== Clang Parser ==================
+  #####################################################
+
+  def self.parse_clang(clang_changes, inspected_file, file_id, file_lines)
+    count = 0
+    file_replacements = []
+    clang_changes.each_line do |line|
+      next unless line =~ %r{</replacement>}
+      hash = parse_str(line)
+      offset = hash[:offset]
+      offset_long = hash[:length]
+      offset_end = offset.to_i + offset_long.to_i
+      code_lines = get_code_lines(offset, offset_end, file_lines)
+      # read current code fragment that include clang format issue
+      current_code_fragment = read_lines_in_file(inspected_file, code_lines[0], code_lines[1], false)
+
+      # make clang format replacement more understandable
+      replacements = hash[:replacements]
+      fixed_code_fragment = replacements
+      fixed_code_fragment = replacements.sub("&#10;", '') if replacements =~ /(&#10;){2,}./
+      fixed_code_fragment.gsub!("&#10;", "\n")
+      replace_in(fixed_code_fragment)
+      fixed_code_fragment = "\n'#{add_code(fixed_code_fragment)}'"
+
+      # if replacements.match(/^([a-zA-Z0-9])[\n&#10;]*(\ )*$/)
+      #   if offset_long.to_i == 1
+      #     fixed_code_fragment = "change one character (remove/add space/tab/new line). Replacement: #{fixed_code_fragment.sub("\n", '')}"
+      #   else
+      #     fixed_code_fragment = "generally needed to remove/add space/tab/new line. Replacement: #{fixed_code_fragment.sub("\n", '')}"
+      #   end
+      # end
+
+      hash_info = { old_code: current_code_fragment,
+      fix_code: fixed_code_fragment,
+      code_lines: code_lines,
+      file: inspected_file,
+      file_id: file_id }
+      file_replacements.push(hash_info)
+
+      count += 1
+    end
+    [count, file_replacements]
+  end
+
+  def self.create_clang_xml(file_replacements, skipped)
+    xml = ''
+    file_replacements.each do |i_hash|
+      if skipped
+        new_code_fragment = read_lines_in_file(i_hash[:file], i_hash[:code_lines][0], i_hash[:code_lines][1], true)
+        error_text = construct_failure_mes(
+          ['Code fragment with formatting issue', "#{xml_level(4)}Clang fix", "#{xml_level(4)}Code fragment after clang fix"],
+          [i_hash[:old_code], i_hash[:fix_code], new_code_fragment]
+        )
+        xml += add_skipped_testcase("F#{i_hash[:file_id]}:#{i_hash[:file]}:#{i_hash[:code_lines][0] + 1}", '', error_text)
+      else
+        error_text = construct_failure_mes(
+          ['Code fragment with formatting issue', "#{xml_level(4)}Clang fix"],
+          [i_hash[:old_code], i_hash[:fix_code]]
+        )
+        failure = add_failure('', '', error_text)
+        xml += add_failed_testcase("F#{i_hash[:file_id]}:#{i_hash[:file]}:#{i_hash[:code_lines][0] + 1}", failure)
+      end
+    end
+    xml
+  end
+
+  def self.read_lines_in_file(file, read_start, read_to, is_fixed)
+    lines = ''
+    read_from = (read_start - 5) < 0 ? 0 : (read_start - 5)
+    read_to += 5
+    index = read_from
+    space_count = read_to.to_s.count "0-9"
+    File.readlines(file).values_at(read_from..read_to).each do |spec_line|
+      unless spec_line.nil?
+        spec_line = spec_line.chomp
+        replace_in(spec_line)
+        if index == read_start and !is_fixed
+          lines += format("\n&#62;&#62;&#32;%-#{space_count}s&#32;%s", (index + 1), add_code(spec_line))
+        else
+          lines += format("\n&#32;&#32;&#32;%-#{space_count}s&#32;%s", (index + 1), add_code(spec_line))
+        end
+      end
+      index += 1
+    end
+    lines
+  end
+
+  def self.parse_str(str)
+    # TODO: check if no any replacements...will it be crashes
+    byte_offset = str.match(/offset='[0-9]+'/).to_s.tr('\'', '').split('=')[1]
+    length_of_changes = str.match(/length='[0-9]+'/).to_s.tr('\'', '').split('=')[1]
+    replaced = str.match(%r{>(.)*</replacement>}).to_s
+    replaced[0] = ''
+    replaced = replaced.sub('</replacement>', '')
+
+    { offset: byte_offset, length: length_of_changes, replacements: replaced }
+  end
+
+  def self.get_code_lines(value, value_end, file_lines)
+    s_line = file_lines[:start]
+    e_line = file_lines[:finish]
+    value = value.to_i
+    start_flag = false
+    finish_flag = false
+    start = 0
+    finish = 0
+    s_line.each_with_index do |line, index|
+      if value >= line and value < e_line[index] and !start_flag
+        start = file_lines[:line][index]
+        start_flag = true
+      end
+      if value_end > line and value_end <= e_line[index] and !finish_flag
+        finish = file_lines[:line][index]
+        finish_flag = true
+      end
+      break if start_flag and finish_flag
+    end
+    [start, finish]
+  end
+
+  def self.replace_in(text)
+    text.gsub!("&lt;",'<')
+    text.gsub!("&gt;",'>')
+    text.gsub!("&quot;",'"')
+    text.gsub!("&amp;",'&')
+    text.gsub!("&apos;",'\'')
+  end
+
+  #####################################################
+  # ============== Universal Hash Parser ==============
+  #####################################################
+
+  # Method return testsuites xml content
+  # after that call create_junit_xml to get full JUnit file
+  def self.parse_hash(data_hash)
+    testcase_xml = ''
+    testcases = data_hash[:testcase]
+    testcases.each do |error|
+      testcase_name = error[:name]
+      testcase_err_num = error[:assertions]
+      testcase_message = error[:message]
+      case error[:status].downcase
+      when 'success'
+        testcase_xml += add_success_testcase(testcase_name, testcase_err_num, '')
+      when 'fail'
+        if testcase_message.nil?
+          failure = add_failure('', '', '')
+        else
+          failure = add_failure(testcase_message[:additional_info], testcase_message[:type], testcase_message[:message])
+        end
+        testcase_xml += add_failed_testcase(testcase_name, failure)
+      when 'skip'
+        testcase_xml += add_skipped_testcase(testcase_name, testcase_err_num, '')
+      end
+    end
+    properties = ''
+    unless data_hash[:properties].nil?
+      keys = data_hash[:properties].keys
+      values = data_hash[:properties].values
+      properties = add_properties(keys, values)
+    end
+    testsuite = add_testsuite(data_hash[:test_group_name], properties + testcase_xml)
+    testsuite
+  end
 end

data/lib/fastlane/plugin/code_static_analyzer/actions/clang_analyzer.rb

@@ -0,0 +1,223 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      CLANG_ANALYZER_STATUS = :CLANG_ANALYZER_STATUS
+    end
+
+    class ClangAnalyzerAction < Action
+      SUPPORTED_STYLE = ['LLVM', 'Google', 'Chromium', 'Mozilla', 'WebKit', 'custom']
+
+      def self.run(params)
+        UI.header 'Clang analyzer' if Actions::CodeStaticAnalyzerAction.run_from_main_action
+        Actions::CodeStaticAnalyzerAction.is_installed('clang-format', 'clang format analyzer') unless Actions::CodeStaticAnalyzerAction.checked_pmd
+        work_dir = Actions::CodeStaticAnalyzerAction.work_dir
+        style = params[:basic_style]
+        autofix = params[:autocorrect]
+        # checking files for analysing
+        files_extentions = params[:files_extention]
+        files_to_exclude = params[:clang_dir_to_exclude] # TODO: add check
+        files_to_inspect = params[:clang_dir_to_inspect] # TODO: add check
+
+        files_extentions = ['m', 'h'] unless files_extentions
+        extention = '{'
+        files_extentions.each do |extent|
+          extention += "#{extent},"
+        end
+        extention += '}'
+        UI.message "[!] CPD analyzer will be run for all files with extentions #{files_extentions}".blue
+
+        # prepare script and metadata for saving results
+        result_dir_path = "#{work_dir}#{params[:result_dir]}"
+        FileUtils.mkdir_p(result_dir_path) unless File.exist?(result_dir_path)
+        result_file = "#{result_dir_path}/codeAnalysResults_clang.xml"
+        run_script_path = File.join CodeStaticAnalyzer::ROOT, "assets/run_script.sh"
+
+        UI.message 'Checking clang configuration file'
+        is_clang_config = Dir.glob("#{work_dir}**/.clang-format").empty?
+
+        if (style == 'custom' and is_clang_config) or style != 'custom'
+          if is_clang_config
+            UI.message 'Your custom clang configuration file (.clang-format) is absent in work directory.'.blue +
+                       ' Clang will be run with default config file based on LLVM style'.blue
+          end
+          run_script = "clang-format -style=#{style} -dump-config "
+          run_script = "#{run_script_path} \"#{run_script}\" '.clang-format'"
+          FastlaneCore::CommandExecutor.execute(command: run_script.to_s,
+                                                     print_all: true,
+                                                     error: proc do |error_output|
+                                                              # handle error here
+                                                            end)
+        end
+
+        UI.message 'Check files:'
+        status_static_arr = []
+        work_files = file_list_for_clang_formatting(work_dir, files_to_inspect, files_to_exclude, extention)
+        data_hash = {}
+        data_hash["file number"] = 'number of replacements'
+        testcase = ''
+        work_files.each_with_index do |file, index|
+          run_script = "find #{file} | xargs clang-format -i -style=file -fallback-style=none "
+          clang_xml_format = " -output-replacements-xml "
+          clang_changes = FastlaneCore::CommandExecutor.execute(command: "#{run_script}#{clang_xml_format}",
+                                             print_all: false,
+                                              print_command: false,
+                                             error: proc do |error_output|
+                                                      # handle error here
+                                                    end)
+          # if index == 22 #23
+          all_lines = file_to_lines_offset(file)
+          clang_data = JunitParser.parse_clang(clang_changes, file, index, all_lines)
+          data_hash[index.to_s] = clang_data[0]
+          Formatter.clang_format("#{index}:#{file}", clang_data[0])
+          status_static_arr.push(clang_data[0])
+
+          if autofix
+            FastlaneCore::CommandExecutor.execute(command: run_script.to_s,
+                                          print_all: false,
+                                          print_command: false,
+                                          error: proc do |error_output|
+                                                   # handle error here
+                                                 end)
+          end
+          testcase += JunitParser.create_clang_xml(clang_data[1], autofix)
+          # end
+          #  JunitParser.create_junit_xml(clang_changes, "#{result_dir_path}/#{index}_clang.xml")
+        end
+
+        # prepare results
+        keys = data_hash.keys
+        values = data_hash.values
+        properties = JunitParser.add_properties(keys, values)
+        junit_xml = JunitParser.add_testsuite('clang', properties + testcase)
+
+        JunitParser.create_junit_xml(junit_xml, result_file)
+        status = if status_static_arr.any? { |x| x > 0 }
+                   1
+                 else
+                   0
+                 end
+        Actions.lane_context[SharedValues::CLANG_ANALYZER_STATUS] = status
+      end
+
+      def self.file_list_for_clang_formatting(work_dir, include, exclude, ext)
+        file_list = []
+        if include
+          include.each do |file|
+            file_list += Dir.glob("#{work_dir}#{file}/**/*.#{ext}")
+          end
+        else
+          file_list = Dir.glob("#{work_dir}**/*.#{ext}")
+        end
+        if exclude
+          exclude.each do |file|
+            file_list -= Dir.glob("#{work_dir}#{file}/**/*")
+          end
+        end
+        file_list
+      end
+
+      def self.file_to_lines_offset(file_path_name)
+        line_start = []
+        line_end = []
+        line_num = []
+        file_stream = File.open(file_path_name)
+        File.readlines(file_path_name).each_with_index do |line, index|
+          line_start_pos = file_stream.pos
+          # linelength = line.length - 1
+          line_end_pos = file_stream.pos + line.length
+          file_stream.seek(line_end_pos)
+          line_start.push(line_start_pos)
+          line_end.push(line_end_pos)
+          line_num.push(index) # in File.read index of first line - 0, but in Xcode - 1
+        end
+        file_stream.close
+        { start: line_start, finish: line_end, line: line_num }
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "A short description with <= 80 characters of what this action does"
+      end
+
+      def self.details
+        # Optional:
+        # this is your chance to provide a more detailed description of this action
+        "You can use this action to do cool things..."
+      end
+
+      def self.available_options
+        # Define all options your action supports.
+
+        # Below a few examples
+        [
+          FastlaneCore::ConfigItem.new(key: :basic_style,
+                        env_name: "FL_CLANG_ANALYZER_BASED_ON_STYLE",
+                        description: "Code style.\nSupported styles: #{SUPPORTED_STYLE}",
+                        optional: true,
+                        type: String,
+                        verify_block: proc do |value|
+                          UI.user_error!("This style is not supported.  Supported languages: #{SUPPORTED_STYLE}") unless SUPPORTED_STYLE.map(&:downcase).include? value.downcase or value.empty? or !value
+                        end,
+                        default_value: 'custom'),
+          FastlaneCore::ConfigItem.new(key: :clang_dir_to_inspect,
+                        env_name: "FL_CLANG_ANALYZER_FILES_TO_INSPECT",
+                        description: "List of directories (relative to work directory) to inspect on clang styling",
+                        optional: true,
+                        type: Array),
+          FastlaneCore::ConfigItem.new(key: :clang_dir_to_exclude,
+                        env_name: "FL_CLANG_ANALYZER_FILES_NOT_TO_INSPECT",
+                        description: "List of directories (relative to work directory) not to inspect on clang styling",
+                        optional: true,
+                        type: Array),
+          FastlaneCore::ConfigItem.new(key: :files_extention,
+                        env_name: "FL_CLANG_ANALYZER_FILES_EXTENTIONS",
+                        description: "List of extentions of inspected files",
+                        optional: true,
+                        type: Array),
+          FastlaneCore::ConfigItem.new(key: :result_dir,
+                        env_name: "FL_CLANG_ANALYZER_RESULT_DIR",
+                        description: "Directory's name for storing results",
+                        optional: true,
+                        type: String,
+                        default_value: 'artifacts'),
+          FastlaneCore::ConfigItem.new(key: :autocorrect,
+                        env_name: "FL_CLANG_ANALYZER_AUTOCORRECT",
+                        optional: true,
+                        is_string: false)
+        ]
+      end
+
+      def self.output
+        # Define the shared values you are going to provide
+        [
+          ['CLANG_ANALYZER_STATUS', 'Clang format analyzer result status (0 - success, any other value - failed)']
+        ]
+      end
+
+      def self.return_value
+        # If you method provides a return value, you can describe here what it does
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["olgakn"]
+      end
+
+      def self.is_supported?(platform)
+        # you can do things like
+        #
+        #  true
+        #
+        #  platform == :ios
+        #
+        #  [:ios, :mac].include?(platform)
+        #
+
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/code_static_analyzer/actions/code_static_analyzer_action.rb

@@ -9,13 +9,13 @@ module Fastlane
     end
 
     class CodeStaticAnalyzerAction < Action
-      SUPPORTED_ANALYZER = ["xcodeWar", "rubocop", "CPD"]
+      SUPPORTED_ANALYZER = ["xcodeWar", "rubocop", "CPD", "clang"]
       RESULT_FILE = 'codeAnalysResults_analyzers.xml'
       attr_accessor :checked_pmd, :checked_xcode_param, :xml_content, :run_main
 
       def self.run(params)
         @run_main = true
-        Actions::CodeStaticAnalyzerAction.is_pmd_installed
+        Actions::CodeStaticAnalyzerAction.is_installed('pmd','copy paste analyzer')
         platform = Actions.lane_context[SharedValues::PLATFORM_NAME].to_s
         @xml_content = ''
         root_dir = work_dir
@@ -46,6 +46,7 @@ module Fastlane
 
         status_rubocop = 0
         status_static = 0
+        status_clang = 0
         clear_all_files = "#{root_dir}#{params[:result_dir]}/*.*"
         # clear_temp_files = "#{root_dir}#{params[:result_dir]}/*temp*.*"
         sh "rm -rf #{clear_all_files}"
@@ -80,6 +81,16 @@ module Fastlane
               ruby_files: params[:ruby_files],
               use_junit_format: use_junit
             )
+          when 'clang'
+            autofix = params[:clang_autocorrect]==nil ? false : params[:clang_autocorrect]
+            status_clang = Actions::ClangAnalyzerAction.run(
+              basic_style: params[:clang_basic_style],
+              files_extention: params[:files_extention],
+              clang_dir_to_inspect: params[:clang_dir_to_inspect],
+              clang_dir_to_exclude: params[:clang_dir_to_exclude],
+              result_dir: params[:result_dir],
+              autocorrect: autofix
+            )    
           end
         end
         # sh "rm -rf #{clear_temp_files}"
@@ -88,7 +99,8 @@ module Fastlane
 
         if  Actions::CodeStaticAnalyzerAction.status_to_boolean(status_cpd) &&
             Actions::CodeStaticAnalyzerAction.status_to_boolean(status_static) &&
-            Actions::CodeStaticAnalyzerAction.status_to_boolean(status_rubocop)
+            Actions::CodeStaticAnalyzerAction.status_to_boolean(status_rubocop) &&
+            Actions::CodeStaticAnalyzerAction.status_to_boolean(status_clang)
           Actions.lane_context[SharedValues::ANALYZER_STATUS] = true
         else
           Actions.lane_context[SharedValues::ANALYZER_STATUS] = false
@@ -151,12 +163,12 @@ module Fastlane
 	    end
 	  end
 	  
-      def self.is_pmd_installed
+      def self.is_installed(command_name, for_analyzer)
         @checked_pmd = false
         begin
-         Actions.sh('type pmd')
+         Actions.sh("type #{command_name}") #pmd
        rescue
-         UI.user_error! 'PMD not installed. Please, install PMD for using copy paste analyzer.'
+         UI.user_error! "#{command_name} not installed. Please, install #{command_name} for using #{for_analyzer}."
        end
         @checked_pmd = true
       end
@@ -316,7 +328,32 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :xcode_targets,
                                  description: "List of Xcode targets to inspect",
                                 optional: true,
-                                type: Array)
+                                type: Array),
+         # parameters for Clang analyzer-formatter
+          FastlaneCore::ConfigItem.new(key: :clang_basic_style,
+                        description: "Style ... ? ... .\nSupported styles: #{Actions::ClangAnalyzerAction::SUPPORTED_STYLE}",
+                        optional: true,
+                        type: String,
+                        verify_block: proc do |value|
+                          UI.user_error!("This style is not supported.  Supported languages: #{Actions::ClangAnalyzerAction::SUPPORTED_STYLE}") unless Actions::ClangAnalyzerAction::SUPPORTED_STYLE.map(&:downcase).include? value.downcase or value.empty? or !value
+                        end,
+                        default_value:'custom'),
+          FastlaneCore::ConfigItem.new(key: :clang_dir_to_inspect,
+                        description: "List of directories (relative to work directory) to inspect on clang styling",
+                        optional: true,
+                        type: Array),
+          FastlaneCore::ConfigItem.new(key: :clang_dir_to_exclude,
+                        description: "List of directories (relative to work directory) not to inspect on clang styling",
+                        optional: true,
+                        type: Array),
+          FastlaneCore::ConfigItem.new(key: :files_extention,
+                        description: "List of extentions of inspected files",
+                        optional: true,
+                        type: Array),
+          FastlaneCore::ConfigItem.new(key: :clang_autocorrect,
+                        description: "--?",
+                        optional: true,
+                        is_string: false)
         ]
       end
 

data/lib/fastlane/plugin/code_static_analyzer/actions/cpd_analyzer.rb

@@ -9,7 +9,7 @@ module Fastlane
 
       def self.run(params)
         UI.header 'CPD analyzer' if Actions::CodeStaticAnalyzerAction.run_from_main_action
-        Actions::CodeStaticAnalyzerAction.is_pmd_installed unless Actions::CodeStaticAnalyzerAction.checked_pmd
+        Actions::CodeStaticAnalyzerAction.is_installed('pmd', 'copy paste analyzer') unless Actions::CodeStaticAnalyzerAction.checked_pmd
         work_dir = Actions::CodeStaticAnalyzerAction.work_dir
         # checking files for analysing
         files_to_exclude = params[:cpd_files_to_exclude]

data/lib/fastlane/plugin/code_static_analyzer/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module CodeStaticAnalyzer
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-code_static_analyzer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Olga Kniazska
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-25 00:00:00.000000000 Z
+date: 2017-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: crack
@@ -135,6 +135,7 @@ files:
 - lib/assets/junit_parser.rb
 - lib/assets/run_script.sh
 - lib/fastlane/plugin/code_static_analyzer.rb
+- lib/fastlane/plugin/code_static_analyzer/actions/clang_analyzer.rb
 - lib/fastlane/plugin/code_static_analyzer/actions/code_static_analyzer_action.rb
 - lib/fastlane/plugin/code_static_analyzer/actions/cpd_analyzer.rb
 - lib/fastlane/plugin/code_static_analyzer/actions/ruby_analyzer.rb