arg_scanner 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a5018e4c54e0aac945b4eb3d1d19c0915109516
-  data.tar.gz: 97a6c8b858413da9a447a4d34d7310ad9ab97f3b
+  metadata.gz: d7016d5a2dddb4f8fd0be218fa11d5e1b65addeb
+  data.tar.gz: c7b233ada70e04c77b73f4b179cda89815f6f16b
 SHA512:
-  metadata.gz: d2b050da192b7def101aea6f66c8ac2fa6cb5e507fe01579bc96bcb129a64e04b8c272fcf1057b197aa53016b1527b2a10f32b5525573488e7ef92bf7d14b2f3
-  data.tar.gz: 55d111320901c78a7a64a71c39c2ba2a991543db1993a5b6b795fd8adf2900202fd9297465829c82ec2b0ae559c9b21f9abca935a9d0992dd8cf580eca250882
+  metadata.gz: c049b2d855fc27e37ff6feb1edad6713644d3955ce6780dc2b052ace6eea1c9afe2b010441106d437a568a52acb7ead358d0565648c85bb5def13ce67e82bf6a
+  data.tar.gz: bd3b07970807bff87c370be1fbc14acd9042a2e42090769056e6f7782ef0c02dc36f13375f5284350534bbfa6234f61871bb12643c4a9c9e71c57e3c0772de56

data/README.md

@@ -1,4 +1,4 @@
-# ArgScanner
+# ArgScanner [![Gem Version](https://badge.fury.io/rb/arg_scanner.svg)](https://badge.fury.io/rb/arg_scanner)
 
 `arg_scanner` is a gem with the purpose to track all method calls and
 deliver the following information:

data/arg_scanner.gemspec

@@ -6,8 +6,8 @@ require 'arg_scanner/version'
 Gem::Specification.new do |spec|
   spec.name = "arg_scanner"
   spec.version = ArgScanner::VERSION
-  spec.authors = ["Nickolay Viuginov", "Valentin Fondaratov"]
-  spec.email = ["viuginov.nickolay@gmail.com", "fondarat@gmail.com"]
+  spec.authors = ["Nickolay Viuginov", "Valentin Fondaratov", "Vladimir Koshelev"]
+  spec.email = ["viuginov.nickolay@gmail.com", "fondarat@gmail.com", "vkkoshelev@gmail.com"]
 
   spec.summary = %q{Program execution tracker to retrieve data types information}
   spec.homepage = "https://github.com/jetbrains/ruby-type-inference"
@@ -33,5 +33,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rake-compiler"
-  spec.add_development_dependency "debase-ruby_core_source", "~> 0.9.6"
+  spec.add_development_dependency "debase-ruby_core_source", ">= 0.10.0"
 end

data/bin/arg-scanner

@@ -2,10 +2,12 @@
 
 require 'optparse'
 require 'arg_scanner/options'
+require 'arg_scanner/version'
 
 options = ArgScanner::OPTIONS
 option_parser = OptionParser.new do |opts|
-  opts.banner = <<~EOB
+  opts.banner = "arg-scanner #{ArgScanner::VERSION}" + <<~EOB
+  
     Usage: arg-scanner [OPTIONS] <ruby cmdline> 
     arg-scanner is a ruby script mediator supposed to be run from the command line or IDE.
         The data will be sent to a signature server so it must be running during arg-scanner execution.
@@ -22,6 +24,30 @@ option_parser = OptionParser.new do |opts|
   opts.on("--no-local", "local source treatment: ignore, do not send data from local sources") do
     options.no_local = true
   end
