ci-syntax-tool 0.1.0

data/lib/ci-syntax-tool/format/base.rb

@@ -0,0 +1,50 @@
+module CI
+  module Syntax
+    module Tool
+      module Format
+        # CI::Syntax::Tool::Format::Base
+        #  Base class for syntax checkers.  Sketches out the
+        #  API you need if you want to add a format.
+        class Base
+
+          attr_reader :out
+          
+          # Args is a hash, contents unspecified as yet.
+          def initialize(io, args)
+            @out = io
+          end
+          
+          def self.descendant_classes
+            # Fairly expensive call...
+            ObjectSpace.each_object(Class).select { |klass| klass < self }
+          end
+          
+          # Called once at the beginning of the check before any languages
+          def overall_started(_overall_result)
+          end
+
+          # Called once at the beginning of the language check before any files
+          def lang_started(_lang_result)
+          end
+
+          # Called once at the beginning of the check on a file.
+          def file_started(_file_result)
+          end
+
+          # Called once at the end of the check on a file.
+          def file_finished(_file_result)
+          end
+
+          # Invoked after all files are inspected, or interrupted by user.
+          def lang_finished(_lang_result)
+          end
+
+          # Called once at the global finish
+          def overall_finished(_overall_result)
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/ci-syntax-tool/format/junit.rb

@@ -0,0 +1,54 @@
+require 'nokogiri'
+
+module CI
+  module Syntax
+    module Tool
+      module Format
+        # CI::Syntax::Tool::Format::Progress
+        #  Prints a dot for each 
+        #  API you need if you want to add a format.
+        class JUnit < Format::Base
+          attr_reader :doc
+          attr_reader :root
+          attr_reader :testsuite  # Equiv to lang
+          attr_reader :testcase   # Equiv to file
+          
+          def initialize(io, args)
+            super
+            @doc = Nokogiri::XML::Document.new()
+            @root = Nokogiri::XML::Element.new('testsuites', doc)
+            doc.add_child(root)            
+          end
+
+          def lang_started(lang_result)
+            @testsuite = Nokogiri::XML::Element.new('testsuite', doc)
+            testsuite['name'] = lang_result.language_name
+            root.add_child(testsuite)
+          end
+
+          def file_started(file_result)
+            @testcase = Nokogiri::XML::Element.new('testcase', doc)
+            testcase['name'] = file_result.path.gsub('/','_').gsub('.','_')
+            testsuite.add_child(testcase)
+          end
+          
+          def file_finished(file_result)
+            file_result.issues.each do |issue|
+              failure = Nokogiri::XML::Element.new('failure', doc)
+              failure['type'] = issue.level.to_s
+              message = Nokogiri::XML::CDATA.new(doc, issue.cooked_message || issue.raw_message)
+              failure.add_child(message)
+              testcase.add_child(failure)
+            end
+          end
+
+          def overall_finished(overall_result)
+            out.write doc.to_s
+            out.flush
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/ci-syntax-tool/format/progress.rb

@@ -0,0 +1,60 @@
+module CI
+  module Syntax
+    module Tool
+      module Format
+        # CI::Syntax::Tool::Format::Progress
+        #  Prints a dot for each 
+        #  API you need if you want to add a format.
+        class Progress < Format::Base
+
+          def initialize(io, args)
+            super
+          end
+
+          def lang_started(lang_result)
+            out.puts "Starting syntax scan for #{lang_result.language_name}..."
+          end
+          
+          # Called once at the end of the check on a file.
+          def file_finished(file_result)
+            if file_result.error_count > 0  
+              out.print 'x'
+            elsif file_result.warning_count > 0
+              out.print '*'
+            else
+              out.print '.'
+            end
+          end
+
+          # Invoked after all files are inspected, or interrupted by user.
+          def lang_finished(lang_result)
+            out.puts
+
+            if lang_result.warning_count > 0
+              out.puts 'Files with warnings:'
+              
+              lang_result.warning_file_results.each do |fr|
+                puts '  ' + fr.path
+                fr.warnings.each do |w|
+                  puts '    ' + (w.line_number.to_s || '?') + ':' + (w.character.to_s || '?') + ':' + w.raw_message
+                end
+              end
+            end
+
+            if lang_result.error_count > 0
+              out.puts 'Files with errors:'
+              
+              lang_result.error_file_results.each do |fr|
+                puts '  ' + fr.path
+                fr.errors.each do |e|
+                  puts '    Line ' + (e.line_number.to_s || '?') + ': Col ' + (e.character.to_s || '?') + ':' + e.raw_message
+                end
+              end
+            end
+
+          end          
+        end
+      end
+    end
+  end
+end

