calyx 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88debcd6bac2845d1d5b6c932aff212a3d93a900cfb6758db486500f49987e7e
-  data.tar.gz: 7a22972ac485e7147f0855bac351badaa25876978655191e75327a54a404cd4d
+  metadata.gz: 8278055314ef40a029522a8237f5c1956e27b449b31bf4bb8d6d2d7e5b6ff904
+  data.tar.gz: ccc0ebfe719a5bfc88582dfb78225edb7562d6e3a7e23e672dcb2822d1c0b9a2
 SHA512:
-  metadata.gz: 716f85a44ca0e852c96695ffdd6ddb91b298c5c6579a61d5082893be445ab78d6e8b7b37ac0f50eac2169f14ada86c0001cabf7c354ae4ba6ecd763c0335de8e
-  data.tar.gz: 63de5c1d2d1ccaa74232eb3c7535df24cdce5fc2065bedc2cf90a8a590080397d9e1881cbee15501aeb8ef61f206b561e5e2888f0c7dee22680eefbb83c1e615
+  metadata.gz: 132390da1638e0b3c4bffc237c9dfe5b565b556269ea55da011aaaddaa7884a6ca6294190c4ceb76bbbd2977b0011601a885df090c2cdf468ad6bac7c657e8ee
+  data.tar.gz: e973005cbb1717949cdda94ea7c1c772301d8fcc1104b38f4a51fa5dd924b3025cf46a960909b7997748db1ee4373e86bd05e01f89eb9488058f703b49015f12

data/.github/workflows/ruby.yml

@@ -23,8 +23,8 @@ jobs:
     - name: Set up Ruby
     # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
     # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@ec106b438a1ff6ff109590de34ddc62c540232e0
+      uses: ruby/setup-ruby@v1
+      #uses: ruby/setup-ruby@ec106b438a1ff6ff109590de34ddc62c540232e0
       with:
         ruby-version: 2.6
     - name: Install dependencies

data/calyx.gemspec

@@ -19,6 +19,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.4'
 end

data/lib/calyx.rb

@@ -8,12 +8,15 @@ require 'calyx/errors'
 require 'calyx/format'
 require 'calyx/registry'
 require 'calyx/modifiers'
+require 'calyx/prefix_tree'
 require 'calyx/mapping'
-require 'calyx/production/memo'
-require 'calyx/production/unique'
-require 'calyx/production/choices'
-require 'calyx/production/concat'
-require 'calyx/production/expression'
-require 'calyx/production/non_terminal'
-require 'calyx/production/terminal'
-require 'calyx/production/weighted_choices'
+require 'calyx/production/affix_table'
+require 'calyx/syntax/token'
+require 'calyx/syntax/memo'
+require 'calyx/syntax/unique'
+require 'calyx/syntax/choices'
+require 'calyx/syntax/concat'
+require 'calyx/syntax/expression'
+require 'calyx/syntax/non_terminal'
+require 'calyx/syntax/terminal'
+require 'calyx/syntax/weighted_choices'

data/lib/calyx/modifiers.rb

@@ -28,7 +28,5 @@ module Calyx
     def lower(value)
       value.downcase
     end
-
-
   end
 end

data/lib/calyx/prefix_tree.rb

