sugar_bee 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2682b6199fd26509a94f89eb0dba48f359b06e6dff5f4fd63a2151daaeedc3e2
-  data.tar.gz: 1c80ab38f1ad79eb1deb0c85d4a00f63ebf0aa4f26b818d70af9ce3bbdea8b3b
+  metadata.gz: 0f2cc41e7f639d90d331659d7eaafad8e852e512ef11384b7129bb40e3810634
+  data.tar.gz: 6c99912c8d11226b9023a1c0bc597111379db1c49844e115d8a9fe4cb8bae414
 SHA512:
-  metadata.gz: 8b723db24c2bdeb06a2b701b585356c10efd7a9247e75b109027783c63db163eb6a58469fe65c2d1b74bd02ea5002592efc0465bc47652a9bd5071496e7e8c52
-  data.tar.gz: 3dd3b0ab9a5fb864631a5057ac653ca5ee85414dbae1a61f48ad7e90c8eac73c736a684301041a4fc0f946085a8c0e229af51c66a07d60c35df5ce71c4165a60
+  metadata.gz: 223214a0a2d6c7c32b92bf2da03194c86c9c7bfbc2b7aef90b72ba239702eee2ddef4988d9c5d1a72326d7c00af3a8392473c4f55476c18b6ae6a907c1ffa24d
+  data.tar.gz: 25c117707750a4e3c0ca4f6d8635e3f74142ab337057a7a635c8daf50f71c9070e42eb20a01b1efb2a8152ac0efa6fcff6b5d6e13a5714b84234a387efe4f361

data/README.md

@@ -26,7 +26,7 @@ TODO: Write usage instructions here
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+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).
 

data/Rakefile

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+Bundler::GemHelper.tag_prefix = "sugar_bee-"
+require "minitest/test_task"
 
-RSpec::Core::RakeTask.new(:spec)
+Minitest::TestTask.create
 
 require "standard/rake"
 
-task default: %i[spec standard]
+task default: %i[test standard]

data/lib/sugar_bee/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SugarBee
+  class Error < StandardError; end
+
+  class UnknownComponentError < Error; end
+
+  class ParseError < Error; end
+end