data/lib/ci-syntax-tool/format_factory.rb

@@ -0,0 +1,55 @@
+
+require 'fileutils'
+
+# Load base class first
+require_relative 'format/base'
+
+# Load all core formats
+Dir.glob(File.dirname(__FILE__) + '/format/*.rb') do |file|
+  require_relative file
+end
+
+module CI
+  module Syntax
+    module Tool
+      # CI:Syntax::Tool::FormatFactory
+      #   Identifies and loads the Format classes, and
+      # creates instances as needed.
+      class FormatFactory
+        
+        def self.all_format_classes
+          Format::Base.descendant_classes
+        end
+
+        def self.all_format_names
+          class_names = all_format_classes.map(&:name)
+          short_names = class_names.map do |name|
+            name.split('::').last
+          end
+          public_names = short_names.reject {|e| e == 'MockFormat'}
+          public_names
+        end
+
+        def self.valid_format?(proposed)
+          permitted_names = all_format_names << 'MockFormat'
+          permitted_names.include?(proposed)
+        end
+
+        def self.create(lang_name, io, args = {})
+          unless io.respond_to? :puts
+            if io == '-'
+              io = $stdout
+            else
+              # Ensure containing dir exists
+              FileUtils.mkdir_p File.dirname(io)
+              io = File.open(io, File::WRONLY | File::CREAT)
+            end
+          end
+            
+          const_get('CI::Syntax::Tool::Format::' + lang_name).new(io, args)
+        end
+        
+      end
+    end
+  end
+end

data/lib/ci-syntax-tool/language/base.rb

@@ -0,0 +1,56 @@
+module CI
+  module Syntax
+    module Tool
+      module Language
+        # CI::Syntax::Tool::Language::Base
+        #  Base class for syntax checkers.  Sketches out the
+        #  API you need if you want to add a language.
+        class Base
+
+          # Args is a hash, contents unspecified as yet.
+          def initialize(args)
+          end
+          
+          def self.descendant_classes
+            # Fairly expensive call...
+            ObjectSpace.each_object(Class).select { |klass| klass < self }
+          end
+          
+          # The globs that will actually be expanded.
+          # You probably don't need to override this.
+          def combined_globs
+            default_globs
+          end
+
+          # The globs you are interested in - you must
+          # override this to match any files.  Will be
+          # fed to Dir.glob().
+          def default_globs
+            []
+          end
+          
+          # Called once before any files are checked
+          # An opportunity to spawn a process, for example.
+          def check_starting(_lang_result)
+          end
+          
+          # Called once for each file being checked.  
+          # file_result [Result::File] - Results object for the outcome.
+          # Returns: Result::File
+          def check_file(_file_result)
+            fail
+          end
+          
+          # Called once after all files are checked
+          # Use for cleanup, or adding metadata to
+          # the result.
+          # result [Language::Result] - populated
+          # results of the run.
+          def check_ending(_result)
+          end
+                              
+        end
+      end
+    end
+  end
+end

