arg_scanner 0.2.0 → 0.3.0

data/ext/arg_scanner/extconf.rb

@@ -22,10 +22,12 @@ config_file = File.join(File.dirname(__FILE__), 'config_options.rb')
 load config_file if File.exist?(config_file)
 
 if ENV['debase_debug']
-  $CFLAGS+=' -Wall -Werror'
-  $CFLAGS+=' -g3'
+  $CFLAGS+=' -Wall -Werror -g3'
 end
 
+$CFLAGS += ' `pkg-config --cflags --libs glib-2.0`'
+$DLDFLAGS += ' `pkg-config --cflags --libs glib-2.0`'
+
 dir_config("ruby")
 if !Debase::RubyCoreSource.create_makefile_with_core(hdrs, "arg_scanner/arg_scanner")
   STDERR.print("Makefile creation failed\n")

data/lib/arg_scanner.rb

@@ -2,7 +2,6 @@ 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

@@ -2,22 +2,22 @@ require 'ostruct'
 
 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 ':'),
       :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'],
+      :catch_only_every_n_call => ENV['ARG_SCANNER_CATCH_ONLY_EVERY_N_CALL'] || 1,
+      :project_root => ENV['ARG_SCANNER_PROJECT_ROOT'],
+      :pipe_file_path => ENV['ARG_SCANNER_PIPE_FILE_PATH'] || '',
+      :buffering => ENV['ARG_SCANNER_BUFFERING']
   )
 
   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
+    ENV['ARG_SCANNER_CATCH_ONLY_EVERY_N_CALL'] = self.catch_only_every_n_call.to_s
+    ENV['ARG_SCANNER_PROJECT_ROOT'] = self.project_root
+    ENV['ARG_SCANNER_PIPE_FILE_PATH'] = self.pipe_file_path
+    ENV['ARG_SCANNER_BUFFERING'] = self.buffering ? "1" : nil
   end
 end

data/lib/arg_scanner/starter.rb

@@ -1,14 +1,11 @@
+# starter.rb is loaded with "ruby -r" option from bin/arg-scanner
+# or by IDEA also with "ruby -r" option
+
 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'

data/lib/arg_scanner/state_tracker.rb

@@ -1,28 +1,35 @@
 require "set"
 require_relative "require_all"
+require_relative "workspace"
 
 
 module ArgScanner
   class StateTracker
     def initialize
+      @workspace = Workspace.new
+      @workspace.on_process_start
       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
+          require_extra_libs
+          @workspace.open_output_json("classes") { |file| print_json(file) }
+        ensure
+          @workspace.on_process_exit
         end
-        begin
-          Rails.application.eager_load!
-        rescue => e
-        end
-
-        File.open(path,"w") { |file| print_json(file) }
       end
     end
 
     private
+    def require_extra_libs
+      begin
+        RequireAll.require_all Rails.root.join('lib')
+      rescue Exception => e
+      end
+      begin
+        Rails.application.eager_load!
+      rescue Exception => e
+      end
+    end
+
     def print_json(file)
       result = {
         :top_level_constants => parse_top_level_constants,
@@ -47,49 +54,7 @@ module ArgScanner
     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
+      value.methods - value.public_methods
     end
 
     def method_to_json(method)
@@ -102,23 +67,28 @@ module ArgScanner
         ret[:line] = method.source_location[1]
       end
       ret
+    rescue Exception => e
+      nil
     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))}
+        :singleton_class_ancestors => mod.singleton_class.ancestors.map{|it| it.to_s},
+        :ancestors => mod.ancestors.map{|it| it.to_s}, # map to_s is needed because for example "Psych" parsed not correctly into JSON format
+                                                       # it's parsed as: "{}\n" check it by launching in rails console: "JSON.generate(Psych)"
+        :class_methods => mod.methods(false).map {|method| method_to_json(mod.method(method))}.compact,
+        :instance_methods => mod.instance_methods(false).map {|method| method_to_json(mod.instance_method(method))}.compact
       }
       ret[:superclass] = mod.superclass if mod.is_a? Class
       ret
+    rescue Exception => e
+      nil
     end
 
     def modules_to_json
-      get_all_modules.map {|mod| module_to_json(mod)}
+      ObjectSpace.each_object(Module).map {|mod| module_to_json(mod)}
     end
   end
 end

data/lib/arg_scanner/type_tracker.rb

@@ -51,99 +51,29 @@ module ArgScanner
   class TypeTracker
     include Singleton
 
-    GEM_PATH_REVERSED_REGEX = /((?:[0-9A-Za-z]+\.)+\d+)-([A-Za-z0-9_-]+)/
-
     def initialize
