nanoc-webpack.rb 0.5.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3e798ff00aa45852e59880aac435054ddf29b3682655e8a9935de50300cfc72
-  data.tar.gz: 1acef686fc1ff408aa5681d307c7879a9c1aada3a85c51912a6adc25a4fd5480
+  metadata.gz: 6089712cbc312cd503ad06f0a1d54e27351901f86b870460f1c6d3c205566d4c
+  data.tar.gz: 8c932b943c81803365dcd2e9a7c46b5cfec2790fb05964c73b60e557fcf1461a
 SHA512:
-  metadata.gz: c47e5a09a5a71e485eedb9a9a6e781d89067c3b86d7128fcb3b8a08ec51cfbb0c851c61b6709b1e7ec332573ea8209a467b2f64eb1d84082562def20920ec3b1
-  data.tar.gz: c3cd143a1b31f035c30339d5c434b1859a4d450a313879a517c843009f9f109419b5632d87650070c20be2c971234ed8820be52213fe1f5f418377fc76d575c7
+  metadata.gz: 9b9f6f1cc40ada346daac98c1b401dc613c327e41c5bf48b1bf4c6ecad8b50c267b3a46164336e677dd8c28415f2c7262b28cab9ff4ea897c7f6a96491cc3c2a
+  data.tar.gz: 62595779fdff296640fa1ddd0030ab3d97e580378f0129c5a5d9260fe13b92e9a08a006316c8ad5de420133557d7f9542a776f7d2c909c2e37642d1c788a8996

data/.rubocop.yml

@@ -45,6 +45,10 @@ RSpec/DescribeClass:
   Enabled: false
 RSpec/ImplicitSubject:
   Enabled: false
+RSpec/MessageSpies:
+  Enabled: false
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
 Style/LambdaCall:
   Enabled: false
 Layout/MultilineMethodCallIndentation:

data/README.md