@@ -0,0 +1,191 @@
+module Calyx
+  PrefixNode = Struct.new(:children, :index)
+  PrefixEdge = Struct.new(:node, :label, :wildcard?)
+  PrefixMatch = Struct.new(:label, :index, :captured)
+
+  class PrefixTree
+    def initialize
+      @root = PrefixNode.new([], nil)
+    end
+
+    def insert(label, index)
+      if @root.children.empty?
+        @root.children << PrefixEdge.new(PrefixNode.new([], index), label, false)
+      end
+    end
+
+    def add_all(elements)
+      elements.each_with_index { |el, i| add(el, i) }
+    end
+
+    def add(label, index)
+      parts = label.split(/(%)/).reject { |p| p.empty? }
+      parts_count = parts.count
+
+      # Can’t use more than one capture symbol which gives the following splits:
+      # - ["literal"]
+      # - ["%", "literal"]
+      # - ["literal", "%"]
+      # - ["literal", "%", "literal"]
+      if parts_count > 3
+        raise "Too many capture patterns: #{label}"
+      end
+
+      current_node = @root
+
+      parts.each_with_index do |part, i|
+        index_slot = (i == parts_count - 1) ? index : nil
+        is_wildcard = part == "%"
+        matched_prefix = false
+
+        current_node.children.each_with_index do |edge, j|
+          prefix = common_prefix(edge.label, part)
+          unless prefix.empty?
+            matched_prefix = true
+
+            if prefix == edge.label
+              # Current prefix matches the edge label so we can continue down the
+              # tree without mutating the current branch
+              next_node = PrefixNode.new([], index_slot)
+              current_node.children << PrefixEdge.new(next_node, label.delete_prefix(prefix), is_wildcard)
+            else
+              # We have a partial match on current edge so replace it with the new
+              # prefix then rejoin the remaining suffix to the existing branch
+              edge.label = edge.label.delete_prefix(prefix)
+              prefix_node = PrefixNode.new([edge], nil)
+              next_node = PrefixNode.new([], index_slot)
+              prefix_node.children << PrefixEdge.new(next_node, label.delete_prefix(prefix), is_wildcard)
+              current_node.children[j] = PrefixEdge.new(prefix_node, prefix, is_wildcard)
+            end
+
+            current_node = next_node
+            break
+          end
+        end
+
+        # No existing edges have a common prefix so push a new branch onto the tree
+        # at the current level
+        unless matched_prefix
+          next_edge = PrefixEdge.new(PrefixNode.new([], index_slot), part, is_wildcard)
+          current_node.children << next_edge
+          current_node = next_edge.node
+        end
+      end
+    end
+
+    # This was basically ported from the pseudocode found on Wikipedia to Ruby,
+    # with a lot of extra internal state tracking that is totally absent from
+    # most algorithmic descriptions. This ends up making a real mess of the
+    # expression of the algorithm, mostly due to choices and conflicts between
+    # whether to go with the standard iterative and procedural flow of statements
+    # or use a more functional style. A mangle that speaks to the questions
+    # around portability between different languages. Is this codebase a design
+    # prototype? Is it an evolving example that should guide implementations in
+    # other languages?
+    #
+    # The problem with code like this is that it’s a bit of a maintenance burden
+    # if not structured compactly and precisely enough to not matter and having
+    # enough tests passing that it lasts for a few years without becoming a
+    # nuisance or leading to too much nonsense.
+    #
+    # There are several ways to implement this, some of these may work better or
+    # worse, and this might be quite different across multiple languages so what
+    # goes well in one place could suck in other places. The only way to make a
+    # good decision around it is to learn via testing and experiments.
+    #
+    # Alternative possible implementations:
+    # - Regex compilation on registration, use existing legacy mapping code
+    # - Prefix tree, trie, radix tree/trie, compressed bitpatterns, etc
+    # - Split string flip, imperative list processing hacks
+    #   (easier for more people to contribute?)
+    def lookup(label)
+      current_node = @root
+      chars_consumed = 0
+      chars_captured = nil
+      label_length = label.length
+
+      # Traverse the tree until reaching a leaf node or all input characters are consumed
+      while current_node != nil && !current_node.children.empty? && chars_consumed < label_length
+        # Candidate edge pointing to the next node to check
+        candidate_edge = nil
+
+        # Traverse from the current node down the tree looking for candidate edges
+        current_node.children.each do |edge|
+          # Generate a suffix based on the prefix already consumed
+          sub_label = label[chars_consumed, label_length]
+
+          # If this edge is a wildcard we check the next level of the tree
+          if edge.wildcard?
+            # Wildcard pattern is anchored to the end of the string so we can
+            # consume all remaining characters and pick this as an edge candidate
+            if edge.node.children.empty?
+              chars_captured = label[chars_consumed, sub_label.length]
+              chars_consumed += sub_label.length
+              candidate_edge = edge
+              break
+            end
+
+            # The wildcard is anchored to the start or embedded in the middle of
+            # the string so we traverse this edge and scan the next level of the
+            # tree with a greedy lookahead. This means we will always match as
+            # much of the wildcard string as possible when there is a trailing
+            # suffix that could be repeated several times within the characters
+            # consumed by the wildcard pattern.
+            #
+            # For example, we expect `"te%s"` to match on `"tests"` rather than
+            # bail out after matching the first three characters `"tes"`.
+            edge.node.children.each do |lookahead_edge|
+              prefix = sub_label.rindex(lookahead_edge.label)
+              if prefix
+                chars_captured = label[chars_consumed, prefix]
+                chars_consumed += prefix + lookahead_edge.label.length
+                candidate_edge = lookahead_edge
+                break
+              end
+            end
+            # We found a candidate so no need to continue checking edges
+            break if candidate_edge
+          else
+            # Look for a common prefix on this current edge label and the remaining suffix
+            if edge.label == common_prefix(edge.label, sub_label)
+              chars_consumed += edge.label.length
+              candidate_edge = edge
+              break
+            end
+          end
+        end
+
+        if candidate_edge
+          # Traverse to the node our edge candidate points to
+          current_node = candidate_edge.node
+        else
+          # We didn’t find a possible edge candidate so bail out of the loop
+          current_node = nil
+        end
+      end
+
+      # In order to return a match, the following postconditions must be true:
+      # - We are pointing to a leaf node
+      # - We have consumed all the input characters
+      if current_node != nil and current_node.index != nil and chars_consumed == label_length
+        PrefixMatch.new(label, current_node.index, chars_captured)
+      else
+        nil
+      end
+    end
+
+    def common_prefix(a, b)
+      selected_prefix = ""
+      min_index_length = a < b ? a.length : b.length
+      index = 0
+
+      until index == min_index_length
+        return selected_prefix if a[index] != b[index]
+        selected_prefix += a[index]
+        index += 1
+      end
+
+      selected_prefix
+    end
+  end
+end