-      @cache = Set.new
-      @socket = TCPSocket.new('127.0.0.1', 7777)
-      @mutex = Mutex.new
-      @prefix = ENV["ARG_SCANNER_PREFIX"]
+      ArgScanner.init(ENV['ARG_SCANNER_PIPE_FILE_PATH'], ENV['ARG_SCANNER_BUFFERING'],
+                      ENV['ARG_SCANNER_PROJECT_ROOT'], ENV['ARG_SCANNER_CATCH_ONLY_EVERY_N_CALL'])
+
       @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
-            handle_call(tp)
-          when :return
-            handle_return(tp)
-        end
-      end
-    end
-
-    attr_accessor :enable_debug
-    attr_accessor :performance_monitor
-    attr_accessor :cache
-    attr_accessor :socket
-    attr_accessor :mutex
-    attr_accessor :prefix
 
+      TracePoint.trace(:call, &ArgScanner.method(:handle_call))
 
+      TracePoint.trace(:return, &ArgScanner.method(:handle_return))
 
-    # @param [String] path
-    def self.extract_gem_name_and_version(path)
-      if OPTIONS.project_roots && path.start_with?(*OPTIONS.project_roots)
-        return OPTIONS.no_local ? ['', ''] : ['LOCAL', OPTIONS.local_version]
+      error_msg = ArgScanner.check_if_arg_scanner_ready()
+      if error_msg != nil
+        STDERR.puts error_msg
+        Process.exit(1)
       end
 
-      reversed = path.reverse
-      return ['', ''] unless GEM_PATH_REVERSED_REGEX =~ reversed
-
-      name_and_version = Regexp.last_match
-      return name_and_version[2].reverse, name_and_version[1].reverse
-    end
-
-    def signatures
-      Thread.current[:signatures] ||= Array.new
-    end
-
-    def at_exit
-      socket.close
-    end
-
-    def put_to_socket(message)
-      mutex.synchronize { socket.puts(message) }
+      ObjectSpace.define_finalizer(self, proc { ArgScanner.destructor() })
     end
 
-    private
-    def handle_call(tp)
-      #handle_call(VALUE self, VALUE lineno, VALUE method_name, VALUE path)
-      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?
-
-        receiver_name = defined_class.name ? defined_class : defined_class.ancestors.first
-        return_type_name = tp.return_value.class
-
-        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}\","
-
-        if cache.add?(json)
-          gem_name, gem_version = TypeTracker.extract_gem_name_and_version(tp.path)
-          json += '"gem_name":"' + gem_name.to_s + '","gem_version":"' + gem_version.to_s + '"}'
-          put_to_socket(json)
-        end
-      end
-    end
+    attr_accessor :enable_debug
+    attr_accessor :performance_monitor
+    attr_accessor :prefix
 
   end
 end

data/lib/arg_scanner/version.rb

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

data/lib/arg_scanner/workspace.rb

@@ -0,0 +1,28 @@
+module ArgScanner
+  class Workspace
+
+    def initialize
+      @dir = ENV["ARG_SCANNER_DIR"] || "."
+      @pid_file = @dir+"/#{Process.pid}.pid"
+    end
+
+    def on_process_start
+      File.open(@pid_file, "w") {}
+    end
+
+
+    def open_output_json(prefix)
+      path = @dir + "/#{prefix}-#{Time.now.strftime('%Y-%m-%d_%H-%M-%S')}-#{Process.pid}.json"
+      path_tmp_name = path + ".temp"
+      File.open(path_tmp_name, "w") { |file| yield file }
+      require 'fileutils'
+      FileUtils.mv(path_tmp_name, path)
+    end
+
+    def on_process_exit
+      require 'fileutils'
+      FileUtils.rm(@pid_file)
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arg_scanner
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Nickolay Viuginov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-23 00:00:00.000000000 Z
+date: 2019-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ email:
 executables:
 - arg-scanner
 - console
+- rubymine-type-tracker
 - setup
 extensions:
 - ext/arg_scanner/extconf.rb
@@ -87,9 +88,9 @@ files:
 - README.md
 - Rakefile
 - arg_scanner.gemspec
-- arg_scanner.iml
 - bin/arg-scanner
 - bin/console
+- bin/rubymine-type-tracker
 - bin/setup
 - ext/arg_scanner/arg_scanner.c
 - ext/arg_scanner/arg_scanner.h
@@ -97,11 +98,11 @@ files:
 - 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
+- lib/arg_scanner/workspace.rb
 - util/state_filter.rb
 homepage: https://github.com/jetbrains/ruby-type-inference
 licenses:
@@ -123,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Program execution tracker to retrieve data types information

data/lib/arg_scanner/return_type_tracker.rb

@@ -1,25 +0,0 @@
-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
-
-