@@ -2,44 +2,44 @@
 
 nanoc-webpack.rb is a
 [nanoc](https://nanoc.app)
-filter
-that integrates
+filter that integrates
 [webpack](https://webpack.js.org/)
-into nanoc-powered websites. The filter provides a bridge that
-connects nanoc, and the JavaScript, TypeScript, and nodejs ecosystems.
+into nanoc. <br>
+The filter acts as a  bridge that connects nanoc,
+and the JavaScript, TypeScript, and nodejs ecosystems.
 
 ## Examples
 
-__app.ts__
+**Defaults**
 
-The following example forwards the entry point `app.ts` to webpack, and
-then writes the result of the webpack compilation to `app.js`:
+The following example forwards the entry point `/js/main/App.tsx`
+to webpack. <br> The result is then written to `/js/main/app.js`:
 
 ``` ruby
 # Rules
 require "nanoc-webpack"
-compile "/js/app.ts" do
+compile "/js/main/App.tsx" do
   filter(:webpack)
-  write("/js/app.js")
+  write("/js/main/app.js")
 end
 ```
 
-__Option: "depend_on"__
+**Option: depend_on**
 
-The `depend_on` option tells nanoc what files an entry point imports or requires.
-When a file being tracked by the `depend_on` option undergoes a change, nanoc
-will initiate a recompilation of the entry point:
+When a file or directory tracked by the `depend_on` option
+is observed to have changed, nanoc will initiate a recompilation
+of the entry point:
 
 ```ruby
 # Rules
 require "nanoc-webpack"
-compile "/js/ReactApp.jsx" do
+compile "/js/main/App.tsx" do
   filter(:webpack, depend_on: ["/js/lib", "/js/components", "/js/hooks"])
-  write("/js/app.js")
+  write("/js/main/app.js")
 end
 ```
 
-__Option: "reject"__
+**Option: reject**
 
 The `depend_on` option can be combined with the `reject` option to exclude
 certain files or directories from being tracked. For example, maybe you want
@@ -48,65 +48,44 @@ to track `/js/lib/` but not `/js/lib/foo/`:
 ```ruby
 # Rules
 require "nanoc-webpack"
-compile "/js/ReactApp.jsx" do
+compile "/js/main/App.tsx" do
   filter :webpack,
          depend_on: ["/js/lib", "/js/components", "/js/hooks"],
          reject: proc { |path| path.start_with?("/js/lib/foo/") }
-  write("/js/app.js")
+  write("/js/main/app.js")
 end
 ```
 
-__Option: "args"__
+**Option: cli**
 
-The `args` option can be used to forward command-line options directly
-to the webpack executable. See `$ webpack build --help` for the list of
-options that are available:
+The `cli` option forwards command-line options directly
+to the webpack executable. <br>
+[Nanoc::Webpack.default_options](https://0x1eef.github.io/x/nanoc-webpack.rb/Nanoc/Webpack.html#default_options-class_method)
+returns the default options nanoc-webpack.rb will
+forward to webpack:
 
 ```ruby
 # Rules
 require "nanoc-webpack"
-compile "/js/ReactApp.jsx" do
-  filter :webpack, args: {"--no-stats" => true}
-  write("/js/app.js")
+compile "/js/main/App.tsx" do
+  filter(:webpack, cli: {"--no-stats" => true})
+  write("/js/main/app.js")
 end
 ```
 
-
-## Requirements
-
-nanoc-webpack.rb assumes that:
-
-* A "node" executable is available in $PATH.
-* [npm](https://www.npmjs.com) or [yarn](https://yarnpkg.com/) are used for
-  package management.
-* "webpack" / "webpack-cli" exist as dependencies in package.json.
-
-## Sources
-
-* [Source code (GitHub)](https://github.com/0x1eef/nanoc-webpack.rb)
-* [Source code (GitLab)](https://gitlab.com/0x1eef/nanoc-webpack.rb)
-
 ## <a id='install'>Install</a>
 
-**Git**
-
-nanoc-webpack.rb is distributed as a RubyGem through its git repositories. <br>
-[GitHub](https://github.com/0x1eef/nanoc-webpack.rb),
-and
-[GitLab](https://gitlab.com/0x1eef/nanoc-webpack.rb)
-are available as sources.
-
-```ruby
-# Gemfile
-gem "nanoc-webpack.rb", github: "0x1eef/nanoc-webpack.rb", tag: "v0.5.4"
-```
-
 **Rubygems.org**
 
 nanoc-webpack.rb can also be installed via rubygems.org.
 
     gem install nanoc-webpack.rb
 
+## Sources
+
+* [GitHub](https://github.com/0x1eef/nanoc-webpack.rb#readme)
+* [GitLab](https://gitlab.com/0x1eef/nanoc-webpack.rb#about)
+
 ## License
 
 [BSD Zero Clause](https://choosealicense.com/licenses/0bsd/).

data/lib/nanoc/webpack/filter.rb

@@ -1,40 +1,53 @@
 # frozen_string_literal: true
 
 ##
-# Compiles a textual nanoc item with webpack.
+# Compiles a nanoc item with webpack.
 class Nanoc::Webpack::Filter < Nanoc::Filter
   require_relative "filter/dependable"
-  Error = Class.new(RuntimeError)
   include FileUtils
   include Dependable
+  Error = Class.new(RuntimeError)
 
   identifier :webpack
   type :text
 
   ##
+  # @example
+  #   Nanoc::Webpack.default_options.merge!(
+  #     "--cache-type" => "memory"
+  #   )
+  #
   # @return [Hash]
-  #  Returns the default command-line options given
-  #  to the webpack executable.
+  #  Returns the default command-line options forwarded to webpack.
   def self.default_options
-    @default_options ||= {}
+    @default_options ||= {"--cache-type" => "filesystem"}
   end
 
+  ##
+  # @param [String] content
+  #  The contents of a file.
+  #
+  # @param [Hash] options
+  #  A hash of options.
+  #
+  # @return [void]
   def run(content, options = {})
-    depend_on dependable(paths: options[:depend_on], reject: options[:reject])
+    options = Ryo.from(options)
+    depend_on dependable(paths: options.depend_on, reject: options.reject)
               .map { items[_1] }
-    webpack temporary_file_for(content),
-            args: self.class.default_options.merge(options[:args] || {})
+    webpack temporary_file(content),
+            cli: self.class.default_options.merge(options.cli || {})
   end
 
   private
 
-  def webpack(file, args: {})
+  def webpack(file, cli:)
     sh "node",
        "./node_modules/webpack/bin/webpack.js",
        "--entry", File.join(Dir.getwd, item.attributes[:content_filename]),
        "--output-path", File.dirname(file.path),
        "--output-filename", File.basename(file.path),
-       *webpack_args(args)
+       *webpack_args(cli)
     if $?.success?
       File.read(file.path).tap { file.tap(&:unlink).close }
     else
@@ -54,10 +67,10 @@ class Nanoc::Webpack::Filter < Nanoc::Filter
     end
   end
 
-  def temporary_file_for(content)
+  def temporary_file(content)
     dir = File.join(Dir.getwd, "tmp", "nanoc-webpack.rb")
     mkdir_p(dir) unless Dir.exist?(dir)
-    file = Tempfile.new(File.basename(item.identifier.to_s), dir)
+    file = Tempfile.new(File.basename(@item.identifier.to_s), dir)
     file.write(content)
     file.tap(&:flush)
   end

data/lib/nanoc/webpack/version.rb

@@ -2,6 +2,6 @@
 
 module Nanoc
   module Webpack
-    VERSION = "0.5.5"
+    VERSION = "0.7.0"
   end
 end

data/lib/nanoc/webpack.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
 require "nanoc"
-require "ryo"
 module Nanoc::Webpack
+  require "ryo"
   require_relative "webpack/filter"
+  ##
+  # @example (see Nanoc::Webpack::Filter.default_options)
+  # @return (see Nanoc::Webpack::Filter.default_options)
+  def self.default_options
+    Nanoc::Webpack::Filter.default_options
+  end
 end

data/nanoc-webpack.rb.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.summary = "nanoc-webpack.rb integrates webpack into nanoc."
   gem.description = gem.summary
-  gem.add_runtime_dependency "ryo.rb", "~> 0.4"
+  gem.add_runtime_dependency "ryo.rb", "~> 0.5"
   gem.add_development_dependency "yard", "~> 0.9"
   gem.add_development_dependency "redcarpet", "~> 3.5"
   gem.add_development_dependency "rspec", "~> 3.10"

data/spec/filter_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+RSpec.describe Nanoc::Webpack::Filter do
+  let(:paths) { ["/1", "/1/1.txt", "/1/2", "/1/2/1.txt"] }
+  let(:root) { File.join("spec", "fakefs", "content") }
+  let(:reject) { nil }
+  let(:item) do
+    Ryo.from(
+      identifier: {to_s: "test.ts"},
+      attributes: {content_filename: "test.ts"}
+    )
+  end
+  let(:items) do
+    paths.each_with_object({}) { _2[_1] = _1 }
+  end
+  let(:config) do
+    Ryo.from(
+      each: {to_h: {data_sources: [{content_dir: root}]}},
+      data_sources: [{content_dir: root}]
+    )
+  end
+  let(:filter) do
+    Nanoc::Filter
+      .named!(:webpack)
+      .new(item:, items:, config:)
+  end
+  include FileUtils
+
+  context "when given dependables" do
+    subject { filter.dependable(paths: target, reject:) }
+
+    before do
+      mkdir_p(root)
+      paths.each do
+        path = File.join(root, _1)
+        File.extname(path).empty? ? mkdir_p(path) : touch(path)
+      end
+    end
+
+    after { rm_rf(root) }
+
+    context "when the directory depth is 2" do
+      context "when given /1 as a path" do
+        let(:target) { "/1" }
+        it { is_expected.to contain_exactly("/1/1.txt", "/1/2/1.txt") }
+      end
+
+      context "when given /1/2 as a path" do
+        let(:target) { "/1/2" }
+        it { is_expected.to contain_exactly("/1/2/1.txt") }
+      end
+    end
+
+    context "when the directory depth is 5" do
+      let(:paths) { super().concat(["/1/2/3/4/5", "/1/2/3/4/5/1.txt"]) }
+
+      context "when given /1 as a path" do
+        let(:target) { "/1" }
+        it do
+          is_expected.to contain_exactly(
+                           "/1/1.txt",
+                           "/1/2/1.txt",
+                           "/1/2/3/4/5/1.txt"
+                         )
+        end
+      end
+
+      context "when given /1/2 as a path" do
+        let(:target) { "/1/2" }
+        it { is_expected.to contain_exactly("/1/2/1.txt", "/1/2/3/4/5/1.txt") }
+      end
+
+      context "when given /1/2/3 as a path" do
+        let(:target) { "/1/2/3" }
+        it { is_expected.to contain_exactly("/1/2/3/4/5/1.txt") }
+      end
+
+      context "when depth 5 has descendant directories" do
+        let(:paths) do
+          super().concat([
+                           "/1/2/3/4/5/a", "/1/2/3/4/5/a/a.txt",
+                           "/1/2/3/4/5/b", "/1/2/3/4/5/b/b.txt",
+                           "/1/2/3/4/5/c", "/1/2/3/4/5/c/c.txt"
+                         ])
+        end
+
+        context "when given /1 as a path" do
+          let(:target) { "/1" }
+          it do
+            is_expected.to contain_exactly(
+                             "/1/1.txt", "/1/2/1.txt", "/1/2/3/4/5/1.txt",
+                             "/1/2/3/4/5/a/a.txt", "/1/2/3/4/5/b/b.txt",
+                             "/1/2/3/4/5/c/c.txt"
+                           )
+          end
+        end
+      end
+    end
+
+    context "when one or more directories are excluded" do
+      let(:paths) { super().concat(["/2/3", "/2/3/1.txt", "/3/4", "/3/4/1.txt"]) }
+
+      context "when the target is [!12]" do
+        let(:target) { "/[!12]/" }
+        it { is_expected.to contain_exactly("/3/4/1.txt") }
+      end
+
+      context "when the reject filter is used" do
+        let(:paths) do
+          ["/lib/WebPackage/", "/lib/WebPackage/foo.ts",
+           "/lib/Web/", "/lib/Web/foo.ts",
+           "/lib/foo/", "/lib/foo/foo.ts"]
+        end
+        let(:target) { "/lib/" }
+        let(:reject) { proc { |path| path.include?("WebPackage") } }
+
+        it do
+          is_expected.to contain_exactly("/lib/Web/foo.ts", "/lib/foo/foo.ts")
+        end
+      end
+    end
+  end
+
+  context "when nodejs is executed" do
+    let(:cmdline) do
+      [
+        "node",
+        "./node_modules/webpack/bin/webpack.js",
+        "--entry", File.join(Dir.getwd, "test.ts"),
+        "--output-path", instance_of(String),
+        "--output-filename", instance_of(String),
+        "--cache-type", "filesystem"
+      ]
+    end
+
+    context "with default arguments" do
+      it "executes nodejs" do
+        expect(filter).to receive(:system).with(*cmdline)
+        filter.run(item)
+      end
+    end
+
+    context "with --no-cache" do
+      let(:cmdline) { super().concat(["--no-cache"]) }
+
+      it "executes nodejs with an argument" do
+        expect(filter).to receive(:system).with(*cmdline)
+        filter.run(item, cli: {"--no-cache" => true})
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nanoc-webpack.rb
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.7.0
 platform: ruby
 authors:
 - '0x1eef'
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-11 00:00:00.000000000 Z
+date: 2024-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ryo.rb
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -116,7 +116,7 @@ files:
 - lib/nanoc/webpack/filter/dependable.rb
 - lib/nanoc/webpack/version.rb
 - nanoc-webpack.rb.gemspec
-- spec/dependable_spec.rb
+- spec/filter_spec.rb
 - spec/setup.rb
 homepage: https://github.com/0x1eef/nanoc-webpack.rb#readme
 licenses:

data/spec/dependable_spec.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "setup"
-
-RSpec.describe Nanoc::Webpack::Filter::Dependable do
-  subject { filter.dependable(paths: target, reject:) }
-  let(:paths) { ["/1", "/1/1.txt", "/1/2", "/1/2/1.txt"] }
-  let(:root) { File.join("spec", "fakefs", "content") }
-  let(:reject) { nil }
-  let(:filter) do
-    Object.new.instance_exec(root, paths) do |root, paths|
-      extend Nanoc::Webpack::Filter::Dependable
-      define_singleton_method(:items) { paths.each_with_object({}) { _2[_1] = _1 } }
-      define_singleton_method(:root) { root }
-      self
-    end
-  end
-  include FileUtils
-
-  before do
-    mkdir_p(root)
-    paths.each do
-      path = File.join(root, _1)
-      File.extname(path).empty? ? mkdir_p(path) : touch(path)
-    end
-  end
-
-  after { rm_rf(root) }
-
-  context "when the directory depth is 2" do
-    context "when given /1 as a path" do
-      let(:target) { "/1" }
-      it { is_expected.to contain_exactly("/1/1.txt", "/1/2/1.txt") }
-    end
-
-    context "when given /1/2 as a path" do
-      let(:target) { "/1/2" }
-      it { is_expected.to contain_exactly("/1/2/1.txt") }
-    end
-  end
-
-  context "when the directory depth is 5" do
-    let(:paths) { super().concat(["/1/2/3/4/5", "/1/2/3/4/5/1.txt"]) }
-
-    context "when given /1 as a path" do
-      let(:target) { "/1" }
-      it do
-        is_expected.to contain_exactly(
-          "/1/1.txt",
-          "/1/2/1.txt",
-          "/1/2/3/4/5/1.txt"
-        )
-      end
-    end
-
-    context "when given /1/2 as a path" do
-      let(:target) { "/1/2" }
-      it { is_expected.to contain_exactly("/1/2/1.txt", "/1/2/3/4/5/1.txt") }
-    end
-
-    context "when given /1/2/3 as a path" do
-      let(:target) { "/1/2/3" }
-      it { is_expected.to contain_exactly("/1/2/3/4/5/1.txt") }
-    end
-
-    context "when depth 5 has descendant directories" do
-      let(:paths) do
-        super().concat([
-          "/1/2/3/4/5/a", "/1/2/3/4/5/a/a.txt",
-          "/1/2/3/4/5/b", "/1/2/3/4/5/b/b.txt",
-          "/1/2/3/4/5/c", "/1/2/3/4/5/c/c.txt"
-        ])
-      end
-
-      context "when given /1 as a path" do
-        let(:target) { "/1" }
-        it do
-          is_expected.to contain_exactly(
-            "/1/1.txt", "/1/2/1.txt", "/1/2/3/4/5/1.txt",
-            "/1/2/3/4/5/a/a.txt", "/1/2/3/4/5/b/b.txt",
-            "/1/2/3/4/5/c/c.txt"
-          )
-        end
-      end
-    end
-  end
-
-  context "when one or more directories are excluded" do
-    let(:paths) { super().concat(["/2/3", "/2/3/1.txt", "/3/4", "/3/4/1.txt"]) }
-
-    context "when the target is [!12]" do
-      let(:target) { "/[!12]/" }
-      it { is_expected.to contain_exactly("/3/4/1.txt") }
-    end
-
-    context "when the reject filter is used" do
-      let(:paths) do
-        ["/lib/WebPackage/", "/lib/WebPackage/foo.ts",
-         "/lib/Web/", "/lib/Web/foo.ts",
-         "/lib/foo/", "/lib/foo/foo.ts"]
-      end
-      let(:target) { "/lib/" }
-      let(:reject) { proc { |path| path.include?("WebPackage") } }
-
-      it do
-        is_expected.to contain_exactly("/lib/Web/foo.ts", "/lib/foo/foo.ts")
-      end
-    end
-  end
-end