import_js 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 330ead6ec7804b53e85225024d9d66d001c29719
+  data.tar.gz: d959cff0e6e106e9035276a1ad69ecb740abbe74
+SHA512:
+  metadata.gz: c6c7c887852626478ab3a3496082ec2733e03570fe46fb3aef9a113a7d490645d9c3485913c611c424e3b51cc33831c148598668b912cc51d78aa6a76579a70c
+  data.tar.gz: eee49961904abde1dbc4135263ed7c637ae8920a76060137c9ed1f679d393f33c4f620c8d6605ed297e16208d42cf2347c927a0c68e69f27f878490b28cec058

data/lib/import_js/configuration.rb

@@ -0,0 +1,128 @@
+require 'json'
+require 'open3'
+
+module ImportJS
+  CONFIG_FILE = '.importjs.json'
+
+  DEFAULT_CONFIG = {
+    'aliases' => {},
+    'declaration_keyword' => 'var',
+    'excludes' => [],
+    'jshint_cmd' => 'jshint',
+    'lookup_paths' => ['.'],
+  }
+
+  # Class that initializes configuration from a .importjs.json file
+  class Configuration
+    def initialize
+      @config = DEFAULT_CONFIG.merge(load_config)
+    end
+
+    def refresh
+      return if @config_time == config_file_last_modified
+      @config = DEFAULT_CONFIG.merge(load_config)
+    end
+
+    # @return [Object] a configuration value
+    def get(key)
+      @config[key]
+    end
+
+    def resolve_alias(variable_name)
+      path = @config['aliases'][variable_name]
+      return resolve_destructured_alias(variable_name) unless path
+
+      path = path['path'] if path.is_a? Hash
+      ImportJS::JSModule.new(nil, path, self)
+    end
+
+    def resolve_destructured_alias(variable_name)
+      @config['aliases'].each do |_, path|
+        next if path.is_a? String
+        if (path['destructure'] || []).include?(variable_name)
+          js_module = ImportJS::JSModule.new(nil, path['path'], self)
+          js_module.is_destructured = true
+          return js_module
+        end
+      end
+      nil
+    end
+
+    # @return [Number?]
+    def columns
+      get_number('&columns')
+    end
+
+    # @return [Number?]
+    def text_width
+      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
+
+    # @return [Array<String>]
+    def package_dependencies
+      return [] unless File.exist?('package.json')
+
+      package = JSON.parse(File.read('package.json'))
+      dependencies = package['dependencies'] ?
+        package['dependencies'].keys : []
+      peer_dependencies = package['peerDependencies'] ?
+        package['peerDependencies'].keys : []
+
+      dependencies.concat(peer_dependencies)
+    end
+
+    private
+
+    # @return [Hash]
+    def load_config
+      @config_time = config_file_last_modified
+      File.exist?(CONFIG_FILE) ? JSON.parse(File.read(CONFIG_FILE)) : {}
+    end
+
+    # @return [Time?]
+    def config_file_last_modified
+      File.exist?(CONFIG_FILE) ? File.mtime(CONFIG_FILE) : nil
+    end
+
+    # Check for the presence of a setting such as:
+    #
+    #   - g:CommandTSmartCase (plug-in setting)
+    #   - &wildignore         (Vim setting)
+    #   - +cursorcolumn       (Vim setting, that works)
+    #
+    # @param str [String]
+    # @return [Boolean]
+    def exists?(str)
+      VIM.evaluate(%{exists("#{str}")}).to_i != 0
+    end
+
+    # @param name [String]
+    # @return [Number?]
+    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/import_js/importer.rb

