querly 0.16.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c34b195fa9bb5ccf96c35fe740b783b3567c137a664949e65c84b6d7980f1270
-  data.tar.gz: 47a16a78713ababe10ae4ec8f51aed46b5b750288cff22ffbf7114ba980a8d6e
+  metadata.gz: 1a365f3cf29cb25703707662a6102e79eb0b838386d1a792b8522ba4dbd45be6
+  data.tar.gz: 24773a3bf4817d76f29e5c96ab02c39650c29a5dac5e712ae58d821eed1b2906
 SHA512:
-  metadata.gz: d612449bfd38faca312aaec2cd6e8e420ff3ac5ee41fa8d1d84c94b5413e5121b4ff49f559b193c4a23f54e1d70c95f4e36d665c31515093acb297c18cd7eed0
-  data.tar.gz: c61989656fb5d91872f4a684339aa5d3f6b83af89b39d73c8cf0b1422d7f2c1833bb788f0c27bb5f78d5f76eeabd3e455ebcbdd6dcd5339066b0ccb03a844691
+  metadata.gz: 2a40df07387dce70a282203e8e30daf5794f5da9f90ec20dc61516a750b3b72aaf77b605ee85707f9f257f5d955f2cc4815742cde27052f762746601b66d55e5
+  data.tar.gz: 53d33483e9d501d8954ad0640a4990bf919eb6f93452a186cb4e593d22dbbbb101c79a60e5905c281703d4887664e87bec0b3d5d3fc602bfd9607d2bd61d916c

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## master
 