data/lib/ci-syntax-tool/language/yaml.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+
+module CI
+  module Syntax
+    module Tool
+      module Language
+        # CI::Syntax::Tool::Language::Base
+        #  Base class for syntax checkers.  Sketches out the
+        #  API you need if you want to add a language.
+        class YAML < Language::Base
+
+          # Args is a hash, contents unspecified as yet.
+          def initialize(args)
+            super
+          end
+          
+          def default_globs
+            ['**/*.yaml', '**/*.yml']
+          end
+          
+          # Called once for each file being checked.  
+          # path [String] - path to filename to check
+          # file_result [Result::File] - Results object for the outcome.
+          # Returns: Result::File
+          def check_file(file_result)
+            begin
+              ::YAML.load(File.read(file_result.path))
+            rescue Psych::SyntaxError => e
+              file_result.add_issue(
+                line_number: e.line,
+                character: e.column,
+                level: :error,
+                raw_message: e.problem,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ci-syntax-tool/language_factory.rb

@@ -0,0 +1,41 @@
+
+# Load base class first
+require_relative 'language/base'
+
+# Load all core languages
+Dir.glob(File.dirname(__FILE__) + '/language/*.rb') do |file|
+  require_relative file
+end
+
+module CI
+  module Syntax
+    module Tool
+      # CI:Syntax::Tool::LanguageFactory
+      #   Identifies and loads the Language classes, and
+      # creates instances as needed.
+      class LanguageFactory
+        
+        def self.all_language_classes
+          Language::Base.descendant_classes
+        end
+
+        def self.all_language_names
+          class_names = all_language_classes.map(&:name)
+          short_names = class_names.map do |name|
+            name.split('::').last
+          end
+          short_names
+        end
+
+        def self.valid_language?(proposed)
+          all_language_names.include?(proposed)
+        end
+
+        def self.create(lang_name, args = {})
+          const_get('CI::Syntax::Tool::Language::' + lang_name).new(args)
+        end
+        
+      end
+    end
+  end
+end

data/lib/ci-syntax-tool/result.rb

@@ -0,0 +1,134 @@
+module CI
+  module Syntax
+    module Tool
+      
+      class Issue
+        attr_reader :line_number
+        attr_reader :character
+        attr_reader :raw_message
+        attr_reader :cooked_message
+        attr_reader :level
+        def initialize(args = {})
+          # Any may be nil, except for level
+          @line_number = args[:line_number]
+          @character = args[:character]
+          @raw_message = args[:raw_message]
+          @cooked_message = args[:cooked_message]
+          @level = args[:level] || :error
+        end
+      end
+      
+      class Result
+
+        class OverallResult < Result
+
+          attr_reader :language_results
+          
+          def initialize
+            @language_results = {}
+          end
+
+          def add_language_result(lang_name)
+            language_results[lang_name] = LanguageResult.new(lang_name)
+          end
+
+          def report_failure?
+            error_count > 0
+          end
+
+          def error_count
+            language_results.inject(0) do |total, (lang,result)|
+              total += result.error_count
+            end
+          end
+
+          def warning_count
+            language_results.inject(0) do |total, (lang,result)|
+              total += result.warning_count
+            end
+          end
+
+          def file_paths
+            files = []
+            language_results.each do |ln, lr|
+              lr.file_results.each do |fp, fr|
+                files << fr.path
+              end
+            end
+            files
+          end
+          
+        end
+        
+        class LanguageResult < Result
+
+          attr_reader :file_results
+          attr_reader :language_name
+          
+          def initialize(lang_name)
+            @language_name = lang_name
+            @file_results = {}
+          end
+
+          def add_file_result(path)
+            file_results[path] = FileResult.new(path)
+          end
+
+          def error_count
+            file_results.inject(0) do |total, (path,result)|
+              total += result.error_count
+            end
+          end
+
+          def warning_count
+            file_results.inject(0) do |total, (path,result)|
+              total += result.warning_count
+            end
+          end
+  
+          def warning_file_results
+            file_results.values.select { |fr| fr.warning_count > 0 }
+          end
+          
+          def error_file_results
+            file_results.values.select { |fr| fr.error_count > 0 }
+          end
+        
+        end
+        
+        class FileResult < Result
+          attr_reader   :path
+          attr_reader  :issues
+          
+          def initialize(path)
+            @path = path
+            @whole_file_processed = false
+            @issues = []
+          end
+
+          def add_issue(opts)
+            issues << Issue.new(opts)
+          end
+
+          def warning_count
+            warnings.count
+          end
+
+          def error_count
+            errors.count
+          end
+
+          def warnings 
+            issues.select { |i| i.level == :warning }
+          end
+
+          def errors 
+            issues.select { |i| i.level == :error }
+          end
+          
+        end
+        
+      end
+    end
+  end
+end