querly 0.1.0

data/lib/querly/pattern/kind.rb

@@ -0,0 +1,78 @@
+module Querly
+  module Pattern
+    module Kind
+      class Base
+        attr_reader :expr
+
+        def initialize(expr:)
+          @expr = expr
+        end
+      end
+
+      module Negatable
+        attr_reader :negated
+
+        def initialize(expr:, negated:)
+          @negated = negated
+          super(expr: expr)
+        end
+      end
+
+      class Any < Base
+        def test_kind(pair)
+          true
+        end
+      end
+
+      class Conditional < Base
+        include Negatable
+
+        def test_kind(pair)
+          !negated == !!conditional?(pair)
+        end
+
+        def conditional?(pair)
+          node = pair.node
+          parent = pair.parent&.node
+
+          case parent&.type
+          when :if
+            node.equal? parent.children.first
+          when :while
+            node.equal? parent.children.first
+          when :and
+            node.equal? parent.children.first
+          when :or
+            node.equal? parent.children.first
+          else
+            false
+          end
+        end
+      end
+
+      class Discarded < Base
+        include Negatable
+
+        def test_kind(pair)
+          !negated == !!discarded?(pair)
+        end
+
+        def discarded?(pair)
+          node = pair.node
+          parent = pair.parent&.node
+
+          case parent&.type
+          when :begin
+            if node.equal? parent.children.last
+              discarded? pair.parent
+            else
+              true
+            end
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/querly/pattern/parser.y

