grundler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7410db73be9001084a6c93445378025b66d07326006d0a161e9881949330bf8a
+  data.tar.gz: '09eac82869728e54c233493ee6542956cfcda0f7950e7c55ac1ec45117d1dbe4'
+SHA512:
+  metadata.gz: 998cf5e2ed076fb77b5ad53f1e6f3b922906045d6429d045b4a146b1349d276d93e326dddee50ad0cbd78c6bd19ea64f705e9e80100eb36f2927a465e613c05e
+  data.tar.gz: a02dfd2d7052e1de7977e9ab587208db688c69522ee2d770c3cf6852565f5e03d9282d889dec0948489ea1c89f5909b42587e87567f25d75fee37d96c08e20ff

data/.github/workflows/main.yml

@@ -0,0 +1,18 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.0
+    - name: Run the default task
+      run: |
+        gem install bundler -v 2.2.5
+        bundle install
+        bundle exec rake

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,23 @@
+AllCops:
+  TargetRubyVersion: 2.4.0
+  NewCops: enable
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 24
+
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  EnforcedStyle: never
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in grundler.gemspec
+gemspec
+
+gem "minitest", "~> 5.0"
+gem "rake", "~> 13.0"
+gem "rubocop", "~> 1.7"
+gem "rubocop-minitest", "~> 0.10.3"
+gem "rubocop-rake", "~> 0.5.1"
+gem "webmock", "~> 3.11.1"

data/Gemfile.lock

