rbexy 1.1.0 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6728982815c307bb37a495c3d11450e9582bf1cd17eef5306c9e940c0c36eea
-  data.tar.gz: 5fdfa1cc3c5fc70b573aa730f827b2f5d38b8031f1adc6344b31926ce520b4af
+  metadata.gz: c25ae0414d2229676a67b1ec6ee63c6092d00bb699668cd1213c93d50dee2356
+  data.tar.gz: 00d80e6099de62ca467cf6c75b661cf43eeb8641fe15c510163ba6f02a1fcc99
 SHA512:
-  metadata.gz: 46385e65a3cd976497efd8d6db789eee4a2c73668e085dd6772d8c6a9a835783f6bb80ef923463af97cfec5d5625fffd641229a5a97a1c24e024b75d996969af
-  data.tar.gz: 025e25a41d9cc5e848342c668721cdef046ab13e5cff9737acc69a66eaca6cdd3ac06493bfcbb42b735fcbd6e7ae243e8a65588d648d3442924306944addb714
+  metadata.gz: e29d842f6f9d90c2908be38c58e8d86a365496eb60b093dacc15364f19af00238457a8e7d4877f8db9305a88a29db5c5a6682b2684c41abd8c0ffa19b8279cb4
+  data.tar.gz: 8298b8fa13abef5f8a85f0df96d9abda969cc0b98417c5668f34b644ba79a9d0821c372989f0111149b4abc1b9851eb4d69e8aa79b5d69a91f425a931845e24d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbexy (1.1.0)
+    rbexy (2.0.0.beta1)
       actionview (>= 6.0, < 7.0)
       activesupport (>= 6.0, < 7.0)
 
@@ -101,6 +101,7 @@ GEM
       mini_mime (>= 0.1.1)
     marcel (0.3.3)
       mimemagic (~> 0.3.2)
+    memory_profiler (0.9.14)
     method_source (1.0.0)
     mimemagic (0.3.5)
     mini_mime (1.0.2)
@@ -199,6 +200,7 @@ PLATFORMS
 
 DEPENDENCIES
   guard-rspec (~> 4.7, >= 4.7.3)
+  memory_profiler (~> 0.9.14)
   pry-byebug
   rails (>= 6.0, < 7.0)
   rake

data/README.md

@@ -173,6 +173,14 @@ Loops:
 </ul>
 ```
 
+Blocks:
+
+```jsx
+{link_to "/" do
+  <span>Click me</span>
+end}
+```
+
 As an attribute:
 
 ```jsx