data/lib/sugar_bee/parser.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "errors"
+require_relative "srb/grammar"
+require_relative "srb/compiler"
+
+module SugarBee
+  # Public interface: `.srb` source string in → compiled ERB string out.
+  # Pure function, no Rails coupling. Parses with the SRB::Grammar, compiles with
+  # the SRB::Compiler transform.
+  module Parser
+    def self.call(source)
+      SRB::Compiler.new.apply(SRB::Grammar.new.parse(source))
+    rescue Parslet::ParseFailed => e
+      raise ParseError, "Invalid .srb template: #{deepest_failure_line(e)}"
+    end
+
+    # The root of `parse_failure_cause.ascii_tree` reports where the top-level
+    # repetition gave up (often "line 1 char 1"); the line that progressed
+    # furthest into the input is the one that names the actual problem.
+    def self.deepest_failure_line(error)
+      error.parse_failure_cause.ascii_tree.lines
+        .map { |line| line.strip.sub(/\A[|`\s-]+/, "") }
+        .reverse # ties resolve to the deepest (most specific) tree node
+        .max_by { |line| line.match(/line (\d+) char (\d+)\.\z/) { |m| [m[1].to_i, m[2].to_i] } || [0, 0] }
+    end
+    private_class_method :deepest_failure_line
+  end
+end

data/lib/sugar_bee/srb/compiler.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "../errors"
+
+module SugarBee
+  module SRB
+    # Compiles an SRB::Grammar parse tree into an ERB string.
+    # `tokens:` is ALWAYS emitted (even empty → `%i[]`); tag pairs emit `do |c|`
+    # (the block param is the slot receiver Story 4.4 will use). Self-closing tags
+    # emit no block.
+    class Compiler < Parslet::Transform
+      # Marks a kv-pair kwarg so render_call can partition it away from plain
+      # token strings; `code` is the already-formatted Ruby value (quoted or verbatim).
+      KvPair = Struct.new(:key, :code)
+
+      rule(text: simple(:t)) { t.to_s }
+      rule(token: simple(:t)) { t.to_s }
+      rule(source: sequence(:nodes)) { nodes.join }
+
+      rule(grouped: {prefix: simple(:prefix), inner: subtree(:inner)}) do
+        Array(inner).map { |tok| "#{prefix}:#{tok}" }
+      end
+
+      rule(kv: {key: simple(:key), dq: subtree(:val)}) do
+        content = val.is_a?(Array) ? "" : val.to_s
+        KvPair.new(key.to_s, "\"#{content}\"")
+      end
+      rule(kv: {key: simple(:key), bare: simple(:val)}) { KvPair.new(key.to_s, val.to_s) }
+
+      rule(self_close: {name: simple(:name), args: subtree(:args)}) do
+        "<%= render(#{Compiler.render_call(name, args)}) %>"
+      end
+
+      rule(tag_pair: {name: simple(:name), args: subtree(:args), source: subtree(:children), close: simple(:close)}) do
+        unless name.to_s == close.to_s
+          raise SugarBee::ParseError, "Mismatched tags: <#{name}> closed by </#{close}>"
+        end
+        "<%= render(#{Compiler.render_call(name, args)}) do |c| %>#{Array(children).join}<% end %>"
+      end
+
+      rule(slot: {sname: simple(:sname), source: subtree(:children), close: simple(:close)}) do
+        unless sname.to_s == close.to_s
+          raise SugarBee::ParseError, "Mismatched slot tags: <:#{sname}> closed by </:#{close}>"
+        end
+        "<% c.with_#{sname} do %>#{Array(children).join}<% end %>"
+      end
+
+      def self.render_call(name, args)
+        const = "#{name}Component"
+        unless Object.const_defined?(const)
+          raise SugarBee::UnknownComponentError, "Unknown component <#{name}>: no #{const} class is defined"
+        end
+
+        token_strings, kv_pairs = [], []
+        Array(args).each do |item|
+          case item
+          when KvPair
+            unless item.key.match?(/\A[a-z_][a-zA-Z0-9_]*\z/)
+              raise SugarBee::ParseError, "Invalid attribute key '#{item.key}': not a valid Ruby keyword argument"
+            end
+            kv_pairs << "#{item.key}: #{item.code}"
+          when Array then token_strings.concat(item)
+          else token_strings << item
+          end
+        end
+        kwargs = kv_pairs.empty? ? "" : ", #{kv_pairs.join(", ")}"
+        "#{const}.new(tokens: %i[#{token_strings.join(" ")}]#{kwargs})"
+      end
+    end
+  end
+end

data/lib/sugar_bee/srb/grammar.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module SugarBee
+  module SRB
+    # PEG grammar for the `.srb` template language (structure only; codegen lives
+    # in SRB::Compiler).
+    class Grammar < Parslet::Parser
+      root(:source)
+
+      rule(:source) { (erb | component | slot | passthrough).repeat.as(:source) }
+
+      # ERB tags are atomic: the whole `<% ... %>` / `<%= ... %>` run is one
+      # opaque verbatim unit, terminated by the first subsequent `%>`. The
+      # parser never looks inside — no interpretation of Ruby content (FR-25/26).
+      rule(:erb) { (erb_edge >> (str("%>").absent? >> any).repeat >> str("%>")).as(:text) }
+
+      # Verbatim text: plain HTML, lowercase tags — anything not opening/closing a component, slot, or ERB tag.
+      rule(:passthrough) { (node_edge.absent? >> any).repeat(1).as(:text) }
+      rule(:node_edge) { component_edge | slot_edge | erb_edge }
+      rule(:component_edge) { (str("<") >> match["A-Z"]) | (str("</") >> sp? >> match["A-Z"]) }
+      # Only a lowercase-initial name opens a slot, so `<:` before anything else
+      # (uppercase, space, punctuation) falls through to passthrough as verbatim
+      # text instead of hard-failing the whole parse.
+      rule(:slot_edge) { (str("<:") | str("</:")) >> match["a-z"] }
+      # Stops passthrough at `<%` so the `erb` rule claims the tag whole —
+      # without this, passthrough would consume into an ERB tag and could
+      # hard-stop at a `<`+uppercase inside it (e.g. `<%= "<Box>" %>`).
+      # `<%%` (ERB's literal-escape) is excluded: it is not an ERB opener, so
+      # neither the erb rule claims it nor does passthrough stop at it — the
+      # sequence falls through to passthrough and emits verbatim.
+      rule(:erb_edge) { str("<%") >> str("%").absent? }
+
+      rule(:component) { self_close | tag_pair }
+      rule(:self_close) { (str("<") >> cname >> args >> sp? >> str("/>")).as(:self_close) }
+      rule(:tag_pair) do
+        (str("<") >> cname >> args >> sp? >> str(">") >>
+          source >> str("</") >> sp? >> cname_close.as(:close) >> sp? >> str(">")).as(:tag_pair)
+      end
+
+      rule(:cname) { (match["A-Z"] >> match["A-Za-z"].repeat).as(:name) }
+      rule(:cname_close) { match["A-Z"] >> match["A-Za-z"].repeat }
+
+      rule(:slot) do
+        (str("<:") >> sname >> sp? >> str(">") >>
+          source >> str("</:") >> sp? >> sname_close.as(:close) >> sp? >> str(">")).as(:slot)
+      end
+      rule(:sname) { (match["a-z"] >> match["a-zA-Z0-9_"].repeat).as(:sname) }
+      rule(:sname_close) { match["a-z"] >> match["a-zA-Z0-9_"].repeat }
+
+      # Mixed bag: tokens (bare/grouped) AND kv pairs. Compiler partitions them apart.
+      rule(:args) { (sp >> attr).repeat.as(:args) }
+      rule(:attr) { grouped | kvattr | token }
+
+      rule(:grouped) do
+        (match["^:\\[\\s"].repeat(1).as(:prefix) >> str(":[") >>
+          (group_token >> (sp >> group_token).repeat).as(:inner) >> str("]")).as(:grouped)
+      end
+      # Same charset as `token`, but a bare "]" ends the token so the group's
+      # closing bracket is never swallowed. A balanced "[...]" run (arbitrary
+      # values like gap-[13px]) is consumed whole, so its inner "]" doesn't
+      # terminate the group prematurely.
+      rule(:group_token) do
+        (bracketed | (str("/") >> str(">").absent?) | match["^\\s/>\\[\\]"]).repeat(1).as(:token)
+      end
+      rule(:bracketed) { str("[") >> match["^\\]"].repeat >> str("]") }
+
+      rule(:kvattr) { (key.as(:key) >> str("=") >> (dquoted | unquoted)).as(:kv) }
+      rule(:key) { match["a-zA-Z_\\-"].repeat(1) }
+      rule(:dquoted) { str('"') >> match['^"'].repeat.as(:dq) >> str('"') }
+      rule(:unquoted) { match["^\\s/>"].repeat(1).as(:bare) }
+
+      rule(:token) { ((str("/") >> str(">").absent?) | match["^\\s/>"]).repeat(1).as(:token) }
+
+      rule(:sp) { match["\\s"].repeat(1) }
+      rule(:sp?) { sp.maybe }
+    end
+  end
+end

data/lib/sugar_bee/template_handler.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "action_view"
+require_relative "parser"
+
+module SugarBee
+  module TemplateHandler
+    def self.call(template, source)
+      compiled_erb = Parser.call(source)
+      ActionView::Template.handler_for_extension(:erb).call(template, compiled_erb)
+    end
+  end
+end
+
+ActionView::Template.register_template_handler(:srb, SugarBee::TemplateHandler)

data/lib/sugar_bee/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SugarBee
-  VERSION = "0.1.0"
+  VERSION = "0.2.2"
 end

data/lib/sugar_bee.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
+require "action_view"
 require_relative "sugar_bee/version"
-require_relative "sugar_bee/handler"
-require_relative "sugar_bee/railtie" if defined?(Rails)
-
-module SugarBee
-  class Error < StandardError; end
-end
+require_relative "sugar_bee/errors"
+require_relative "sugar_bee/parser"
+require_relative "sugar_bee/template_handler"

metadata

@@ -1,34 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: sugar_bee
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Fabio Papa
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: actionview
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 9.0.0
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 9.0.0
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -43,45 +37,29 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-description: Handles a new SRB template type that builds on ERB, allowing JSX-like
-  tags that render ViewComponents.`<Card></Card>` renders `CardComponent` for example.
+description: ActionView .srb template handler for Sugar Cube.
 email:
 - me@fabiopapa.dev
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".standard.yml"
 - README.md
 - Rakefile
 - lib/sugar_bee.rb
-- lib/sugar_bee/handler.rb
-- lib/sugar_bee/railtie.rb
-- lib/sugar_bee/srb.rb
-- lib/sugar_bee/srb_to_erb.rb
+- lib/sugar_bee/errors.rb
+- lib/sugar_bee/parser.rb
+- lib/sugar_bee/srb/compiler.rb
+- lib/sugar_bee/srb/grammar.rb
+- lib/sugar_bee/template_handler.rb
 - lib/sugar_bee/version.rb
 - sig/sugar_bee.rbs
-homepage: https://github.com/fapapa/sugar_bee
+homepage: https://github.com/fapapa/sugar_cube_system/tree/main/gems/sugar_bee
 licenses: []
 metadata:
-  homepage_uri: https://github.com/fapapa/sugar_bee
-  source_code_uri: https://github.com/fapapa/sugar_bee
-  changelog_uri: https://github.com/fapapa/sugar_bee/changelog.md
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/fapapa/sugar_cube_system/tree/main/gems/sugar_bee
+  source_code_uri: https://github.com/fapapa/sugar_cube_system/tree/main/gems/sugar_bee
 rdoc_options: []
 require_paths:
 - lib
@@ -89,14 +67,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.2
 specification_version: 4
-summary: Syntactic sugar on top of ERB to render ViewComponents with JSX-like tags.
+summary: ActionView .srb template handler for Sugar Cube.
 test_files: []

data/.rspec

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

data/.standard.yml

@@ -1,3 +0,0 @@
-# For available configuration options, see:
-#   https://github.com/standardrb/standard
-ruby_version: 3.1

data/lib/sugar_bee/handler.rb

@@ -1,18 +0,0 @@
-require "action_view"
-require "action_view/template"
-require_relative "srb"
-require_relative "srb_to_erb"
-
-module SugarBee
-  class Handler
-    def self.call(template, source)
-      processed = process(source)
-      ActionView::Template.registered_template_handler(:erb).call(template, processed)
-    end
-
-    def self.process(source)
-      srb = Srb.new.parse(source)
-      SrbToErb.new.apply(srb)
-    end
-  end
-end

data/lib/sugar_bee/railtie.rb

@@ -1,9 +0,0 @@
-module SugarBee
-  class Railtie < Rails::Railtie
-    initializer "sugar_bee.register_template_handler" do
-      ActiveSupport.on_load(:action_view) do
-        ActionView::Template.register_default_template_handler :srb, SugarBee::Handler
-      end
-    end
-  end
-end

data/lib/sugar_bee/srb.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-class SugarBee::Srb < Parslet::Parser
-  root(:source)
-  rule(:source) { (non_srb | srb).repeat.as(:source) }
-
-  rule(:non_srb) { (srb_detector.absent? >> any).repeat(1).as(:erb) }
-  rule(:srb) { (self_closing_tag | tag_pair).as(:srb) }
-  rule(:self_closing_tag) do
-    str("<") >> srb_self_close_detector.absent? >> (component_name >> vattrs.maybe).as(:simple_component) >> space? >> srb_self_close_detector
-  end
-  rule(:tag_pair) { (opening_tag >> source >> closing_tag).as(:tag_pair) }
-
-  rule(:opening_tag) { (str("<") >> (component_name >> vattrs.maybe).as(:open) >> space? >> str(">")) }
-  rule(:closing_tag) { (str("</") >> space? >> component_name.as(:close) >> str(">")) }
-  rule(:component_name) { (match["A-Z"] >> match["A-Za-z"].repeat).as(:name) }
-  rule(:vattrs) { space? >> (vattr >> space?).repeat.as(:vattrs) }
-  rule(:vattr) { match["-a-z0-9"].repeat(1).as(:val) }
-
-  rule(:srb_detector) { (srb_open_detector | srb_close_detector) }
-  rule(:srb_open_detector) { str("<") >> match["A-Z"] }
-  rule(:srb_close_detector) { str("</") >> space? >> match["A-Z"] }
-  rule(:srb_self_close_detector) { str("/>") }
-  rule(:space) { str("\s") }
-  rule(:space?) { space.maybe }
-end

data/lib/sugar_bee/srb_to_erb.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-class SugarBee::SrbToErb < Parslet::Transform
-  rule(source: sequence(:erb_fragments)) { erb_fragments.join }
-  rule(
-    srb: {
-      simple_component: {
-        name: simple(:component_name),
-        vattrs: sequence(:values)
-      }
-    }
-  ) do
-    args = "(vattrs: %w[#{values.join(" ")}])" if values.any?
-    "<%= render(#{component_name}Component.new#{args}) %>"
-  end
-  rule(
-    srb: {
-      tag_pair: {
-        open: {name: simple(:component_name), vattrs: sequence(:values)},
-        source: sequence(:erb_fragments),
-        close: {name: simple(:component_name)}
-      }
-    }
-  ) do
-    args = "(vattrs: %w[#{values.join(" ")}])" if values.any?
-    "<%= render(#{component_name}Component.new#{args}) do %>#{erb_fragments.join}<% end %>"
-  end
-  rule(erb: simple(:content)) { content }
-  rule(val: simple(:vattr)) { vattr }
-end