rux-rails 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80c3381d7ae7854540067cd7267c5636961a7b30a538fad7c5fd063c5cb12a64
-  data.tar.gz: c4234d93e5b93109b612a5249f06b065cc53157999246cc04f12aea1bdc98cad
+  metadata.gz: 1dd540a2fa0ae930bc671d469c20928dc71faba5ad1ef3d52a13212f1e6373ef
+  data.tar.gz: 6f8d5e0c2897d8c03c4bdea2b6fec7c170a1103c9ca2ef5a58edf07396c98328
 SHA512:
-  metadata.gz: 8b61ed880646e3a058c4bd525f6f7fe9e308fe066f40d76c53ea312a5c604874eb321405f9d41f3a026221df3a83b3049356c1146f897ca7c9c4cf96b5274443
-  data.tar.gz: 6aa7c072623ab565de33479b0428c096412377f9cf020c0c91751cf9b80e2f21fad1c2f8500a95b2b67dd5450a985ef8a5d0162ac72978d6cd1de04d706b64dc
+  metadata.gz: 694511000ee0f54d57a382d18986d50130811e2c74d3f5f8b4963f7e9472b4629174a893d659fe42b9e03fa6f683f3b1e9e0ffad9714411c34d2de9a13d61949
+  data.tar.gz: 859fcf4b865afe9cd22f77d990263ac495acb275dccd21d487c0d01bf047b5ae0ab616ba57e61426c2d67d8eb8eebeadf90fea78048e7672e92376ba38849934

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 2.0.0
+* Remove the `Image`, `Audio`, and `Video` components (was anyone actually using these?)
+* Remove support for Rails 6.1 and 6.0.
+* Upgrade to onload v1.1 and rux to v1.3.
+  - Add `config.rux.ignore_path` to Rails config for controlling which ignore file should be populated with generated paths.
+* Add a series of Rails helper components:
+  - `Rails::ButtonTo`
+  - `Rails::LinkTo`
+  - `Rails::ContentTag`
+  - `Rails::FormWith`
+  - `Rails::Label`
+  - `Rails::Button`
+  - `Rails::HiddenField`
+  - `Rails::PasswordField`
+  - `Rails::TextField`
+* Add the `Rux::Component` component for rendering component instances.
+  - Eg: `<Rux::Component instance={@child} />`.
+
+## 1.5.0
+* Extract monkeypatches into the [onload gem](https://github.com/camertron/onload).
+* Upgrade to rux v1.2.
+* Drop official support for Rails < 6 and Ruby < 3.
+
 ## 1.4.0
 * Make rux-rails safe to load in production.
   - All the monkeypatches to `Kernel`, etc are now only loaded if `config.rux.transpile` is `true`.

data/Gemfile

@@ -2,21 +2,21 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rux', github: 'camertron/rux'  # path: '/Users/cdutro/workspace/rux'
-
 group :development, :test do
-  gem 'pry-byebug'
   gem 'rake'
+  gem 'debug'
 end
 
 group :development do
   gem 'appraisal'
   gem 'benchmark-ips'
-  gem 'rails', '~> 7.0'
   gem 'slim', '~> 5.0'
+  gem 'appraisal-run', '~> 1.0'
 end
 
 group :test do
   gem 'rspec-rails'
   gem 'capybara', '~> 3.0'
 end
+
+gem "csv"

data/README.md

@@ -81,11 +81,9 @@ In my humble opinion, the rux version:
 
 Integrating rux into your Rails app is pretty straightforward.
 
-1. Add rux-rails to the development group in your Gemfile, eg:
+1. Add rux-rails to your Gemfile, eg:
     ```ruby
-    group :development do
-      gem 'rux-rails', '~> 1.0'
-    end
+    gem 'rux-rails', '~> 1.0'
     ```
 1. Run `bundle install`
 1. ... that's it.
@@ -104,7 +102,7 @@ config.rux.transpile = false
 
 ### Production Environment
 
-By including rux-rails in the `:development` group in your Gemfile, rux-rails and its monkeypatches to `Kernel` aren't loaded in production (which is a good thing). You could choose to include rux-rails in the default group, but automatic transpilation of .rux files is disabled in the production environment for the same reasons the asset pipeline is disabled. Your view components (and static assets) don't change once deployed, so it's more efficient to precompile (or pre-transpile) them before deploying. Rux-rails comes with a handy rake task that can pre-transpile all your .rux templates:
+By default, `config.rux.transpile` is set to `false` in the production environment, which means rux-rails' monkeypatches to `Kernel`, etc aren't loaded in production (which is a good thing). You could choose to turn it on, but automatic transpilation of .rux files is disabled automatically in the production environment for the same reasons the asset pipeline is disabled. Your view components (and static assets) don't change once deployed, so it's more efficient to precompile (or pre-transpile) them before deploying. Rux-rails comes with a handy rake task that can pre-transpile all your .rux templates:
 
 ```bash
 bundle exec rake rux:transpile
@@ -284,6 +282,62 @@ There are also monkeypatches in place for Zeitwerk and `ActiveSupport::Dependenc
 
 Hit me up if you know of a less invasive way of enabling auto-transpilation.
 
+## Built-in Components
+
+The rux-rails gem contains several helper components to make it easier to work with Rails forms and tag helpers. Only a subset of Rails helpers are implemented. If you need others, please open an issue or, better yet, submit a pull request.
+
+### Tag Helpers
+
+The following tag helpers are available as components:
+
+1. `button_to`: Use the `Rails::ButtonTo` component, eg: `<Rails::ButtonTo url: "http://example.com" label: "Click me" />`.
+1. `link_to`: Use the `Rails::LinkTo` component, eg: `<Rails::LinkTo url="http://example.com" label="Navigate" />`.
+1. `content_tag`: Use the `Rails::ContentTag` component, eg: `<Rails::ContentTag tag={:div}>content</Rails::ContentTag>`
+
+### Form Helpers
+
+1. `form_with`: `Rails::FormWith`
+1. `button_tag` or `f.submit`: `Rails::Button`
+1. `label_tag` or `f.label`: `Rails::Label`
+1. `text_field_tag` or `f.text_field`: `Rails::TextField`
+1. `password_field_tag` or `f.password_field`: `Rails::PasswordField`
+1. `hidden_field_tag` or `f.hidden_field`: `Rails::HiddenField`
+
+### Form Example
+
+Here's how to use the above components to build eg. a simple sign up form:
+
+```ruby
+<Rails::FormWith model={User.new}>
+  <Rails::Label name="name">Name</Rails::Label>
+  <Rails::TextField name="name" />
+  <Rails::Label name="email_address">Email address</Rails::Label>
+  <Rails::TextField name="email_address" />
+  <Rails::Label name="password">Password</Rails::Label>
+  <Rails::PasswordField name="password" />
+  <Rails::Label name="password_confirm">Confirm password</Rails::Label>
+  <Rails::PasswordField name="password_confirmation" />
+</Rails::FormWith>
+```
+
+### The `Component` component
+
+Occasionally it can be useful to create an instance of a component outside the `call` method. While such a component can be rendered via the `render` method, doing so doesn't feel very "ruxy." That's where the `Rux::Component` component comes into play. It accepts a single `instance:` argument and renders it. For example:
+
+```ruby
+class ParentComponent < ApplicationComponent
+  def initialize
+    @child = ChildComponent.new
+  end
+
+  def call
+    <div>
+      <Rux::Component instance={@child} />
+    </div>
+  end
+end
+```
+
 ## Editor Support
 
 Sublime Text: [https://github.com/camertron/rux-SublimeText](https://github.com/camertron/rux-SublimeText)

data/lib/rux-rails/engine.rb

@@ -0,0 +1,46 @@
+require 'onload'
+
+module RuxRails
+  class Engine < ::Rails::Engine
+    isolate_namespace RuxRails
+
+    config.rux = ActiveSupport::OrderedOptions.new
+
+    initializer 'rux-rails.initialize', before: 'onload.initialize' do |app|
+      if config.rux.transpile.nil? && (Rails.env.development? || Rails.env.test?)
+        config.rux.transpile = true
+        Onload.enabled = true
+      else
+        Onload.enabled = config.rux.transpile
+      end
+
+      if config.rux.transpile
+        Onload.register('.rux', RuxRails::RuxLoader)
+      end
+
+      ActionView::Template.register_template_handler(
+        :ruxt, RuxRails::TemplateHandler
+      )
+
+      Rux.library_paths.each do |library_path|
+        app.config.eager_load_paths << library_path
+        app.config.autoload_paths << library_path
+      end
+    end
+
+    config.after_initialize do
+      ignore_path = config.rux.ignore_path || Onload.config.ignore_path
+
+      if ignore_path.nil? && Rails.root.join(".gitignore").exist?
+        ignore_path = Rails.root.join(".gitignore").to_s
+      end
+
+      Onload.config.ignore_path = ignore_path
+      config.rux.ignore_path = ignore_path
+    end
+
+    rake_tasks do
+      load File.expand_path(File.join(*%w(. tasks transpile.rake)), __dir__)
+    end
+  end
+end

data/lib/rux-rails/output_buffer.rb

@@ -0,0 +1,13 @@
+require 'action_view'
+
+module RuxRails
+  class OutputBuffer < ActionView::OutputBuffer
+    def safe_append(obj)
+      Array(obj).each { |o| self.safe_append=(o) }
+    end
+
+    def append(obj)
+      Array(obj).each { |o| self.append=(o) }
+    end
+  end
+end

data/lib/rux-rails/rux_loader.rb

@@ -0,0 +1,7 @@
+module RuxRails
+  class RuxLoader
+    def self.call(source)
+      Rux.to_ruby(source)
+    end
+  end
+end

data/lib/rux-rails/tag_builder.rb

@@ -2,8 +2,8 @@ require 'rux'
 
 module RuxRails
   class TagBuilder < ::Rux::DefaultTagBuilder
-    def call(*args)
-      super.html_safe
+    def call(*args, &block)
+      build(*args, &block).html_safe
     end
   end
 end

data/lib/rux-rails/tasks/transpile.rake

@@ -3,18 +3,19 @@ require 'set'
 
 namespace :rux do
   task transpile: :environment do
-    config = Rails.application.config
-    paths = Set.new(config.autoload_paths + config.eager_load_paths)
+    ignore_file = if Rails.application.config.rux.ignore_path
+      Onload::IgnoreFile.load(Rails.application.config.rux.ignore_path)
+    end
+
+    Dir.glob(Rails.root.join('**/*.rux')) do |file|
+      rux_file = Rux::File.new(file)
+      rux_file.write
 
-    paths.each do |path|
-      # Skip library paths. Libraries should ship with all their rux files
-      # pre-transpiled.
-      next if Rux.library_paths.include?(path)
+      puts "Wrote #{rux_file.default_outfile}"
 
-      Dir.glob(File.join(path, '**/*.rux')).each do |file|
-        Rux::File.new(file).write
-        puts "Wrote #{file}"
-      end
+      ignore_file&.add(rux_file.default_outfile)
     end
+
+    ignore_file&.persist!
   end
 end

data/lib/rux-rails/version.rb

@@ -1,3 +1,3 @@
 module RuxRails
-  VERSION = '1.4.0'
+  VERSION = '2.0.0'
 end

data/lib/rux-rails.rb

@@ -1,6 +1,7 @@
 module RuxRails
   autoload :Components,      'rux-rails/components'
-  autoload :SafeBuffer,      'rux-rails/safe_buffer'
+  autoload :OutputBuffer,    'rux-rails/output_buffer'
+  autoload :RuxLoader,       'rux-rails/rux_loader'
   autoload :TagBuilder,      'rux-rails/tag_builder'
   autoload :TemplateHandler, 'rux-rails/template_handler'
   autoload :Visitor,         'rux-rails/visitor'
@@ -16,23 +17,17 @@ module RuxRails
     def tag_builder
       @tag_builder ||= TagBuilder.new
     end
-
-    def transpile_on_load?
-      transpile_on_load.call
-    end
   end
 
-  self.transpile_on_load = -> () { true }
+  self.transpile_on_load = true
 end
 
 
 require 'rux'
-require 'rux-rails/railtie'
 
-# require both of these to support multiple versions of view_component
-require 'view_component'
-require 'view_component/engine'
+if defined?(Rails)
+  require 'rux-rails/engine'
+end
 
-ViewComponent::Base.send(:include, RuxRails::Components)
 Rux.tag_builder = RuxRails.tag_builder
-Rux.buffer = RuxRails::SafeBuffer
+Rux.buffer = RuxRails::OutputBuffer

data/rux-rails.gemspec

@@ -10,9 +10,11 @@ Gem::Specification.new do |s|
   s.description = s.summary = 'Rux view components on Rails.'
   s.platform = Gem::Platform::RUBY
 
-  s.add_dependency 'rux', '~> 1.0'
+  s.add_dependency 'rux', '~> 1.3'
   s.add_dependency 'railties', '>= 5.0'
-  s.add_dependency 'view_component', '>= 2', '< 4'
+  s.add_dependency 'view_component', '>= 2', '< 5'
+  s.add_dependency 'onload', '~> 1.1'
+  s.add_dependency 'use_context', '~> 1.2'
 
   s.require_path = 'lib'
 

data/spec/components/rails/button_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Rails::Button, type: :component do
+  it 'renders with defaults' do
+    render_inline(described_class.new)
+    expect(rendered_content).to eq("<button name=\"button\" type=\"submit\">Button</button>")
+  end
+
+  it 'renders with the given label' do
+    render_inline(described_class.new(label: "Click me"))
+    expect(rendered_content).to eq("<button name=\"button\" type=\"submit\">Click me</button>")
+  end
+
+  it 'renders with the given attributes' do
+    render_inline(described_class.new(disabled: true))
+    expect(rendered_content).to eq("<button name=\"button\" type=\"submit\" disabled=\"disabled\">Button</button>")
+  end
+end

data/spec/components/rails/button_to_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Rails::ButtonTo, type: :component do
+  it 'renders with defaults' do
+    render_inline(described_class.new(url: "http://example.com"))
+    expect(rendered_content).to include(
+      /<form .* action=\"http:\/\/example.com".*<button type=\"submit\"><\/button>/
+    )
+  end
+
+  it 'renders with a label' do
+    render_inline(described_class.new(label: "Click me", url: "http://example.com"))
+    expect(rendered_content).to include(
+      /<form .* action=\"http:\/\/example.com".*<button type=\"submit\">Click me<\/button>/
+    )
+  end
+
+  it 'renders with the content as the label' do
+    render_inline(described_class.new(url: "http://example.com")) { "Click me" }
+    expect(rendered_content).to include(
+      /<form .* action=\"http:\/\/example.com".*<button type=\"submit\">Click me<\/button>/
+    )
+  end
+end

data/spec/components/rails/content_tag_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Rails::ContentTag, type: :component do
+  it 'renders an empty tag by default' do
+    render_inline(described_class.new(tag: :div))
+    expect(rendered_content).to eq("<div></div>")
+  end
+
+  it 'renders content within the tags' do
+    render_inline(described_class.new(tag: :div)) { 'Hello, world' }
+    expect(rendered_content).to eq("<div>Hello, world</div>")
+  end
+end

data/spec/components/rails/form_with_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Rails::FormWith, type: :component do
+  it 'renders with defaults' do
+    render_inline(described_class.new(url: "/foo"))
+    expect(rendered_content).to include("<form action=\"/foo\" accept-charset=\"UTF-8\" method=\"post\"><input type=\"hidden\" name=\"authenticity_token\"")
+  end
+
+  it 'adds the builder to the rux context' do
+    builder = nil
+
+    render_inline(described_class.new(url: "/foo")) do
+      UseContext.use_context(:rux, :form_builder) do |f|
+        builder = f
+      end
+    end
+
+    expect(builder).to be_a(ActionView::Helpers::FormBuilder)
+  end
+end

data/spec/components/rails/hidden_field_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rails::HiddenField, type: :component do
+  it 'renders with defaults' do
+    render_inline(Rails::FormWith.new(url: "/foo")) do
+      described_class.new(name: "bar").render_in(view_context)
+    end
+
+    expect(rendered_content).to include("<input autocomplete=\"off\" type=\"hidden\" name=\"bar\" id=\"bar\" />")
+  end
+end

data/spec/components/rails/label_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Rails::Label, type: :component do
+  it 'renders with defaults' do
+    render_inline(Rails::FormWith.new(url: "/foo")) do
+      described_class.new(name: "bar").render_in(view_context)
+    end
+
+    expect(rendered_content).to include("<label for=\"bar\">Bar</label>")
+  end
+
+  it 'renders content within the tags' do
+    render_inline(Rails::FormWith.new(url: "/foo")) do
+      described_class.new(name: "bar").render_in(view_context) do
+        "Hello, world"
+      end
+    end
+
+    expect(rendered_content).to include("<label for=\"bar\">Hello, world</label>")
+  end
+end

data/spec/components/rails/link_to_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Rails::LinkTo, type: :component do
+  it 'renders with defaults' do
+    render_inline(described_class.new(url: "http://example.com", label: "foo"))
+    expect(rendered_content).to eq("<a href=\"http://example.com\">foo</a>")
+  end
+
+  it 'renders the content between the tags' do
+    render_inline(described_class.new(url: "http://example.com")) do
+      "Hello, world"
+    end
+
+    expect(rendered_content).to eq("<a href=\"http://example.com\">Hello, world</a>")
+  end
+end

data/spec/components/rails/password_field_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rails::PasswordField, type: :component do
+  it 'renders with defaults' do
+    render_inline(Rails::FormWith.new(url: "/foo")) do
+      described_class.new(name: "bar").render_in(view_context)
+    end
+
+    expect(rendered_content).to include("<input type=\"password\" name=\"bar\" id=\"bar\" />")
+  end
+end

data/spec/components/rails/text_field_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rails::TextField, type: :component do
+  it 'renders with defaults' do
+    render_inline(Rails::FormWith.new(url: "/foo")) do
+      described_class.new(name: "bar").render_in(view_context)
+    end
+
+    expect(rendered_content).to include("<input type=\"text\" name=\"bar\" id=\"bar\" />")
+  end
+end

data/spec/components/rux/component_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Rux::Component, type: :component do
+  it 'renders the given instance' do
+    render_inline(Rux::Component.new(instance: Image.new(src: "foo.png")))
+
+    expect(rendered_content).to include("<img src=\"/images/foo.png\" />")
+  end
+end

data/spec/controllers/home_controller_spec.rb

@@ -2,7 +2,12 @@ require 'spec_helper'
 
 describe HomeController, type: :request do
   describe '#index' do
-    it 'works' do
+    before(:each) do
+      # Force a recompile to avoid test pollution
+      HomeComponent.respond_to?(:__vc_compile) ? HomeComponent.__vc_compile : HomeComponent.compile
+    end
+
+    it 'transpiles the file' do
       get '/'
 
       expect(response).to have_http_status(:ok)
@@ -10,5 +15,36 @@ describe HomeController, type: :request do
         have_selector("div.container img[src='/images/cat.png'] + button", text: "Click Me!")
       )
     end
+
+    it "allows hot reloading" do
+      get "/"
+
+      expect(response).to have_http_status(:ok)
+      expect(response.body).to(
+        have_selector(".container", text: "Click Me!")
+      )
+
+      new_contents = <<~RUX
+        class HomeComponent < ViewComponent::Base
+          def call
+            <div class="container">
+              <Image src="cat.png" size="40" />
+              <Button outline={true} disabled size={:large}>
+                Click if you dare
+              </Button>
+            </div>
+          end
+        end
+      RUX
+
+      with_file_contents(Rails.root.join(*%w[app components home_component.rux]), new_contents) do
+        get "/"
+
+        expect(response).to have_http_status(:ok)
+        expect(response.body).to(
+          have_selector(".container", text: "Click if you dare")
+        )
+      end
+    end
   end
 end

data/spec/dummy/app/components/html_safety_component.rb

@@ -0,0 +1,13 @@
+class HtmlSafetyComponent < ViewComponent::Base
+  def initialize(value:)
+    @value = value
+  end
+
+  def call
+    Rux.tag("div") {
+      Rux.create_buffer.tap { |_rux_buf_|
+        _rux_buf_.append(@value)
+      }.to_s
+    }
+  end
+end

data/spec/dummy/app/components/html_safety_component.rux

@@ -0,0 +1,9 @@
+class HtmlSafetyComponent < ViewComponent::Base
+  def initialize(value:)
+    @value = value
+  end
+
+  def call
+    <div>{@value}</div>
+  end
+end

data/spec/dummy/app/components/image.rux

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Image < ViewComponent::Base
+  include ActionView::Helpers::AssetUrlHelper
+
+  attr_reader :src, :params
+
+  def initialize(src:, **params)
+    @src = src
+    @params = params
+  end
+
+  def call
+    image_tag(src, **params)
+  end
+end

data/spec/dummy/config/application.rb

@@ -1,3 +1,7 @@
+# require both of these to support multiple versions of view_component
+require 'view_component'
+require 'view_component/engine'
+
 module RuxRails
   class DummyApplication < ::Rails::Application
     if config.respond_to?(:load_defaults)