@@ -189,6 +197,16 @@ Pass a lambda to a prop, that when called returns a tag:
 </Hero>
 ```
 
+_Note that when using tags inside blocks, the block must evaluate to a single root element. Rbexy behaves similar to JSX in this way. E.g.:_
+
+```
+# Do
+-> { <span><i>Hello</i> World</span> }
+
+# Don't
+-> { <i>Hello</i> World }
+```
+
 ### Tags
 
 You can put standard HTML tags anywhere.

data/lib/rbexy.rb

@@ -1,15 +1,22 @@
 require "rbexy/version"
+require "active_support/inflector"
+require "active_support/concern"
+require "action_view/helpers/output_safety_helper"
+require "action_view/helpers/capture_helper"
+require "action_view/helpers/tag_helper"
+require "action_view/context"
 
 module Rbexy
   autoload :Lexer, "rbexy/lexer"
   autoload :Parser, "rbexy/parser"
   autoload :Nodes, "rbexy/nodes"
   autoload :Runtime, "rbexy/runtime"
-  autoload :HashMash, "rbexy/hash_mash"
-  autoload :ComponentTagBuilder, "rbexy/component_tag_builder"
-  autoload :ViewContextHelper, "rbexy/view_context_helper"
   autoload :ComponentContext, "rbexy/component_context"
   autoload :Configuration, "rbexy/configuration"
+  autoload :ComponentResolver, "rbexy/component_resolver"
+  autoload :Template, "rbexy/template"
+  autoload :Refinements, "rbexy/refinements"
+  autoload :ASTTransformer, "rbexy/ast_transformer"
 
   ContextNotFound = Class.new(StandardError)
 
@@ -22,14 +29,24 @@ module Rbexy
       @configuration ||= Configuration.new
     end
 
-    def compile(template_string)
-      tokens = Rbexy::Lexer.new(template_string).tokenize
-      template = Rbexy::Parser.new(tokens).parse
-      template.compile
+    def compile(template, context = build_default_compile_context(template))
+      tokens = Lexer.new(template, context.element_resolver).tokenize
+      root = Parser.new(tokens).parse
+      root.inject_compile_context(context)
+      root.transform!
+      root.precompile.compile
     end
 
-    def evaluate(template_string, runtime)
-      runtime.evaluate compile(template_string)
+    def evaluate(template_string, runtime = Rbexy::Runtime.new)
+      runtime.evaluate compile(Template.new(template_string))
+    end
+
+    def build_default_compile_context(template)
+      OpenStruct.new(
+        template: template,
+        element_resolver: configuration.element_resolver,
+        ast_transformer: configuration.transforms
+      )
     end
   end
 end

data/lib/rbexy/ast_transformer.rb

@@ -0,0 +1,21 @@
+module Rbexy
+  class ASTTransformer
+    attr_reader :registry
+
+    def initialize
+      clear!
+    end
+
+    def register(*node_classes, &block)
+      node_classes.each { |k| (registry[k] ||= []) << block }
+    end
+
+    def transform(node, context)
+      registry[node.class]&.each { |t| t.call(node, context) }
+    end
+
+    def clear!
+      @registry = {}
+    end
+  end
+end

data/lib/rbexy/component.rb

@@ -1,5 +1,4 @@
 require "action_view"
-require "active_support/core_ext/class/attribute"
 
 module Rbexy
   class Component < ActionView::Base
@@ -63,11 +62,7 @@ module Rbexy
     attr_reader :view_context, :content_block
 
     def method_missing(meth, *args, &block)
-      if view_context.respond_to?(meth)
-        view_context.send(meth, *args, &block)
-      else
-        super
-      end
+      view_context.send(meth, *args, &block)
     end
 
     def clean_template_backtrace(backtrace)

data/lib/rbexy/component_resolver.rb

@@ -0,0 +1,60 @@
+module Rbexy
+  class ComponentResolver
+    using Rbexy::Refinements::Array::FindMap
+
+    KNOWN_HTML_ELEMENTS = %w(
+      a abbr acronym address animate animateMotion animateTransform applet area article aside audio b base basefont
+      bdi bdo bgsound big blink blockquote body br button canvas caption center circle cite clipPath code col colgroup
+      color-profile command content data datalist dd defs del desc details dfn dialog dir discard div dl dt element
+      ellipse em embed feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix feDiffuseLighting
+      feDisplacementMap feDistantLight feDropShadow feFlood feFuncA feFuncB feFuncG feFuncR feGaussianBlur feImage
+      feMerge feMergeNode feMorphology feOffset fePointLight feSpecularLighting feSpotLight feTile feTurbulence
+      fieldset figcaption figure filter font footer foreignObject form frame frameset g h1 h2 h3 h4 h5 h6 hatch
+      hatchpath head header hgroup hr html i iframe image img input ins isindex kbd keygen label legend li line
+      linearGradient link listing main map mark marker marquee mask menu menuitem mesh meshgradient meshpatch meshrow
+      meta metadata meter mpath multicol nav nextid nobr noembed noframes noscript object ol optgroup option output p
+      param path pattern picture plaintext polygon polyline pre progress q radialGradient rb rect rp rt rtc ruby s
+      samp script section select set shadow slot small solidcolor source spacer span stop strike strong style sub
+      summary sup svg switch symbol table tbody td template text textarea textPath tfoot th thead time title tr track
+      tspan tt u ul unknown use var video view wbr xmp
+    ).to_set
+
+    attr_reader :component_namespaces
+
+    def initialize
+      self.component_namespaces = {}
+    end
+
+    def component_namespaces=(hash)
+      @component_namespaces = hash.transform_keys(&:to_s)
+    end
+
+    def component?(name, template)
+      return false if KNOWN_HTML_ELEMENTS.include?(name)
+      return true if component_class(name, template)
+      false
+    end
+
+    def component_class(name, template)
+      possible_names = matching_namespaces(template).map { |ns| "#{ns}.#{name}" } << name
+      possible_names.find_map(&method(:find))
+    end
+
+    private
+
+    def find(name)
+      find!(name)
+    rescue NameError => e
+      raise e unless e.message =~ /wrong constant name/ || e.message =~ /uninitialized constant/
+      nil
+    end
+
+    def matching_namespaces(template)
+      component_namespaces.select { |path, ns| template.identifier.start_with?(path) }.values.flatten.uniq
+    end
+
+    def find!(name)
+      ActiveSupport::Inflector.constantize("#{name.gsub(".", "::")}Component")
+    end
+  end
+end

data/lib/rbexy/configuration.rb

@@ -1,12 +1,29 @@
 module Rbexy
   class Configuration
-    attr_accessor :component_provider
+    attr_accessor :element_resolver
     attr_accessor :template_paths
     attr_accessor :enable_context
     attr_accessor :debug
+    attr_accessor :component_rendering_templates
+    attr_accessor :transforms
 
     def template_paths
       @template_paths ||= []
     end
+
+    def element_resolver
+      @element_resolver ||= ComponentResolver.new
+    end
+
+    def transforms
+      @transforms ||= ASTTransformer.new
+    end
+
+    def component_rendering_templates
+      @component_rendering_templates ||= {
+        children: "{capture{%{children}}}",
+        component: "::%{component_class}.new(%{view_context},%{kwargs}).render%{children_block}"
+      }
+    end
   end
 end

data/lib/rbexy/lexer.rb

@@ -10,7 +10,7 @@ module Rbexy
       end
     end
 
-    Patterns = HashMash.new(
+    Patterns = OpenStruct.new(
       open_expression: /{/,
       close_expression: /}/,
       expression_content: /[^}{"'<]+/,
@@ -33,19 +33,19 @@ module Rbexy
       declaration: /<![^>]*>/
     )
 
-    attr_reader :stack, :tokens, :scanner, :curr_expr_quote_levels
-    attr_accessor :curr_expr_bracket_levels, :curr_expr, :curr_default_text,
+    attr_reader :stack, :tokens, :scanner, :element_resolver, :template
+    attr_accessor :curr_expr, :curr_default_text,
                   :curr_quoted_text
 
-    def initialize(code)
+    def initialize(template, element_resolver)
+      @template = template
+      @scanner = StringScanner.new(template.source)
+      @element_resolver = element_resolver
       @stack = [:default]
-      @curr_expr_bracket_levels = 0
-      @curr_expr_quote_levels = { single: 0, double: 0 }
       @curr_expr = ""
       @curr_default_text = ""
       @curr_quoted_text = ""
       @tokens = []
-      @scanner = StringScanner.new(code)
     end
 
     def tokenize
@@ -59,7 +59,7 @@ module Rbexy
           elsif scanner.scan(Patterns.open_expression)
             open_expression
           elsif scanner.scan(Patterns.comment)
-            tokens << [:SILENT_NEWLINE]
+            tokens << [:NEWLINE]
           elsif scanner.check(Patterns.text_content)
             stack.push(:default_text)
           else
@@ -74,7 +74,7 @@ module Rbexy
           elsif scanner.scan(Patterns.open_expression)
             open_expression
           elsif scanner.scan(Patterns.comment)
-            tokens << [:SILENT_NEWLINE]
+            tokens << [:NEWLINE]
           elsif scanner.check(Patterns.text_content)
             stack.push(:default_text)
           else
@@ -163,9 +163,9 @@ module Rbexy
             tokens << [:CLOSE_TAG_DEF]
             stack.pop
           elsif scanner.scan(Patterns.tag_name)
-            tokens << [:TAG_NAME, scanner.matched]
+            tokens << [:TAG_DETAILS, tag_details(scanner.matched)]
           elsif scanner.scan(Patterns.whitespace)
-            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+            scanner.matched.count("\n").times { tokens << [:NEWLINE] }
             tokens << [:OPEN_ATTRS]
             stack.push(:tag_attrs)
           else
@@ -182,7 +182,7 @@ module Rbexy
           end
         when :tag_attrs
           if scanner.scan(Patterns.whitespace)
-            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+            scanner.matched.count("\n").times { tokens << [:NEWLINE] }
           elsif scanner.check(Patterns.close_tag)
             tokens << [:CLOSE_ATTRS]
             stack.pop
@@ -205,7 +205,7 @@ module Rbexy
             open_expression
           elsif scanner.scan(Patterns.whitespace) || scanner.check(Patterns.close_tag)
             tokens << [:CLOSE_ATTR_VALUE]
-            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+            scanner.matched.count("\n").times { tokens << [:NEWLINE] }
             stack.pop
           else
             raise SyntaxError, self
@@ -286,5 +286,12 @@ module Rbexy
       # etc).
       scanner.scan(Patterns.expression_content) || scanner.scan(Patterns.open_tag_end)
     end
+
+    def tag_details(name)
+      type = element_resolver.component?(name, template) ? :component : :html
+      details = { name: scanner.matched, type: type }
+      details[:component_class] = element_resolver.component_class(name, template) if type == :component
+      details
+    end
   end
 end

data/lib/rbexy/nodes.rb

@@ -1,139 +1,19 @@
 module Rbexy
   module Nodes
-    module Util
-      def self.safe_string(str)
-        str.gsub('"', '\\"')
-      end
-
-      def self.safe_tag_name(name)
-        name.gsub(".", "__")
-      end
-    end
-
-    class Template
-      attr_reader :children
-
-      def initialize(children)
-        @children = children
-      end
-
-      def compile
-        "#{children.map(&:compile).map { |c| "@output_buffer << rbexy_prep_output(#{c})"}.join(";")};@output_buffer"
-      end
-    end
-
-    class Text
-      attr_reader :content
-
-      def initialize(content)
-        @content = content
-      end
-
-      def compile
-        "\"#{Util.safe_string(content)}\""
-      end
-    end
-
-    class ExpressionGroup
-      attr_reader :statements
-
-      def initialize(statements)
-        @statements = statements
-      end
-
-      def compile
-        statements.map(&:compile).join
-      end
-    end
-
-    class Expression
-      attr_reader :content
-
-      def initialize(content)
-        @content = content
-      end
-
-      def compile
-        content
-      end
-    end
-
-    class XmlNode
-      attr_reader :name, :members, :children
-
-      def initialize(name, members, children)
-        @name = name
-        @members = members || []
-        @children = children
-      end
-
-      def compile
-        base_tag = "rbexy_tag.#{Util.safe_tag_name(name)}(#{compile_members})"
-        tag = if children.length > 0
-          [
-            "#{base_tag} { capture {",
-              children.map(&:compile).map { |c| "@output_buffer << rbexy_prep_output(#{c})" }.join(";"),
-            "} }"
-          ].join
-        else
-          base_tag
-        end + ".html_safe"
-
-        if Rbexy.configuration.enable_context
-          [
-            "(",
-              "rbexy_context.push({});",
-              "#{tag}.tap { rbexy_context.pop }",
-            ")"
-          ].join
-        else
-          tag
-        end
-      end
-
-      def compile_members
-        members.each_with_object("") do |member, result|
-          case member
-          when ExpressionGroup
-            result << "**#{member.compile},"
-          when SilentNewline
-            result << member.compile
-          else
-            result << "#{member.compile},"
-          end
-        end
-      end
-    end
-
-    class XmlAttr
-      attr_reader :name, :value
-
-      def initialize(name, value)
-        @name = name
-        @value = value
-      end
-
-      def compile
-        "\"#{name}\": #{value.compile}"
-      end
-    end
-
-    class SilentNewline
-      def compile
-        "\n"
-      end
-    end
-
-    class Declaration
-      attr_reader :content
-
-      def initialize(content)
-        @content = content
-      end
-
-      def compile
-        "\"#{Util.safe_string(content)}\".html_safe"
-      end
-    end
+    autoload :Util, "rbexy/nodes/util"
+    autoload :AbstractNode, "rbexy/nodes/abstract_node"
+    autoload :Root, "rbexy/nodes/root"
+    autoload :Raw, "rbexy/nodes/raw"
+    autoload :Text, "rbexy/nodes/text"
+    autoload :ExpressionGroup, "rbexy/nodes/expression_group"
+    autoload :Expression, "rbexy/nodes/expression"
+    autoload :AbstractElement, "rbexy/nodes/abstract_element"
+    autoload :HTMLElement, "rbexy/nodes/html_element"
+    autoload :ComponentElement, "rbexy/nodes/component_element"
+    autoload :AbstractAttr, "rbexy/nodes/abstract_attr"
+    autoload :HTMLAttr, "rbexy/nodes/html_attr"
+    autoload :ComponentProp, "rbexy/nodes/component_prop"
+    autoload :Newline, "rbexy/nodes/newline"
+    autoload :Declaration, "rbexy/nodes/declaration"
   end
 end