data/lib/calyx/production/affix_table.rb

@@ -0,0 +1,53 @@
+module Calyx
+  module Production
+    # A type of production rule representing a bidirectional dictionary of
+    # mapping pairs that can be used as a substitution table in template
+    # expressions.
+    class AffixTable
+      def self.parse(productions, registry)
+        # TODO: handle wildcard expressions
+        self.new(productions)
+      end
+
+      # %es
+      # prefix: nil, suffix: 'es'
+      # match: 'buses' -> ends_with(suffix)
+
+      # %y
+      # prefix: nil, suffix: 'ies'
+
+      def initialize(mapping)
+        @lhs_index = PrefixTree.new
+        @rhs_index = PrefixTree.new
+
+        @lhs_list = mapping.keys
+        @rhs_list = mapping.values
+
+        @lhs_index.add_all(@lhs_list)
+        @rhs_index.add_all(@rhs_list)
+      end
+
+      def value_for(key)
+        match = @lhs_index.lookup(key)
+        result = @rhs_list[match.index]
+
+        if match.captured
+          result.sub("%", match.captured)
+        else
+          result
+        end
+      end
+
+      def key_for(value)
+        match = @rhs_index.lookup(value)
+        result = @lhs_list[match.index]
+
+        if match.captured
+          result.sub("%", match.captured)
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/calyx/production/uniform_branch.rb

@@ -0,0 +1,6 @@
+module Calyx
+  module Productions
+    class UniformBranch
+    end
+  end
+end

data/lib/calyx/production/weighted_branch.rb

@@ -0,0 +1,6 @@
+module Calyx
+  module Productions
+    class WeightedBranch
+    end
+  end
+end

data/lib/calyx/registry.rb

@@ -1,12 +1,13 @@
 module Calyx
   # Lookup table of all the available rules in the grammar.
   class Registry