@@ -0,0 +1,288 @@
+# encoding: utf-8
+require 'json'
+require 'open3'
+
+module ImportJS
+  class Importer
+    def initialize(editor = ImportJS::VIMEditor.new)
+      @config = ImportJS::Configuration.new
+      @editor = editor
+    end
+
+    # Finds variable under the cursor to import. By default, this is bound to
+    # `<Leader>j`.
+    def import
+      @config.refresh
+      variable_name = @editor.current_word
+      if variable_name.empty?
+        message(<<-EOS.split.join(' '))
+          No variable to import. Place your cursor on a variable, then try
+          again.
+        EOS
+        return
+      end
+      current_row, current_col = @editor.cursor
+
+      old_buffer_lines = @editor.count_lines
+      import_one_variable variable_name
+      return unless lines_changed = @editor.count_lines - old_buffer_lines
+      @editor.cursor = [current_row + lines_changed, current_col]
+    end
+
+    def goto
+      @config.refresh
+      @timing = { start: Time.now }
+      variable_name = @editor.current_word
+      js_modules = find_js_modules(variable_name)
+      @timing[:end] = Time.now
+      return if js_modules.empty?
+      js_module = resolve_one_js_module(js_modules, variable_name)
+      @editor.open_file(js_module.file_path)
+    end
+
+    # Finds all variables that haven't yet been imported.
+    def import_all
+      @config.refresh
+      unused_variables = find_unused_variables
+
+      if unused_variables.empty?
+        message('No variables to import')
+        return
+      end
+
+      unused_variables.each do |variable|
+        import_one_variable(variable)
+      end
+    end
+
+    private
+
+    def message(str)
+      str = "[import-js] #{str}"
+      if str.length > @config.columns - 1
+        str = str[0...(@config.columns - 2)] + '…'
+      end
+
+      @editor.message(str)
+    end
+
+    # @return [Array]
+    def find_unused_variables
+      content = "/* jshint undef: true, strict: true */\n" +
+                "/* eslint no-unused-vars: [2, { \"vars\": \"all\", \"args\": \"none\" }] */\n" +
+                @editor.current_file_content
+
+      out, _ = Open3.capture3("#{@config.get('jshint_cmd')} -", stdin_data: content)
+      result = []
+      out.split("\n").each do |line|
+        /.*['"]([^'"]+)['"] is not defined/.match(line) do |match_data|
+          result << match_data[1]
+        end
+      end
+      result.uniq
+    end
+
+    # @param variable_name [String]
+    def import_one_variable(variable_name)
+      @timing = { start: Time.now }
+      js_modules = find_js_modules(variable_name)
+      @timing[:end] = Time.now
+      if js_modules.empty?
+        message(<<-EOS.split.join(' '))
+          No js module to import for variable `#{variable_name}` #{timing}
+        EOS
+        return
+      end
+
+      resolved_js_module = resolve_one_js_module(js_modules, variable_name)
+      return unless resolved_js_module
+
+      write_imports(variable_name, resolved_js_module)
+    end
+
+    # @param variable_name [String]
+    # @param js_module [ImportJS::JSModule]
+    def write_imports(variable_name, js_module)
+      old_imports = find_current_imports
+
+      # Ensure that there is a blank line after the block of all imports
+      unless @editor.read_line(old_imports[:newline_count] + 1).strip.empty?
+        @editor.append_line(old_imports[:newline_count], '')
+      end
+
+      modified_imports = old_imports[:imports] # Array
+
+      # Add new import to the block of imports, wrapping at text_width
+      unless js_module.is_destructured && inject_destructured_variable(
+        variable_name, js_module, modified_imports)
+        modified_imports << generate_import(variable_name, js_module)
+      end
+
+      # Sort the block of imports
+      modified_imports.sort!.uniq! do |import|
+        # Determine uniqueness by discarding the declaration keyword (`const`,
+        # `let`, or `var`) and normalizing multiple whitespace chars to single
+        # spaces.
+        import.sub(/\A(const|let|var)\s+/, '').sub(/\s\s+/s, ' ')
+      end
+
+      # Delete old imports, then add the modified list back in.
+      old_imports[:newline_count].times { @editor.delete_line(1) }
+      modified_imports.reverse_each do |import|
+        # We need to add each line individually because the Vim buffer will
+        # convert newline characters to `~@`.
+        import.split("\n").reverse_each { |line| @editor.append_line(0, line) }
+      end
+    end
+
+    def inject_destructured_variable(variable_name, js_module, imports)
+      imports.each do |import|
+        match = import.match(%r{((const|let|var) \{ )(.*)( \} = require\('#{js_module.import_path}'\);)})
+        next unless match
+
+        variables = match[3].split(/,\s*/).concat([variable_name]).uniq.sort
+        import.sub!(/.*/, "#{match[1]}#{variables.join(', ')}#{match[4]}")
+        return true
+      end
+      false
+    end
+
+    # @return [Hash]
+    def find_current_imports
+      potential_import_lines = []
+      @editor.count_lines.times do |n|
+        line = @editor.read_line(n + 1)
+        break if line.strip.empty?
+        potential_import_lines << line
+      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")
+
+      imports = []
+
+      # Scan potential imports for everything ending in a semicolon, then
+      # iterate through those and stop at anything that's not an import.
+      potential_imports_blob.scan(/^.*?;/m).each do |potential_import|
+        break unless potential_import.match(
+          /(?:const|let|var)\s+.+=\s+require\(.*\).*;/)
+        imports << potential_import
+      end
+
+      newline_count = imports.length + imports.reduce(0) do |sum, import|
+        sum + import.scan(/\n/).length
+      end
+      {
+        imports: imports,
+        newline_count: newline_count
+      }
+    end
+
+    # @param variable_name [String]
+    # @param js_module [ImportJS::JSModule]
+    # @return [String] the import string to be added to the imports block
+    def generate_import(variable_name, js_module)
+      declaration_keyword = @config.get('declaration_keyword')
+      if js_module.is_destructured
+        declaration = "#{declaration_keyword} { #{variable_name} } ="
+      else
+        declaration = "#{declaration_keyword} #{variable_name} ="
+      end
+      value = "require('#{js_module.import_path}');"
+
+      if @config.text_width && "#{declaration} #{value}".length > @config.text_width
+        "#{declaration}\n#{@config.tab}#{value}"
+      else
+        "#{declaration} #{value}"
+      end
+    end
+
+    # @param variable_name [String]
+    # @return [Array]
+    def find_js_modules(variable_name)
+      if alias_module = @config.resolve_alias(variable_name)
+        return [alias_module]
+      end
+
+      egrep_command =
+        "egrep -i \"(/|^)#{formatted_to_regex(variable_name)}(/index)?(/package)?\.js.*\""
+      matched_modules = []
+      @config.get('lookup_paths').each do |lookup_path|
+        find_command = "find #{lookup_path} -name \"**.js*\""
+        out, _ = Open3.capture3("#{find_command} | #{egrep_command}")
+        matched_modules.concat(
+          out.split("\n").map do |f|
+            next if @config.get('excludes').any? do |glob_pattern|
+              File.fnmatch(glob_pattern, f)
+            end
+            js_module = ImportJS::JSModule.new(lookup_path, f, @config)
+            next if js_module.skip
+            js_module
+          end.compact
+        )
+      end
+
+      # Find imports from package.json
+      @config.package_dependencies.each do |dep|
+        next unless dep =~ /^#{formatted_to_regex(variable_name)}$/
+        js_module = ImportJS::JSModule.new(
+          'node_modules', "node_modules/#{dep}/package.json", @config)
+        next if js_module.skip
+        matched_modules << js_module
+      end
+
+      # If you have overlapping lookup paths, you might end up seeing the same
+      # module to import twice. In order to dedupe these, we remove the module
+      # with the longest path
+      matched_modules.sort do |a, b|
+        a.import_path.length <=> b.import_path.length
+      end.uniq do |m|
+        m.lookup_path + '/' + m.import_path
+      end.sort do |a, b|
+        a.display_name <=> b.display_name
+      end
+    end
+
+    # @param js_modules [Array]
+    # @param variable_name [String]
+    # @return [String]
+    def resolve_one_js_module(js_modules, variable_name)
+      if js_modules.length == 1
+        message("Imported `#{js_modules.first.display_name}` #{timing}")
+        return js_modules.first
+      end
+
+      selected_index = @editor.ask_for_selection(
+        "\"[import-js] Pick js module to import for '#{variable_name}': #{timing}\"",
+        js_modules.map {|m| m.display_name}
+      )
+      return unless selected_index
+      js_modules[selected_index]
+    end
+
+    # Takes a string in any of the following four formats:
+    #   dash-separated
+    #   snake_case
+    #   camelCase
+    #   PascalCase
+    # and turns it into a star-separated lower case format, like so:
+    #   star*separated
+    #
+    # @param string [String]
+    # @return [String]
+    def formatted_to_regex(string)
+      # Based on
+      # http://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+      string.
+        gsub(/([a-z\d])([A-Z])/, '\1.?\2'). # separates camelCase words with '.?'
+        tr('-_', '.'). # replaces underscores or dashes with '.'
+        downcase # converts all upper to lower case
+    end
+
+    # @return [String]
+    def timing
+      "(#{(@timing[:end] - @timing[:start]).round(2)}s)"
+    end
+  end
+end

