brandish 0.1.1

data/lib/brandish/parser/node/block.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  class Parser
+    class Node
+      # A "block" node.  Basically, this is a node that encapsulates a block of
+      # text.  This typically has a 1-to-1 relationship with the body of text,
+      # while a command may not.
+      class Block < Node
+        # The name of the block.
+        #
+        # @return [::String]
+        attr_reader :name
+
+        # The body of the block.
+        #
+        # @return [Node::Root]
+        attr_reader :body
+
+        # The "pairs" of arguments to be passed to the command.
+        #
+        # @return [{::String => ::String}]
+        attr_reader :pairs
+
+        # Creates a block with the given name, body, and location.  If no
+        # location is given, it is assumed from the name and body.
+        #
+        # @param name [Scanner::Token] The name of the block.
+        # @param body [Node::Root] The body of the block.
+
+        # @param location [Location] The location of the block.
+        def initialize(name:, body:, arguments: nil, pairs: nil, location: nil)
+          if !location && !arguments
+            fail ArgumentError, "Expected either a location or " \
+              "arguments, got neither"
+          end
+
+          @name = name.is_a?(Yoga::Token) ? name.value : name
+          @body = body
+          @location = location || arguments.map(&:location)
+                                           .inject(name.location.union(body.location),
+                                             :union)
+          @pairs = pairs.freeze || derive_pairs(arguments).freeze
+        end
+
+        # Pretty inspect.
+        #
+        # @return [::String]
+        def inspect
+          "#<#{self.class} name=#{@name.inspect} pairs=#{@pairs.inspect} " \
+            "body=#{@body.inspect} location=#{@location.inspect}>"
+        end
+
+        # Equates this object with another object.  If the other object is
+        # this object, it returns true; otherwise, if it is a block, whose
+        # properties all equal this one, it returns true; otherwise, it
+        # returns false.
+        #
+        # @param other [::Object]
+        # @return [Boolean]
+        def ==(other)
+          equal?(other) || other.is_a?(Block) && @name == other.name &&
+            @body == other.body && @location == other.location
+        end
+
+      private
+
+        def update_name(name)
+          Block.new(name: name, body: @body, pairs: @pairs, location: @location)
+        end
+
+        def update_body(body)
+          Block.new(name: @name, body: body, pairs: @pairs, location: @location)
+        end
+
+        def update_pairs(pairs)
+          Block.new(name: @name, body: @body, pairs: pairs, location: @location)
+        end
+
+        def update_arguments(arguments)
+          update_pairs(derive_pairs(arguments))
+        end
+
+        def update_location(location)
+          Block.new(name: @name, body: @body, pairs: @pairs, location: location)
+        end
+
+        def derive_pairs(arguments)
+          arguments.inject({}) do |a, pair|
+            k, v = pair.key, pair.value
+            a.merge!(k.value => v.value)
+          end.freeze
+        end
+      end
+    end
+  end
+end