-    attr_reader :rules, :transforms, :modifiers
+    attr_reader :rules, :dicts, :transforms, :modifiers
 
     # Construct an empty registry.
     def initialize
       @options = Options.new({})
       @rules = {}
+      @dicts = {}
       @transforms = {}
       @modifiers = Modifiers.new
     end
@@ -67,7 +68,17 @@ module Calyx
     # @param [Symbol] name
     # @param [Array] productions
     def define_rule(name, trace, productions)
-      rules[name.to_sym] = Rule.new(name.to_sym, Rule.build_ast(productions, self), trace)
+      symbol = name.to_sym
+
+      # TODO: this could be tidied up by consolidating parsing in a single class
+      branch = Rule.build_ast(productions, self)
+
+      # If the static rule is a map of k=>v pairs then add it to the lookup dict
+      if branch.is_a?(Production::AffixTable)
+        dicts[symbol] = branch
+      else
+        rules[symbol] = Rule.new(symbol, branch, trace)
+      end
     end
 
     # Defines a rule in the temporary evaluation context.
@@ -90,7 +101,7 @@ module Calyx
         if @options.strict?
           raise Errors::UndefinedRule.new(@last_expansion, symbol)
         else
-          expansion = Production::Terminal.new('')
+          expansion = Syntax::Terminal.new('')
         end
       end
 
@@ -98,12 +109,12 @@ module Calyx
       expansion
     end
 
-    # Applies the given modifier function to the given value to transform it.
+    # Applies the given modifier function to the given value to filter it.
     #
     # @param [Symbol] name
     # @param [String] value
     # @return [String]
-    def transform(name, value)
+    def expand_filter(name, value)
       if transforms.key?(name)
         transforms[name].call(value)
       else
@@ -111,6 +122,23 @@ module Calyx
       end
     end
 
+    # Applies a modifier to substitute the value with a bidirectional map
+    # lookup.
+    #
+    # @param [Symbol] name
+    # @param [String] value
+    # @param [Symbol] direction :left or :right
+    # @return [String]
+    def expand_map(name, value, direction)
+      map_lookup = dicts[name]
+
+      if direction == :left
+        map_lookup.key_for(value)
+      else
+        map_lookup.value_for(value)
+      end
+    end
+
     # Expands a memoized rule symbol by evaluating it and storing the result
     # for later.
     #

data/lib/calyx/rule.rb

@@ -4,11 +4,22 @@ module Calyx
   class Rule
     def self.build_ast(productions, registry)
       if productions.first.is_a?(Hash)
-        Production::WeightedChoices.parse(productions.first.to_a, registry)
+        # TODO: test that key is a string
+
+        if productions.first.first.last.is_a?(String)
+          # If value of the production is a strings then this is a
+          # paired mapping production.
+          Production::AffixTable.parse(productions.first, registry)
+        else
+          # Otherwise, we assume this is a weighted choice declaration and
+          # convert the hash to an array
+          Syntax::WeightedChoices.parse(productions.first.to_a, registry)
+        end
       elsif productions.first.is_a?(Enumerable)
-        Production::WeightedChoices.parse(productions, registry)
+        # TODO: this needs to change to support attributed/tagged grammars
+        Syntax::WeightedChoices.parse(productions, registry)
       else
-        Production::Choices.parse(productions, registry)
+        Syntax::Choices.parse(productions, registry)
       end
     end
 

data/lib/calyx/{production → syntax}/choices.rb

@@ -1,7 +1,7 @@
 module Calyx
   # A type of production rule representing a list of possible rules, one of
   # which will chosen each time the grammar runs.
-  module Production
+  module Syntax
     class Choices
       # Parse a list of productions and return a choice node which is the head
       # of a syntax tree of child nodes.

data/lib/calyx/{production → syntax}/concat.rb

@@ -1,12 +1,12 @@
 module Calyx
-  module Production
+  module Syntax
     # A type of production rule representing a string combining both template
     # substitutions and raw content.
     class Concat