+  opts.on("--type-tracker", "enable type tracker") do
+    options.enable_type_tracker = true
+  end
+  opts.on("--state-tracker", "enable state tracker") do
+    options.enable_state_tracker = true
+  end
+  opts.on("--return-type-tracker", "enable return type tracker") do
+    options.enable_return_type_tracker = true
+  end
+
+  opts.on("--no-type-tracker", "disable type tracker") do
+    options.enable_type_tracker = false
+  end
+  opts.on("--no-state-tracker", "disable state tracker") do
+    options.enable_state_tracker = false
+  end
+  opts.on("--no-return-type-tracker", "disable return type tracker") do
+    options.enable_return_type_tracker = false
+  end
+
+  opts.on("--output-dir=[Dir]", String, "specify output directory (ignored by type tracker)") do |dir|
+    options.output_dir = dir
+  end
+
 end
 
 begin

data/ext/arg_scanner/arg_scanner.c

@@ -8,6 +8,12 @@
 
 //#define DEBUG_ARG_SCANNER 1
 
+#if RUBY_API_VERSION_CODE >= 20500
+    #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->ec.cfp)
+#else
+    #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->cfp)
+#endif
+
 #ifdef DEBUG_ARG_SCANNER
     #define LOG(f, args...) { fprintf(stderr, "DEBUG: '%s'=", #args); fprintf(stderr, f, ##args); fflush(stderr); }
 #else
@@ -186,7 +192,7 @@ get_call_info()
     call_info_t *info;
 
     thread = ruby_current_thread;
-    cfp = thread->cfp;
+    cfp = TH_CFP(thread);
     info = malloc(sizeof(call_info_t));
     //info = ALLOC(call_info_t);
     //info = malloc;
@@ -297,11 +303,6 @@ calc_sane_class_name(VALUE ptr)
         klass_name = "<err>";
     }
 
-    if (strlen(klass_name) >= 200)
-    {
-        fprintf(stderr, "ERROR: too long class name: '%s'\n", klass_name);
-        assert(false);
-    }
     return klass_name;
 }
 
@@ -370,7 +371,7 @@ get_args_info()
     rb_control_frame_t *cfp;
 
     thread = ruby_current_thread;
-    cfp = thread->cfp;
+    cfp = TH_CFP(thread);
 
     cfp += 3;
 
@@ -406,7 +407,10 @@ get_args_info()
 
     ans_iterator = 0;
 
-    for(i = param_size - 1 - (RUBY_VERSION >= "2.4.1"), types_iterator = 0; (size_t)types_iterator < param_size; i--, types_iterator++)
+    int new_version_flag = strcmp(RUBY_VERSION, "2.4.0") >= 0 ? 1 : 0;
+    LOG("%d\n", new_version_flag);
+
+    for(i = param_size - 1 - new_version_flag, types_iterator = 0; (size_t)types_iterator < param_size; i--, types_iterator++)
     {
         types[types_iterator] = calc_sane_class_name(*(ep + i - 1));
         types_ids[types_iterator] = i - 1;
@@ -437,10 +441,7 @@ get_args_info()
         const char* name = rb_id2name(cfp->iseq->body->local_table[ans_iterator]);
 
         char* type;
-        if(RARRAY_LEN(*(ep + types_ids[types_iterator])) == 0)
-            type = "Array/empty";
-        else
-            type = types[types_iterator];
+        type = types[types_iterator];
 
         ans[ans_iterator] = fast_join(',', 3, "REST", type, name);
     }
@@ -472,7 +473,7 @@ get_args_info()
         }
     }
 
-    if(param_size - has_block > 1 && has_kwrest)
+    if(param_size - has_block > 1 && has_kwrest && TYPE(*(ep + types_ids[types_iterator])) == T_FIXNUM)
         types_iterator--;
 
     for(i = 0; i < has_kwrest; i++, ans_iterator++, types_iterator--)
@@ -482,10 +483,7 @@ get_args_info()
         LOG("%d\n", rb_hash_size(*(ep + types_ids[types_iterator])));
         char* type;
 