data/lib/brandish/parser/node/command.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  class Parser
+    class Node
+      # A command node.  This takes the form of `{.a b=c}`, and executes a
+      # given command with the given options.
+      class Command < Node
+        # The name of the command node.  This is the name of the command that
+        # is executed.
+        #
+        # @return [::String]
+        attr_reader :name
+
+        # The "pairs" of arguments to be passed to the command.
+        #
+        # @return [{::String => ::String}]
+        attr_reader :pairs
+
+        # Initialize the command node.
+        #
+        # @overload initialize(name:, arguments:, location: nil)
+        #   Creates a command node with the given name.  The arguments are
+        #   processed to turn into a hash that is a key-value store of the
+        #   arguments; if there are duplicate key-values pairs, the earlier
+        #   ones are overwritten.  If no location is provided, it is assumed
+        #   from the name and arguments.
+        #
+        #   @param name [::String, Scanner::Token] The name of the command.  If
+        #     no location is provided, this *must* respond to `#location`.
+        #   @param arguments [<Node::Pair>] The pairs of arguments as an array
+        #     of nodes.
+        # @overload initialize(name:, pairs:, location:)
+        #   Creates a command node with the given name and argument pairs.
+        #   Since no location can be derived from either, the location is
+        #   required.
+        #
+        #   @param name [::String, Scanner::Token] The name of the command.
+        #   @param pairs [{::String => ::String, ::Numeric}] The argument pairs
+        #     for the command.
+        #   @param location [Location] The location of the node.
+        def initialize(name:, arguments: nil, pairs: nil, location: nil)
+          if !location && !arguments
+            fail ArgumentError, "Expected either a location or " \
+              "arguments, got neither"
+          end
+
+          @name = name.is_a?(Yoga::Token) ? name.value : name.freeze
+          @location = location || arguments.map(&:location)
+                                           .inject(name.location, :union)
+          @pairs = pairs.freeze || derive_pairs(arguments).freeze
+        end
+
+        # Determines if this object and the given object are equal.  If the
+        # other object is this object, it returns true; otherwise, if the other
+        # object is a {Command}, and all of the properties of that object equal
+        # this one, then it returns true; otherwise, it returns false.
+        #
+        # @param other [::Object] The object to equal.
+        # @return [Boolean]
+        def ==(other)
+          equal?(other) || (other.is_a?(Command) && @name == other.name &&
+            @location == other.location && @pairs == other.pairs)
+        end
+
+        # Pretty inspect.
+        #
+        # @return [::String]
+        def inspect
+          "#<#{self.class} name=#{@name.inspect} pairs=#{@pairs.inspect} " \
+            "location=#{@location.inspect}>"
+        end
+
+      private
+
+        def update_name(name)
+          Command.new(name: name, pairs: @pairs, location: @location)
+        end
+
+        def update_pairs(pairs)
+          Command.new(name: @name, pairs: pairs, location: @location)
+        end
+
+        def update_arguments(arguments)
+          update_pairs(derive_pairs(arguments))
+        end
+
+        def update_location(location)
+          Command.new(name: @name, pairs: @pairs, location: location)
+        end
+
+        def derive_pairs(arguments)
+          arguments.inject({}) do |a, pair|
+            k, v = pair.key, pair.value
+            a.merge!(k.value => v.value)
+          end.freeze
+        end
+      end
+    end
+  end
+end

data/lib/brandish/parser/node/pair.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  class Parser
+    class Node
+      # A key-value pair used for a command.  This is used to represent an
+      # argument for the command node.
+      class Pair < Node
+        # The key of the pair.  This will *always* be a `:TEXT`.
+        #
+        # @return [Scanner::Token] The key.
+        attr_reader :key
+
+        # The value of the pair.
+        #
+        # @return [Parser::Node::Text, Parser::Node::String] The value.
+        attr_reader :value
+
+        # Initialize the pair node with the given key, value and location.
+        #
+        # @param key [Yoga::Token] The key.
+        # @param value [Parser::Node::Text, Parser::Node::String] The value.
+        # @param location [Location] The location of the key-value pair.
+        def initialize(key:, value:, location: nil)
+          @key = key
+          @value = value
+          @location = location || key.location.union(value.location)
+          freeze
+        end
+
+        # Pretty inspect.
+        #
+        # @return [::String]
+        def inspect
+          "#<#{self.class} key=#{@key.inspect} value=#{@value.inspect} " \
+            "location=#{@location.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/brandish/parser/node/root.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  class Parser
+    class Node
+      # The root node.  This is the parent of the full document.
+      class Root < Node
+        # The children of the root node.  This should be a series of nodes
+        # that are in the body.
+        #
+        # @return [<Node>]
+        attr_reader :children
+
+        # Initialize the root node with the given children and location.
+        #
+        # @param children [<Node>] The children of the root node.  See
+        #   {#children}.
+        # @param location [Location] The location of the node.  If no location
+        #   is provided, it assumed from the children.
+        def initialize(children:, location: nil)
+          @children = children.freeze
+          @location = location || derive_location(children)
+          fail unless children.any?
+          freeze
+        end
+
+        # Pretty inspect.
+        #
+        # @return [::String]
+        def inspect
+          "#<#{self.class} children=#{@children.inspect} " \
+            "location=#{@location.inspect}>"
+        end
+
+        # Checks for equivalence between this and another object.  If the other
+        # object is this object, it returns true; otherwise, if the other
+        # object is a root, and its properties are equal to this one, it returns
+        # true; otherwise, it returns false.
+        #
+        # @param other [::Object]
+        # @return [Boolean]
+        def ==(other)
+          equal?(other) || other.is_a?(Root) && @children == other.children &&
+            @location == other.location
+        end
+
+        # This flattens out the root node into a single string value.  This is
+        # used for outputing the contents.
+        #
+        # @raise [NodeError] if the node contains a non-root or non-text node.
+        # @return [::String]
+        def flatten
+          children.map do |child|
+            case child
+            when Node::Root then child.flatten
+            when Node::Text then child.value
+            else
+              fail NodeError.new("Unexpected node `#{child.class}",
+                node.location)
+            end
+          end.join
+        end
+
+      private
+
+        def derive_location(children)
+          children.map(&:location).inject(:union) || Yoga::Location.default
+        rescue
+          Yoga::Location.default
+        end
+
+        def update_children(children)
+          Root.new(children: children, location: @location)
+        end
+
+        def update_location(location)
+          Root.new(children: @children, location: location)
+        end
+      end
+    end
+  end
+end

