rupkl 0.1.0

data/lib/rupkl/parser/literal.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    #
+    # Boolean literal
+    #
+    define_parser do
+      rule(:boolean_literal) do
+        kw_true.as(:true_value) | kw_false.as(:false_value)
+      end
+    end
+
+    define_transform do
+      rule(true_value: simple(:v)) do
+        Node::Boolean.new(true, node_position(v))
+      end
+
+      rule(false_value: simple(:v)) do
+        Node::Boolean.new(false, node_position(v))
+      end
+    end
+
+    #
+    # Integer literal
+    #
+    define_parser do
+      rule(:bin_literal) do
+        str('0b') >> match('[01]') >> match('[_01]').repeat
+      end
+
+      rule(:oct_literal) do
+        str('0o') >> match('[0-7]') >> match('[_0-7]').repeat
+      end
+
+      rule(:dec_literal) do
+        match('[\d]') >> match('[_\d]').repeat
+      end
+
+      rule(:hex_literal) do
+        str('0x') >> match('[\h]') >> match('[_\h]').repeat
+      end
+
+      rule(:integer_literal) do
+        (
+          bin_literal | oct_literal | hex_literal | dec_literal
+        ).as(:integer_literal)
+      end
+    end
+
+    define_transform do
+      rule(integer_literal: simple(:v)) do
+        base = { 'b' => 2, 'o' => 8, 'x' => 16 }.fetch(v.to_s[1], 10)
+        value = v.to_s.tr('_', '').to_i(base)
+        Node::Integer.new(value, node_position(v))
+      end
+    end
+
+    #
+    # Float literal
+    #
+    define_parser do
+      rule(:float_literal) do
+        (
+          (dec_literal.maybe >> str('.') >> dec_literal >> exponent.maybe) |
+          (dec_literal >> exponent)
+        ).as(:float_literal)
+      end
+
+      rule(:exponent) do
+        match('[eE]') >> (match('[+-]') >> str('_').maybe).maybe >> dec_literal
+      end
+    end
+
+    define_transform do
+      rule(float_literal: simple(:f)) do
+        v = f.to_s.tr('_', '').to_f
+        Node::Float.new(v, node_position(f))
+      end
+    end
+
+    #
+    # String literal
+    #
+    ESCAPED_CHARS =
+      {
+        't' => "\t", 'n' => "\n", 'r' => "\r",
+        '"' => '"', '\\' => '\\'
+      }.freeze
+
+    define_parser do
+      rule(:ss_empty_literal) do
+        ss_bq(false).as(:ss_bq) >> ss_eq('').as(:ss_eq)
+      end
+
+      rule(:ss_literal) do
+        ss_bq(false).as(:ss_bq) >>
+          ss_portions('').as(:ss_portions) >> ss_eq('').as(:ss_eq)
+      end
+
+      rule(:ss_empty_literal_custom_delimiters) do
+        ss_bq(true).capture(:bq).as(:ss_bq) >>
+          dynamic do |_, c|
+            ss_eq(c.captures[:bq].to_s[0..-2]).as(:ss_eq)
+          end
+      end
+
+      rule(:ss_literal_custom_delimiters) do
+        ss_bq(true).capture(:bq).as(:ss_bq) >>
+          dynamic do |_, c|
+            pounds = c.captures[:bq].to_s[0..-2]
+            ss_portions(pounds).as(:ss_portions) >> ss_eq(pounds).as(:ss_eq)
+          end
+      end
+
+      rule(:ms_empty_literal) do
+        ms_bq(false).as(:ms_bq) >> ms_eq('', false).as(:ms_eq)
+      end
+
+      rule(:ms_literal) do
+        ms_bq(false).as(:ms_bq) >>
+          ms_portions('').as(:ms_portions) >> ms_eq('', false).as(:ms_eq)
+      end
+
+      rule(:ms_empty_literal_custom_delimiters) do
+        ms_bq(true).capture(:bq).as(:ms_bq) >>
+          dynamic do |_, c|
+            ms_eq(c.captures[:bq].to_s[0..-4], false).as(:ms_eq)
+          end
+      end
+
+      rule(:ms_literal_custom_delimiters) do
+        ms_bq(true).capture(:bq).as(:ms_bq) >>
+          dynamic do |_, c|
+            pounds = c.captures[:bq].to_s[0..-4]
+            ms_portions(pounds).as(:ms_portions) >> ms_eq(pounds, false).as(:ms_eq)
+          end
+      end
+
+      rule(:string_literal) do
+        [
+          ms_empty_literal_custom_delimiters, ms_literal_custom_delimiters,
+          ms_empty_literal, ms_literal,
+          ss_empty_literal_custom_delimiters, ss_literal_custom_delimiters,
+          ss_empty_literal, ss_literal
+        ].inject(:|)
+      end
+
+      private
+
+      def interplation(pounds)
+        str("\\#{pounds}") >> bracketed(expression, '(', ')')
+      end
+
+      def unicode_char(pounds)
+        str("\\#{pounds}u") >> str('{') >> match('[\h]').repeat(1) >> str('}')
+      end
+
+      def escaped_char(pounds)
+        str("\\#{pounds}") >> match('[^\(u]')
+      end
+
+      def ss_char(pounds)
+        (nl | str("\\#{pounds}") | ss_eq(pounds)).absent? >> any
+      end
+
+      def ss_string(pounds)
+        (unicode_char(pounds) | escaped_char(pounds) | ss_char(pounds)).repeat(1)
+      end
+
+      def ss_portions(pounds)
+        (
+          interplation(pounds).as(:interplation) |
+          ss_string(pounds).as(:ss_string)
+        ).repeat(1)
+      end
+
+      def ss_bq(custom)
+        if custom
+          str('#').repeat(1) >> str('"')
+        else
+          str('"')
+        end
+      end
+
+      def ss_eq(pounds)
+        str("\"#{pounds}")
+      end
+
+      def ms_char(pounds)
+        (nl | str("\\#{pounds}") | ms_eq(pounds, true)).absent? >> any
+      end
+
+      def ms_string(pounds)
+        (unicode_char(pounds) | escaped_char(pounds) | ms_char(pounds)).repeat(1)
+      end
+
+      def ms_portion(pounds)
+        (
+          interplation(pounds).as(:interplation) |
+          ms_string(pounds).as(:ms_string)
+        ).repeat(1)
+      end
+
+      def ms_portions(pounds)
+        (ms_portion(pounds).maybe >> nl.as(:ms_nl)).repeat(1)
+      end
+
+      def ms_bq(custom)
+        if custom
+          str('#').repeat(1) >> str('"""') >> nl.ignore
+        else
+          str('"""') >> nl.ignore
+        end
+      end
+
+      def ms_eq(pounds, pattern_only)
+        if pattern_only
+          str('"""'"#{pounds}")
+        else
+          match('[ \t]').repeat >> str('"""'"#{pounds}")
+        end
+      end
+    end
+
+    define_transform do
+      rule(ss_bq: simple(:bq), ss_eq: simple(:eq)) do
+        Node::String.new(nil, nil, node_position(bq))
+      end
+
+      rule(ss_bq: simple(:bq), ss_portions: subtree(:portions), ss_eq: simple(:eq)) do
+        Node::String.new(nil, process_ss_portions(portions, bq), node_position(bq))
+      end
+
+      rule(ms_bq: simple(:bq), ms_eq: simple(:eq)) do
+        Node::String.new(nil, nil, node_position(bq))
+      end
+
+      rule(ms_bq: simple(:bq), ms_portions: subtree(:portions), ms_eq: simple(:eq)) do
+        Node::String.new(nil, process_ms_portions(portions, bq, eq), node_position(bq))
+      end
+
+      private
+
+      def process_ss_portions(portions, ss_bq)
+        pounds = ss_bq.to_s[0..-2]
+        portions.map { process_sring_portion(_1.first, pounds) }
+      end
+
+      def process_ms_portions(portions, ms_bq, ms_eq)
+        pounds = ms_bq.to_s[0..-4]
+        portions
+          .flat_map(&:to_a)
+          .then { _1[0..-2] }
+          .then { trim_leading_shapes(_1, ms_eq) }
+          .map { process_sring_portion(_1, pounds) }
+      end
+
+      def trim_leading_shapes(portins, ms_eq)
+        prefix = ms_eq.to_s[/^[ \t]+/]
+        return portins unless prefix
+
+        portins.map do |t, s|
+          if include_bol?(s)
+            [t, s.to_s.delete_prefix(prefix)]
+          else
+            [t, s]
+          end
+        end
+      end
+
+      def include_bol?(string)
+        _, column = string.line_and_column
+        column == 1
+      end
+
+      def process_sring_portion(portion, pounds)
+        type, string = portion
+        case type
+        when :ss_string, :ms_string then unescape_string(string, pounds)
+        when :ms_nl then "\n"
+        when :interplation then string
+        end
+      end
+
+      def unescape_string(string, pounds)
+        string
+          .to_s
+          .then { unescape_unicode(_1, pounds) }
+          .then { unescape_char(_1, pounds, string) }
+      end
+
+      def unescape_unicode(string, pounds)
+        re = /\\#{pounds}u\{([\h]+)\}/
+        string.gsub(re) { Regexp.last_match(1).to_i(16).chr(Encoding::UTF_8) }
+      end
+
+      def unescape_char(string, pounds, node)
+        string.gsub(/(\\#{pounds}.)/) do |m|
+          ESCAPED_CHARS[m[-1]] ||
+            begin
+              message = "invalid escape sequence is given: #{m}"
+              parse_error(message, node_position(node))
+            end
+        end
+      end
+    end
+  end
+end

data/lib/rupkl/parser/misc.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    WS_PATTERN = '[ \t\f\r\n;]'
+
+    define_parser do
+      rule(:line_comment) do
+        str('//') >> match('[^\n]').repeat >> (nl | eof)
+      end
+
+      rule(:block_comment) do
+        str('/*') >> (block_comment | (str('*/').absent? >> any)).repeat >> str('*/')
+      end
+
+      rule(:comment) do
+        line_comment | block_comment
+      end
+
+      rule(:nl) do
+        match('\n')
+      end
+
+      rule(:eof) do
+        any.absent?
+      end
+
+      rule(:ws) do
+        (match(WS_PATTERN) | comment).repeat(1).ignore
+      end
+
+      rule(:ws?) do
+        (match(WS_PATTERN) | comment).repeat.ignore
+      end
+
+      rule(:pure_ws?) do
+        (match('[ \t\f]') | comment).repeat.ignore
+      end
+
+      private
+
+      def bracketed(atom, bra = '(', cket = ')')
+        bra_matcher, cket_matcher =
+          [bra, cket]
+            .map { _1.is_a?(String) && str(_1).ignore || _1 }
+        bra_matcher >> ws? >> atom >> ws? >> cket_matcher
+      end
+    end
+  end
+end

data/lib/rupkl/parser/object.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    define_parser do
+      rule(:object) do
+        bracketed(
+          object_members.as(:members).maybe,
+          str('{').as(:start), '}'
+        ).as(:object)
+      end
+
+      rule(:object_members) do
+        object_member >> (ws >> object_member).repeat
+      end
+
+      rule(:object_member) do
+        object_property | object_entry | object_element
+      end
+
+      rule(:object_property) do
+        (
+          id.as(:name) >> ws? >>
+            (
+              (str('=').ignore >> ws? >> expression.as(:value)) |
+              (object >> (ws? >> object).repeat).as(:objects)
+            )
+        ).as(:object_property)
+      end
+
+      rule(:object_entry) do
+        (
+          bracketed(expression.as(:key), '[', ']') >> ws? >>
+            (
+              (str('=').ignore >> ws? >> expression.as(:value)) |
+              (object >> (ws? >> object).repeat).as(:objects)
+            )
+        ).as(:object_entry)
+      end
+
+      rule(:object_element) do
+        expression
+      end
+    end
+
+    define_transform do
+      rule(object: { start: simple(:s) }) do
+        Node::UnresolvedObject.new(nil, node_position(s))
+      end
+
+      rule(object: { start: simple(:s), members: subtree(:m) }) do
+        Node::UnresolvedObject.new(Array(m), node_position(s))
+      end
+
+      rule(object_property: { name: simple(:n), value: simple(:v) }) do
+        Node::ObjectProperty.new(n, v, nil, n.position)
+      end
+
+      rule(object_property: { name: simple(:n), objects: subtree(:o) }) do
+        Node::ObjectProperty.new(n, nil, Array(o), n.position)
+      end
+
+      rule(object_entry: { key: simple(:k), value: simple(:v) }) do
+        Node::ObjectEntry.new(k, v, nil, k.position)
+      end
+
+      rule(object_entry: { key: simple(:k), objects: subtree(:o) }) do
+        Node::ObjectEntry.new(k, nil, Array(o), k.position)
+      end
+    end
+  end
+end

data/lib/rupkl/parser/pkl_class.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    define_parser do
+      rule(:pkl_class_property) do
+        (
+          id.as(:name) >> ws? >>
+          (
+            (str('=').ignore >> ws? >> expression.as(:value)) |
+            (object >> (ws? >> object).repeat).as(:objects)
+          )
+        ).as(:class_property)
+      end
+    end
+
+    define_transform do
+      rule(class_property: { name: simple(:n), value: simple(:v) }) do
+        Node::PklClassProperty.new(n, v, nil, n.position)
+      end
+    end
+
+    define_transform do
+      rule(class_property: { name: simple(:n), objects: subtree(:o) }) do
+        Node::PklClassProperty.new(n, nil, Array(o), n.position)
+      end
+    end
+  end
+end

data/lib/rupkl/parser/pkl_module.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    define_parser do
+      rule(:pkl_module) do
+        (
+          ws? >> pkl_module_items.as(:items).maybe >> ws?
+        ).as(:pkl_module)
+      end
+
+      rule(:pkl_module_items) do
+        pkl_module_item >> (ws >> pkl_module_item).repeat
+      end
+
+      rule(:pkl_module_item) do
+        pkl_class_property
+      end
+    end
+
+    define_transform do
+      rule(pkl_module: simple(:_)) do
+        Node::PklModule.new(nil, sof_position)
+      end
+
+      rule(pkl_module: { items: subtree(:items) }) do
+        Array(items)
+          .then { Node::PklModule.new(_1, _1.first.position) }
+      end
+    end
+  end
+end

data/lib/rupkl/parser.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    Position = Struct.new(:filename, :line, :column)
+
+    class Parser < Parslet::Parser
+      def parse(io, filename: nil, root: nil)
+        root_parser(root).parse(io)
+      rescue Parslet::ParseFailed => e
+        raise_parse_error(e, filename)
+      end
+
+      def root_parser(root)
+        root && __send__(root) || __send__(:root)
+      end
+
+      private
+
+      def raise_parse_error(error, filename)
+        cause = error.parse_failure_cause
+        pos = create_error_pos(cause, filename)
+        message = compose_error_message(cause)
+        raise ParseError.new(message, pos, cause)
+      end
+
+      def create_error_pos(cause, filename)
+        Position.new(filename, *cause.source.line_and_column(cause.pos))
+      end
+
+      def compose_error_message(cause)
+        Array(cause.message)
+          .map { |m| m.respond_to?(:to_slice) ? m.str.inspect : m.to_s }
+          .join
+      end
+    end
+
+    class Context < Parslet::Context
+      def initialize(bindings, transform)
+        super(bindings)
+        @__transform = transform
+      end
+
+      def method_missing(method, ...)
+        if @__transform.respond_to?(method, true)
+          __define_delegator__(method)
+          __send__(method, ...)
+        else
+          # :nocov:
+          super
+          # :nocov:
+        end
+      end
+
+      def respond_to_missing?(method, include_private)
+        # :nocov:
+        super || @__transform.respond_to?(method, include_private)
+        # :nocov:
+      end
+
+      private
+
+      def __define_delegator__(method)
+        self.class.class_eval(<<~M, __FILE__, __LINE__ + 1)
+          # def foo(...)
+          #   @__transform.__send__(:foo, ...)
+          # end
+          def #{method}(...)
+            @__transform.__send__(:#{method}, ...)
+          end
+        M
+      end
+    end
+
+    class Transform < Parslet::Transform
+      def apply(obj, context = nil, filename: nil)
+        @filename = filename if filename
+        super(obj, context)
+      end
+
+      def call_on_match(bindings, block)
+        return unless block
+
+        context = Context.new(bindings, self)
+        context.instance_exec(&block)
+      end
+
+      private
+
+      def node_position(node)
+        Position.new(@filename, *node.line_and_column)
+      end
+
+      def sof_position
+        Position.new(@filename, 1, 1)
+      end
+
+      def parse_error(message, position)
+        raise ParseError.new(message, position, nil)
+      end
+    end
+
+    class << self
+      private
+
+      def define_parser(&body)
+        Parser.class_eval(&body)
+      end
+
+      def define_transform(&body)
+        Transform.class_eval(&body)
+      end
+    end
+
+    def parse(string, filename: nil, root: nil)
+      tree = parse_string(string, filename, root)
+      transform_tree(tree, filename)
+    end
+
+    private
+
+    def parse_string(string, filename, root)
+      parser.parse(string, filename: filename, root: root)
+    end
+
+    def parser
+      @parser ||= Parser.new
+    end
+
+    def transform_tree(tree, filename)
+      transform.apply(tree, filename: filename)
+    end
+
+    def transform
+      @transform ||= Transform.new
+    end
+  end
+end