+## 1.0.0 (2019-7-19)
+
+* Add `--config` option for `find` and `console` [#67](https://github.com/soutaro/querly/pull/67)
+* Improve preprocessor performance by processing concurrently [#68](https://github.com/soutaro/querly/pull/68)
+
 ## 0.16.0 (2019-04-23)
 
 * Support string literal pattern (@pocke) [#64](https://github.com/soutaro/querly/pull/64)

data/lib/querly.rb

@@ -5,6 +5,7 @@ require "parser/ruby25"
 require "set"
 require "open3"
 require "active_support/inflector"
+require "parallel"
 
 require "querly/version"
 require 'querly/analyzer'

data/lib/querly/cli.rb

@@ -12,6 +12,7 @@ module Querly
     option :root
     option :format, default: "text", type: :string, enum: %w(text json)
     option :rule, type: :string
+    option :threads, default: Parallel.processor_count, type: :numeric
     def check(*paths)
       require 'querly/cli/formatter'
 
@@ -23,6 +24,8 @@ module Querly
                   end
       formatter.start
 
+      threads = Integer(options[:threads])
+
       begin
         unless config_path.file?
           STDERR.puts <<-Message
@@ -32,20 +35,15 @@ Specify configuration file by --config option.
           exit 1
         end
 
-        root_option = options[:root]
-        root_path = root_option ? Pathname(root_option).realpath : config_path.parent.realpath
-
-        config = begin
-          yaml = YAML.load(config_path.read)
-          Config.load(yaml, config_path: config_path, root_dir: root_path, stderr: STDERR)
+        begin
+          config = config(root_option: options[:root])
         rescue => exn
           formatter.config_error config_path, exn
-          exit 1
         end
 
         analyzer = Analyzer.new(config: config, rule: options[:rule])
 
-        ScriptEnumerator.new(paths: paths.empty? ? [Pathname.pwd] : paths.map {|path| Pathname(path) }, config: config).each do |path, script|
+        ScriptEnumerator.new(paths: paths.empty? ? [Pathname.pwd] : paths.map {|path| Pathname(path) }, config: config, threads: threads).each do |path, script|
           case script
           when Script
             analyzer.scripts << script
@@ -67,6 +65,8 @@ Specify configuration file by --config option.
     end
 
     desc "console [paths]", "Start console for given paths"
+    option :config, default: "querly.yml"
+    option :threads, default: Parallel.processor_count, type: :numeric
     def console(*paths)
       require 'querly/cli/console'
       home_path = if (path = ENV["QUERLY_HOME"])
@@ -75,21 +75,32 @@ Specify configuration file by --config option.
                        Pathname(Dir.home) + ".querly"
                      end
       home_path.mkdir unless home_path.exist?
+      config = config_path.file? ? config(root_option: nil) : nil
+      threads = Integer(options[:threads])
 
       Console.new(
         paths: paths.empty? ? [Pathname.pwd] : paths.map {|path| Pathname(path) },
         history_path: home_path + "history",
-        history_size: ENV["QUERLY_HISTORY_SIZE"]&.to_i || 1_000_000
+        history_size: ENV["QUERLY_HISTORY_SIZE"]&.to_i || 1_000_000,
+        config: config,
+        threads: threads
       ).start
     end
 
     desc "find pattern [paths]", "Find for the pattern in given paths"
+    option :config, default: "querly.yml"
+    option :threads, default: Parallel.processor_count, type: :numeric
     def find(pattern, *paths)
       require 'querly/cli/find'
 
+      config = config_path.file? ? config(root_option: nil) : nil
+      threads = Integer(options[:threads])
+
       Find.new(
         pattern: pattern,
         paths: paths.empty? ? [Pathname.pwd] : paths.map {|path| Pathname(path) },
+        config: config,
+        threads: threads
       ).start
     end
 
@@ -125,6 +136,13 @@ Specify configuration file by --config option.
 
     private
 
+    def config(root_option:)
+      root_path = root_option ? Pathname(root_option).realpath : config_path.parent.realpath
+
+      yaml = YAML.load(config_path.read)
+      Config.load(yaml, config_path: config_path, root_dir: root_path, stderr: STDERR)
+    end
+
     def config_path
       [Pathname(options[:config]),
        Pathname("querly.yaml")].compact.find(&:file?) || Pathname(options[:config])

data/lib/querly/cli/console.rb

@@ -8,13 +8,17 @@ module Querly
       attr_reader :paths
       attr_reader :history_path
       attr_reader :history_size
+      attr_reader :config
       attr_reader :history
+      attr_reader :threads
 
-      def initialize(paths:, history_path:, history_size:)
+      def initialize(paths:, history_path:, history_size:, config: nil, threads:)
         @paths = paths
         @history_path = history_path
         @history_size = history_size
+        @config = config
         @history = []
+        @threads = threads
       end
 
       def start
@@ -42,9 +46,9 @@ Querly #{VERSION}, interactive console
       def analyzer
         return @analyzer if @analyzer
 
-        @analyzer = Analyzer.new(config: nil, rule: nil)
+        @analyzer = Analyzer.new(config: config, rule: nil)
 
-        ScriptEnumerator.new(paths: paths, config: nil).each do |path, script|
+        ScriptEnumerator.new(paths: paths, config: config, threads: threads).each do |path, script|
           case script
           when Script
             @analyzer.scripts << script

data/lib/querly/cli/find.rb

@@ -7,10 +7,14 @@ module Querly
 
       attr_reader :pattern_str
       attr_reader :paths
+      attr_reader :config
+      attr_reader :threads
 
-      def initialize(pattern:, paths:)
+      def initialize(pattern:, paths:, config: nil, threads:)
         @pattern_str = pattern
         @paths = paths
+        @config = config
+        @threads = threads
       end
 
       def start
@@ -36,7 +40,7 @@ module Querly
         puts "#{count} results"
       rescue => exn
         STDOUT.puts Rainbow("Error: #{exn}").red
-        STDTOU.puts "pattern: #{pattern_str}"
+        STDOUT.puts "pattern: #{pattern_str}"
         STDOUT.puts "Backtrace:"
         STDOUT.puts format_backtrace(exn.backtrace)
       end
@@ -48,9 +52,9 @@ module Querly
       def analyzer
         return @analyzer if @analyzer
 
-        @analyzer = Analyzer.new(config: nil, rule: nil)
+        @analyzer = Analyzer.new(config: config, rule: nil)
 
-        ScriptEnumerator.new(paths: paths, config: nil).each do |path, script|
+        ScriptEnumerator.new(paths: paths, config: config, threads: threads).each do |path, script|
           case script
           when Script
             @analyzer.scripts << script

data/lib/querly/script_enumerator.rb

@@ -2,23 +2,36 @@ module Querly
   class ScriptEnumerator
     attr_reader :paths
     attr_reader :config
+    attr_reader :threads
 
-    def initialize(paths:, config:)
+    def initialize(paths:, config:, threads:)
       @paths = paths
       @config = config
+      @threads = threads
     end
 
+    # Yields `Script` object concurrently, in different threads.
     def each(&block)
+      if block_given?
+        Parallel.each(each_path, in_threads: threads) do |path|
+          load_script_from_path path, &block
+        end
+      else
+        self.enum_for :each
+      end
+    end
+
+    def each_path(&block)
       if block_given?
         paths.each do |path|
           if path.directory?
             enumerate_files_in_dir(path, &block)
           else
-            load_script_from_path path, &block
+            yield path
           end
         end
       else
-        self.enum_for :each
+        enum_for :each_path
       end
     end
 
@@ -89,7 +102,7 @@ module Querly
                              preprocessors.key?(path.extname)
                            end
 
-        load_script_from_path(path, &block) if should_load_file
+        yield path if should_load_file
       end
     end
   end

data/lib/querly/version.rb

@@ -1,3 +1,3 @@
 module Querly
-  VERSION = "0.16.0"
+  VERSION = "1.0.0"
 end

data/querly.gemspec

@@ -35,4 +35,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "parser", ">= 2.5.0"
   spec.add_dependency "rainbow", ">= 2.1"
   spec.add_dependency "activesupport", ">= 5.0"
+  spec.add_dependency "parallel", "~>1.17"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: querly
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-23 00:00:00.000000000 Z
+date: 2019-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -184,6 +184,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
 description: Querly is a query language and tool to find out method calls from Ruby
   programs. Define rules to check your program with patterns to find out *bad* pieces.
   Querly finds out matching pieces from your program.