data/lib/import_js/js_module.rb

@@ -0,0 +1,46 @@
+module ImportJS
+  # Class that represents a js module found in the file system
+  class JSModule
+    attr_reader :import_path
+    attr_reader :lookup_path
+    attr_reader :file_path
+    attr_reader :main_file
+    attr_reader :skip
+    attr_accessor :is_destructured
+
+    # @param lookup_path [String] the lookup path in which this module was found
+    # @param relative_file_path [String] a full path to the file, relative to
+    #   the project root.
+    # @param configuration [ImportJS::Configuration]
+    def initialize(lookup_path, relative_file_path, configuration)
+      @lookup_path = lookup_path
+      @file_path = relative_file_path
+      if relative_file_path.end_with? '/package.json'
+        @main_file = JSON.parse(File.read(relative_file_path))['main']
+        match = relative_file_path.match(/(.*)\/package\.json/)
+        @import_path = match[1]
+        @skip = !@main_file
+      elsif relative_file_path.match(/\/index\.js.*$/)
+        match = relative_file_path.match(/(.*)\/(index\.js.*)/)
+        @main_file = match[2]
+        @import_path = match[1]
+      else
+        @import_path = relative_file_path
+        unless configuration.get('keep_file_extensions')
+          @import_path = @import_path.sub(/\.js.*$/, '')
+        end
+      end
+
+      if lookup_path
+        @import_path = @import_path.sub("#{@lookup_path}\/", '') # remove path prefix
+      end
+    end
+
+    # @return [String] a readable description of the module
+    def display_name
+      parts = [import_path]
+      parts << " (main: #{@main_file})" if @main_file
+      parts.join('')
+    end
+  end
+end

