goodcheck 0.1.0

data/lib/goodcheck/commands/check.rb

@@ -0,0 +1,89 @@
+module Goodcheck
+  module Commands
+    class Check
+      attr_reader :config_path
+      attr_reader :rules
+      attr_reader :targets
+      attr_reader :reporter
+      attr_reader :stderr
+
+      include ConfigLoading
+
+      def initialize(config_path:, rules:, targets:, reporter:, stderr:)
+        @config_path = config_path
+        @rules = rules
+        @targets = targets
+        @reporter = reporter
+        @stderr = stderr
+      end
+
+      def run
+        reporter.analysis do
+          load_config!
+          each_check do |buffer, rule|
+            reporter.rule(rule) do
+              analyzer = Analyzer.new(rule: rule, buffer: buffer)
+              analyzer.scan do |issue|
+                reporter.issue(issue)
+              end
+            end
+          end
+        end
+        0
+      rescue Psych::Exception => exn
+        stderr.puts "Unexpected error happens while loading YAML file: #{exn.inspect}"
+        exn.backtrace.each do |trace_loc|
+          stderr.puts "  #{trace_loc}"
+        end
+        1
+      rescue StrongJSON::Type::Error => exn
+        stderr.puts "Invalid config at #{exn.path.map {|x| "[#{x}]" }.join}"
+        1
+      rescue Errno::ENOENT => exn
+        stderr.puts "#{exn}"
+        1
+      end
+
+      def each_check
+        targets.each do |target|
+          each_file target do |path|
+            reporter.file(path) do
+              buffers = {}
+
+              config.rules_for_path(path, rules_filter: rules) do |rule, glob|
+                begin
+                  encoding = glob&.encoding || Encoding.default_external.name
+
+                  if buffers[encoding]
+                    buffer = buffers[encoding]
+                  else
+                    content = path.read(encoding: encoding).encode(Encoding.default_internal || Encoding::UTF_8)
+                    buffer = Buffer.new(path: path, content: content)
+                    buffers[encoding] = buffer
+                  end
+
+                  yield buffer, rule
+                rescue ArgumentError => exn
+                  stderr.puts "#{path}: #{exn.inspect}"
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def each_file(path, &block)
+        realpath = path.realpath
+
+        case
+        when realpath.directory?
+          path.children.each do |child|
+            each_file(child, &block)
+          end
+        when realpath.file?
+          yield path
+        end
+      end
+    end
+  end
+end

data/lib/goodcheck/commands/config_loading.rb

@@ -0,0 +1,13 @@
+module Goodcheck
+  module Commands
+    module ConfigLoading
+      attr_reader :config
+
+      def load_config!
+        content = JSON.parse(JSON.dump(YAML.load(config_path.read, config_path.to_s)), symbolize_names: true)
+        loader = ConfigLoader.new(path: config_path, content: content)
+        @config = loader.load
+      end
+    end
+  end
+end

data/lib/goodcheck/commands/init.rb

@@ -0,0 +1,48 @@
+module Goodcheck
+  module Commands
+    class Init
+      CONFIG = <<-EOC
+rules:
+  - id: com.example.1
+    pattern: Github
+    message: Do you want to write GitHub?
+    glob: 
+      - "**/*.rb"
+      - "**/*.yaml"
+      - "**/*.yml"
+      - "**/*.html"
+    fail:
+      - Signup via Github
+    pass:
+      - Signup via GitHub
+      EOC
+
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :path
+      attr_reader :force
+
+      def initialize(stdout:, stderr:, path:, force:)
+        @stdout = stdout
+        @stderr = stderr
+        @path = path
+        @force = force
+      end
+
+      def run
+        if path.file? && !force
+          stderr.puts "#{path} already exists. Try --force option to overwrite the file."
+          return 1
+        end
+
+        path.open("w") do |io|
+          io.print(CONFIG)
+        end
+
+        stdout.puts "Wrote #{path}. ✍️"
+
+        0
+      end
+    end
+  end
+end

data/lib/goodcheck/commands/test.rb

@@ -0,0 +1,95 @@
+module Goodcheck
+  module Commands
+    class Test
+      include ConfigLoading
+
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :config_path
+
+      def initialize(stdout:, stderr:, config_path:)
+        @stdout = stdout
+        @stderr = stderr
+        @config_path = config_path
+      end
+
+      def run
+        load_config!
+
+        validate_rule_uniqueness or return 1
+        validate_rules or return 1
+
+        0
+      end
+
+      def validate_rule_uniqueness
+        stdout.puts "Validating rule id uniqueness..."
+
+        duplicated_ids = []
+
+        config.rules.group_by(&:id).each do |id, rules|
+          if rules.size > 1
+            duplicated_ids << id
+          end
+        end
+
+        if duplicated_ids.empty?
+          stdout.puts "  OK!👍"
+          true
+        else
+          stdout.puts(Rainbow("  Found #{duplicated_ids.size} duplications.😞").red)
+          duplicated_ids.each do |id|
+            stdout.puts "    #{id}"
+          end
+          false
+        end
+      end
+
+      def validate_rules
+        test_pass = true
+
+        config.rules.each do |rule|
+          if !rule.passes.empty? || !rule.fails.empty?
+            stdout.puts "Testing rule #{rule.id}..."
+
+            pass_errors = rule.passes.each.with_index.select do |pass, index|
+              rule_matches_example?(rule, pass)
+            end
+
+            fail_errors = rule.fails.each.with_index.reject do |fail, index|
+              rule_matches_example?(rule, fail)
+            end
+
+            unless pass_errors.empty?
+              test_pass = false
+
+              pass_errors.each do |_, index|
+                stdout.puts "  #{(index+1).ordinalize} pass example matched.😱"
+              end
+            end
+
+            unless fail_errors.empty?
+              test_pass = false
+
+              fail_errors.each do |_, index|
+                stdout.puts "  #{(index+1).ordinalize} fail example didn't match.😱"
+              end
+            end
+
+            if pass_errors.empty? && fail_errors.empty?
+              stdout.puts "  OK!🎉"
+            end
+          end
+        end
+
+        test_pass
+      end
+
+      def rule_matches_example?(rule, example)
+        buffer = Buffer.new(path: Pathname("-"), content: example)
+        analyzer = Analyzer.new(rule: rule, buffer: buffer)
+        analyzer.scan.count > 0
+      end
+    end
+  end
+end

data/lib/goodcheck/config.rb

@@ -0,0 +1,28 @@
+module Goodcheck
+  class Config
+    attr_reader :rules
+
+    def initialize(rules:)
+      @rules = rules
+    end
+
+    def rules_for_path(path, rules_filter:, &block)
+      if block_given?
+        rules.map do |rule|
+          if rules_filter.empty? || rules_filter.any? {|filter| /\A#{Regexp.escape(filter)}\.?/ =~ rule.id }
+            if rule.globs.empty?
+              [rule, nil]
+            else
+              glob = rule.globs.find {|glob| path.fnmatch?(glob.pattern, File::FNM_PATHNAME) }
+              if glob
+                [rule, glob]
+              end
+            end
+          end
+        end.compact.each(&block)
+      else
+        enum_for(:rules_for_path, path, rules_filter: rules_filter)
+      end
+    end
+  end
+end

data/lib/goodcheck/config_loader.rb

@@ -0,0 +1,90 @@
+module Goodcheck
+  class ConfigLoader
+    include ArrayHelper
+
+    class InvalidPattern < StandardError; end
+
+    Schema = StrongJSON.new do
+      let :regexp_pattern, object(regexp: string, case_insensitive: boolean?, multiline: boolean?)
+      let :literal_pattern, object(literal: string, case_insensitive: boolean?)
+      let :token_pattern, object(token: string)
+      let :pattern, enum(regexp_pattern, literal_pattern, token_pattern, string)
+
+      let :encoding, enum(*Encoding.name_list.map {|name| literal(name) })
+      let :glob, object(pattern: string, encoding: optional(encoding))
+
+      let :rule, object(
+        id: string,
+        pattern: enum(array(pattern), pattern),
+        message: string,
+        justification: optional(enum(array(string), string)),
+        glob: optional(enum(array(enum(glob, string)), glob, string)),
+        pass: optional(enum(array(string), string)),
+        fail: optional(enum(array(string), string))
+      )
+
+      let :rules, array(rule)
+
+      let :config, object(rules: rules)
+    end
+
+    attr_reader :path
+    attr_reader :content
+
+    def initialize(path:, content:)
+      @path = path
+      @content = content
+    end
+
+    def load
+      Schema.config.coerce(content)
+      rules = content[:rules].map {|hash| load_rule(hash) }
+      Config.new(rules: rules)
+    end
+
+    def load_rule(hash)
+      id = hash[:id]
+      patterns = array(hash[:pattern]).map {|pat| load_pattern(pat) }
+      justifications = array(hash[:justification])
+      globs = load_globs(array(hash[:glob]))
+      message = hash[:message].chomp
+      passes = array(hash[:pass])
+      fails = array(hash[:fail])
+
+      Rule.new(id: id, patterns: patterns, justifications: justifications, globs: globs, message: message, passes: passes, fails: fails)
+    end
+
+    def load_globs(globs)
+      globs.map do |glob|
+        case glob
+        when String
+          Glob.new(pattern: glob, encoding: nil)
+        when Hash
+          Glob.new(pattern: glob[:pattern], encoding: glob[:encoding])
+        end
+      end
+    end
+
+    def load_pattern(pattern)
+      case pattern
+      when String
+        Pattern.literal(pattern, case_insensitive: false)
+      when Hash
+        case
+        when pattern[:literal]
+          ci = pattern[:case_insensitive]
+          literal = pattern[:literal]
+          Pattern.literal(literal, case_insensitive: ci)
+        when pattern[:regexp]
+          regexp = pattern[:regexp]
+          ci = pattern[:case_insensitive]
+          multiline = pattern[:multiline]
+          Pattern.regexp(regexp, case_insensitive: ci, multiline: multiline)
+        when pattern[:token]
+          tok = pattern[:token]
+          Pattern.token(tok)
+        end
+      end
+    end
+  end
+end

data/lib/goodcheck/glob.rb

@@ -0,0 +1,11 @@
+module Goodcheck
+  class Glob
+    attr_reader :pattern
+    attr_reader :encoding
+
+    def initialize(pattern:, encoding:)
+      @pattern = pattern
+      @encoding = encoding
+    end
+  end
+end

data/lib/goodcheck/issue.rb

@@ -0,0 +1,29 @@
+module Goodcheck
+  class Issue
+    attr_reader :buffer
+    attr_reader :range
+    attr_reader :rule
+    attr_reader :text
+
+    def initialize(buffer:, range:, rule:, text:)
+      @buffer = buffer
+      @range = range
+      @rule = rule
+      @text = text
+    end
+
+    def path
+      buffer.path
+    end
+
+    def location
+      unless @location
+        start_line, start_column = buffer.location_for_position(range.begin)
+        end_line, end_column = buffer.location_for_position(range.end)
+        @location = Location.new(start_line: start_line, start_column: start_column, end_line: end_line, end_column: end_column)
+      end
+
+      @location
+    end
+  end
+end

data/lib/goodcheck/location.rb

@@ -0,0 +1,23 @@
+module Goodcheck
+  class Location
+    attr_reader :start_line
+    attr_reader :start_column
+    attr_reader :end_line
+    attr_reader :end_column
+
+    def initialize(start_line:, start_column:, end_line:, end_column:)
+      @start_line = start_line
+      @start_column = start_column
+      @end_line = end_line
+      @end_column = end_column
+    end
+
+    def ==(other)
+      other.is_a?(Location) &&
+        other.start_line == start_line &&
+        other.start_column == start_column &&
+        other.end_line == end_line &&
+        other.end_column == end_column
+    end
+  end
+end

data/lib/goodcheck/matcher.rb

@@ -0,0 +1,21 @@
+module Goodcheck
+  class Matcher
+    attr_reader :path
+    attr_reader :src
+    attr_reader :rule
+
+    def initialize(path:, src:, rule:)
+      @path = path
+      @src = src
+      @rule = rule
+    end
+
+    def each
+      if block_given?
+
+      else
+        enum_for :each
+      end
+    end
+  end
+end