antlers 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0d88855d8351d4ce9b4ebf2bfeaf0fc05faef8a33a882ffd206fa1c8241ec9e
-  data.tar.gz: e72f72db347e9f0f442e0a15cb4dce3f2c7405bf1bd7da6b33ab919a7003785b
+  metadata.gz: 8d3bcf6e14ade37294793b87b3ab3ab152e519f8c081a130644b0d28d489b63b
+  data.tar.gz: d9886a3044fb8654b37f111a9536ba7dfef4945c26fb08112e400ab14e76d8e7
 SHA512:
-  metadata.gz: 6f1e6d6f8f512d327ee25068a3286d8f1e557407bf99f4ec274cd8c8e7336ef9c2d9db9980e66d13ce58b8055d07f6908108afcb8cd91d2da65224ac567946d4
-  data.tar.gz: 27520e044188ae13cde780d7438286e510dae3874cd2218debf2901a1b3c7e9909847c44ae38ce4353e8b0482afa2516fa47857836070a58e8683934865a58c7
+  metadata.gz: a4179e613ca96ea49fdbc7d991a627a45640182ae5aaa5f01dc935396586ba8b583df469113c26c7a139308956bc18980cdbd04877c73a9b7cd14617682dd2d3
+  data.tar.gz: 698769c0d6bfd0e9872c5022f72555290acff3888615f44061ed10847af8f97af58477c35059678c2e02a2bdafc16d3f06ff514ab80aa539abc2de7cbfeda6bd

data/lib/interfaces/lexeme.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Antlers
+  module Lexeme
+    KEYWORDS = []
+
+    def match?(name: nil, keywords: {}) = false
+
+    def lexeme(name:, props:, keywords:)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/lexemes/for_lexeme.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module ForLexeme
+    include Lexeme
+    extend self
+
+    KEYWORDS = ['for:', 'in:', ':for'].freeze
+
+    def match?(keywords:, **)
+      KEYWORDS.include?(keywords.keys.first)
+    end
+
+    def lexeme(keywords:, **)
+      if keywords['for:']
+        *key, value = keywords['for:'].split(',').map(&:strip)
+        for_def = { for_def: value, in: keywords['in:'] }
+        for_def[:key] = key.first unless key.empty?
+        return for_def
+      end
+
+      # TODO: Keep track of which for loop we're in to allow nested for loops.
+      { for_end: 'level_1' }
+    end
+  end
+end

data/lib/lexemes/form_lexeme.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module FormLexeme
+    include Lexeme
+    extend self
+
+    KEYWORDS = ['form:', ':form'].freeze
+
+    def match?(keywords:, **)
+      KEYWORDS.include?(keywords.keys.first)
+    end
+
+    def lexeme(keywords:, **)
+      if keywords.key?('form:')
+        action = keywords['form:'] ? keywords['form:'][1...-1] : nil
+        return { form_def: action }
+      end
+
+      { form_end: 'level_1' }
+    end
+  end
+end

data/lib/lexemes/if_lexeme.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module IfLexeme
+    include Lexeme
+    extend self
+
+    KEYWORDS = ['if:', ':if'].freeze
+
+    def match?(keywords:, **)
+      KEYWORDS.include?(keywords.keys.first)
+    end
+
+    def lexeme(keywords:, **)
+      return { if_def: keywords['if:'] } if keywords.key?('if:')
+
+      { if_end: 'level_1' }
+    end
+  end
+end

data/lib/lexemes/prop_lexeme.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module PropLexeme
+    include Lexeme
+    extend self
+
+    def match?(name:, **)
+      name && [*'A'..'Z'].include?(name[0]) && !(name.start_with?(':') || name.end_with?(':'))
+    end
+
+    def lexeme(name:, props:, **)
+      prop = { prop: name }
+      prop[:props] = props(props) unless props.empty?
+      prop
+    end
+
+    private
+
+    def props(props)
+      odd_props = props.join(' ').split(/(=)|\s/)
+
+      return {} unless odd_props.any?
+
+      props = {}
+      until odd_props.empty?
+        prop = odd_props.shift
+        value = nil
+
+        if odd_props.first == '='
+          odd_props.shift
+          value = odd_props.shift
+        end
+
+        props[prop.to_sym] = value
+      end
+
+      props
+    end
+  end
+end

