import_js 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7281a4ddb53f991a2649b7fe3be8a49299cc5e4a
-  data.tar.gz: 44a9e946d556775eda9572bdd1fd411fff8434ff
+  metadata.gz: 0c2841cf4974c8a53e788a4ec74e78091948e470
+  data.tar.gz: 97e8905dc410a022a31522585054fda588a622c9
 SHA512:
-  metadata.gz: 768713a538e2e4c13eeb3fcb8d73df611a679add1f0a2bc65476c3c859f68aa260d61837e94b38aebdad234e776249347adccba2574c78817171ade902fc199c
-  data.tar.gz: 198423cbd91368c37904ff26f9e2ceaf2bbcb83b4d9db37be3e26ee094b9341ebd7f75360021a67fc99bd61700fe07dff3fd3bfc56c36f29926dcf533964d6e1
+  metadata.gz: a0c6a2f736161c17bf7ad89b0921c36295618930f1b598c565e748e25ea74837662b78d835c9801464ced440bb8c2e52461942e75c598c3a80294229b5858603
+  data.tar.gz: 9695778534d541cf215728512635f7d78b01e4f2c72ab315021e2d5b2900170e5db7379a4205e06b9ec7c1393b2ca31527519235a7a167670f31267e7856411d

data/lib/import_js/import_statement.rb

@@ -26,10 +26,22 @@ module ImportJS
       ;?\s*
     }xm
 
+    REGEX_DESTRUCTURE = %r{
+      (?:                    # non-capturing group
+        (?<default>.*?)      # <default> variable
+        ,\s*
+      )?
+      \{
+        \s*
+        (?<destructured>.*)  # <destructured> variables
+        \s*
+      \}
+    }x
+
     attr_accessor :assignment
     attr_accessor :original_import_string # a cache of the parsed import string
-    attr_accessor :variables
-    attr_accessor :is_destructured # can't use `destructured?` because of 1.9.3
+    attr_accessor :default_variable
+    attr_accessor :destructured_variables
     attr_accessor :path
 
     # @param string [String] a possible import statement, e.g.
@@ -45,66 +57,123 @@ module ImportJS
       statement.original_import_string = match.string
       statement.path = match[:path]
       statement.assignment = match[:assignment]
-      if dest_match = statement.assignment.match(/\{\s*(.*)\s*\}/)
-        statement.variables = dest_match[1].split(/,\s*/).map(&:strip)
-        statement.is_destructured = true
+      if dest_match = statement.assignment.match(REGEX_DESTRUCTURE)
+        statement.default_variable = dest_match[:default]
+        statement.destructured_variables =
+          dest_match[:destructured].split(/,\s*/).map(&:strip)
       else
-        statement.variables = [statement.assignment]
+        statement.default_variable = statement.assignment
       end
       statement
     end
 
+    # Sets the default_variable and clears the original import string cache.
+    # @param value [String]
+    def set_default_variable(value)
+      @default_variable = value
+      @original_import_string = nil # clear import string cache if there was one
+    end
+
     # Injects a new variable into an already existing set of destructured
     #   variables.
     # @param variable_name [String]
-    def inject_variable(variable_name)
-      variables << variable_name
-      variables.sort!.uniq!
+    def inject_destructured_variable(variable_name)
+      @destructured_variables ||= []
+      destructured_variables << variable_name
+      destructured_variables.sort!.uniq!
 
       @original_import_string = nil # clear import string cache if there was one
     end
 
-    # Deletes a variable from an already existing set of destructured
-    #   variables.
+    # Deletes a variable from an already existing default variable or set of
+    #   destructured variables.
     # @param variable_name [String]
     def delete_variable(variable_name)
-      variables.delete(variable_name)
+      @default_variable = nil if default_variable == variable_name
+      @destructured_variables.delete(variable_name) unless destructured_variables.nil?
 
       @original_import_string = nil # clear import string cache if there was one
     end
 
+    # @return [Boolean] true if there are destructured variables
+    def destructured?
+      !destructured_variables.nil? && !destructured_variables.empty?
+    end
+
+    # @return [Boolean] true if there is no default variable and there are no
+    #   destructured variables
+    def empty?
+      default_variable.nil? && !destructured?
+    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';`
-    def normalize
-      [variables, path]
+    def to_normalized
+      [default_variable, destructured_variables, path]
     end
 
     # @param declaration_keyword [String] const, let, var, or import
     # @param max_line_length [Number] where to cap lines at
     # @param tab [String] e.g. '  ' (two spaces)
-    # @return a generated import statement string
-    def to_import_string(declaration_keyword, max_line_length, tab)
-      return original_import_string if original_import_string
-
-      declaration = if is_destructured
-                      "#{declaration_keyword} { #{variables.join(', ')} }"
-                    else
-                      "#{declaration_keyword} #{variables.first}"
-                    end
-
-      equals, value = if declaration_keyword == 'import'
-                        ['from', "'#{path}';"]
-                      else
-                        ['=', "require('#{path}');"]
-                      end
+    # @return [Array] generated import statement strings
+    def to_import_strings(declaration_keyword, max_line_length, tab)
+      return [original_import_string] if original_import_string
+
+      if declaration_keyword == 'import'
+        # ES2015 Modules (ESM) syntax can support default values and
+        # destructuring on the same line.
+        declaration = declaration_keyword
+        if destructured?
+          declaration += " #{default_variable}," if default_variable
+          declaration += " #{destructured_string}"
+        else
+          declaration += " #{default_variable}"
+        end
+        declaration += ' from'
+
+        [wrap_import(declaration, "'#{path}';", max_line_length, tab)]
+      else # const/let/var
+        value = "require('#{path}');"
 