data/lib/import_js/vim_editor.rb

@@ -0,0 +1,98 @@
+module ImportJS
+  # This is the implementation of the VIM integration in Import-JS. It can be
+  # used as a template for other editor integrations.
+  class VIMEditor
+    # Get the word currently under the cursor.
+    #
+    # @return [String]
+    def current_word
+      VIM.evaluate("expand('<cword>')")
+    end
+
+    # Open a file specified by a path.
+    #
+    # @param file_path [String]
+    def open_file(file_path)
+      VIM.command("e #{file_path}")
+    end
+
+    # Display a message to the user.
+    #
+    # @param str [String]
+    def message(str)
+      VIM.command(":call importjs#WideMsg('#{str}')")
+    end
+
+    # Read the entire file into a string.
+    #
+    # @return [String]
+    def current_file_content
+      VIM.evaluate('join(getline(1, "$"), "\n")')
+    end
+
+    # Reads a line from the file.
+    #
+    # Lines are one-indexed, so 1 means the first line in the file.
+    # @return [String]
+    def read_line(line_number)
+      VIM::Buffer.current[line_number]
+    end
+
+    # Get the cursor position.
+    #
+    # @return [Array(Number, Number)]
+    def cursor
+      VIM::Window.current.cursor
+    end
+
+    # Place the cursor at a specified position.
+    #
+    # @param position_tuple [Array(Number, Number)] the row and column to place
+    #   the cursor at.
+    def cursor=(position_tuple)
+      VIM::Window.current.cursor = position_tuple
+    end
+
+    # Delete a line.
+    #
+    # @param line_number [Number] One-indexed line number.
+    #   1 is the first line in the file.
+    def delete_line(line_number)
+      VIM::Buffer.current.delete(line_number)
+    end
+
+    # Append a line right after the specified line.
+    #
+    # Lines are one-indexed, but you need to support appending to line 0 (add
+    # content at top of file).
+    # @param line_number [Number]
+    def append_line(line_number, str)
+      VIM::Buffer.current.append(line_number, str)
+    end
+
+    # Count the number of lines in the file.
+    #
+    # @return [Number] the number of lines in the file
+    def count_lines
+      VIM::Buffer.current.count
+    end
+
+    # Ask the user to select something from a list of alternatives.
+    #
+    # @param heading [String] A heading text
+    # @param alternatives [Array<String>] A list of alternatives
+    # @return [Number, nil] the index of the selected alternative, or nil if
+    #   nothing was selected.
+    def ask_for_selection(heading, alternatives)
+      escaped_list = [heading]
+      escaped_list << alternatives.each_with_index.map do |alternative, i|
+        "\"#{i + 1}: #{alternative}\""
+      end
+      escaped_list_string = '[' + escaped_list.join(',') + ']'
+
+      selected_index = VIM.evaluate("inputlist(#{escaped_list_string})")
+      return if selected_index < 1
+      selected_index - 1
+    end
+  end
+end

data/lib/import_js.rb

@@ -0,0 +1,10 @@
+# Namespace declaration
+module ImportJS
+  # We initialize an empty "ImportJS" namespace here so that we can define
+  # classes under that namespace, e.g. `ImportJS::Importer`.
+end
+
+require_relative 'import_js/js_module'
+require_relative 'import_js/importer'
+require_relative 'import_js/vim_editor'
+require_relative 'import_js/configuration'

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: import_js
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Henric Trotzig
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-15 00:00:00.000000000 Z
+dependencies: []
+description: A tool to simplify importing javascript modules
+email: henric.trotzig@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/import_js.rb
+- lib/import_js/configuration.rb
+- lib/import_js/importer.rb
+- lib/import_js/js_module.rb
+- lib/import_js/vim_editor.rb
+homepage: http://rubygems.org/gems/import_js
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Import-JS
+test_files: []
+has_rdoc: