importmap 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84dd54a2297318f246781b1acee8edd024c4ca2650a65a287269416d2dd903a3
+  data.tar.gz: 203d783fc05f8a442440aa17c072d8a875e11fbd16cc634406f1c348aa1f28af
+SHA512:
+  metadata.gz: ffe2c28e6e9312108f9c0bdce4eabc1b5f8a30dc5c8428e266ed5ee7cf98d6918f48b79acf38dfea5f560dbd195a899b8c0faafa1567712d036b2bfcf9021023
+  data.tar.gz: 2a502c24447c2530fd3072a7f98a5f0577546e988469880a040240cb4a931a12e308d47443b6a6db54b8deadbfa9b78162b0133de06950c7550183a82a409d3a

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+/.bundle
+/.config
+/.yardoc
+/_yardoc
+/coverage
+/doc/
+/Gemfile.lock
+/InstalledFiles
+/lib/bundler/man
+/pkg
+/rdoc
+/spec/reports
+/test/tmp
+/test/version_tmp
+/tmp

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--color
+--format documentation

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+This project *loosely tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
+
+## [0.1.0]
+- Initial release.

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem dependencies in importmap.gemspec
+gemspec
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/Guardfile

@@ -0,0 +1,19 @@
+guard "bundler", cmd: "bundle" do
+  watch("Gemfile")
+  watch(/^.+\.gemspec/)
+end
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) Tung Nguyen
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,20 @@
+# Importmap
+
+[![Gem Version](https://badge.fury.io/rb/jets-responders.png)](http://badge.fury.io/rb/jets-responders)
+
+[![BoltOps Badge](https://img.boltops.com/boltops/badges/boltops-badge.png)](https://www.boltops.com)
+
+[![BoltOps Learn Badge](https://img.boltops.com/boltops-learn/boltops-learn.png)](https://learn.boltops.com)
+
+Importmap library that is use as a part of [importmap-jets](https://github.com/rubyonjets/importmap-jets).
+
+## Usage
+
+    importmap audit               # Run a security audit
+    importmap json                # Show the full importmap in json
+    importmap outdated            # Check for outdated packages
+    importmap packages            # Print out packages with version numbers
+    importmap pin [*PACKAGES]     # Pin new packages
+    importmap unpin [*PACKAGES]   # Unpin existing packages
+    importmap version             # prints version
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task default: :spec
+
+RSpec::Core::RakeTask.new

data/exe/importmap

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+# Trap ^C
+Signal.trap("INT") {
+  puts "\nCtrl-C detected. Exiting..."
+  sleep 0.1
+  exit
+}
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require "importmap"
+require "importmap/cli"
+
+Importmap::CLI.start(ARGV)

data/importmap.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "importmap/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "importmap"
+  spec.version       = Importmap::VERSION
+  spec.authors       = ["Tung Nguyen"]
+  spec.email         = ["tongueroo@gmail.com"]
+  spec.summary       = "Importmap Library and CLI"
+  spec.homepage      = "https://github.com/rubyonjets/importmap"
+  spec.license       = "MIT"
+
+  spec.files         = File.directory?('.git') ? `git ls-files`.split($/) : Dir.glob("**/*")
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "memoist"
+  spec.add_dependency "rainbow"
+  spec.add_dependency "thor"
+  spec.add_dependency "zeitwerk"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "cli_markdown"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/importmap/autoloader.rb

@@ -0,0 +1,22 @@
+require "zeitwerk"
+
+module Importmap
+  class Autoloader
+    class Inflector < Zeitwerk::Inflector
+      def camelize(basename, _abspath)
+        map = { cli: "CLI", version: "VERSION" }
+        map[basename.to_sym] || super
+      end
+    end
+
+    class << self
+      def setup
+        loader = Zeitwerk::Loader.new
+        loader.inflector = Inflector.new
+        lib = File.dirname(__dir__)
+        loader.push_dir(lib) # lib
+        loader.setup
+      end
+    end
+  end
+end

data/lib/importmap/cli/help/completion.md

@@ -0,0 +1,20 @@
+## Examples
+
+    importmap completion
+
+Prints words for TAB auto-completion.
+
+    importmap completion
+    importmap completion hello
+    importmap completion hello name
+
+To enable, TAB auto-completion add the following to your profile:
+
+    eval $(importmap completion_script)
+
+Auto-completion example usage:
+
+    importmap [TAB]
+    importmap hello [TAB]
+    importmap hello name [TAB]
+    importmap hello name --[TAB]

data/lib/importmap/cli/help/completion_script.md

@@ -0,0 +1,3 @@
+To use, add the following to your `~/.bashrc` or `~/.profile`
+
+    eval $(importmap completion_script)

data/lib/importmap/cli/help/pin.md

@@ -0,0 +1,5 @@
+## Examples
+
+    importmap pin
+    importmap pin NAME
+    importmap pin NAME --download

data/lib/importmap/cli/help.rb

@@ -0,0 +1,11 @@
+class Importmap::CLI
+  module Help
+    class << self
+      def text(namespaced_command)
+        path = namespaced_command.to_s.gsub(':','/')
+        path = File.expand_path("../help/#{path}.md", __FILE__)
+        IO.read(path) if File.exist?(path)
+      end
+    end
+  end
+end

data/lib/importmap/cli.rb

@@ -0,0 +1,156 @@
+module Importmap
+  class CLI < Command
+    include Thor::Actions
+
+    desc "pin [*PACKAGES]", "Pin new packages"
+    option :env, type: :string, aliases: :e, default: "production"
+    option :from, type: :string, aliases: :f, default: "jspm"
+    option :download, type: :boolean, aliases: :d, default: false
+    def pin(*packages)
+      if imports = packager.import(*packages, env: options[:env], from: options[:from])
+        imports.each do |package, url|
+          if options[:download]
+            puts %(Pinning "#{package}" to #{packager.vendor_path}/#{package}.js via download from #{url})
+            packager.download(package, url)
+            pin = packager.vendored_pin_for(package, url)
+          else
+            puts %(Pinning "#{package}" to #{url})
+            pin = packager.pin_for(package, url)
+          end
+
+          if packager.packaged?(package)
+            gsub_file("config/importmap.rb", /^pin "#{package}".*$/, pin, verbose: false)
+          else
+            append_to_file("config/importmap.rb", "#{pin}\n", verbose: false)
+          end
+        end
+      else
+        puts "Couldn't find any packages in #{packages.inspect} on #{options[:from]}"
+      end
+    end
+
+    desc "unpin [*PACKAGES]", "Unpin existing packages"
+    option :env, type: :string, aliases: :e, default: "production"
+    option :from, type: :string, aliases: :f, default: "jspm"
+    option :download, type: :boolean, aliases: :d, default: false
+    def unpin(*packages)
+      if imports = packager.import(*packages, env: options[:env], from: options[:from])
+        imports.each do |package, url|
+          if packager.packaged?(package)
+            if options[:download]
+              puts %(Unpinning and removing "#{package}")
+            else
+              puts %(Unpinning "#{package}")
+            end
+
+            packager.remove(package)
+          end
+        end
+      else
+        puts "Couldn't find any packages in #{packages.inspect} on #{options[:from]}"
+      end
+    end
+
+    desc "json", "Show the full importmap in json"
+    def json
+      Importmap.framework_boot
+      puts Importmap.framework.application.importmap.to_json(resolver: ActionController::Base.helpers)
+    end
+
+    desc "audit", "Run a security audit"
+    def audit
+      vulnerable_packages = npm.vulnerable_packages
+
+      if vulnerable_packages.any?
+        table = [["Package", "Severity", "Vulnerable versions", "Vulnerability"]]
+        vulnerable_packages.each { |p| table << [p.name, p.severity, p.vulnerable_versions, p.vulnerability] }
+
+        puts_table(table)
+        vulnerabilities = 'vulnerability'.pluralize(vulnerable_packages.size)
+        severities = vulnerable_packages.map(&:severity).tally.sort_by(&:last).reverse
+                                        .map { |severity, count| "#{count} #{severity}" }
+                                        .join(", ")
+        puts "  #{vulnerable_packages.size} #{vulnerabilities} found: #{severities}"
+
+        exit 1
+      else
+        puts "No vulnerable packages found"
+      end
+    end
+
+    desc "outdated", "Check for outdated packages"
+    def outdated
+      outdated_packages = npm.outdated_packages
+
+      if outdated_packages.any?
+        table = [["Package", "Current", "Latest"]]
+        outdated_packages.each { |p| table << [p.name, p.current_version, p.latest_version || p.error] }
+
+        puts_table(table)
+        packages = 'package'.pluralize(outdated_packages.size)
+        puts "  #{outdated_packages.size} outdated #{packages} found"
+
+        exit 1
+      else
+        puts "No outdated packages found"
+      end
+    end
+
+    desc "packages", "Print out packages with version numbers"
+    def packages
+      puts npm.packages_with_versions.map { |x| x.join(' ') }
+    end
+
+    desc "completion *PARAMS", "Prints words for auto-completion."
+    long_desc Help.text(:completion)
+    def completion(*params)
+      Completer.new(CLI, *params).run
+    end
+
+    desc "completion_script", "Generates a script that can be eval to setup auto-completion."
+    long_desc Help.text(:completion_script)
+    def completion_script
+      Completer::Script.generate
+    end
+
+    desc "version", "prints version"
+    def version
+      puts Importmap::VERSION
+    end
+
+  private
+    def packager
+      @packager ||= Importmap::Packager.new
+    end
+
+    def npm
+      @npm ||= Importmap::Npm.new
+    end
+
+    def remove_line_from_file(path, pattern)
+      path = File.expand_path(path, destination_root)
+
+      all_lines = File.readlines(path)
+      with_lines_removed = all_lines.select { |line| line !~ pattern }
+
+      File.open(path, "w") do |file|
+        with_lines_removed.each { |line| file.write(line) }
+      end
+    end
+
+    def puts_table(array)
+      column_sizes = array.reduce([]) do |lengths, row|
+        row.each_with_index.map{ |iterand, index| [lengths[index] || 0, iterand.to_s.length].max }
+      end
+
+      puts head = "+" + (column_sizes.map { |s| "-" * (s + 2) }.join('+')) + '+'
+      array.each_with_index do |row, row_number|
+        row = row.fill(nil, row.size..(column_sizes.size - 1))
+        row = row.each_with_index.map { |v, i| v.to_s + " " * (column_sizes[i] - v.to_s.length) }
+        puts "| " + row.join(" | ") + " |"
+        puts head if row_number == 0
+      end
+      puts head
+    end
+  end
+end

data/lib/importmap/command.rb

@@ -0,0 +1,89 @@
+require "thor"
+
+# Override thor's long_desc identation behavior
+# https://github.com/erikhuda/thor/issues/398
+class Thor
+  module Shell
+    class Basic
+      def print_wrapped(message, options = {})
+        message = "\n#{message}" unless message[0] == "\n"
+        stdout.puts message
+      end
+    end
+  end
+end
+
+module Importmap
+  class Command < Thor
+    class << self
+      def dispatch(m, args, options, config)
+        # Allow calling for help via:
+        #   importmap command help
+        #   importmap command -h
+        #   importmap command --help
+        #   importmap command -D
+        #
+        # as well thor's normal way:
+        #
+        #   importmap help command
+        help_flags = Thor::HELP_MAPPINGS + ["help"]
+        if args.length > 1 && !(args & help_flags).empty?
+          args -= help_flags
+          args.insert(-2, "help")
+        end
+
+        #   importmap version
+        #   importmap --version
+        #   importmap -v
+        version_flags = ["--version", "-v"]
+        if args.length == 1 && !(args & version_flags).empty?
+          args = ["version"]
+        end
+
+        super
+      end
+
+      # Override command_help to include the description at the top of the
+      # long_description.
+      def command_help(shell, command_name)
+        meth = normalize_command_name(command_name)
+        command = all_commands[meth]
+        alter_command_description(command)
+        super
+      end
+
+      def alter_command_description(command)
+        return unless command
+
+        # Add description to beginning of long_description
+        long_desc = if command.long_description
+            "#{command.description}\n\n#{command.long_description}"
+          else
+            command.description
+          end
+
+        # add reference url to end of the long_description
+        unless website.empty?
+          full_command = [command.ancestor_name, command.name].compact.join('-')
+          url = "#{website}/reference/importmap-#{full_command}"
+          long_desc += "\n\nHelp also available at: #{url}"
+        end
+
+        command.long_description = long_desc
+      end
+      private :alter_command_description
+
+      # meant to be overriden
+      def website
+        ""
+      end
+
+      # https://github.com/erikhuda/thor/issues/244
+      # Deprecation warning: Thor exit with status 0 on errors. To keep this behavior, you must define `exit_on_failure?` in `Lono::CLI`
+      # You can silence deprecations warning by setting the environment variable THOR_SILENCE_DEPRECATION.
+      def exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/importmap/completer/script.rb

@@ -0,0 +1,8 @@
+class Importmap::Completer
+  class Script
+    def self.generate
+      bash_script = File.expand_path("script.sh", File.dirname(__FILE__))
+      puts "source #{bash_script}"
+    end
+  end
+end

data/lib/importmap/completer/script.sh

@@ -0,0 +1,10 @@
+_importmap() {
+  COMPREPLY=()
+  local word="${COMP_WORDS[COMP_CWORD]}"
+  local words=("${COMP_WORDS[@]}")
+  unset words[0]
+  local completion=$(importmap completion ${words[@]})
+  COMPREPLY=( $(compgen -W "$completion" -- "$word") )
+}
+
+complete -F _importmap importmap

data/lib/importmap/completer.rb

@@ -0,0 +1,158 @@
+=begin
+Code Explanation:
+
+There are 3 types of things to auto-complete:
+
+  1. command: the command itself
+  2. parameters: command parameters.
+  3. options: command options
+
+Here's an example:
+
+  mycli hello name --from me
+
+  * command: hello
+  * parameters: name
+  * option: --from
+
+When command parameters are done processing, the remaining completion words will be options.  We can tell that the command params are completed based on the method arity.
+
+## Arity
+
+For example, say you had a method for a CLI command with the following form:
+
+  CLI COMMAND service count --cluster development
+
+It's equivalent ruby method:
+
+  scale(service, count) = has an arity of 2
+
+So typing:
+
+  CLI COMMAND service count [TAB] # there are 3 parameters including the "scale" command according to Thor's CLI processing.
+
+So the completion should only show options, something like this:
+
+  --noop --verbose --cluster
+
+## Splat Arguments
+
+When the ruby method has a splat argument, it's arity is negative.  Here are some example methods and their arities.
+
+   ship(service) = 1
+   scale(service, count) = 2
+   foo(example, *rest) = -2
+
+Fortunately, negative and positive arity values are processed the same way. So we take simply take the absolute value of the arity and process it the same.
+
+Here are some test cases, hit TAB after typing the command:
+
+  importmap completion
+  importmap completion hello
+  importmap completion hello name
+  importmap completion hello name --
+  importmap completion hello name --noop
+
+  importmap completion
+  importmap completion sub:goodbye
+  importmap completion sub:goodbye name
+
+## Subcommands and Thor::Group Registered Commands
+
+Sometimes the commands are not simple thor commands but are subcommands or Thor::Group commands. A good specific example is the CLI COMMAND.
+
+  * regular command: CLI COMMAND
+  * subcommand: CLI COMMAND
+  * Thor::Group command: CLI COMMAND
+
+Auto-completion accounts for each of these type of commands.
+=end
+module Importmap
+  class Completer
+    def initialize(command_class, *params)
+      @params = params
+      @current_command = @params[0]
+      @command_class = command_class # CLI initiall
+    end
+
+    def run
+      if subcommand?(@current_command)
+        subcommand_class = @command_class.subcommand_classes[@current_command]
+        @params.shift # destructive
+        Completer.new(subcommand_class, *@params).run # recursively use subcommand
+        return
+      end
+
+      # full command has been found!
+      unless found?(@current_command)
+        puts all_commands
+        return
+      end
+
+      # will only get to here if command aws found (above)
+      arity = @command_class.instance_method(@current_command).arity.abs
+      if @params.size > arity or thor_group_command?
+        puts options_completion
+      else
+        puts params_completion
+      end
+    end
+
+    def subcommand?(command)
+      @command_class.subcommands.include?(command)
+    end
+
+    # hacky way to detect that command is a registered Thor::Group command
+    def thor_group_command?
+      command_params(raw=true) == [[:rest, :args]]
+    end
+
+    def found?(command)
+      public_methods = @command_class.public_instance_methods(false)
+      command && public_methods.include?(command.to_sym)
+    end
+
+    # all top-level commands
+    def all_commands
+      commands = @command_class.all_commands.reject do |k,v|
+        v.is_a?(Thor::HiddenCommand)
+      end
+      commands.keys
+    end
+
+    def command_params(raw=false)
+      params = @command_class.instance_method(@current_command).parameters
+      # Example:
+      # >> Sub.instance_method(:goodbye).parameters
+      # => [[:req, :name]]
+      # >>
+      raw ? params : params.map!(&:last)
+    end
+
+    def params_completion
+      offset = @params.size - 1
+      offset_params = command_params[offset..-1]
+      command_params[offset..-1].first
+    end
+
+    def options_completion
+      used = ARGV.select { |a| a.include?('--') } # so we can remove used options
+
+      method_options = @command_class.all_commands[@current_command].options.keys
+      class_options = @command_class.class_options.keys
+
+      all_options = method_options + class_options + ['help']
+
+      all_options.map! { |o| "--#{o.to_s.gsub('_','-')}" }
+      filtered_options = all_options - used
+      filtered_options.uniq
+    end
+
+    # Useful for debugging. Using puts messes up completion.
+    def log(msg)
+      File.open("/tmp/complete.log", "a") do |file|
+        file.puts(msg)
+      end
+    end
+  end
+end

data/lib/importmap/framework/jets_framework.rb

@@ -0,0 +1,11 @@
+class Importmap::Framework
+  module JetsFramework
+    def framework_class
+      Jets
+    end
+
+    def boot
+      Jets.boot
+    end
+  end
+end