data/lib/lexemes/slot_lexeme.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module SlotLexeme
+    include Lexeme
+    extend self
+
+    KEYWORDS = ['slot:', ':slot'].freeze
+
+    def match?(name:, **)
+      name && (name.start_with?(':') || name.end_with?(':'))
+    end
+
+    def lexeme(name:, props:, **)
+      if name.end_with?(':')
+        slot_def = { slot_def: name.delete_suffix(':') }
+        slot_def[:props] = props(props) unless props.empty?
+        return slot_def
+      end
+
+      { slot_end: name.delete_prefix(':') }
+    end
+  end
+end

data/lib/lexemes/yield_lexeme.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/lexeme'
+
+module Antlers
+  module YieldLexeme
+    include Lexeme
+    extend self
+
+    def match?(keywords:, **)
+      keywords.keys.include?(':slot')
+    end
+
+    def lexeme(**)
+      { slot: :default }
+    end
+  end
+end

data/lib/lexer.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'lexemes/for_lexeme'
+require_relative 'lexemes/form_lexeme'
+require_relative 'lexemes/if_lexeme'
+require_relative 'lexemes/prop_lexeme'
+require_relative 'lexemes/slot_lexeme'
+require_relative 'lexemes/yield_lexeme'
 require_relative 'support/queries'
 
 module Antlers
@@ -7,14 +13,20 @@ module Antlers
 
   class LexerParseError < StandardError; end
 
-  class Lexer
-    IF_KEYWORDS = ['if:', ':if'].freeze
-    FOR_KEYWORDS = ['for:', 'in:', ':for'].freeze
-    FORM_KEYWORDS = ['form:', ':form'].freeze
+  LEXEMES = [
+    # FormLexeme must be ordered before ForLexeme for regex to work.
+    Antlers::FormLexeme,
+    Antlers::ForLexeme,
+    Antlers::IfLexeme,
+    Antlers::PropLexeme,
+    Antlers::SlotLexeme,
+    Antlers::YieldLexeme,
+  ]
 
+  class Lexer
     def initialize
       @delimiters = ['<{', '}>', '{', '}']
-      @keywords = [*IF_KEYWORDS, *FORM_KEYWORDS, *FOR_KEYWORDS, 'slot:', ':slot']
+      @keywords = LEXEMES.flat_map { |lexeme| lexeme.const_get(:KEYWORDS) }
       @cursor = 0
     end
 
@@ -55,12 +67,8 @@ module Antlers
 
       name, props, keywords = parse_segment(antlers_segment:)
 
-      return slot_yield if slot_yield?(keywords:)
-      return slot(name:, props:) if slot?(name)
-      return prop(name:, props:) if prop?(name)
-      return if_block(keywords:) if if_block?(keywords:)
-      return for_loop(keywords:) if for_loop?(keywords:)
-      return form(keywords:) if form?(keywords:)
+      lexeme = LEXEMES.find { it.match?(name:, keywords:) }
+      return lexeme.lexeme(name:, props:, keywords:) if lexeme
       return var(antlers_segment:, raw: true) if deerheads?(segments:)
 
       raise LexerParseError, "Unrecognised syntax: '#{antlers_segment}'"
@@ -100,30 +108,6 @@ module Antlers
       first == '<{' && last == '}>'
     end
 
-    def if_block?(keywords:)
-      IF_KEYWORDS.include?(keywords.keys.first)
-    end
-
-    def for_loop?(keywords:)
-      FOR_KEYWORDS.include?(keywords.keys.first)
-    end
-
-    def form?(keywords:)
-      FORM_KEYWORDS.include?(keywords.keys.first)
-    end
-
-    def slot?(name)
-      name && (name.start_with?(':') || name.end_with?(':'))
-    end
-
-    def slot_yield?(keywords:)
-      keywords.keys.include?(':slot')
-    end
-
-    def prop?(name)
-      name && [*'A'..'Z'].include?(name[0])
-    end
-
     def var(antlers_segment:, raw: false)
       # String is already interpolated or not depending on user input on the template layer, now we store it without those template quotes.
       antlers_segment = antlers_segment[1..-2] if Queries.user_defined_string?(antlers_segment)