-      EXPRESSION = /(\{[A-Za-z0-9_@$\.]+\})/.freeze
+      EXPRESSION = /(\{[A-Za-z0-9_@$<>\.]+\})/.freeze
+      DEREF_OP = /([<>\.])/.freeze
       START_TOKEN = '{'.freeze
       END_TOKEN = '}'.freeze
-      DEREF_TOKEN = '.'.freeze
 
       # Parses an interpolated string into fragments combining terminal strings
       # and non-terminal rules.
@@ -16,21 +16,14 @@ module Calyx
       # @param [String] production
       # @param [Calyx::Registry] registry
       def self.parse(production, registry)
-        expansion = production.split(EXPRESSION).map do |atom|
+        expressions = production.split(EXPRESSION).map do |atom|
           if atom.is_a?(String)
             if atom.chars.first == START_TOKEN && atom.chars.last == END_TOKEN
-              head, *tail = atom.slice(1, atom.length-2).split(DEREF_TOKEN)
-              if head[0] == Memo::SIGIL
-                rule = Memo.new(head, registry)
-              elsif head[0] == Unique::SIGIL
-                rule = Unique.new(head, registry)
+              head, *tail = atom.slice(1, atom.length-2).split(DEREF_OP)
+              if tail.any?
+                ExpressionChain.parse(head, tail, registry)
               else
-                rule = NonTerminal.new(head, registry)
-              end
-              unless tail.empty?
-                Expression.new(rule, tail, registry)
-              else
-                rule
+                Expression.parse(head, registry)
               end
             else
               Terminal.new(atom)
@@ -38,28 +31,31 @@ module Calyx
           end
         end
 
-        self.new(expansion)
+        self.new(expressions)
       end
 
       # Initialize the concat node with an expansion of terminal and
       # non-terminal fragments.
       #
       # @param [Array] expansion
-      def initialize(expansion)
-        @expansion = expansion
+      def initialize(expressions)
+        @expressions = expressions
       end
 
-      # Evaluate all the child nodes of this node and concatenate them together
-      # into a single result.
+      # Evaluate all the child nodes of this node and concatenate each expansion
+      # together into a single result.
       #
       # @param [Calyx::Options] options
       # @return [Array]
       def evaluate(options)
-        concat = @expansion.reduce([]) do |exp, atom|
+        expansion = @expressions.reduce([]) do |exp, atom|
           exp << atom.evaluate(options)
         end
 
-        [:concat, concat]
+        #[:expansion, expansion]
+        # TODO: fix this along with a git rename
+        # Commented out because of a lot of tests depending on :concat symbol
+        [:concat, expansion]
       end
     end
   end

data/lib/calyx/syntax/expression.rb

