import_js 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3808c953be3c8a47d0212d952f35b4329774cba8
-  data.tar.gz: f1929ccab0f99004521babc2dbbf8d35347c7313
+  metadata.gz: eddd4e67b47ab663fb4bb1fc39a2e11810f9f640
+  data.tar.gz: 399fee47fa49f677e9646ae1451a897869a441cc
 SHA512:
-  metadata.gz: 9380c3f44a4306a0e9d843496bf846c47200e696649a88348135e9c7f1d928e04ad5520d67a7c15beb3306e02af1ad7aa2fd2aaaef983c0eec2463e6ca9fd288
-  data.tar.gz: cc46051020022e9e7ba9db5b4c8750b104ad372bb72442f5fb7712867084f8bfff92f9dcba06826ca77d87a42d4897dfe72b5b96b7fb89f7dcb61d804e684f75
+  metadata.gz: d3269f091d4da05e069fd26f935450964495da18d1a970a77cacc6bea9fc5593c002c16c3cb53a2b8234ed2be711018aefbfb03e58e5b76e04cfd4b383ee9513
+  data.tar.gz: 545f69bfb8caadcc9bd30e3ae04ab73640d369272b47997be3e5c8718fee06f4f7f740fa9e608fa55872c4f606d04a8af9c9ff804867485ed7451a85714e4b8f

data/bin/import-js

@@ -5,22 +5,45 @@ require 'slop'
 require 'json'
 
 opts = Slop.parse do |o|
-  o.string '-w', '--word', 'a word/variable to import'
-  o.bool '--goto', 'instead of importing, just print the path to a module'
-  o.array '--selections', 'a list of resolved selections, e.g. Foo:0,Bar:1'
-  o.string '--filename',
-           'a path to the file which contents are being passed in as stdin'
-  o.on '-v', '--version', 'print the current version' do
+  o.banner = 'Usage: import-js [<path-to-file>] [options] ...'
+  o.string '-w', '--word', 'A word/variable to import'
+  o.bool '--goto', 'Instead of importing, just print the path to a module'
+  o.array '--selections', 'A list of resolved selections, e.g. Foo:0,Bar:1'
+  o.string '--stdin-file-path',
+           'A path to the file whose content is being passed in as stdin. ' \
+           'This is used as a way to make sure that the right configuration ' \
+           'is applied.'
+  o.bool '--overwrite',
+         'Overwrite the file with the result after importing (the default ' \
+         'behavior is to print to stdout). This only applies if you are ' \
+         'passing in a file (<path-to-file>) as the first positional argument.'
+  o.string '--filename', '(deprecated) Alias for --stdin-file-path'
+  o.bool '--rewrite',
+         'Rewrite all current imports to match Import-JS configuration. ' \
+         'This does not add missing imports or remove unused imports.'
+
+  o.on '-v', '--version', 'Prints the current version' do
     puts ImportJS::VERSION
     exit
   end
-  o.on '-h', '--help', 'prints help' do
+  o.on '-h', '--help', 'Prints help' do
     puts o
     exit
   end
 end
 
-file_contents = STDIN.read.split("\n")
+path_to_file = opts.arguments[0] || opts['stdin-file-path'] || opts[:filename]
+
+file_contents = if STDIN.tty?
+                  unless path_to_file
+                    puts 'Error: missing <path-to-file>'
+                    puts opts
+                    exit 1
+                  end
+                  File.read(path_to_file).split("\n")
+                else
+                  STDIN.read.split("\n")
+                end
 
 if opts[:selections]
   # Convert array of string tuples to hash, `word` => `selectedIndex`
@@ -30,12 +53,15 @@ if opts[:selections]
   end]
 end
 
-editor = ImportJS::CommandLineEditor.new(file_contents, opts)
+editor = ImportJS::CommandLineEditor.new(
+  file_contents, opts.to_hash.merge(path_to_file: path_to_file))
 importer = ImportJS::Importer.new(editor)
 if opts.goto?
   importer.goto
 elsif opts[:word]
   importer.import
+elsif opts[:rewrite]
+  importer.rewrite_imports
 else
   importer.fix_imports
 end
@@ -43,6 +69,10 @@ end
 if opts.goto?
   # Print the path to the module to go to
   puts editor.goto
+elsif opts[:overwrite]
+  File.open(path_to_file, 'w') do |f|
+    f.write editor.current_file_content + "\n"
+  end
 else
   # Print resulting file to stdout
   puts editor.current_file_content

data/lib/import_js.rb

@@ -4,15 +4,15 @@ module ImportJS
   # under that namespace, e.g. `ImportJS::Importer`.
 
   class ParseError < StandardError
-    # Error thrown when a JS file can't be parsed
+    # Error raised when a JS file can't be parsed
   end
 
   class FindError < StandardError
-    # Error thrown when the find command fails
+    # Error raised when the find command fails
   end
 
   class ClientTooOldError < StandardError
-    # Error thrown when the client is too old to handle the config
+    # Error raised when the client is too old to handle the config
   end
 end
 
@@ -20,6 +20,7 @@ require_relative 'import_js/command_line_editor'
 require_relative 'import_js/configuration'
 require_relative 'import_js/emacs_editor'
 require_relative 'import_js/import_statement'
+require_relative 'import_js/import_statements'
 require_relative 'import_js/importer'
 require_relative 'import_js/js_module'
 require_relative 'import_js/version'

data/lib/import_js/command_line_editor.rb

@@ -7,7 +7,7 @@ module ImportJS
       @ask_for_selections = []
       @selections = opts[:selections] unless opts[:selections].empty?
       @word = opts[:word]
-      @filename = opts[:filename]
+      @path_to_file = opts[:path_to_file]
     end
 
     # @return [String]
@@ -17,7 +17,7 @@ module ImportJS
 
     # @return [String?]
     def path_to_current_file
-      @filename
+      @path_to_file
     end
 
     # @param file_path [String]
@@ -110,17 +110,5 @@ module ImportJS
         nil
       end
     end
-
-    # Get the preferred max length of a line.
-    # @return [Number?]
-    def max_line_length
-      80
-    end
-
-    # @return [String] shiftwidth number of spaces if expandtab is not set,
-    #   otherwise `\t`.
-    def tab
-      '  '
-    end
   end
 end

data/lib/import_js/configuration.rb

@@ -15,9 +15,11 @@ module ImportJS
     'import_dev_dependencies' => false,
     'import_function' => 'require',
     'lookup_paths' => ['.'],
+    'max_line_length' => 80,
     'minimum_version' => '0.0.0',
     'strip_file_extensions' => ['.js', '.jsx'],
     'strip_from_path' => nil,
+    'tab' => '  ',
     'use_relative_paths' => false,
   }.freeze
 
@@ -110,9 +112,9 @@ module ImportJS
       return if Gem::Dependency.new('', ">= #{minimum_version}")
                                .match?('', VERSION)
 
-      fail ClientTooOldError,
-           'The .importjs.json file you are using requires version ' \
-           "#{get('minimum_version')}. You are using #{VERSION}."
+      raise ClientTooOldError,
+            'The .importjs.json file you are using requires version ' \
+            "#{get('minimum_version')}. You are using #{VERSION}."
     end
   end
 end

data/lib/import_js/emacs_editor.rb

@@ -138,22 +138,5 @@ module ImportJS
       return if selected_index < 1
       selected_index - 1
     end
-
-    # Get the preferred max length of a line
-    # @return [Number?]
-    def max_line_length
-      80
-    end
-
-    # @return [String] shiftwidth number of spaces if expandtab is not set,
-    #   otherwise `\t`
-    def tab
-      ' ' * shift_width || 2
-    end
-
-    # @return [Number?]
-    def shift_width
-      2
-    end
   end
 end

data/lib/import_js/import_statement.rb

@@ -9,12 +9,13 @@ module ImportJS
       (?<declaration_keyword>const|let|var)\s+ # <declaration_keyword>
       (?<assignment>.+?)   # <assignment> variable assignment
       \s*=\s*
-      (?<import_function>[^\(]+?)\( # <import_function> variable assignment
+      (?<import_function>\w+?)\( # <import_function> variable assignment
         (?<quote>'|")      # <quote> opening quote
-        (?<path>[^\2]+)    # <path> module path
+        (?<path>[^\2\n]+)  # <path> module path
         \k<quote>          # closing quote
       \);?
       \s*
+      \Z
     /xm
 
     REGEX_IMPORT = /
@@ -23,12 +24,14 @@ module ImportJS
       (?<assignment>.*?) # <assignment> variable assignment
       \s+from\s+
       (?<quote>'|")      # <quote> opening quote
-      (?<path>[^\2]+)    # <path> module path
+      (?<path>[^\2\n]+)  # <path> module path
       \k<quote>          # closing quote
       ;?\s*
+      \Z
     /xm
 
     REGEX_NAMED = /
+      \A
       (?:                # non-capturing group
         (?<default>.*?)  # <default> default import
         ,\s*
@@ -38,6 +41,7 @@ module ImportJS
         (?<named>.*)      # <named> named imports
         \s*
       \}
+      \Z
     /xm
 
     attr_accessor :assignment
@@ -59,50 +63,67 @@ module ImportJS
               REGEX_IMPORT.match(string)
       return unless match
 
-      statement = new
-      statement.original_import_string = match.string
-      statement.declaration_keyword = match[:declaration_keyword]
-      statement.path = match[:path]
-      statement.assignment = match[:assignment]
-      if match.names.include? 'import_function'
-        statement.import_function = match[:import_function]
-      end
-      dest_match = statement.assignment.match(REGEX_NAMED)
+      import_function = if match.names.include?('import_function')
+                          match[:import_function]
+                        else
+                          'require'
+                        end
+
+      dest_match = match[:assignment].match(REGEX_NAMED)
       if dest_match
-        statement.default_import = dest_match[:default]
-        statement.named_imports =
-          dest_match[:named].split(/,\s*/).map(&:strip)
+        default_import = dest_match[:default]
+        named_imports = dest_match[:named].split(/,\s*/).map(&:strip)
       else
-        statement.default_import = statement.assignment
+        default_import = match[:assignment]
+        return unless default_import =~ /\A\w+\Z/
       end
-      statement
-    end
 
-    # Sets the default_import and clears the original import string cache.
-    # @param value [String]
-    def set_default_import(value)
-      @default_import = value
-      clear_import_string_cache
+      new(
+        assignment: match[:assignment],
+        declaration_keyword: match[:declaration_keyword],
+        default_import: default_import,
+        import_function: import_function,
+        named_imports: named_imports,
+        original_import_string: match.string,
+        path: match[:path]
+      )
     end
 
-    # Injects a new variable into an already existing set of named imports.
-    # @param variable_name [String]
-    def inject_named_import(variable_name)
-      @named_imports ||= []
-      named_imports << variable_name
-      named_imports.sort!.uniq!
-
-      clear_import_string_cache
+    def initialize(
+      assignment: nil,
+      declaration_keyword: nil,
+      default_import: nil,
+      import_function: nil,
+      named_imports: nil,
+      original_import_string: nil,
+      path: nil
+    )
+      @assignment = assignment
+      @declaration_keyword = declaration_keyword
+      @default_import = default_import
+      @import_function = import_function
+      @named_imports = named_imports
+      @original_import_string = original_import_string
+      @path = path
     end
 
     # Deletes a variable from an already existing default import or set of
-    #   named imports.
+    # named imports.
     # @param variable_name [String]
-    def delete_variable(variable_name)
-      @default_import = nil if default_import == variable_name
-      @named_imports.delete(variable_name) if named_imports?
+    def delete_variable!(variable_name)
+      touched = false
 
-      clear_import_string_cache
+      if default_import == variable_name
+        @default_import = nil
+        touched = true
+      end
+
+      if named_imports?
+        deleted = @named_imports.delete(variable_name)
+        touched = true if deleted
+      end
+
+      clear_import_string_cache if touched
     end
 
     # @return [Boolean] true if there are named imports
@@ -116,39 +137,38 @@ module ImportJS
       default_import.nil? && !named_imports?
     end
 
-    # @return [Array] an array that can be used in `uniq!` to dedupe equal
-    #   statements, e.g.
-    #   `const foo = require('foo');`
-    #   `import foo from 'foo';`
+    # @return [Boolean] true if this instance was created through parsing an
+    #   existing import and it hasn't been altered since it was created.
+    def parsed_and_untouched?
+      !original_import_string.nil?
+    end
+
+    # @return [Array] an array that can be used in `sort` and `uniq`
     def to_normalized
-      [default_import, named_imports, path]
+      [default_import || '', named_imports || '']
+    end
+
+    # @return [Array<String>] Array of all variables that this ImportStatement
+    #   imports.
+    def variables
+      [@default_import, *@named_imports].compact
     end
 
     # @param max_line_length [Number] where to cap lines at
     # @param tab [String] e.g. '  ' (two spaces)
-    # @return [Array] generated import statement strings
+    # @return [Array<String>] generated import statement strings
     def to_import_strings(max_line_length, tab)
       return [original_import_string] if original_import_string
 
       if declaration_keyword == 'import'
         # ES2015 Modules (ESM) syntax can support default imports and
         # named imports on the same line.
-        if named_imports?
-          [named_import_string(max_line_length, tab)]
-        else
-          [default_import_string(max_line_length, tab)]
-        end
+        return [named_import_string(max_line_length, tab)] if named_imports?
+        [default_import_string(max_line_length, tab)]
       else # const/var
         strings = []
-
-        if default_import
-          strings << default_import_string(max_line_length, tab)
-        end
-
-        if named_imports?
-          strings << named_import_string(max_line_length, tab)
-        end
-
+        strings << default_import_string(max_line_length, tab) if default_import
+        strings << named_import_string(max_line_length, tab) if named_imports?
         strings
       end
     end
@@ -156,15 +176,22 @@ module ImportJS
     # Merge another ImportStatement into this one.
     # @param import_statement [ImportJS::ImportStatement]
     def merge(import_statement)
-      if import_statement.default_import
+      if import_statement.default_import &&
+         @default_import != import_statement.default_import
         @default_import = import_statement.default_import
         clear_import_string_cache
       end
 
       if import_statement.named_imports?
         @named_imports ||= []
+        original_named_imports = @named_imports.clone
         @named_imports.concat(import_statement.named_imports)
         @named_imports.sort!.uniq!
+        clear_import_string_cache if original_named_imports != @named_imports
+      end
+
+      if @declaration_keyword != import_statement.declaration_keyword
+        @declaration_keyword = import_statement.declaration_keyword
         clear_import_string_cache
       end
     end
@@ -181,7 +208,7 @@ module ImportJS
     # @return [Array]
     def equals_and_value
       return ['from', "'#{path}';"] if declaration_keyword == 'import'
-      ['=', "#{import_function}('#{path}');"]
+      ['=', "#{@import_function}('#{path}');"]
     end
 
     # @param max_line_length [Number] where to cap lines at
@@ -189,10 +216,10 @@ module ImportJS
     # @return [String] import statement, wrapped at max line length if necessary
     def default_import_string(max_line_length, tab)
       equals, value = equals_and_value
-      line = "#{declaration_keyword} #{default_import} #{equals} #{value}"
+      line = "#{@declaration_keyword} #{@default_import} #{equals} #{value}"
       return line unless line_too_long?(line, max_line_length)
 
-      "#{declaration_keyword} #{default_import} #{equals}\n#{tab}#{value}"
+      "#{@declaration_keyword} #{@default_import} #{equals}\n#{tab}#{value}"
     end
 
     # @param max_line_length [Number] where to cap lines at
@@ -200,17 +227,17 @@ module ImportJS
     # @return [String] import statement, wrapped at max line length if necessary
     def named_import_string(max_line_length, tab)
       equals, value = equals_and_value
-      if declaration_keyword == 'import' && default_import
-        prefix = "#{default_import}, "
+      if @declaration_keyword == 'import' && @default_import
+        prefix = "#{@default_import}, "
       end
 
-      named = "{ #{named_imports.join(', ')} }"
-      line = "#{declaration_keyword} #{prefix}#{named} #{equals} " \
+      named = "{ #{@named_imports.join(', ')} }"
+      line = "#{@declaration_keyword} #{prefix}#{named} #{equals} " \
         "#{value}"
       return line unless line_too_long?(line, max_line_length)
 
-      named = "{\n#{tab}#{named_imports.join(",\n#{tab}")},\n}"
-      "#{declaration_keyword} #{prefix}#{named} #{equals} #{value}"
+      named = "{\n#{tab}#{@named_imports.join(",\n#{tab}")},\n}"
+      "#{@declaration_keyword} #{prefix}#{named} #{equals} #{value}"
     end
 
     def clear_import_string_cache

data/lib/import_js/import_statements.rb

@@ -0,0 +1,175 @@
+module ImportJS
+  # Class that sorts ImportStatements as they are pushed in
+  class ImportStatements
+    include Enumerable
+
+    STYLE_IMPORT = :import
+    STYLE_CONST = :const
+    STYLE_VAR = :var
+    STYLE_CUSTOM = :custom
+
+    # Order is significant here
+    STYLES = [STYLE_IMPORT, STYLE_CONST, STYLE_VAR, STYLE_CUSTOM].freeze
+
+    PATH_TYPE_PACKAGE = :package
+    PATH_TYPE_NON_RELATIVE = :non_relative
+    PATH_TYPE_RELATIVE = :relative
+
+    # Order is significant here
+    PATH_TYPES = [
+      PATH_TYPE_PACKAGE,
+      PATH_TYPE_NON_RELATIVE,
+      PATH_TYPE_RELATIVE,
+    ].freeze
+
+    GROUPINGS_ARRAY = STYLES.map do |style|
+      PATH_TYPES.map do |location|
+        "#{style} #{location}"
+      end
+    end.flatten.freeze
+
+    GROUPINGS = Hash[
+      GROUPINGS_ARRAY.each_with_index.map { |group, index| [group, index] }
+    ].freeze
+
+    # @param config [ImportJS::Configuration]
+    # @param imports [Hash]
+    def initialize(config, imports = {})
+      @config = config
+      @imports = imports
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @imports.each do |_, import_statement|
+        yield import_statement
+      end
+    end
+
+    def clone
+      ImportStatements.new(@config, @imports.clone)
+    end
+
+    # @param import_statement [ImportJS::ImportStatement]
+    # @return [ImportJS::ImportStatements]
+    def push(import_statement)
+      if @imports[import_statement.path]
+        # Import already exists, so this line is likely one of a named imports
+        # pair. Combine it into the same ImportStatement.
+        @imports[import_statement.path].merge(import_statement)
+      else
+        # This is a new import, so we just add it to the hash.
+        @imports[import_statement.path] = import_statement
+      end
+
+      self # for chaining
+    end
+    alias << push
+
+    # @param variable_names [Array<String>]
+    # @return [ImportJS::ImportStatements]
+    def delete_variables!(variable_names)
+      @imports.reject! do |_, import_statement|
+        variable_names.each do |variable_name|
+          import_statement.delete_variable!(variable_name)
+        end
+        import_statement.empty?
+      end
+
+      self # for chaining
+    end
+
+    # Convert the import statements into an array of strings, with an empty
+    # string between each group.
+    # @return [Array<String>]
+    def to_a
+      max_line_length = @config.get('max_line_length')
+      tab = @config.get('tab')
+
+      strings = []
+      to_groups.each do |group|
+        group.each do |import_statement|
+          strings.concat(
+            import_statement.to_import_strings(max_line_length, tab))
+        end
+        strings << '' # Add a blank line between groups.
+      end
+
+      # We don't want to include a trailing newline at the end of all the
+      # groups here.
+      strings.pop if strings.last == ''
+
+      strings
+    end
+
+    private
+
+    # Sort the import statements by path and group them based on our heuristic
+    # of style and path type.
+    # @return [Array<Array<ImportJS::ImportStatement>>]
+    def to_groups
+      groups = []
+
+      imports_array = @imports.values
+
+      # There's a chance we have duplicate imports (can happen when switching
+      # declaration_keyword for instance). By first sorting imports so that new
+      # ones are first, then removing duplicates, we guarantee that we delete
+      # the old ones that are now redundant.
+      partitioned = imports_array.partition do |import_statement|
+        !import_statement.parsed_and_untouched?
+      end.flatten.uniq(&:to_normalized).sort_by(&:to_normalized)
+
+      package_dependencies = @config.package_dependencies
+      partitioned.each do |import_statement|
+        # Figure out what group to put this import statement in
+        group_index = import_statement_group_index(
+          import_statement, package_dependencies)
+
+        # Add the import statement to the group
+        groups[group_index] ||= []
+        groups[group_index] << import_statement
+      end
+
+      groups.compact! unless groups.empty?
+      groups
+    end
+
+    # @param import_statement [ImportJS::ImportStatement]
+    # @param package_dependencies [Array<String>]
+    # @return [Number]
+    def import_statement_group_index(import_statement, package_dependencies)
+      style = import_statement_style(import_statement)
+      path_type = import_statement_path_type(
+        import_statement, package_dependencies)
+
+      GROUPINGS["#{style} #{path_type}"]
+    end
+
+    # Determine import statement style
+    # @param import_statement [ImportJS::ImportStatement]
+    # @return [String] 'import', 'const', 'var', or 'custom'
+    def import_statement_style(import_statement)
+      return STYLE_IMPORT if import_statement.declaration_keyword == 'import'
+
+      if import_statement.import_function == 'require'
+        return STYLE_CONST if import_statement.declaration_keyword == 'const'
+        return STYLE_VAR if import_statement.declaration_keyword == 'var'
+      end
+
+      STYLE_CUSTOM
+    end
+
+    # Determine import path type
+    # @param import_statement [ImportJS::ImportStatement]
+    # @param package_dependencies [Array<String>]
+    # @return [String] 'package, 'non-relative', 'relative'
+    def import_statement_path_type(import_statement, package_dependencies)
+      path = import_statement.path
+      return PATH_TYPE_RELATIVE if path.start_with?('.')
+      return PATH_TYPE_PACKAGE if package_dependencies.include?(path)
+      PATH_TYPE_NON_RELATIVE
+    end
+  end
+end

data/lib/import_js/importer.rb

@@ -1,14 +1,10 @@
 require 'json'
 require 'open3'
+require 'set'
+require 'strscan'
 
 module ImportJS
   class Importer
-    REGEX_USE_STRICT = /(['"])use strict\1;?/
-    REGEX_SINGLE_LINE_COMMENT = %r{\A\s*//}
-    REGEX_MULTI_LINE_COMMENT_START = %r{\A\s*/\*}
-    REGEX_MULTI_LINE_COMMENT_END = %r{\*/}
-    REGEX_WHITESPACE_ONLY = /\A\s*\Z/
-
     def initialize(editor = VIMEditor.new)
       @editor = editor
     end
@@ -31,10 +27,9 @@ module ImportJS
 
       maintain_cursor_position do
         old_imports = find_current_imports
-        inject_js_module(variable_name, js_module, old_imports[:imports])
-        replace_imports(old_imports[:newline_count],
-                        old_imports[:imports],
-                        old_imports[:imports_start_at])
+        import_statement = js_module.to_import_statement(variable_name, @config)
+        old_imports[:imports] << import_statement
+        replace_imports(old_imports[:range], old_imports[:imports])
       end
     end
 
@@ -43,16 +38,11 @@ module ImportJS
       js_modules = []
       variable_name = @editor.current_word
       time do
-        js_modules = find_js_modules(variable_name)
-      end
-
-      if js_modules.empty?
-        # No JS modules are found for the variable, so there is nothing to go to
-        # and we return early.
-        return message("No modules were found for `#{variable_name}`")
+        js_modules = find_js_modules_for(variable_name)
       end
 
-      js_module = resolve_goto_module(js_modules, variable_name)
+      js_module = resolve_module_using_current_imports(
+        js_modules, variable_name)
 
       unless js_module
         # The current word is not mappable to one of the JS modules that we
@@ -83,38 +73,48 @@ module ImportJS
       reload_config
       eslint_result = run_eslint_command
 
-      unused_variables = []
-      undefined_variables = []
+      unused_variables = Set.new
+      undefined_variables = Set.new
 
       eslint_result.each do |line|
         match = REGEX_ESLINT_RESULT.match(line)
         next unless match
         if match[:type] == 'is defined but never used'
-          unused_variables << match[:variable_name]
+          unused_variables.add match[:variable_name]
         else
-          undefined_variables << match[:variable_name]
+          undefined_variables.add match[:variable_name]
         end
       end
 
-      unused_variables.uniq!
-      undefined_variables.uniq!
-
       old_imports = find_current_imports
-      new_imports = old_imports[:imports].reject do |import_statement|
-        unused_variables.each do |unused_variable|
-          import_statement.delete_variable(unused_variable)
-        end
-        import_statement.empty?
-      end
+      new_imports = old_imports[:imports].clone
+      new_imports.delete_variables!(unused_variables.to_a)
 
       undefined_variables.each do |variable|
         js_module = find_one_js_module(variable)
-        inject_js_module(variable, js_module, new_imports) if js_module
+        next unless js_module
+        new_imports << js_module.to_import_statement(variable, @config)
+      end
+
+      replace_imports(old_imports[:range], new_imports)
+    end
+
+    def rewrite_imports
+      reload_config
+
+      old_imports = find_current_imports
+      new_imports = old_imports[:imports].clone
+
+      old_imports[:imports].each do |import|
+        import.variables.each do |variable|
+          js_module = resolve_module_using_current_imports(
+            find_js_modules_for(variable), variable)
+          next unless js_module
+          new_imports << js_module.to_import_statement(variable, @config)
+        end
       end
 
-      replace_imports(old_imports[:newline_count],
-                      new_imports,
-                      old_imports[:imports_start_at])
+      replace_imports(old_imports[:range], new_imports)
     end
 
     private
@@ -158,11 +158,11 @@ module ImportJS
                                 stdin_data: @editor.current_file_content)
 
       if ESLINT_STDOUT_ERROR_REGEXES.any? { |regex| out =~ regex }
-        fail ParseError.new, out
+        raise ParseError.new, out
       end
 
       if ESLINT_STDERR_ERROR_REGEXES.any? { |regex| err =~ regex }
-        fail ParseError.new, err
+        raise ParseError.new, err
       end
 
       out.split("\n")
@@ -173,7 +173,7 @@ module ImportJS
     def find_one_js_module(variable_name)
       js_modules = []
       time do
-        js_modules = find_js_modules(variable_name)
+        js_modules = find_js_modules_for(variable_name)
       end
       if js_modules.empty?
         message(
@@ -184,59 +184,30 @@ module ImportJS
       resolve_one_js_module(js_modules, variable_name)
     end
 
-    # Add new import to the block of imports, wrapping at the max line length
-    # @param variable_name [String]
-    # @param js_module [ImportJS::JSModule]
-    # @param imports [Array<ImportJS::ImportStatement>]
-    def inject_js_module(variable_name, js_module, imports)
-      import = imports.find do |an_import|
-        an_import.path == js_module.import_path
-      end
-
-      if import
-        import.declaration_keyword = @config.get(
-          'declaration_keyword', from_file: js_module.file_path)
-        import.import_function = @config.get(
-          'import_function', from_file: js_module.file_path)
-        if js_module.has_named_exports
-          import.inject_named_import(variable_name)
-        else
-          import.set_default_import(variable_name)
-        end
-      else
-        imports.unshift(js_module.to_import_statement(variable_name, @config))
-      end
-
-      # Remove duplicate import statements
-      imports.uniq!(&:to_normalized)
-    end
-
     # @param imports [Array<ImportJS::ImportStatement>]
     # @return [String]
     def generate_import_strings(import_statements)
       import_statements.map do |import|
-        import.to_import_strings(@editor.max_line_length, @editor.tab)
+        import.to_import_strings(@config.get('max_line_length'),
+                                 @config.get('tab'))
       end.flatten.sort
     end
 
-    # @param old_imports_lines [Number]
-    # @param new_imports [Array<ImportJS::ImportStatement>]
-    # @param imports_start_at [Number]
-    def replace_imports(old_imports_lines, new_imports, imports_start_at)
-      imports_end_at = old_imports_lines + imports_start_at
+    # @param old_imports_range [Range]
+    # @param new_imports [ImportJS::ImportStatements]
+    def replace_imports(old_imports_range, new_imports)
+      import_strings = new_imports.to_a
 
       # Ensure that there is a blank line after the block of all imports
-      if old_imports_lines + new_imports.length > 0 &&
-         !@editor.read_line(imports_end_at + 1).strip.empty?
-        @editor.append_line(imports_end_at, '')
+      if old_imports_range.size + import_strings.length > 0 &&
+         !@editor.read_line(old_imports_range.last + 1).strip.empty?
+        @editor.append_line(old_imports_range.last, '')
       end
 
-      import_strings = generate_import_strings(new_imports)
-
       # Find old import strings so we can compare with the new import strings
       # and see if anything has changed.
       old_import_strings = []
-      (imports_start_at...imports_end_at).each do |line_index|
+      old_imports_range.each do |line_index|
         old_import_strings << @editor.read_line(line_index + 1)
       end
 
@@ -245,97 +216,72 @@ module ImportJS
       return if import_strings == old_import_strings
 
       # Delete old imports, then add the modified list back in.
-      old_imports_lines.times { @editor.delete_line(1 + imports_start_at) }
+      old_imports_range.each do
+        @editor.delete_line(1 + old_imports_range.first)
+      end
       import_strings.reverse_each do |import_string|
         # We need to add each line individually because the Vim buffer will
         # convert newline characters to `~@`.
-        import_string.split("\n").reverse_each do |line|
-          @editor.append_line(imports_start_at, line)
+        if import_string.include? "\n"
+          import_string.split("\n").reverse_each do |line|
+            @editor.append_line(old_imports_range.first, line)
+          end
+        else
+          @editor.append_line(old_imports_range.first, import_string)
         end
       end
     end
 
-    # @return [Number]
-    def find_imports_start_line_index
-      imports_start_line_index = 0
-
-      # Skip over things at the top, like "use strict" and comments.
-      inside_multi_line_comment = false
-      matched_non_whitespace_line = false
-      (0...@editor.count_lines).each do |line_index|
-        line = @editor.read_line(line_index + 1)
-
-        if inside_multi_line_comment || line =~ REGEX_MULTI_LINE_COMMENT_START
-          matched_non_whitespace_line = true
-          imports_start_line_index = line_index + 1
-          inside_multi_line_comment = !(line =~ REGEX_MULTI_LINE_COMMENT_END)
-          next
-        end
-
-        if line =~ REGEX_USE_STRICT || line =~ REGEX_SINGLE_LINE_COMMENT
-          matched_non_whitespace_line = true
-          imports_start_line_index = line_index + 1
-          next
-        end
-
-        if line =~ REGEX_WHITESPACE_ONLY
-          imports_start_line_index = line_index + 1
-          next
-        end
-
-        break
-      end
-
-      # We don't want to skip over blocks that are only whitespace
-      return imports_start_line_index if matched_non_whitespace_line
-      0
-    end
+    REGEX_SKIP_SECTION = %r{
+      \s*                       # preceding whitespace
+      (?:
+        (['"])use\sstrict\1;?   # 'use strict';
+        |
+        //.*                    # single-line comment
+        |
+        /\*                     # open multi-line comment
+        (?:\n|.)*?              # inside of multi-line comment
+        \*/                     # close multi-line comment
+      )?                        # ? b/c we want to match on only whitespace
+      \n                        # end of line
+    }x
 
     # @return [Hash]
     def find_current_imports
-      result = {
-        imports: [],
-        newline_count: 0,
-        imports_start_at: find_imports_start_line_index,
-      }
+      imports_start_at = 0
+      newline_count = 0
 
-      # Find block of lines that might be imports.
-      potential_import_lines = []
-      (result[:imports_start_at]...@editor.count_lines).each do |line_index|
-        line = @editor.read_line(line_index + 1)
-        break if line.strip.empty?
-        potential_import_lines << line
+      scanner = StringScanner.new(@editor.current_file_content)
+      skipped = ''
+      while skip_section = scanner.scan(REGEX_SKIP_SECTION)
+        skipped += skip_section
       end
 
-      # We need to put the potential imports back into a blob in order to scan
-      # for multiline imports
-      potential_imports_blob = potential_import_lines.join("\n")
+      # We don't want to skip over blocks that are only whitespace
+      if skipped =~ /\A(\s*\n)+\Z/m
+        scanner = StringScanner.new(@editor.current_file_content)
+      else
+        imports_start_at += skipped.count("\n")
+      end
 
-      # Scan potential imports for everything ending in a semicolon, then
-      # iterate through those and stop at anything that's not an import.
-      imports = {}
-      potential_imports_blob.scan(/^.*?;/m).each do |potential_import|
-        import_statement = ImportStatement.parse(potential_import)
+      imports = ImportStatements.new(@config)
+      while potential_import = scanner.scan(/(^\s*\n)*^.*?;\n/m)
+        import_statement = ImportStatement.parse(potential_import.strip)
         break unless import_statement
 
-        if imports[import_statement.path]
-          # Import already exists, so this line is likely one of a named imports
-          # pair. Combine it into the same ImportStatement.
-          imports[import_statement.path].merge(import_statement)
-        else
-          # This is a new import, so we just add it to the hash.
-          imports[import_statement.path] = import_statement
-        end
-
-        result[:newline_count] += potential_import.scan(/\n/).length + 1
+        imports << import_statement
+        newline_count += potential_import.scan(/\n/).length
       end
-      result[:imports] = imports.values
-      result
+
+      {
+        imports: imports,
+        range: imports_start_at...(imports_start_at + newline_count),
+      }
     end
 
     # @param variable_name [String]
     # @return [Array]
-    def find_js_modules(variable_name)
+    def find_js_modules_for(variable_name)
       path_to_current_file = @editor.path_to_current_file
 
       alias_module = @config.resolve_alias(variable_name, path_to_current_file)
@@ -352,8 +298,8 @@ module ImportJS
         if lookup_path == ''
           # If lookup_path is an empty string, the `find` command will not work
           # as desired so we bail early.
-          fail FindError.new,
-               "lookup path cannot be empty (#{lookup_path.inspect})"
+          raise FindError.new,
+                "lookup path cannot be empty (#{lookup_path.inspect})"
         end
 
         find_command = %W[
@@ -364,7 +310,7 @@ module ImportJS
         command = "#{find_command} | #{egrep_command}"
         out, err = Open3.capture3(command)
 
-        fail FindError.new, err unless err == ''
+        raise FindError.new, err unless err == ''
 
         matched_modules.concat(
           out.split("\n").map do |f|
@@ -443,15 +389,35 @@ module ImportJS
     # @param js_modules [Array]
     # @param variable_name [String]
     # @return [ImportJS::JSModule]
-    def resolve_goto_module(js_modules, variable_name)
+    def resolve_module_using_current_imports(js_modules, variable_name)
       return js_modules.first if js_modules.length == 1
 
-      # Look for a current import matching the goto
-      find_current_imports[:imports].each do |ist|
+      # Look at the current imports and grab what is already imported for the
+      # variable.
+      matching_import_statement = find_current_imports[:imports].find do |ist|
+        next true if variable_name == ist.default_import
+        next false unless ist.named_imports
+        ist.named_imports.include?(variable_name)
+      end
+
+      if matching_import_statement
+        if js_modules.empty?
+          # We couldn't resolve any module for the variable. As a fallback, we
+          # can use the matching import statement. If that maps to a package
+          # dependency, we will still open the right file.
+          matched_module = JSModule.new(
+            import_path: matching_import_statement.path)
+          if matching_import_statement.named_imports?
+            matched_module.has_named_exports =
+              matching_import_statement.named_imports.include?(variable_name)
+          end
+          return matched_module
+        end
+
+        # Look for a module matching what is already imported
         js_modules.each do |js_module|
-          next unless variable_name == ist.default_import ||
-                      (ist.named_imports || []).include?(variable_name)
-          return js_module if ist.path == js_module.import_path
+          return js_module if matching_import_statement.path ==
+                              js_module.import_path
         end
       end
 

data/lib/import_js/js_module.rb

@@ -16,6 +16,7 @@ module ImportJS
     #   e.g. ['.js', '.jsx']
     # @param make_relative_to [String|nil] a path to a different file which the
     #   resulting import path should be relative to.
+    # @param strip_from_path [String]
     def self.construct(lookup_path: nil,
                        relative_file_path: nil,
                        strip_file_extensions: nil,
@@ -30,13 +31,12 @@ module ImportJS
 
       return unless import_path
 
-      import_path = import_path.sub(
-        %r{^#{Regexp.escape(js_module.lookup_path)}/}, '')
+      import_path.sub!(%r{^#{Regexp.escape(js_module.lookup_path)}/}, '')
 
       js_module.import_path = import_path
       js_module.main_file = main_file
       js_module.make_relative_to(make_relative_to) if make_relative_to
-      js_module.strip_from_path(strip_from_path) unless make_relative_to
+      js_module.strip_from_path!(strip_from_path) unless make_relative_to
       js_module
     end
 
@@ -101,15 +101,18 @@ module ImportJS
     # @param make_relative_to [String]
     def make_relative_to(make_relative_to)
       return unless lookup_path
+
+      # Prevent mutating the argument that was passed in
+      make_relative_to = make_relative_to.dup
+
       # First, strip out any absolute path up until the current directory
-      make_relative_to = make_relative_to.sub("#{Dir.pwd}/", '')
+      make_relative_to.sub!("#{Dir.pwd}/", '')
 
       # Ignore if the file to relate to is part of a different lookup_path
       return unless make_relative_to.start_with? lookup_path
 
       # Strip out the lookup_path
-      make_relative_to = make_relative_to.sub(
-        %r{^#{Regexp.escape(lookup_path)}/}, '')
+      make_relative_to.sub!(%r{^#{Regexp.escape(lookup_path)}/}, '')
 
       path = Pathname.new(import_path).relative_path_from(
         Pathname.new(File.dirname(make_relative_to))
@@ -122,9 +125,9 @@ module ImportJS
     end
 
     # @param prefix [String]
-    def strip_from_path(prefix)
+    def strip_from_path!(prefix)
       return unless prefix
-      self.import_path = import_path.sub(/^#{Regexp.escape(prefix)}/, '')
+      import_path.sub!(/^#{Regexp.escape(prefix)}/, '')
     end
 
     # @return [String] a readable description of the module
@@ -171,18 +174,20 @@ module ImportJS
     # @param config [ImportJS::Configuration]
     # @return [ImportJS::ImportStatement]
     def to_import_statement(variable_name, config)
-      ImportStatement.new.tap do |statement|
-        if has_named_exports
-          statement.inject_named_import(variable_name)
-        else
-          statement.default_import = variable_name
-        end
-        statement.path = import_path
-        statement.declaration_keyword = config.get('declaration_keyword',
-                                                   from_file: file_path)
-        statement.import_function = config.get('import_function',
-                                               from_file: file_path)
+      if has_named_exports
+        named_imports = [variable_name]
+      else
+        default_import = variable_name
       end
+
+      ImportStatement.new(
+        declaration_keyword:
+          config.get('declaration_keyword', from_file: file_path),
+        default_import: default_import,
+        import_function: config.get('import_function', from_file: file_path),
+        named_imports: named_imports,
+        path: import_path
+      )
     end
   end
 end

data/lib/import_js/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 module ImportJS
-  VERSION = '0.4.1'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/lib/import_js/vim_editor.rb

@@ -110,19 +110,6 @@ module ImportJS
       selected_index - 1
     end
 
-    # Get the preferred max length of a line
-    # @return [Number?]
-    def max_line_length
-      get_number('&textwidth')
-    end
-
-    # @return [String] shiftwidth number of spaces if expandtab is not set,
-    #   otherwise `\t`
-    def tab
-      return "\t" unless expand_tab?
-      ' ' * (shift_width || 2)
-    end
-
     private
 
     # Check for the presence of a setting such as:
@@ -147,21 +134,5 @@ module ImportJS
     def get_number(name)
       exists?(name) ? VIM.evaluate(name).to_i : nil
     end
-
-    # @param name [String]
-    # @return [Boolean?]
-    def get_bool(name)
-      exists?(name) ? VIM.evaluate(name).to_i != 0 : nil
-    end
-
-    # @return [Boolean?]
-    def expand_tab?
-      get_bool('&expandtab')
-    end
-
-    # @return [Number?]
-    def shift_width
-      get_number('&shiftwidth')
-    end
   end
 end

data/lib/vim_import_js.rb

@@ -0,0 +1,4 @@
+# This is a proxy file for ./import_js.rb. Vim needs it so that we can prevent
+# any installed import_js gems from being loaded before the files in the local
+# filesystem.
+require_relative './import_js'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: import_js
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Henric Trotzig
@@ -43,10 +43,12 @@ files:
 - lib/import_js/configuration.rb
 - lib/import_js/emacs_editor.rb
 - lib/import_js/import_statement.rb
+- lib/import_js/import_statements.rb
 - lib/import_js/importer.rb
 - lib/import_js/js_module.rb
 - lib/import_js/version.rb
 - lib/import_js/vim_editor.rb
+- lib/vim_import_js.rb
 homepage: http://rubygems.org/gems/import_js
 licenses:
 - MIT