data/lib/brandish/parser/node/string.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Brandish
+  class Parser
+    class Node
+      # A "string."  Because of how loose the language is, this is similar to
+      # a {Text} node, but has no restriction on the allowed values for the
+      # node.
+      class String < Text
+        # A set of tokens kinds that are allowed to be in a string node.
+        #
+        # @return [::Set<::Symbol>]
+        TOKENS = (Node::Text::TOKENS - ::Set[:'"']) + ::Set[:<, :>]
+      end
+    end
+  end
+end

data/lib/brandish/parser/node/text.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "set"
+
+module Brandish
+  class Parser
+    class Node
+      # A text node.  This contains only text, and has no  other node
+      # decendants.  This node automatically merges the contents of the text
+      # into a single value, and places it in the `value` attribute.
+      class Text < Node
+        # A set of tokens kinds that are allowed to be in a text node.
+        #
+        # @return [::Set<::Symbol>]
+        TOKENS =
+          ::Set[:SPACE, :TEXT, :LINE, :NUMERIC, :ESCAPE, :/, :'"', :'='].freeze
+
+        # The value of the text node.  This is the string value of the source
+        # text that this node is based off of.
+        #
+        # @return [::String]
+        attr_reader :value
+
+        # Initialize the node.
+        #
+        # @overload initialize(tokens:, location: nil)
+        #   Initialize the text node with the given series of tokens.  The
+        #   location can be either provided, or assumed from the locations of
+        #   the tokens.  The tokens are concatenated into a single string,
+        #   and used to provide the text.
+        #
+        #   @param tokens [<Scanner::Token>] The tokens that make up
+        #     this text node.
+        #   @param location [Location] The location of the text node.  If none
+        #     is provided, it is assumed from the tokens.
+        # @overload initialize(value:, location:)
+        #   Initialize the text node with the given value.  The location must
+        #   be provided.
+        #
+        #   @param value [::String] The value of the text node.
+        #   @param location [Location] The location of the text node.
+        def initialize(tokens: nil, value: nil, location: nil)
+          unless tokens || (value && location)
+            fail ::ArgumentError, "Expected either a set of tokens or a " \
+              "value and a location, got neither"
+          end
+
+          @value = value || derive_value(tokens)
+          @location = location || derive_location(tokens)
+          freeze
+        end
+
+        # Pretty inspect.
+        #
+        # @return [::String]
+        def inspect
+          "#<#{self.class} value=#{@value.inspect} " \
+            "location=#{@location.inspect}>"
+        end
+
+        # Determines if this object equals another object.  If the other object
+        # is this object, it returns true; otherwise, if the other object is a
+        # {Text}, and all of the properties are equal, it returns true;
+        # otherwise, it returns false.
+        #
+        # @param other [::Object]
+        # @return [Boolean]
+        def ==(other)
+          equal?(other) || other.is_a?(self.class) && @value == other.value &&
+            @location == other.location
+        end
+
+      private
+
+        def update_value(value)
+          Text.new(value: value, location: @location)
+        end
+
+        def update_tokens(tokens)
+          update_value(derive_value(tokens))
+        end
+
+        def update_location(location)
+          Text.new(value: @value, location: location)
+        end
+
+        def derive_location(tokens)
+          unless tokens
+            fail ::ArgumentError, "Expected either location or tokens, got" \
+              " neither"
+          end
+
+          tokens.map(&:location).inject(:union)
+        end
+
+        def derive_value(tokens)
+          assert_valid_tokens(tokens)
+          tokens
+            .map { |t| t.kind == :ESCAPE ? t.value[-1] : t.value }
+            .join
+            .freeze
+        end
+
+        def assert_valid_tokens(tokens)
+          valid = tokens.all? { |t| TOKENS.include?(t.kind) }
+          return valid if valid
+          fail ::ArgumentError, "Expected tokens to all be one of " \
+            "#{TOKENS.map(&:inspect).join(', ')}"
+        end
+      end
+    end
+  end
+end