-        if(rb_hash_size(*(ep + types_ids[types_iterator])) == 1)
-            type = "Hash/empty";
-        else
-            type = types[types_iterator];
+        type = types[types_iterator];
 
         ans[ans_iterator] = fast_join(',', 3, "KEYREST", type, name);
     }
@@ -558,7 +556,7 @@ is_call_info_needed()
     rb_control_frame_t *cfp;
 
     thread = ruby_current_thread;
-    cfp = thread->cfp;
+    cfp = TH_CFP(thread);
     cfp += 3;
 
     return (cfp->iseq->body->param.flags.has_opt

data/lib/arg_scanner.rb

@@ -1,6 +1,8 @@
 require "arg_scanner/version"
 require "arg_scanner/arg_scanner"
 require "arg_scanner/type_tracker"
+require "arg_scanner/state_tracker"
+require "arg_scanner/return_type_tracker"
 
 module ArgScanner
   # Your code goes here...

data/lib/arg_scanner/options.rb

@@ -4,12 +4,20 @@ module ArgScanner
   OPTIONS = OpenStruct.new(
       :local_version => ENV['ARG_SCANNER_LOCAL_VERSION'] || '0',
       :no_local => ENV['ARG_SCANNER_NO_LOCAL'] ? true : false,
-      :project_roots => ((ENV['ARG_SCANNER_PROJECT_ROOTS'] || "").split ':')
+      :project_roots => ((ENV['ARG_SCANNER_PROJECT_ROOTS'] || "").split ':'),
+      :enable_type_tracker => ENV['ARG_SCANNER_ENABLE_TYPE_TRACKER'],
+      :enable_state_tracker => ENV['ARG_SCANNER_ENABLE_STATE_TRACKER'],
+      :enable_return_type_tracker => ENV['ARG_SCANNER_ENABLE_RETURN_TYPE_TRACKER'],
+      :output_directory => ENV['ARG_SCANNER_DIR'],
   )
 
   def OPTIONS.set_env
     ENV['ARG_SCANNER_LOCAL_VERSION'] = self.local_version.to_s
     ENV['ARG_SCANNER_NO_LOCAL'] = self.no_local ? "1" : nil
     ENV['ARG_SCANNER_PROJECT_ROOTS'] = self.project_roots.join ':'
+    ENV['ARG_SCANNER_ENABLE_TYPE_TRACKER'] = self.enable_type_tracker ? "1" : nil
+    ENV['ARG_SCANNER_ENABLE_STATE_TRACKER'] = self.enable_state_tracker ? "1" : nil
+    ENV['ARG_SCANNER_ENABLE_RETURN_TYPE_TRACKER'] = self.enable_return_type_tracker ? "1" : nil
+    ENV['ARG_SCANNER_DIR'] = self.output_directory
   end
 end

data/lib/arg_scanner/require_all.rb

@@ -0,0 +1,289 @@
+# Copyright (c) 2009 Jarmo Pertman
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RequireAll
+  # A wonderfully simple way to load your code.
+  #
+  # The easiest way to use require_all is to just point it at a directory
+  # containing a bunch of .rb files.  These files can be nested under
+  # subdirectories as well:
+  #
+  #  require_all 'lib'
+  #
+  # This will find all the .rb files under the lib directory and load them.
+  # The proper order to load them in will be determined automatically.
+  #
+  # If the dependencies between the matched files are unresolvable, it will
+  # throw the first unresolvable NameError.
+  #
+  # You can also give it a glob, which will enumerate all the matching files:
+  #
+  #  require_all 'lib/**/*.rb'
+  #
+  # It will also accept an array of files:
+  #
+  #  require_all Dir.glob("blah/**/*.rb").reject { |f| stupid_file(f) }
+  #
+  # Or if you want, just list the files directly as arguments:
+  #
+  #  require_all 'lib/a.rb', 'lib/b.rb', 'lib/c.rb', 'lib/d.rb'
+  #
+  def require_all(*args)
+    # Handle passing an array as an argument
+    args.flatten!
+
+    options = {:method => :require}
+    options.merge!(args.pop) if args.last.is_a?(Hash)
+
+    if args.empty?
+      puts "no files were loaded due to an empty Array" if $DEBUG
+      return false
+    end
+
+    if args.size > 1
+      # Expand files below directories
+      files = args.map do |path|
+        if File.directory? path
+          Dir[File.join(path, '**', '*.rb')]
+        else
+          path
+        end
+      end.flatten
+    else
+      arg = args.first
+      begin
+        # Try assuming we're doing plain ol' require compat
+        stat = File.stat(arg)
+
+        if stat.file?
+          files = [arg]
+        elsif stat.directory?
+          files = Dir.glob File.join(arg, '**', '*.rb')
+        else
+          raise ArgumentError, "#{arg} isn't a file or directory"
+        end
+      rescue SystemCallError
+        # If the stat failed, maybe we have a glob!
+        files = Dir.glob arg
+
+        # Maybe it's an .rb file and the .rb was omitted
+        if File.file?(arg + '.rb')
+          file = arg + '.rb'
+          options[:method] != :autoload ? Kernel.send(options[:method], file) : __autoload(file, file, options)
+          return true
+        end
+
+        # If we ain't got no files, the glob failed
+        raise LoadError, "no such file to load -- #{arg}" if files.empty?
+      end
+    end
+
+    return if files.empty?
+
+    if options[:method] == :autoload
+      files.map! { |file_| [file_, File.expand_path(file_)] }
+      files.each do |file_, full_path|
+        __autoload(file_, full_path, options)
+      end
+
+      return true
+    end
+
+    files.map! { |file_| File.expand_path file_ }
+    files.sort!
+
+    begin
+      failed = []
+      first_name_error = nil
+
+      # Attempt to load each file, rescuing which ones raise NameError for
+      # undefined constants.  Keep trying to successively reload files that
+      # previously caused NameErrors until they've all been loaded or no new
+      # files can be loaded, indicating unresolvable dependencies.
+      files.each do |file_|
+        begin
+          Kernel.send(options[:method], file_)
+        rescue NameError => ex
+          failed << file_
+          first_name_error ||= ex
+        rescue ArgumentError => ex
+          # Work around ActiveSuport freaking out... *sigh*
+          #
+          # ActiveSupport sometimes throws these exceptions and I really
+          # have no idea why.  Code loading will work successfully if these
+          # exceptions are swallowed, although I've run into strange
+          # nondeterministic behaviors with constants mysteriously vanishing.
+          # I've gone spelunking through dependencies.rb looking for what
+          # exactly is going on, but all I ended up doing was making my eyes
+          # bleed.
+          #
+          # FIXME: If you can understand ActiveSupport's dependencies.rb
+          # better than I do I would *love* to find a better solution
+          raise unless ex.message["is not missing constant"]
+
+          STDERR.puts "Warning: require_all swallowed ActiveSupport 'is not missing constant' error"
+          STDERR.puts ex.backtrace[0..9]
+        end
+      end
+
+      # If this pass didn't resolve any NameErrors, we've hit an unresolvable
+      # dependency, so raise one of the exceptions we encountered.
+      if failed.size == files.size
+        raise first_name_error
+      else
+        files = failed
+      end
+    end until failed.empty?
+
+    true
+  end
+
+  # Works like require_all, but paths are relative to the caller rather than
+  # the current working directory
+  def require_rel(*paths)
+    # Handle passing an array as an argument
+    paths.flatten!
+    return false if paths.empty?
+
+    source_directory = File.dirname caller.first.sub(/:\d+$/, '')
+    paths.each do |path|
+      require_all File.join(source_directory, path)
+    end
+  end
+
+  # Loads all files like require_all instead of requiring
+  def load_all(*paths)
+    require_all paths, :method => :load
+  end
+
+  # Loads all files by using relative paths of the caller rather than
+  # the current working directory
+  def load_rel(*paths)
+    paths.flatten!
+    return false if paths.empty?
+
+    source_directory = File.dirname caller.first.sub(/:\d+$/, '')
+    paths.each do |path|
+      require_all File.join(source_directory, path), :method => :load
+    end
+  end
+
+  # Performs Kernel#autoload on all of the files rather than requiring immediately.
+  #
+  # Note that all Ruby files inside of the specified directories should have same module name as
+  # the directory itself and file names should reflect the class/module names.
+  # For example if there is a my_file.rb in directories dir1/dir2/ then
+  # there should be a declaration like this in my_file.rb:
+  #   module Dir1
+  #     module Dir2
+  #       class MyFile
+  #         ...
+  #       end
+  #     end
+  #  end
+  #
+  # If the filename and namespaces won't match then my_file.rb will be loaded into wrong module!
+  # Better to fix these files.
+  #
+  # Set $DEBUG=true to see how files will be autoloaded if experiencing any problems.
+  #
+  # If trying to perform autoload on some individual file or some inner module, then you'd have
+  # to always specify *:base_dir* option to specify where top-level namespace resides.
+  # Otherwise it's impossible to know the namespace of the loaded files.
+  #
+  # For example loading only my_file.rb from dir1/dir2 with autoload_all:
+  #
+  #   autoload_all File.dirname(__FILE__) + '/dir1/dir2/my_file',
+  #                :base_dir => File.dirname(__FILE__) + '/dir1'
+  #
+  # WARNING: All modules will be created even if files themselves aren't loaded yet, meaning
+  # that all the code which depends of the modules being loaded or not will not work, like usages
+  # of define? and it's friends.
+  #
+  # Also, normal caveats of using Kernel#autoload apply - you have to remember that before
+  # applying any monkey-patches to code using autoload, you'll have to reference the full constant
+  # to load the code before applying your patch!
+
+  def autoload_all(*paths)
+    paths.flatten!
+    return false if paths.empty?
+    require "pathname"
+
+    options = {:method => :autoload}
+    options.merge!(paths.pop) if paths.last.is_a?(Hash)
+
+    paths.each do |path|
+      require_all path, {:base_dir => path}.merge(options)
+    end
+  end
+
+  # Performs autoloading relatively from the caller instead of using current working directory
+  def autoload_rel(*paths)
+    paths.flatten!
+    return false if paths.empty?
+    require "pathname"
+
+    options = {:method => :autoload}
+    options.merge!(paths.pop) if paths.last.is_a?(Hash)
+
+    source_directory = File.dirname caller.first.sub(/:\d+$/, '')
+    paths.each do |path|
+      file_path = Pathname.new(source_directory).join(path).to_s
+      require_all file_path, {:method => :autoload,
+                              :base_dir => source_directory}.merge(options)
+    end
+  end
+
+  private
+
+  def __autoload(file, full_path, options)
+    last_module = "Object" # default constant where namespaces are created into
+    begin
+      base_dir = Pathname.new(options[:base_dir]).realpath
+    rescue Errno::ENOENT
+      raise LoadError, ":base_dir doesn't exist at #{options[:base_dir]}"
+    end
+    Pathname.new(file).realpath.descend do |entry|
+      # skip until *entry* is same as desired directory
+      # or anything inside of it avoiding to create modules
+      # from the top-level directories
+      next if (entry <=> base_dir) < 0
+
+      # get the module into which a new module is created or
+      # autoload performed
+      mod = Object.class_eval(last_module)
+
+      without_ext = entry.basename(entry.extname).to_s
+      const = without_ext.split("_").map {|word| word.capitalize}.join
+
+      if entry.directory?
+        mod.class_eval "module #{const} end"
+        last_module += "::#{const}"
+      else
+        mod.class_eval do
+          puts "autoloading #{mod}::#{const} from #{full_path}" if $DEBUG
+          autoload const, full_path
+        end
+      end
+    end
+  end
+
+end

data/lib/arg_scanner/return_type_tracker.rb

@@ -0,0 +1,25 @@
+require 'set'
+
+module ArgScanner
+  class ReturnTypeTracker
+    def initialize
+      @result = Set.new
+      TracePoint.new(:return) do |tp|
+        @result.add( {
+          def: tp.defined_class,
+          name: tp.method_id,
+          ret: tp.return_value.class
+        })
+      end.enable
+      at_exit do
+        dir = ENV["ARG_SCANNER_DIR"]
+        dir = "." if dir.nil? || dir == ""
+        path = dir + "/calls-#{Time.now.strftime('%Y-%m-%d_%H-%M-%S')}-#{Process.pid}.json"
+        require 'json'
+        File.open(path,"w") { |file| file.puts(JSON.dump(@result.to_a)) }
+      end
+    end
+  end
+end
+
+

data/lib/arg_scanner/starter.rb

@@ -1,4 +1,21 @@
-require 'arg_scanner'
+unless ENV["ARG_SCANNER_ENABLE_STATE_TRACKER"].nil?
+  require_relative 'state_tracker'
+  ArgScanner::StateTracker.new
+end
+
+unless ENV["ARG_SCANNER_ENABLE_RETURN_TYPE_TRACKER"].nil?
+  require_relative 'return_type_tracker'
+  ArgScanner::ReturnTypeTracker.new
+end
+
+
+unless ENV["ARG_SCANNER_ENABLE_TYPE_TRACKER"].nil?
+  require_relative 'arg_scanner'
+  require_relative 'type_tracker'
+
+  # instantiating type tracker will enable calls tracing and sending the data
+  ArgScanner::TypeTracker.instance
+end
+
+
 
-# instantiating type tracker will enable calls tracing and sending the data
-ArgScanner::TypeTracker.instance

data/lib/arg_scanner/state_tracker.rb

@@ -0,0 +1,124 @@
+require "set"
+require_relative "require_all"
+
+
+module ArgScanner
+  class StateTracker
+    def initialize
+      at_exit do
+        dir = ENV["ARG_SCANNER_DIR"]
+        dir = "." if dir.nil? || dir == ""
+        path = dir + "/" + "classes-#{Time.now.strftime('%Y-%m-%d_%H-%M-%S')}-#{Process.pid}.json"
+        begin
+          RequireAll.require_all Rails.root.join('lib')
+        rescue => e
+        end
+        begin
+          Rails.application.eager_load!
+        rescue => e
+        end
+
+        File.open(path,"w") { |file| print_json(file) }
+      end
+    end
+
+    private
+    def print_json(file)
+      result = {
+        :top_level_constants => parse_top_level_constants,
+        :modules => modules_to_json,
+        :load_path => $:
+      }
+      require "json"
+      file.puts(JSON.dump(result))
+    end
+
+    def parse_top_level_constants
+      Module.constants.select { |const| Module.const_defined?(const)}.map do |const|
+        begin
+          value = Module.const_get(const)
+          (!value.is_a? Module) ? {
+              :name => const,
+              :class_name => value.class,
+              :extended => get_extra_methods(value)} : nil
+        rescue Exception => e
+        end
+      end.compact
+    end
+
+    def get_extra_methods(value)
+      begin
+       (value.methods - value.class.public_instance_methods).map do |method_name|
+           method = value.public_method(method_name)
+           method.owner
+       end.uniq
+      rescue Exception => e
+        value.methods - value.class.instance_methods
+      end
+
+    end
+
+    def get_constants_of_class(constants, parent, klass)
+        constants.select {|const| parent.const_defined?(const)}.map do |const|
+          begin
+            parent.const_get(const)
+          rescue Exception => e
+          end
+        end.select { |const| const.is_a? klass}
+    rescue => e
+      $stderr.puts(e)
+      []
+    end
+
+
+    def get_modules(mod)
+      get_constants_of_class(mod.constants, mod, Module)
+    end
+
+    def get_all_modules
+      queue = Queue.new
+      visited = Set.new
+      get_modules(Module).each {|mod| queue.push(mod); visited.add(mod)}
+
+      until queue.empty? do
+        mod = queue.pop
+        get_modules(mod).each do |child|
+          unless visited.include?(child)
+            queue.push(child)
+            visited.add(child)
+          end
+        end
+      end
+      visited
+    end
+
+    def method_to_json(method)
+      ret = {
+          :name => method.name,
+          :parameters => method.parameters
+      }
+      unless method.source_location.nil?
+        ret[:path] = method.source_location[0]
+        ret[:line] = method.source_location[1]
+      end
+      ret
+    end
+
+    def module_to_json(mod)
+      ret = {
+        :name => mod.to_s,
+        :type => mod.class.to_s,
+        :singleton_class_included => mod.singleton_class.included_modules,
+        :included => mod.included_modules,
+        :class_methods => mod.methods(false).map {|method| method_to_json(mod.method(method))},
+        :instance_methods => mod.instance_methods(false).map {|method| method_to_json(mod.instance_method(method))}
+      }
+      ret[:superclass] = mod.superclass if mod.is_a? Class
+      ret
+    end
+
+    def modules_to_json
+      get_all_modules.map {|mod| module_to_json(mod)}
+    end
+  end
+end

data/lib/arg_scanner/type_tracker.rb

@@ -1,10 +1,53 @@
 require 'set'
 require 'socket'
 require 'singleton'
+require 'thread'
 
 require_relative 'options'
 
 module ArgScanner
+
+  class TypeTrackerPerformanceMonitor
+    def initialize
+      @enable_debug = ENV["ARG_SCANNER_DEBUG"]
+      @call_counter = 0
+      @handled_call_counter = 0
+      @submitted_call_counter = 0
+      @old_handled_call_counter = 0
+      @time = Time.now
+    end
+
+
+    def on_call
+      @submitted_call_counter += 1
+    end
+
+    def on_return
+      @call_counter += 1
+
+      if enable_debug && call_counter % 100000 == 0
+        $stderr.puts("calls #{call_counter} handled #{handled_call_counter} submitted #{submitted_call_counter}"\
+                     "delta  #{handled_call_counter - old_handled_call_counter} time #{Time.now - @time}")
+        @old_handled_call_counter = handled_call_counter
+        @time = Time.now
+      end
+    end
+
+    def on_handled_return
+      @handled_call_counter += 1
+    end
+
+    private
+
+    attr_accessor :submitted_call_counter
+    attr_accessor :handled_call_counter
+    attr_accessor :old_handled_call_counter
+    attr_accessor :call_counter
+    attr_accessor :enable_debug
+
+  end
+
+
   class TypeTracker
     include Singleton
 
@@ -13,7 +56,10 @@ module ArgScanner
     def initialize
       @cache = Set.new
       @socket = TCPSocket.new('127.0.0.1', 7777)
-
+      @mutex = Mutex.new
+      @prefix = ENV["ARG_SCANNER_PREFIX"]
+      @enable_debug = ENV["ARG_SCANNER_DEBUG"]
+      @performance_monitor = if @enable_debug then TypeTrackerPerformanceMonitor.new else nil end
       TracePoint.trace(:call, :return) do |tp|
         case tp.event
           when :call
@@ -24,8 +70,13 @@ module ArgScanner
       end
     end
 
+    attr_accessor :enable_debug
+    attr_accessor :performance_monitor
     attr_accessor :cache
     attr_accessor :socket
+    attr_accessor :mutex
+    attr_accessor :prefix
+
 
 
     # @param [String] path
@@ -50,20 +101,30 @@ module ArgScanner
     end
 
     def put_to_socket(message)
-      socket.puts(message)
+      mutex.synchronize { socket.puts(message) }
     end
 
     private
     def handle_call(tp)
       #handle_call(VALUE self, VALUE lineno, VALUE method_name, VALUE path)
-      signature = ArgScanner.handle_call(tp.lineno, tp.method_id, tp.path)
-      signatures.push(signature)
+      if prefix.nil? || tp.path.start_with?(prefix)
+        performance_monitor.on_call unless performance_monitor.nil?
+        signature = ArgScanner.handle_call(tp.lineno, tp.method_id, tp.path)
+        signatures.push(signature)
+      else
+        signatures.push(false)
+      end
     end
 
     def handle_return(tp)
       sigi = signatures
+      performance_monitor.on_return unless performance_monitor.nil?
+
       unless sigi.empty?
         signature = sigi.pop
+        return unless signature
+
+        performance_monitor.on_handled_return unless performance_monitor.nil?
 
         defined_class = tp.defined_class
         return if !defined_class || defined_class.singleton_class?
@@ -74,7 +135,7 @@ module ArgScanner
         return if !receiver_name || !receiver_name.to_s || receiver_name.to_s.length > 200
 
         json = ArgScanner.handle_return(signature, return_type_name) +
-            "\"receiver_name\":\"#{receiver_name}\",\"return_type_name\":\"#{return_type_name}\","
+          "\"receiver_name\":\"#{receiver_name}\",\"return_type_name\":\"#{return_type_name}\","
 
         if cache.add?(json)
           gem_name, gem_version = TypeTracker.extract_gem_name_and_version(tp.path)

data/lib/arg_scanner/version.rb

@@ -1,3 +1,3 @@
 module ArgScanner
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

data/util/state_filter.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'set'
+
+if ARGV.length < 3
+  puts("state_filter.rb <in-file> <out-file> [<list-of-names]")
+  exit
+end
+
+json = JSON.parse(File.read(ARGV[0]))
+
+modules2names = {}
+
+json["modules"].each {|mod| modules2names[mod["name"]] = mod}
+
+visited = Set.new
+queue = Queue.new
+ARGV[2..-1].each do |it|
+  visited.add(it)
+  queue.push(it)
+end
+
+until queue.empty? do
+  elem = modules2names[queue.pop] || next
+  (elem["singleton_class_included"] + elem["included"] + [elem["superclass"]]).each do |mod|
+    queue.push(mod) if visited.add?(mod)
+  end
+end
+
+output_modules = visited.map do |mod|
+  modules2names[mod]
+end.compact
+
+File.write(ARGV[1], JSON.pretty_generate({:modules => output_modules, :load_path => json["load_path"]}))

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: arg_scanner
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - Nickolay Viuginov
 - Valentin Fondaratov
+- Vladimir Koshelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-13 00:00:00.000000000 Z
+date: 2017-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -57,20 +58,21 @@ dependencies:
   name: debase-ruby_core_source
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.6
+        version: 0.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.6
+        version: 0.10.0
 description: 
 email:
 - viuginov.nickolay@gmail.com
 - fondarat@gmail.com
+- vkkoshelev@gmail.com
 executables:
 - arg-scanner
 - console
@@ -94,9 +96,13 @@ files:
 - ext/arg_scanner/extconf.rb
 - lib/arg_scanner.rb
 - lib/arg_scanner/options.rb
+- lib/arg_scanner/require_all.rb
+- lib/arg_scanner/return_type_tracker.rb
 - lib/arg_scanner/starter.rb
+- lib/arg_scanner/state_tracker.rb
 - lib/arg_scanner/type_tracker.rb
 - lib/arg_scanner/version.rb
+- util/state_filter.rb
 homepage: https://github.com/jetbrains/ruby-type-inference
 licenses:
 - MIT
@@ -117,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Program execution tracker to retrieve data types information