@@ -0,0 +1,82 @@
+PATH
+  remote: .
+  specs:
+    grundler (0.1.0)
+      down (~> 5.2.0)
+      http (~> 4.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    ast (2.4.1)
+    crack (0.4.5)
+      rexml
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
+    down (5.2.0)
+      addressable (~> 2.5)
+    ffi (1.14.2)
+    ffi-compiler (1.0.1)
+      ffi (>= 1.0.0)
+      rake
+    hashdiff (1.0.1)
+    http (4.3.0)
+      addressable (~> 2.3)
+      http-cookie (~> 1.0)
+      http-form_data (~> 2.2)
+      http-parser (~> 1.2.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    http-form_data (2.3.0)
+    http-parser (1.2.3)
+      ffi-compiler (>= 1.0, < 2.0)
+    minitest (5.14.2)
+    parallel (1.20.1)
+    parser (3.0.0.0)
+      ast (~> 2.4.1)
+    public_suffix (4.0.6)
+    rainbow (3.0.0)
+    rake (13.0.3)
+    regexp_parser (2.0.3)
+    rexml (3.2.4)
+    rubocop (1.8.1)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.2.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.4.0)
+      parser (>= 2.7.1.5)
+    rubocop-minitest (0.10.3)
+      rubocop (>= 0.87, < 2.0)
+    rubocop-rake (0.5.1)
+      rubocop
+    ruby-progressbar (1.11.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.7)
+    unicode-display_width (2.0.0)
+    webmock (3.11.1)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  x86_64-darwin-19
+
+DEPENDENCIES
+  grundler!
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  rubocop (~> 1.7)
+  rubocop-minitest (~> 0.10.3)
+  rubocop-rake (~> 0.5.1)
+  webmock (~> 3.11.1)
+
+BUNDLED WITH
+   2.2.5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Johan Halse
+
+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,163 @@
+# Grundler
+
+The no-faff Ruby frontend bundler.
+
+Now that all the evergreen browsers have support for JavaScript module loading, we can finally pretend like node.js never happened! Grundler is the sinecure for everyone who's sick to death of npm, yarn, babel, webpack, parcel, rollup, vite, fartspray, and snowpack. And I only made one of those up.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "grundler"
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install grundler
+
+## But we have enough package managers, please stop
+
+Sorry! But Grundler fills one of the most _important niches_ in the Ruby ecosystem: MINE. Specifically, that would be the niche where I sit, precariously perched, cursing the bloat and complexity of node's module ecosystem, longing for the easy and carefree days of dropping a .js file into a "lib" folder and calling it a day. Seriously, we got ourselves into this hellscape just because we didn't think globals were enterprise-grade or whatever?! Like what were people even
+
+## Alright, settle down, explain how it works
+
+You've totally used a package manager before. You'll need to use one to install this one, in fact. So you probably know most of the stuff you need to know. Grundler, as a design goal, tries to 1) leverage the new browser-supported module format and 2) do as little as possible. You won't find any script sections or dev dependencies in its configuration. You can't run commands through it, shrinkwrap, or add prepublish steps. It'll only grab packages for you off npm's repository so you can use them and you should be damn well content with that.
+
+## Please tell me you didn't invent a new configuration file though
+
+I'm not below that sort of thing but no, it reads your `package.json` kind of like you'd expect. Grundler only bothers with the important part, the `{ "dependencies" }` section. If you expect it to also run your dev server or test suite or whatever, you will be disappointed. You might be disappointed anyway but I'd honestly prefer you at least be disappointed with the right things?
+
+## So what actually happens when I add a package then
+
+Grundler goes to everyone's favorite JavaScript repository, [npm](https://www.npmjs.com/), to look for the package you wanted to install. If it's found, it'll look up the most recent version, download its tarball, and analyze the JSON metadata to see if it uses the new ES module format. If it does, bingo, we can untar the module file _and only the module file_ to our dependency folder (currently called [nodules](https://twitter.com/hejsna/status/987043794427240448) because come on, it was **right there** but the node people were too buttoned-up I guess). This is cool because it's reminiscent of the old "go to someone's site and download a JS file" but structured and reproducible.
+
+If the package you're trying to fetch isn't using ES module format though, you're in trouble.
+
+## Trouble
+
+Trouble. Grundler has a thing I've aptly named `CrapMode` that gets engaged whenever a package is using one of the old bothersome and browser-incompatible module formats (which, unfortunately, is pretty often). It will wrap the library in a simple little shim of sorts, to fool the module into believing it can hook into `module.exports` but AHA that's a honeypot we put there and then we can export. It's bound to fail in mysterious ways but it turns out there are a lot of packages that work just fine with it.
+
+So you may get lucky. Or you may not. People have really been contorting themselves over the years doing weird shit to get their packages loading across the various formats the Internet has coughed up, and `module.exports` might not be a thing they use. Either way, if the package is one you really want, the responsible and adult thing to do is to go to their repository and help them out with a PR to convert to the new module format. Node has had support for quite a while, now browsers have it too — we're finally on track towards the compilation-free past/future again. Contribute and be part of it!
+
+## And how do I use my freshly downloaded package again
+
+You import it, like you would any file you wrote yourself. Look:
+
+```bash
+$ bundle exec grundle add three
+Installing three 0.124.0
+```
+
+That should result in a file called `nodules/three.js`. That's your package, ready for pickup! Now, in order to import things in the browser, you need to opt in to the browser's module system by using `type="module"` in your script tag:
+
+```html
+<script src="main.js" type="module"></script>
+```
+
+And inside main.js you can do:
+
+```javascript
+import * as THREE from "./nodules/three.js";
+console.log(THREE);
+```
+
+And if that thing is an ES module, or the CrapMode shim worked, you're good to go!
+
+## That import statement though, slashes and stuff, ew
+
+I hear you. It's not as pretty as just `from "three"`. People are working on this problem, with something called [import maps](https://github.com/WICG/import-maps). But it's not THAT ugly and look: the code is there. It can be loaded, just the way you'd expect if a teammate had written the code. You don't have npm's hundreds of megabytes of dep-tree lurking beneath the depths, ready to kneecap your CI system and bog down your builds. Let's hope we can all get back to the fairytale land of "it's just another file in your project". I'd even check the `nodules` folder in to your project if I were you — after all, in the end you're responsible for everything you ship, so why do we keep pretending our dependencies are this pristine thing, never to be touched?
+
+## But I'm using TypeScript, if you just download the compiled and minified JS distribution I won't have my d.ts files and
+
+Go away! Contemplate your life choices. I will have no truck with your transpiled abomination. The entire point of Grundler is to dramatically shorten the build chain, get back to just writing JS files, doing away with build servers and transpilation once and for all. Plus everyone knows TypeScript is just .NET wearing JavaScript's skin, ready to murder you in your sleep with a rictus grin on its rotting, lying face.
+
+## Ok but what about deployment, won't this ruin my artisanal never-expiring cached CDN
+
+Yes. I'm throwing my hands up here and again saying look, I'm sorry, but browsers don't do the import maps thing yet. And adding version numbers to downloaded libs would be murder on your actual source files: going through every file in your project that has `import * from thing-0.10.1.js` and replacing it with `thing-0.10.2.js` every time you bumped versions would absolutely SUCK.
+
+You realistically have three options at this time:
+
+1) Weep and use Webpack
+2) Ditch your far-future cache and trust people's browsers to do the right thing
+3) Use an import-aware fingerprint tool when building for production
+
+## But... there IS no import-aware fingerprinting tool
+
+Ha! Pop quiz, hotshot: what has two thumbs and has just written that kind of fingerprinting tool? It trawls a directory full of js files, copies them to md5-stamped files, and rewrites all import statements to use the stamped files. I'll put it up once it's been documented and more thoroughly tested. And once I've made sure it's actually a good idea.
+
+Yes, yes, it's a build step, which makes me a little sad, but fingers crossed we can get rid of it when browsers have robust support for import maps. I bet the Babel crew have said something similar but then it kind of never happened and the tools got entrenched and suddenly everyone's stuck in the labyrinth with no way out and an angry minotaur belching somewhere behind them. But you can trust me! I'm a very honest-looking guy and I totally mean it: ship import maps and this won't be a problem anymore.
+
+## Cool, how do I use Grundler then
+
+Grundler tries its best to not do very much. No spiderweb of metadata or configuration, no weird executable sandbox things, and only four commands:
+
+### Adding packages
+
+Run `grundle add [list of packages]`. If you wanted to install, say, [three.js](https://github.com/mrdoob/three.js/) and [ky](https://github.com/sindresorhus/ky/) and have installed Grundler from your Gemfile it'd look like this:
+
+```bash
+bundle exec grundle add three ky
+```
+
+Grundler will go and find the latest version of those packages, install them, and add them to the `package.json` file.
+
+### Installing from package.json
+
+Once you've added a few packages, you can distribute the package.json and install using that, and Grundler will fetch the version specified. To install from package.json, run:
+
+```bash
+bundle exec grundle install
+```
+
+### Updating packages
+
+Sometimes a package has been updated! To grab all the newest versions, run:
+
+```bash
+bundle exec grundle update
+```
+
+All your packages will be updated and written to package.json. You currently can't use the `update` command to update single packages, but Grundler is dumb enough that adding the packages again by running `add package1 package2` will do that for you.
+
+### Removing packages
+
+Tired of a package? No module export and CrapMode didn't work? Run:
+
+```bash
+bundle exec grundle remove packagename
+```
+
+It'll be removed from your nodules folder and your `package.json` file. Grundler will also get rid of any empty directories left after a removal.
+
+## Configuration
+
+There's only one configuration directive at this point and it's called `nodulePath`. Say you have all your JS source files in a directory called `src`. Then you might want your dependencies to live in `src/nodules`. Add the `nodulePath` directive to your package.json like so:
+```json
+{
+  "dependencies": {},
+  "nodulePath": "./src/nodules"
+}
+```
+
+That'll make all of Grundler's operations work on that directory instead.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Testing is done with [Minitest](https://github.com/seattlerb/minitest) and mocking of npm is done with [webmock](https://github.com/bblimke/webmock). I initially wanted to use VCR for the JSON stubs but there seemed to be a lot of configuration and nothing worked and so I just put them there by hand and this is all TMI and never mind, there's like 200 lines of tests in a single file, you'll get the hang of it quickly.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/johanhalse/grundler.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/bin/console

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "grundler"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/grundle

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "grundler"
+
+Grundler::CLI.new

data/grundler.gemspec

@@ -0,0 +1,32 @@
+require_relative "lib/grundler/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "grundler"
+  spec.version       = Grundler::VERSION
+  spec.authors       = ["Johan Halse"]
+  spec.email         = ["johan@hal.se"]
+
+  spec.summary       = "The no-faff frontend bundler"
+  spec.description   = "Grundler is the simplest (as in most understandable) way to install npm packages."
+  spec.homepage      = "https://github.com/johanhalse/grundler"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/johanhalse/grundler"
+  spec.metadata["changelog_uri"] = "https://github.com/johanhalse/grundler/CHANGES.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "down", "~> 5.2.0"
+  spec.add_dependency "http", "~> 4.3.0"
+end

data/lib/grundler.rb

@@ -0,0 +1,43 @@
+require "http"
+require "down/http"
+
+require_relative "grundler/version"
+require_relative "grundler/package_json_writer"
+require_relative "grundler/commands/add"
+require_relative "grundler/commands/install"
+require_relative "grundler/commands/update"
+require_relative "grundler/commands/remove"
+require_relative "grundler/commands/help"
+
+module Grundler
+  DEFAULT_NODULE_PATH = "#{Dir.pwd}/nodules".freeze
+  LOCKFILE_PATH = "#{Dir.pwd}/package.json".freeze
+  COMMANDS = %w[add install update remove help].freeze
+
+  class CLI
+    def initialize
+      json_writer = PackageJsonWriter.new(lockfile_path)
+      Grundler::Commands.const_get(current_command).new(self, arguments, json_writer)
+    end
+
+    def current_command
+      COMMANDS.find { |c| ARGV.first == c }&.capitalize || "Help"
+    end
+
+    def arguments
+      @switches = ARGV.select { |a| a[0] == "-" }
+
+      ARGV.drop(1) - @switches
+    end
+
+    def nodule_path
+      @nodule_path ||=
+        (JSON.parse(File.read(LOCKFILE_PATH))["nodulePath"] if File.exist?(LOCKFILE_PATH)) ||
+        DEFAULT_NODULE_PATH
+    end
+
+    def lockfile_path
+      LOCKFILE_PATH
+    end
+  end
+end

data/lib/grundler/commands/add.rb

@@ -0,0 +1,29 @@
+require_relative "common"
+
+module Grundler
+  module Commands
+    class Add
+      include Common
+
+      def initialize(cli, packages, json_writer)
+        super(cli)
+        if packages.empty?
+          puts "Must specify a package name!"
+          return
+        end
+
+        json_writer.add(added_packages(packages))
+      end
+
+      private
+
+      def added_packages(packages)
+        packages
+          .map { |package_name| install(latest_version(package_name)) }
+          .compact
+          .map { |package| [package["name"], package["version"]] }
+          .to_h
+      end
+    end
+  end
+end

data/lib/grundler/commands/common.rb

@@ -0,0 +1,38 @@
+require "grundler/good_mode"
+require "grundler/crap_mode"
+
+module Grundler
+  module Commands
+    module Common
+      def initialize(cli)
+        @cli = cli
+      end
+
+      def module?(version)
+        !version["module"].nil? || version["type"] == "module"
+      end
+
+      def latest_version(package_name)
+        package_metadata = JSON.parse(HTTP.get("https://registry.npmjs.org/#{package_name}").to_s)
+        latest_version_number = package_metadata.dig("dist-tags", "latest")
+        package_metadata["error"] || package_metadata.dig("versions", latest_version_number)
+      end
+
+      def install(version)
+        return no_such_package if version == "Not found"
+
+        if module?(version)
+          GoodMode.new(@cli, version).write
+        else
+          CrapMode.new(@cli, version).write
+        end
+
+        version
+      end
+
+      def no_such_package
+        puts "That package could not be found in the npm repository!"
+      end
+    end
+  end
+end

data/lib/grundler/commands/help.rb

@@ -0,0 +1,23 @@
+module Grundler
+  module Commands
+    class Help
+      def initialize(_cli, _arguments, _json_writer)
+        puts Help.help_text
+      end
+
+      def self.help_text
+        <<~HELP_TEXT
+
+          Usage: grundle <command>
+
+          grundle add      add package to project
+          grundle install  install all packages in lockfile
+          grundle update   update all packages in lockfile
+          grundle remove   remove a package from project
+          grundle help     display this help
+
+        HELP_TEXT
+      end
+    end
+  end
+end

data/lib/grundler/commands/install.rb

@@ -0,0 +1,27 @@
+require_relative "common"
+
+module Grundler
+  module Commands
+    class Install
+      include Common
+
+      def initialize(cli, _arguments, _json_writer)
+        super(cli)
+        unless File.exist?(Grundler::LOCKFILE_PATH)
+          puts "No #{Grundler::LOCKFILE_PATH} file found!"
+          return
+        end
+
+        loaded_versions = JSON.parse(File.read(Grundler::LOCKFILE_PATH))["dependencies"]
+        loaded_versions.each { |k, v| install(specific_version(k, v)) }
+      end
+
+      private
+
+      def specific_version(package_name, version_number)
+        package_metadata = JSON.parse(HTTP.get("https://registry.npmjs.org/#{package_name}").to_s)
+        package_metadata.dig("versions", version_number.delete_prefix("^")) || "Not found"
+      end
+    end
+  end
+end

data/lib/grundler/commands/remove.rb

@@ -0,0 +1,41 @@
+require_relative "common"
+
+module Grundler
+  module Commands
+    class Remove
+      include Common
+
+      def initialize(cli, packages, json_writer)
+        super(cli)
+        unless File.exist?(Grundler::LOCKFILE_PATH)
+          puts "No #{Grundler::LOCKFILE_PATH} file found!"
+          return
+        end
+
+        if packages.empty?
+          puts "Must specify a package name!"
+          return
+        end
+
+        json_writer.remove(delete(packages))
+      end
+
+      private
+
+      def delete(packages)
+        packages.each do |package|
+          puts "Removing #{package}"
+          FileUtils.rm "#{@cli.nodule_path}/#{package}.js" if File.exist?("#{@cli.nodule_path}/#{package}.js")
+          remove_directory_if_empty(package)
+        end
+
+        packages.map { |package| [package, package] }.to_h
+      end
+
+      def remove_directory_if_empty(package)
+        dirname = File.dirname("#{@cli.nodule_path}/#{package}.js")
+        FileUtils.rm_rf dirname if Dir.exist?(dirname) && Dir.empty?(dirname)
+      end
+    end
+  end
+end

data/lib/grundler/commands/update.rb

@@ -0,0 +1,35 @@
+require_relative "common"
+
+module Grundler
+  module Commands
+    class Update
+      include Common
+
+      def initialize(cli, _arguments, json_writer)
+        super(cli)
+        unless File.exist?(Grundler::LOCKFILE_PATH)
+          puts "No #{Grundler::LOCKFILE_PATH} file found!"
+          return
+        end
+
+        json_writer.add(
+          json_writer.existing_packages
+            .map { |k, v| update(k, latest_version(k), v) }
+            .compact
+            .to_h
+        )
+      end
+
+      private
+
+      def update(name, latest_version, current_version_number)
+        if latest_version["version"] == current_version_number
+          puts "#{latest_version["name"]} is already the latest version (#{current_version_number})"
+          return
+        end
+
+        [name, install(latest_version)["version"]]
+      end
+    end
+  end
+end

data/lib/grundler/crap_mode.rb

@@ -0,0 +1,28 @@
+require_relative "mode"
+
+class CrapMode < Mode
+  def write
+    notify
+    File.write(file_path, process(untar))
+  rescue Mode::NoEntryPointError
+    puts "\e[31mNo entry point found for file #{@version["name"]}\e[0m"
+  end
+
+  private
+
+  def notify
+    super
+
+    puts "\e[36mPackage #{@version["name"]} has no module defined and will be written in compatibility mode."
+    puts "If that doesn't work, you should consider opening a pull request to add ES module support."
+    puts "The package repository is here: #{@version.dig("repository", "url")}\e[0m"
+  end
+
+  def process(str)
+    %(
+      var module = { exports: {} };
+      (function(){#{str}}).call(window);
+      export default module.exports;
+    )
+  end
+end

data/lib/grundler/good_mode.rb

@@ -0,0 +1,10 @@
+require_relative "mode"
+
+class GoodMode < Mode
+  def write
+    notify
+    File.write(file_path, untar)
+  rescue Mode::NoEntryPointError
+    puts "\e[31mNo entry point found for file #{@version["name"]}\e[0m"
+  end
+end

data/lib/grundler/mode.rb

@@ -0,0 +1,49 @@
+require "rubygems/package"
+require "zlib"
+
+class Mode
+  class NoEntryPointError < StandardError; end
+
+  def initialize(cli, version)
+    @cli = cli
+    @version = version
+  end
+
+  private
+
+  def notify
+    puts "Installing #{@version["name"]} #{@version["version"]}"
+  end
+
+  def untar
+    tar = Gem::Package::TarReader.new(Zlib::GzipReader.open(tempfile.path))
+    file = tar.find { |f| f.full_name == index_file }
+    tar.close
+
+    raise NoEntryPointError if file.nil?
+
+    file.read
+  end
+
+  def tempfile
+    Down::Http.download(@version.dig("dist", "tarball"))
+  end
+
+  def file_path
+    file_path = "#{@cli.nodule_path}/#{@version["name"]}.js"
+    FileUtils.mkdir_p(File.dirname(file_path))
+    file_path
+  end
+
+  def index_file
+    @index_file ||= Pathname.new(index_file_path).cleanpath.to_s
+  end
+
+  def index_file_path
+    return "package/#{@version["module"]}" if @version["module"]
+    return "package/#{@version["exports"]}" if @version["exports"]
+    return "package/#{@version["main"]}" if @version["main"]
+
+    "package/index.js"
+  end
+end

data/lib/grundler/package_json_writer.rb

@@ -0,0 +1,44 @@
+require "json"
+
+module Grundler
+  class PackageJsonWriter
+    def initialize(path)
+      @path = path
+    end
+
+    def add(packages)
+      write(existing_packages.merge(packages))
+    end
+
+    def remove(packages)
+      write(
+        existing_packages.delete_if { |k, _v| packages.include?(k) }
+      )
+    end
+
+    def existing_packages
+      existing_content["dependencies"]
+    end
+
+    private
+
+    def write(packages)
+      File.write(
+        @path,
+        JSON.pretty_generate(
+          existing_content.merge({ "dependencies" => packages })
+        )
+      )
+    end
+
+    def existing_content
+      @existing_content ||= load_existing_content
+    end
+
+    def load_existing_content
+      JSON.parse(File.read(@path))
+    rescue StandardError
+      { "dependencies" => {} }
+    end
+  end
+end

data/lib/grundler/version.rb

@@ -0,0 +1,3 @@
+module Grundler
+  VERSION = "0.1.0".freeze
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: grundler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Johan Halse
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: down
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+description: Grundler is the simplest (as in most understandable) way to install npm
+  packages.
+email:
+- johan@hal.se
+executables:
+- grundle
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/grundle
+- grundler.gemspec
+- lib/grundler.rb
+- lib/grundler/commands/add.rb
+- lib/grundler/commands/common.rb
+- lib/grundler/commands/help.rb
+- lib/grundler/commands/install.rb
+- lib/grundler/commands/remove.rb
+- lib/grundler/commands/update.rb
+- lib/grundler/crap_mode.rb
+- lib/grundler/good_mode.rb
+- lib/grundler/mode.rb
+- lib/grundler/package_json_writer.rb
+- lib/grundler/version.rb
+homepage: https://github.com/johanhalse/grundler
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/johanhalse/grundler
+  source_code_uri: https://github.com/johanhalse/grundler
+  changelog_uri: https://github.com/johanhalse/grundler/CHANGES.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: The no-faff frontend bundler
+test_files: []