@@ -0,0 +1,169 @@
+class Querly::Pattern::Parser
+prechigh
+  nonassoc EXCLAMATION
+  nonassoc LPAREN
+  left DOT
+preclow
+
+rule
+
+target: kinded_expr
+
+kinded_expr: expr { result = Kind::Any.new(expr: val[0]) }
+  | expr CONDITIONAL_KIND { result = Kind::Conditional.new(expr: val[0], negated: val[1]) }
+  | expr DISCARDED_KIND { result = Kind::Discarded.new(expr: val[0], negated: val[1]) }
+
+expr: constant { result = Expr::Constant.new(path: val[0]) }
+  | send
+  | EXCLAMATION expr { result = Expr::Not.new(pattern: val[1]) }
+  | BOOL { result = Expr::Literal.new(type: :bool, value: val[0]) }
+  | STRING { result = Expr::Literal.new(type: :string, value: val[0]) }
+  | INT { result = Expr::Literal.new(type: :int, value: val[0]) }
+  | FLOAT { result = Expr::Literal.new(type: :float, value: val[0]) }
+  | SYMBOL { result = Expr::Literal.new(type: :symbol, value: val[0]) }
+  | NUMBER { result = Expr::Literal.new(type: :number, value: val[0]) }
+  | DSTR { result = Expr::Dstr.new() }
+  | UNDERBAR { result = Expr::Any.new }
+  | NIL { result = Expr::Nil.new }
+  | LPAREN expr RPAREN { result = val[1] }
+  | IVAR { result = Expr::Ivar.new(name: val[0]) }
+
+args:  { result = nil }
+  | expr { result = Argument::Expr.new(expr: val[0], tail: nil)}
+  | expr COMMA args { result = Argument::Expr.new(expr: val[0], tail: val[2]) }
+  | AMP expr { result = Argument::BlockPass.new(expr: val[1]) }
+  | kw_args
+  | DOTDOTDOT { result = Argument::AnySeq.new }
+  | DOTDOTDOT COMMA kw_args { result = Argument::AnySeq.new(tail: val[2]) }
+
+kw_args: { result = nil }
+  | AMP expr { result = Argument::BlockPass.new(expr: val[1]) }
+  | DOTDOTDOT { result = Argument::AnySeq.new }
+  | key_value { result = Argument::KeyValue.new(key: val[0][:key],
+                                                value: val[0][:value],
+                                                tail: nil,
+                                                negated: val[0][:negated]) }
+  | key_value COMMA kw_args { result = Argument::KeyValue.new(key: val[0][:key],
+                                                              value: val[0][:value],
+                                                              tail: val[2],
+                                                              negated: val[0][:negated]) }
+
+key_value: keyword COLON expr { result = { key: val[0], value: val[2], negated: false } }
+  | EXCLAMATION keyword COLON expr { result = { key: val[1], value: val[3], negated: true } }
+
+method_name: METHOD
+  | EXCLAMATION
+
+method_name_or_ident: method_name
+  | LIDENT
+  | UIDENT
+
+keyword: LIDENT | UIDENT
+
+constant: UIDENT { result = [val[0]] }
+  | UIDENT COLONCOLON constant { result = [val[0]] + val[2] }
+
+send: LIDENT { result = Expr::Vcall.new(name: val[0]) }
+  | method_name { result = Expr::Send.new(receiver: Expr::Any.new, name: val[0]) }
+  | method_name_or_ident LPAREN args RPAREN { result = Expr::Send.new(receiver: Expr::Any.new,
+                                                             name: val[0],
+                                                             args: val[2]) }
+  | expr DOT method_name_or_ident { result = Expr::Send.new(receiver: val[0], name: val[2], args: Argument::AnySeq.new) }
+  | expr DOT method_name_or_ident LPAREN args RPAREN { result = Expr::Send.new(receiver: val[0],
+                                                                      name: val[2],
+                                                                      args: val[4]) }
+
+end
+
+---- inner
+
+require "strscan"
+
+attr_reader :input
+
+def initialize(input)
+  super()
+  @input = StringScanner.new(input)
+end
+
+def self.parse(str)
+  self.new(str).do_parse
+end
+
+def next_token
+  input.scan(/\s+/)
+
+  case
+  when input.eos?
+    [false, false]
+  when input.scan(/true/)
+    [:BOOL, true]
+  when input.scan(/false/)
+    [:BOOL, false]
+  when input.scan(/nil/)
+    [:NIL, false]
+  when input.scan(/:string:/)
+    [:STRING, nil]
+  when input.scan(/:dstr:/)
+    [:DSTR, nil]
+  when input.scan(/:int:/)
+    [:INT, nil]
+  when input.scan(/:float:/)
+    [:FLOAT, nil]
+  when input.scan(/:bool:/)
+    [:BOOL, nil]
+  when input.scan(/:symbol:/)
+    [:SYMBOL, nil]
+  when input.scan(/:number:/)
+    [:NUMBER, nil]
+  when input.scan(/:\w+/)
+    s = input.matched
+    [:SYMBOL, s[1, s.size - 1].to_sym]
+  when input.scan(/[+-]?[0-9]+\.[0-9]/)
+    [:FLOAT, input.matched.to_f]
+  when input.scan(/[+-]?[0-9]+/)
+    [:INT, input.matched.to_i]
+  when input.scan(/\_/)
+    [:UNDERBAR, input.matched]
+  when input.scan(/[A-Z]\w*/)
+    [:UIDENT, input.matched.to_sym]
+  when input.scan(/[a-z_](\w)*(\?|\!|=)?/)
+    [:LIDENT, input.matched.to_sym]
+  when input.scan(/\(/)
+    [:LPAREN, input.matched]
+  when input.scan(/\)/)
+    [:RPAREN, input.matched]
+  when input.scan(/\.\.\./)
+    [:DOTDOTDOT, input.matched]
+  when input.scan(/\,/)
+    [:COMMA, input.matched]
+  when input.scan(/\./)
+    [:DOT, input.matched]
+  when input.scan(/\!/)
+    [:EXCLAMATION, input.matched.to_sym]
+  when input.scan(/\[conditional\]/)
+    [:CONDITIONAL_KIND, false]
+  when input.scan(/\[!conditional\]/)
+    [:CONDITIONAL_KIND, true]
+  when input.scan(/\[discarded\]/)
+    [:DISCARDED_KIND, false]
+  when input.scan(/\[!discarded\]/)
+    [:DISCARDED_KIND, true]
+  when input.scan(/\[\]=/)
+    [:METHOD, :"[]="]
+  when input.scan(/\[\]/)
+    [:METHOD, :"[]"]
+  when input.scan(/::/)
+    [:COLONCOLON, input.matched]
+  when input.scan(/:/)
+    [:COLON, input.matched]
+  when input.scan(/\*/)
+    [:STAR, "*"]
+  when input.scan(/@\w+/)
+    [:IVAR, input.matched.to_sym]
+  when input.scan(/@/)
+    [:IVAR, nil]
+  when input.scan(/&/)
+    [:AMP, nil]
+  end
+end

data/lib/querly/preprocessor.rb

@@ -0,0 +1,27 @@
+module Querly
+  class Preprocessor
+    class Error < StandardError
+      attr_reader :command
+      attr_reader :status
+
+      def initialize(command:, status:)
+        @command = command
+        @status = status
+      end
+    end
+
+    attr_reader :ext
+    attr_reader :command
+
+    def initialize(ext:, command:)
+      @ext = ext
+      @command = command
+    end
+
+    def run!(source_code)
+      output, status = Open3.capture2({ 'RUBYOPT' => nil }, command, stdin_data: source_code)
+      raise Error.new(status: status, command: command) unless status.success?
+      output
+    end
+  end
+end

data/lib/querly/rule.rb

@@ -0,0 +1,26 @@
+module Querly
+  class Rule
+    attr_reader :id
+    attr_reader :patterns
+
+    attr_reader :messages
+    attr_reader :justifications
+    attr_reader :before_examples
+    attr_reader :after_examples
+    attr_reader :tags
+    attr_reader :scope
+
+    def initialize(id:, scope: :nil)
+      @id = id
+      @scope = scope
+
+      @patterns = []
+      @messages = []
+      @justifications = []
+      @before_examples = []
+      @after_examples = []
+      @tags = Set.new
+      @scope = scope
+    end
+  end
+end

data/lib/querly/script.rb

@@ -0,0 +1,15 @@
+module Querly
+  class Script
+    attr_reader :path
+    attr_reader :node
+
+    def initialize(path:, node:)
+      @path = path
+      @node = node
+    end
+
+    def root_pair
+      NodePair.new(node: node)
+    end
+  end
+end

data/lib/querly/script_enumerator.rb

@@ -0,0 +1,84 @@
+module Querly
+  class ScriptEnumerator
+    attr_reader :paths
+    attr_reader :preprocessors
+
+    def initialize(paths:, preprocessors: {})
+      @paths = paths
+      @preprocessors = preprocessors
+    end
+
+    def each(&block)
+      if block_given?
+        paths.each do |path|
+          case
+          when path.file?
+            load_script_from_path path, &block
+          when path.directory?
+            enumerate_files_in_dir(path, &block)
+          end
+        end
+      else
+        self.enum_for :each
+      end
+    end
+
+    @loaders = []
+
+    def self.register_loader(pattern, loader)
+      @loaders << [pattern, loader]
+    end
+
+    def self.find_loader(path)
+      basename = path.basename.to_s
+      @loaders.find {|pair| pair.first === basename }&.last
+    end
+
+    private
+
+    def load_script_from_path(path, &block)
+      preprocessor = preprocessors[path.extname]
+
+      begin
+        source = if preprocessor
+                   preprocessor.run!(path.read)
+                 else
+                   path.read
+                 end
+
+        script = Script.new(path: path, node: Parser::CurrentRuby.parse(source, path.to_s))
+      rescue StandardError, LoadError, Preprocessor::Error => exn
+        script = exn
+      end
+
+      yield(path, script)
+    end
+
+    def enumerate_files_in_dir(path, &block)
+      if path.basename.to_s =~ /\A\.[^\.]+/
+        # skip hidden paths
+        return
+      end
+
+      case
+      when path.directory?
+        path.children.each do |child|
+          enumerate_files_in_dir child, &block
+        end
+      when path.file?
+        should_load_file = case
+                           when path.extname == ".rb"
+                             true
+                           when path.extname == ".gemspec"
+                             true
+                           when path.basename.to_s == "Rakefile"
+                             true
+                           else
+                             preprocessors.key?(path.extname)
+                           end
+
+        load_script_from_path(path, &block) if should_load_file
+      end
+    end
+  end
+end

data/lib/querly/tagging.rb

@@ -0,0 +1,32 @@
+module Querly
+  class Tagging
+    attr_reader :path_pattern
+    attr_reader :tags_set
+
+    def initialize(path_pattern:, tags_set:)
+      @path_pattern = path_pattern
+      @tags_set = tags_set
+    end
+
+    def applicable?(script)
+      return true unless path_pattern
+
+      pattern_components = path_pattern.split('/')
+
+      script_path = if script.path.absolute?
+                      script.path
+                    else
+                      script.path.realpath
+                    end
+      path_components = script_path.to_s.split(File::Separator)
+
+      path_components.each_cons(pattern_components.size) do |slice|
+        if slice == pattern_components
+          return true
+        end
+      end
+
+      false
+    end
+  end
+end

data/lib/querly/version.rb

@@ -0,0 +1,3 @@
+module Querly
+  VERSION = "0.1.0"
+end

data/querly.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'querly/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "querly"
+  spec.version       = Querly::VERSION
+  spec.authors       = ["Soutaro Matsumoto"]
+  spec.email         = ["matsumoto@soutaro.com"]
+
+  spec.summary       = %q{Query Method Calls from Ruby Programs}
+  spec.description   = %q{Querly is a query language and tool to find out method calls from Ruby programs. You write simple query, and Querly finds out wrong pieces in your program.}
+  spec.homepage      = "https://github.com/soutaro/querly"
+
+  spec.files         = `git ls-files -z`
+    .split("\x0")
+    .reject { |f| f.match(%r{^(test|spec|features)/}) }
+    .push('lib/querly/pattern/parser.rb')
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "racc", "= 1.4.14"
+
+  spec.add_dependency 'thor', "~> 0.19"
+  spec.add_dependency "parser", "~> 2.3.1"
+  spec.add_dependency "rainbow", "~> 2.1"
+end