querly 0.1.0

data/lib/querly/cli/formatter.rb

@@ -0,0 +1,143 @@
+module Querly
+  class CLI
+    module Formatter
+      class Base
+        # Called when analyzer started
+        def start; end
+
+        # Called when config is successfully loaded
+        def config_load(config); end
+
+        # Called when failed to load config
+        # Exit(status == 0) after the call
+        def config_error(path, error); end
+
+        # Called when script is successfully loaded
+        def script_load(script); end
+
+        # Called when failed to load script
+        # Continue after the call
+        def script_error(path, error); end
+
+        # Called when issue is found
+        def issue_found(script, rule, pair); end
+
+        # Called on other error
+        # Abort(status != 0) after the call
+        def fatal_error(error)
+          STDERR.puts Rainbow("Fatal error: #{error}").red
+          STDERR.puts error.backtrace.inspect
+        end
+
+        # Called on exit/abort
+        def finish; end
+      end
+
+      class Text < Base
+        def config_error(path, error)
+          STDERR.puts Rainbow("Failed to load configuration: #{path}").red
+          STDERR.puts error
+          STDERR.puts error.backtrace.inspect
+        end
+
+        def script_error(path, error)
+          STDERR.puts Rainbow("Failed to load script: #{path}").red
+          STDERR.puts error.inspect
+        end
+
+        def issue_found(script, rule, pair)
+          path = script.path.to_s
+          src = Rainbow(pair.node.loc.expression.source.split(/\n/).first).red
+          line = pair.node.loc.first_line
+          col = pair.node.loc.column
+          message = rule.messages.first.split(/\n/).first
+
+          STDOUT.puts "#{path}:#{line}:#{col}\t#{src}\t#{message}"
+        end
+      end
+
+      class JSON < Base
+        def initialize
+          @issues = []
+          @script_errors = []
+          @config_errors = []
+          @fatal = nil
+        end
+
+        def config_error(path, error)
+          @config_errors << [path, error]
+        end
+
+        def script_error(path, error)
+          @script_errors << [path, error]
+        end
+
+        def issue_found(script, rule, pair)
+          @issues << [script, rule, pair]
+        end
+
+        def finish
+          STDOUT.print as_json.to_json
+        end
+
+        def fatal_error(error)
+          super
+          @fatal = error
+        end
+
+        def as_json
+          case
+          when @fatal
+            # Fatal error found
+            {
+              fatal_error: {
+                message: @fatal.inspect,
+                backtrace: @fatal.backtrace
+              }
+            }
+          when !@config_errors.empty?
+            # Error found during config load
+            {
+              config_errors: @config_errors.map {|(path, error)|
+                {
+                  path: path.to_s,
+                  error: {
+                    message: error.inspect,
+                    backtrace: error.backtrace
+                  }
+                }
+              }
+            }
+          else
+            # Successfully checked
+            {
+              issues: @issues.map {|(script, rule, pair)|
+                {
+                  script: script.path.to_s,
+                  rule: {
+                    id: rule.id,
+                    messages: rule.messages,
+                    justifications: rule.justifications,
+                  },
+                  location: {
+                    start: [pair.node.loc.first_line, pair.node.loc.column],
+                    end: [pair.node.loc.last_line, pair.node.loc.last_column]
+                  }
+                }
+              },
+              errors: @script_errors.map {|path, error|
+                {
+                  path: path.to_s,
+                  error: {
+                    message: error.inspect,
+                    backtrace: error.backtrace
+                  }
+                }
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/querly/cli/test.rb

@@ -0,0 +1,118 @@
+module Querly
+  class CLI
+    class Test
+      attr_reader :config_path
+      attr_reader :stdout
+      attr_reader :stderr
+
+      def initialize(config_path:, stdout: STDOUT, stderr: STDERR)
+        @config_path = config_path
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def run
+        config = load_config
+
+        unless config
+          stdout.puts "There is nothing to test at #{config_path} ..."
+          stdout.puts "Make a configuration and run test again!"
+          return
+        end
+
+        validate_rule_uniqueness(config.rules)
+        validate_rule_patterns(config.rules)
+      rescue => exn
+        stderr.puts Rainbow("Fatal error:").red
+        stderr.puts exn.inspect
+        stderr.puts exn.backtrace.map {|x| "  " + x }.join("\n")
+      end
+
+      def validate_rule_uniqueness(rules)
+        ids = Set.new
+
+        stdout.puts "Checking rule id uniqueness..."
+
+        duplications = 0
+
+        rules.each do |rule|
+          unless ids.add?(rule.id)
+            stdout.puts Rainbow("  Rule id #{rule.id} duplicated!").red
+            duplications += 1
+          end
+        end
+      end
+
+      def validate_rule_patterns(rules)
+        stdout.puts "Checking rule patterns..."
+
+        tests = 0
+        false_positives = 0
+        false_negatives = 0
+        errors = 0
+
+        rules.each do |rule|
+          rule.before_examples.each.with_index do |example, example_index|
+            tests += 1
+
+            begin
+              unless rule.patterns.any? {|pat| test_pattern(pat, example, expected: true) }
+                stdout.puts(Rainbow("  #{rule.id}").red + ":\t#{example_index}th *before* example didn't match with any pattern")
+                false_negatives += 1
+              end
+            rescue Parser::SyntaxError
+              errors += 1
+              stdout.puts(Rainbow("  #{rule.id}").red + ":\tParsing failed for #{example_index}th *before* example")
+            end
+          end
+
+          rule.after_examples.each.with_index do |example, example_index|
+            tests += 1
+
+            begin
+              unless rule.patterns.all? {|pat| test_pattern(pat, example, expected: false) }
+                stdout.puts(Rainbow("  #{rule.id}").red + ":\t#{example_index}th *after* example matched with some of patterns")
+                false_positives += 1
+              end
+            rescue Parser::SyntaxError
+              errors += 1
+              stdout.puts(Rainbow("  #{rule.id}") + ":\tParsing failed for #{example_index}th *after* example")
+            end
+          end
+        end
+
+        stdout.puts "Tested #{rules.size} rules with #{tests} tests."
+        if false_positives > 0 || false_negatives > 0 || errors > 0
+          stdout.puts "  #{false_positives} examples found which should not match, but matched"
+          stdout.puts "  #{false_negatives} examples found which should match, but didn't"
+          stdout.puts "  #{errors} examples raised error"
+        else
+          stdout.puts Rainbow("  All tests green!").green
+        end
+      end
+
+      def test_pattern(pattern, example, expected:)
+        analyzer = Analyzer.new(taggings: [])
+
+        found = false
+
+        node = Parser::CurrentRuby.parse(example)
+        analyzer.each_subnode NodePair.new(node: node) do |pair|
+          if analyzer.test_pair(pair, pattern)
+            found = true
+          end
+        end
+
+        found == expected
+      end
+
+      def load_config
+        if config_path.file?
+          config = Config.new
+          config.add_file config_path
+          config
+        end
+      end
+    end
+  end
+end

data/lib/querly/config.rb

@@ -0,0 +1,56 @@
+module Querly
+  class Config
+    attr_reader :rules
+    attr_reader :paths
+    attr_reader :taggings
+    attr_reader :preprocessors
+
+    def initialize()
+      @rules = []
+      @paths = []
+      @taggings = []
+      @preprocessors = {}
+    end
+
+    def add_file(path)
+      paths << path
+
+      content = YAML.load(path.read)
+      load_rules(content)
+      load_taggings(content)
+      load_preprocessors(content["preprocessor"] || {})
+    end
+
+    def load_rules(yaml)
+      yaml["rules"].each do |hash|
+        id = hash["id"]
+        patterns = Array(hash["pattern"]).map {|src| Pattern::Parser.parse(src) }
+        messages = Array(hash["message"])
+        justifications = Array(hash["justification"])
+
+        rule = Rule.new(id: id)
+        rule.patterns.concat patterns
+        rule.messages.concat messages
+        rule.justifications.concat justifications
+        Array(hash["tags"]).each {|tag| rule.tags << tag }
+        rule.before_examples.concat Array(hash["before"])
+        rule.after_examples.concat Array(hash["after"])
+
+        rules << rule
+      end
+    end
+
+    def load_taggings(yaml)
+      @taggings = Array(yaml["tagging"]).map {|hash|
+        Tagging.new(path_pattern: hash["path"],
+                    tags_set: Array(hash["tags"]).map {|string| Set.new(string.split) })
+      }.sort_by {|tagging| -tagging.path_pattern.size }
+    end
+
+    def load_preprocessors(preprocessors)
+      @preprocessors = preprocessors.each.with_object({}) do |(key, value), hash|
+        hash[key] = Preprocessor.new(ext: key, command: value)
+      end
+    end
+  end
+end

data/lib/querly/node_pair.rb

@@ -0,0 +1,21 @@
+module Querly
+  class NodePair
+    attr_reader :node
+    attr_reader :parent
+
+    def initialize(node:, parent: nil)
+      @node = node
+      @parent = parent
+    end
+
+    def children
+      node.children.flat_map do |child|
+        if child.is_a?(Parser::AST::Node)
+          self.class.new(node: child, parent: self)
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/querly/pattern/argument.rb

@@ -0,0 +1,61 @@
+module Querly
+  module Pattern
+    module Argument
+      class Base
+        attr_reader :tail
+
+        def initialize(tail:)
+          @tail = tail
+        end
+
+        def ==(other)
+          other.class == self.class && other.attributes == attributes
+        end
+
+        def attributes
+          instance_variables.each.with_object({}) do |name, hash|
+            hash[name] = instance_variable_get(name)
+          end
+        end
+      end
+
+      class AnySeq < Base
+        def initialize(tail: nil)
+          super(tail: tail)
+        end
+      end
+
+      class Expr < Base
+        attr_reader :expr
+
+        def initialize(expr:, tail:)
+          @expr = expr
+          super(tail: tail)
+        end
+      end
+
+      class KeyValue < Base
+        attr_reader :key
+        attr_reader :value
+        attr_reader :negated
+
+        def initialize(key:, value:, tail:, negated: false)
+          @key = key
+          @value = value
+          @negated = negated
+
+          super(tail: tail)
+        end
+      end
+
+      class BlockPass < Base
+        attr_reader :expr
+
+        def initialize(expr:)
+          @expr = expr
+          super(tail: nil)
+        end
+      end
+    end
+  end
+end

data/lib/querly/pattern/expr.rb

@@ -0,0 +1,301 @@
+module Querly
+  module Pattern
+    module Expr
+      class Base
+        def =~(pair)
+          test_node(pair.node)
+        end
+
+        def test_node(node)
+          false
+        end
+
+        def ==(other)
+          other.class == self.class && other.attributes == attributes
+        end
+
+        def attributes
+          instance_variables.each.with_object({}) do |name, hash|
+            hash[name] = instance_variable_get(name)
+          end
+        end
+      end
+
+      class Any < Base
+        def test_node(node)
+          true
+        end
+      end
+
+      class Not < Base
+        attr_reader :pattern
+
+        def initialize(pattern:)
+          @pattern = pattern
+        end
+
+        def test_node(node)
+          !pattern.test_node(node)
+        end
+      end
+
+      class Constant < Base
+        attr_reader :path
+
+        def initialize(path:)
+          @path = path
+        end
+
+        def test_node(node)
+          if path
+            test_constant node, path
+          else
+            node&.type == :const
+          end
+        end
+
+        def test_constant(node, path)
+          if node
+            case node.type
+            when :const
+              parent = node.children[0]
+              name = node.children[1]
+
+              if name == path.last
+                path.count == 1 || test_constant(parent, path.take(path.count - 1))
+              end
+            when :cbase
+              path.empty?
+            end
+          else
+            path.empty?
+          end
+        end
+      end
+
+      class Nil < Base
+        def test_node(node)
+          node&.type == :nil
+        end
+      end
+
+      class Literal < Base
+        attr_reader :type
+        attr_reader :value
+
+        def initialize(type:, value: nil)
+          @type = type
+          @value = value
+        end
+
+        def test_node(node)
+          case node&.type
+          when :int
+            return false unless type == :int || type == :number
+            if value
+              value == node.children.first
+            else
+              true
+            end
+
+          when :float
+            return false unless type == :float || type == :number
+            if value
+              value == node.children.first
+            else
+              true
+            end
+
+          when :true
+            type == :bool && (value == nil || value == true)
+
+          when :false
+            type == :bool && (value == nil || value == false)
+
+          when :str
+            return false unless type == :string
+            if value
+              value == node.children.first
+            else
+              true
+            end
+
+          when :sym
+            return false unless type == :symbol
+            if value
+              value == node.children.first
+            else
+              true
+            end
+
+          end
+        end
+      end
+
+      class Send < Base
+        attr_reader :name
+        attr_reader :receiver
+        attr_reader :args
+
+        def initialize(receiver:, name:, args: Argument::AnySeq.new)
+          @name = name
+          @receiver = receiver
+          @args = args
+        end
+
+        def =~(pair)
+          # Skip send node with block
+          if pair.node.type == :send && pair.parent
+            if pair.parent.node.type == :block
+              if pair.parent.node.children.first == pair.node
+                return false
+              end
+            end
+          end
+
+          test_node pair.node
+        end
+
+        def test_node(node)
+          node = node.children.first if node&.type == :block
+
+          case node&.type
+          when :send
+            return false unless name == node.children[1]
+            return false unless receiver.test_node(node.children[0])
+            return false unless test_args(node.children.drop(2), args)
+            true
+          end
+        end
+
+        def test_args(nodes, args)
+          first_node = nodes.first
+
+          case args
+          when Argument::AnySeq
+            if args.tail && first_node
+              case
+              when nodes.last.type == :kwsplat
+                true
+              when nodes.last.type == :hash && args.tail.is_a?(Argument::KeyValue)
+                hash = hash_node_to_hash(nodes.last)
+                test_hash_args(hash, args.tail)
+              else
+                true
+              end
+            else
+              true
+            end
+          when Argument::Expr
+            if first_node
+              args.expr.test_node(nodes.first) && test_args(nodes.drop(1), args.tail)
+            end
+          when Argument::KeyValue
+            if first_node
+              types = nodes.map(&:type)
+              if types == [:hash]
+                hash = hash_node_to_hash(nodes.first)
+                test_hash_args(hash, args)
+              elsif types == [:hash, :kwsplat]
+                true
+              else
+                args.negated
+              end
+            else
+              test_hash_args({}, args)
+            end
+          when Argument::BlockPass
+            first_node&.type == :block_pass && args.expr.test_node(first_node.children.first)
+          when nil
+            nodes.empty?
+          end
+        end
+
+        def hash_node_to_hash(node)
+          node.children.each.with_object({}) do |pair, h|
+            key = pair.children[0]
+            value = pair.children[1]
+
+            if key.type == :sym
+              h[key.children[0]] = value
+            end
+          end
+        end
+
+        def test_hash_args(hash, args)
+          while args
+            if args.is_a?(Argument::KeyValue)
+              node = hash[args.key]
+
+              if !args.negated == !!(node && args.value.test_node(node))
+                hash.delete args.key
+              else
+                return false
+              end
+            else
+              break
+            end
+
+            args = args.tail
+          end
+
+          args.is_a?(Argument::AnySeq) || hash.empty?
+        end
+      end
+
+      class Vcall < Base
+        attr_reader :name
+
+        def initialize(name:)
+          @name = name
+        end
+
+        def =~(pair)
+          node = pair.node
+
+          if node.type == :lvar
+            # We don't want lvar without method call
+            # Skips when the node is not receiver of :send
+            parent_node = pair.parent&.node
+            if parent_node && parent_node.type == :send && parent_node.children.first.equal?(node)
+              test_node(node)
+            end
+          else
+            test_node(node)
+          end
+        end
+
+        def test_node(node)
+          case node&.type
+          when :send
+            node.children[1] == name
+          when :lvar
+            node.children.first == name
+          when :self
+            name == :self
+          end
+        end
+      end
+
+      class Dstr < Base
+        def test_node(node)
+          node&.type == :dstr
+        end
+      end
+
+      class Ivar < Base
+        attr_reader :name
+
+        def initialize(name:)
+          @name = name
+        end
+
+        def test_node(node)
+          if node&.type == :ivar
+            name.nil? || node.children.first == name
+          end
+        end
+      end
+    end
+  end
+end