@@ -132,73 +116,5 @@ module Antlers
 
       { var: antlers_segment }
     end
-
-    def if_block(keywords:)
-      return { if_def: keywords['if:'] } if keywords.key?('if:')
-
-      { if_end: 'level_1' }
-    end
-
-    def for_loop(keywords:)
-      if keywords['for:']
-        *key, value = keywords['for:'].split(',').map(&:strip)
-        for_def = { for_def: value, in: keywords['in:'] }
-        for_def[:key] = key.first unless key.empty?
-        return for_def
-      end
-
-      # TODO: Keep track of which for loop we're in to allow nested for loops.
-      { for_end: 'level_1' }
-    end
-
-    def form(keywords:)
-      if keywords.key?('form:')
-        action = keywords['form:'] ? keywords['form:'][1...-1] : nil
-        return { form_def: action }
-      end
-
-      { form_end: 'level_1' }
-    end
-
-    def slot(name:, props:)
-      if name.end_with?(':')
-        slot_def = { slot_def: name.delete_suffix(':') }
-        slot_def[:props] = props(props) unless props.empty?
-        return slot_def
-      end
-
-      { slot_end: name.delete_prefix(':') }
-    end
-
-    def slot_yield
-      { slot: :default }
-    end
-
-    def prop(name:, props:)
-      prop = { prop: name }
-      prop[:props] = props(props) unless props.empty?
-      prop
-    end
-
-    def props(props)
-      odd_props = props.join(' ').split(/(=)|\s/)
-
-      return {} unless odd_props.any?
-
-      props = {}
-      until odd_props.empty?
-        prop = odd_props.shift
-        value = nil
-
-        if odd_props.first == '='
-          odd_props.shift
-          value = odd_props.shift
-        end
-
-        props[prop.to_sym] = value
-      end
-
-      props
-    end
   end
 end

data/lib/nodes/prop_node.rb

@@ -23,8 +23,8 @@ module Antlers
       # TODO: Get LowLoad to load constants defined in "<{ MyNode }>" syntax so that we can resolve namespace/params on class load.
       klass = class_constant(namespace: @namespace&.split('::') || [], name: @name)
       class_proxy = Lowkey[klass.to_s].first[klass.to_s]
-      instance = create_instance(class_proxy:, klass:, event:)
 
+      instance = create_instance(class_proxy:, klass:, event:, props:)
       return instance.render_template(event:, parent_binding:, props:) if klass.template
 
       render_args(class_proxy:, instance:, event:, props:)
@@ -32,9 +32,10 @@ module Antlers
 
     private
 
-    def create_instance(class_proxy:, klass:, event:)
+    def create_instance(class_proxy:, klass:, event:, props:)
       initialize_params = class_proxy.instance_methods[:initialize]&.tagged_params(:keyword)&.map(&:name) || []
       return klass.new(event:, **props) if initialize_params.include?(:event) && initialize_params.count > 1
+      return klass.new(**props) if initialize_params.count > 1
       return klass.new(event:) if initialize_params.include?(:event)
 
       klass.new

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Antlers
-  VERSION = '0.8.0'
+  VERSION = '0.8.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antlers
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - maedi
@@ -64,6 +64,13 @@ files:
 - lib/interfaces/antler_node.rb
 - lib/interfaces/branch_node.rb
 - lib/interfaces/leaf_node.rb
+- lib/interfaces/lexeme.rb
+- lib/lexemes/for_lexeme.rb
+- lib/lexemes/form_lexeme.rb
+- lib/lexemes/if_lexeme.rb
+- lib/lexemes/prop_lexeme.rb
+- lib/lexemes/slot_lexeme.rb
+- lib/lexemes/yield_lexeme.rb
 - lib/lexer.rb
 - lib/modules/namespace.rb
 - lib/modules/props.rb