+        if destructured? && !default_variable.nil?
+          # We have both a default variable and a destructuring to do, so we
+          # need to generate 2 lines for CommonJS style syntax.
+          default_declaration = "#{declaration_keyword} #{default_variable} ="
+          destructured_declaration = "#{declaration_keyword} #{destructured_string} ="
+
+          return [
+            wrap_import(default_declaration, value, max_line_length, tab),
+            wrap_import(destructured_declaration, value, max_line_length, tab)
+          ]
+        end
+
+        declaration_assignment =
+          destructured? ? destructured_string : default_variable
+        declaration = "#{declaration_keyword} #{declaration_assignment} ="
+        [wrap_import(declaration, value, max_line_length, tab)]
+      end
+    end
+
+    private
+
+    # @return [String]
+    def destructured_string
+      "{ #{destructured_variables.join(', ')} }"
+    end
+
+    # @param declaration [String]
+    # @param value [String]
+    # @param max_line_length [Number] where to cap lines at
+    # @param tab [String] e.g. '  ' (two spaces)
+    # @return [String] import statement, wrapped at max line length if necessary
+    def wrap_import(declaration, value, max_line_length, tab)
       if max_line_length &&
-         "#{declaration} #{equals} #{value}".length > max_line_length
-        "#{declaration} #{equals}\n#{tab}#{value}"
+         "#{declaration} #{value}".length > max_line_length
+        "#{declaration}\n#{tab}#{value}"
       else
-        "#{declaration} #{equals} #{value}"
+        "#{declaration} #{value}"
       end
     end
   end

data/lib/import_js/importer.rb

@@ -68,7 +68,7 @@ module ImportJS
         unused_variables.each do |unused_variable|
           import_statement.delete_variable(unused_variable)
         end
-        import_statement.variables.empty?
+        import_statement.empty?
       end
 
       undefined_variables.each do |variable|
@@ -128,18 +128,25 @@ 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)
-      # Add new import to the block of imports, wrapping at the max line length
-      unless js_module.is_destructured && inject_destructured_variable(
-        variable_name, js_module, imports)
+      import = imports.find { |import| import.path == js_module.import_path }
+
+      if import
+        if js_module.is_destructured
+          import.inject_destructured_variable(variable_name)
+        else
+          import.set_default_variable(variable_name)
+        end
+      else
         imports.unshift(js_module.to_import_statement(variable_name))
       end
 
       # Remove duplicate import statements
-      imports.uniq!(&:normalize)
+      imports.uniq!(&:to_normalized)
     end
 
     # @param old_imports_lines [Number]
@@ -154,11 +161,11 @@ module ImportJS
 
       # Generate import strings
       import_strings = new_imports.map do |import|
-        import.to_import_string(
+        import.to_import_strings(
           @config.get('declaration_keyword'),
           @editor.max_line_length,
           @editor.tab)
-      end.sort
+      end.flatten.sort
 
       # Delete old imports, then add the modified list back in.
       old_imports_lines.times { @editor.delete_line(1 + imports_start_at) }
@@ -171,17 +178,6 @@ module ImportJS
       end
     end
 
-    def inject_destructured_variable(variable_name, js_module, imports)
-      imports.each do |import|
-        next unless import.path == js_module.import_path
-        next unless import.is_destructured
-
-        import.inject_variable(variable_name)
-        return true
-      end
-      false
-    end
-
     # @return [Hash]
     def find_current_imports
       potential_import_lines = []
@@ -208,13 +204,32 @@ module ImportJS
 
       # 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 = ImportJS::ImportStatement.parse(potential_import)
         break unless import_statement
 
-        result[:imports] << import_statement
+        if imports[import_statement.path]
+          # Import already exists, so this line is likely one of a destructuring
+          # pair. Combine it into the same ImportStatement.
+          unless import_statement.default_variable.nil?
+            imports[import_statement.path].default_variable =
+              import_statement.default_variable
+          end
+
+          if import_statement.destructured?
+            imports[import_statement.path].destructured_variables ||= []
+            imports[import_statement.path].destructured_variables
+              .concat(import_statement.destructured_variables)
+          end
+        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
       end
+      result[:imports] = imports.values
       result
     end
 

data/lib/import_js/js_module.rb

@@ -51,8 +51,11 @@ module ImportJS
     # @return [ImportJS::ImportStatement]
     def to_import_statement(variable_name)
       ImportJS::ImportStatement.new.tap do |statement|
-        statement.is_destructured = is_destructured
-        statement.variables = [variable_name]
+        if is_destructured
+          statement.inject_destructured_variable(variable_name)
+        else
+          statement.default_variable = variable_name
+        end
         statement.path = import_path
       end
     end

data/lib/import_js/version.rb

@@ -1,4 +1,4 @@
 # Defines the gem version.
 module ImportJS
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: import_js
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Henric Trotzig