rbexy 1.0.2 → 2.0.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8c0ebb095f668e7b85fbd14fe770be07fc9f42565b7f71a02e4001a5a0c88c6
-  data.tar.gz: 4670b8929fba14f2cdb197eca4c9d72f37ecdef6d1e84d33d43f18bdb09b0a07
+  metadata.gz: d9cb20a821099f8fd51a0abb4b80ad3b2d8d936afcfe240a4b99ea29f4dea92a
+  data.tar.gz: aab32903c9632f245857c917b0b99743e5e58ddb8356fce1274c5dd2e4791b37
 SHA512:
-  metadata.gz: 8e9920411ff9198828488d984cfd9e69c67e1ced6600a48d701c01153c4bc06419aaac58d2395ab61676798e9bb0a45137f40788d293fade0c0344c596e60c06
-  data.tar.gz: 3da407f7258c3d2f2ef33a157747f6bf0f9ac945ebf801ec064430d80237f802ae7deac36de07a905b055dc9bd7f1958e80774a57f73d036a931a1c4cdac8b81
+  metadata.gz: a849303b1f41e2e6295558b09f1a608a3b24bca8317bde650c579c6a0da2206c67f1ea9bb49e4b7bf15e66497960fff70703845544a57271c4947e4abe16d5ef
+  data.tar.gz: 5f08d1838d39cf38d3f3d727e5c1ea098255e81e4a2ab4affd2b67a77a10d7f55dccdff52114f5ce9d544238d81d09a66f548ed74961298026f7887ad30339fd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbexy (1.0.2)
+    rbexy (2.0.0.beta4)
       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,14 +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)
 
@@ -21,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
@@ -28,7 +27,7 @@ module Rbexy
 
       @view_context = view_context
 
-      setup(**props)
+      after_initialize(**props)
     end
 
     # Override in your subclass to handle props, setup your component, etc.
@@ -54,17 +53,6 @@ module Rbexy
       content_block ? content_block.call : ""
     end
 
-    def create_context(name, value)
-      rbexy_context.last[name] = value
-    end
-
-    def use_context(name)
-      index = rbexy_context.rindex { |c| c.has_key?(name) }
-      index ?
-        rbexy_context[index][name] :
-        raise(ContextNotFound, "no parent context `#{name}`")
-    end
-
     def compiled_method_container
       Rbexy::Component
     end
@@ -74,16 +62,20 @@ 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 respond_to_missing?(method_name, include_all)
+      view_context.respond_to?(method_name, include_all)
     end
 
     def clean_template_backtrace(backtrace)
       return backtrace if Rbexy.configuration.debug
       BacktraceCleaner.new(backtrace).call
     end
+
+    def after_initialize(**props)
+      setup(**props)
+    end
   end
 end

data/lib/rbexy/component_context.rb

@@ -0,0 +1,18 @@
+module Rbexy
+  module ComponentContext
+    def rbexy_context
+      @rbexy_context ||= [{}]
+    end
+
+    def create_context(name, value)
+      rbexy_context.last[name] = value
+    end
+
+    def use_context(name)
+      index = rbexy_context.rindex { |c| c.has_key?(name) }
+      index ?
+        rbexy_context[index][name] :
+        raise(ContextNotFound, "no parent context `#{name}`")
+    end
+  end
+end

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: /[^}{"'<]+/,
@@ -29,23 +29,23 @@ module Rbexy
       single_quote: /'/,
       double_quoted_text_content: /[^"]+/,
       single_quoted_text_content: /[^']+/,
-      expression_internal_tag_prefixes: /(\s+(&&|\?|:|do|do\s*\|[^\|]+\||{|{\s*\|[^\|]+\|)\s+\z|\A\s*\z)/,
+      expression_internal_tag_prefixes: /(\s+(&&|\|\||\?|:|do|do\s*\|[^\|]+\||{|{\s*\|[^\|]+\|)\s+\z|\A\s*\z)/,
       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