@@ -0,0 +1,87 @@
+module Calyx
+  module Syntax
+    # A symbolic expression representing a single template substitution.
+    class Expression
+      def self.parse(symbol, registry)
+        if symbol[0] == Memo::SIGIL
+          Memo.new(symbol, registry)
+        elsif symbol[0] == Unique::SIGIL
+          Unique.new(symbol, registry)
+        else
+          NonTerminal.new(symbol, registry)
+        end
+      end
+    end
+
+    class Modifier < Struct.new(:type, :name, :map_dir)
+      def self.filter(name)
+        new(:filter, name, nil)
+      end
+
+      def self.map_left(name)
+        new(:map, name, :left)
+      end
+
+      def self.map_right(name)
+        new(:map, name, :right)
+      end
+    end
+
+    # Handles filter chains that symbolic expressions can pass through to
+    # generate a custom substitution.
+    class ExpressionChain
+      def self.parse(production, production_chain, registry)
+        modifier_chain = production_chain.each_slice(2).map do |op_token, target|
+          rule = target.to_sym
+          case op_token
+          when Token::EXPR_FILTER then Modifier.filter(rule)
+          when Token::EXPR_MAP_LEFT then Modifier.map_left(rule)
+          when Token::EXPR_MAP_RIGHT then Modifier.map_right(rule)
+          else
+            # Should not end up here because the regex excludes it but this
+            # could be a place to add a helpful parse error on any weird
+            # chars used by the expression—current behaviour is to pass
+            # the broken expression through to the result as part of the
+            # text, as if that is what the author meant.
+            raise("unreachable")
+          end
+        end
+
+        expression = Expression.parse(production, registry)
+
+        self.new(expression, modifier_chain, registry)
+      end
+
+      # @param [#evaluate] production
+      # @param [Array] modifiers
+      # @param [Calyx::Registry] registry
+      def initialize(production, modifiers, registry)
+        @production = production
+        @modifiers = modifiers
+        @registry = registry
+      end
+
+      # Evaluate the expression by expanding the non-terminal to produce a
+      # terminal string, then passing it through the given modifier chain and
+      # returning the transformed result.
+      #
+      # @param [Calyx::Options] options
+      # @return [Array]
+      def evaluate(options)
+        expanded = @production.evaluate(options).flatten.reject { |o| o.is_a?(Symbol) }.join
+        chain = []
+
+        expression = @modifiers.reduce(expanded) do |value, modifier|
+          case modifier.type
+          when :filter
+            @registry.expand_filter(modifier.name, value)
+          when :map
+            @registry.expand_map(modifier.name, value, modifier.map_dir)
+          end
+        end
+
+        [:expression, expression]
+      end
+    end
+  end
+end

data/lib/calyx/{production → syntax}/memo.rb

@@ -1,5 +1,5 @@
 module Calyx
-  module Production
+  module Syntax
     # A type of production rule representing a memoized subsitution which
     # returns the first value selected on all subsequent lookups.
     class Memo

data/lib/calyx/{production → syntax}/non_terminal.rb

@@ -1,5 +1,5 @@
 module Calyx
-  module Production
+  module Syntax
     # A type of production rule that represents a non-terminal expansion,
     # linking one rule to another.
     class NonTerminal

data/lib/calyx/syntax/paired_mapping.rb

@@ -0,0 +1,53 @@
+module Calyx
+  module Syntax
+    # A type of production rule representing a bidirectional dictionary of
+    # mapping pairs that can be used as a substitution table in template
+    # expressions.
+    class PairedMapping
+      def self.parse(productions, registry)
+        # TODO: handle wildcard expressions
+        self.new(productions)
+      end
+
+      # %es
+      # prefix: nil, suffix: 'es'
+      # match: 'buses' -> ends_with(suffix)
+
+      # %y
+      # prefix: nil, suffix: 'ies'
+
+      def initialize(mapping)
+        @lhs_index = PrefixTree.new
+        @rhs_index = PrefixTree.new
+
+        @lhs_list = mapping.keys
+        @rhs_list = mapping.values
+
+        @lhs_index.add_all(@lhs_list)
+        @rhs_index.add_all(@rhs_list)
+      end
+
+      def value_for(key)
+        match = @lhs_index.lookup(key)
+        result = @rhs_list[match.index]
+
+        if match.captured
+          result.sub("%", match.captured)
+        else
+          result
+        end
+      end
+
+      def key_for(value)
+        match = @rhs_index.lookup(value)
+        result = @lhs_list[match.index]
+
+        if match.captured
+          result.sub("%", match.captured)
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/calyx/{production → syntax}/terminal.rb

@@ -1,5 +1,5 @@
 module Calyx
-  module Production
+  module Syntax
     # A type of production rule that terminates with a resulting string atom.
     class Terminal
       # Construct a terminal node with the given value.

data/lib/calyx/syntax/token.rb

@@ -0,0 +1,9 @@
+module Calyx
+  module Syntax
+    module Token
+      EXPR_MAP_LEFT = "<"
+      EXPR_MAP_RIGHT = ">"
+      EXPR_FILTER = "."
+    end
+  end
+end

data/lib/calyx/{production → syntax}/unique.rb

@@ -1,5 +1,5 @@
 module Calyx
-  module Production
+  module Syntax
     # A type of production rule representing a unique substitution which only
     # returns values that have not previously been selected. The probability
     # that a given rule will be selected increases as more selections are made

data/lib/calyx/{production → syntax}/weighted_choices.rb

@@ -1,5 +1,5 @@
 module Calyx
-  module Production
+  module Syntax
     # A type of production rule representing a map of possible rules with
     # associated weights that define the expected probability of a rule
     # being chosen.
@@ -12,7 +12,7 @@ module Calyx
       #
       # @param [Array<Array>, Hash<#to_s, Float>] productions
       # @param [Calyx::Registry] registry
-      # @return [Calyx::Production::WeightedChoices]
+      # @return [Calyx::Syntax::WeightedChoices]
       def self.parse(productions, registry)
         if productions.first.last.is_a?(Range)
           range_max = productions.max { |a,b| a.last.max <=> b.last.max }.last.max

data/lib/calyx/version.rb

@@ -1,3 +1,3 @@
 module Calyx
-  VERSION = '0.21.0'.freeze
+  VERSION = '0.22.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calyx
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.0
 platform: ruby
 authors:
 - Mark Rickerby
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-23 00:00:00.000000000 Z
+date: 2021-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -62,7 +62,6 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
 - Gemfile
@@ -81,23 +80,29 @@ files:
 - lib/calyx/mapping.rb
 - lib/calyx/modifiers.rb
 - lib/calyx/options.rb
-- lib/calyx/production/choices.rb
-- lib/calyx/production/concat.rb
-- lib/calyx/production/expression.rb
-- lib/calyx/production/memo.rb
-- lib/calyx/production/non_terminal.rb
-- lib/calyx/production/terminal.rb
-- lib/calyx/production/unique.rb
-- lib/calyx/production/weighted_choices.rb
+- lib/calyx/prefix_tree.rb
+- lib/calyx/production/affix_table.rb
+- lib/calyx/production/uniform_branch.rb
+- lib/calyx/production/weighted_branch.rb
 - lib/calyx/registry.rb
 - lib/calyx/result.rb
 - lib/calyx/rule.rb
+- lib/calyx/syntax/choices.rb
+- lib/calyx/syntax/concat.rb
+- lib/calyx/syntax/expression.rb
+- lib/calyx/syntax/memo.rb
+- lib/calyx/syntax/non_terminal.rb
+- lib/calyx/syntax/paired_mapping.rb
+- lib/calyx/syntax/terminal.rb
+- lib/calyx/syntax/token.rb
+- lib/calyx/syntax/unique.rb
+- lib/calyx/syntax/weighted_choices.rb
 - lib/calyx/version.rb
 homepage: https://github.com/maetl/calyx
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -113,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Generate text with declarative recursive grammars
 test_files: []

data/.travis.yml

@@ -1,10 +0,0 @@
-language: ruby
-rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-  - ruby-head
-  - jruby-9.1.13.0
-  - rbx
-before_install: gem install bundler
-script: bundle exec rspec

data/lib/calyx/production/expression.rb

@@ -1,32 +0,0 @@
-module Calyx
-  module Production
-    # A type of production rule representing a single template substitution.
-    class Expression
-      # Constructs a node representing a single template substitution.
-      #
-      # @param [#evaluate] production
-      # @param [Array] methods
-      # @param [Calyx::Registry] registry
-      def initialize(production, methods, registry)
-        @production = production
-        @methods = methods.map { |m| m.to_sym }
-        @registry = registry
-      end
-
-      # Evaluate the expression by expanding the non-terminal to produce a
-      # terminal string, then passing it through the given modifier chain and
-      # returning the transformed result.
-      #
-      # @param [Calyx::Options] options
-      # @return [Array]
-      def evaluate(options)
-        terminal = @production.evaluate(options).flatten.reject { |o| o.is_a?(Symbol) }.join
-        expression = @methods.reduce(terminal) do |value, method|
-          @registry.transform(method, value)
-        end
-
-        [:expression, expression]
-      end
-    end
-  end
-end