rupkl 0.1.0

data/lib/rupkl/node/operation.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module OperationCommon
+      def to_ruby(scopes)
+        evaluate(scopes).to_ruby(nil)
+      end
+
+      def to_string(scopes)
+        evaluate(scopes).to_string(nil)
+      end
+
+      def to_pkl_string(scopes)
+        evaluate(scopes).to_pkl_string(nil)
+      end
+
+      private
+
+      def s_op(scopes)
+        r = receiver.evaluate(scopes)
+        check_operator(r)
+
+        k = key.evaluate(scopes)
+        check_key_operand(r, k)
+
+        r.find_by_key(k) ||
+          begin
+            message = "cannot find key '#{k.to_pkl_string(scopes)}'"
+            raise EvaluationError.new(message, position)
+          end
+      end
+
+      def u_op(scopes)
+        o = operand.evaluate(scopes)
+        check_operator(o)
+
+        result =
+          if operator == :-
+            -o.value
+          else
+            !o.value
+          end
+        create_op_result(result)
+      end
+
+      def b_op(scopes)
+        l = l_operand.evaluate(scopes)
+        check_operator(l)
+        return l if short_circuit?(l)
+
+        r = r_operand.evaluate(scopes)
+        check_r_operand(l, r)
+
+        l, r = l.coerce(operator, r)
+        create_op_result(l.__send__(ruby_op, r))
+      end
+
+      def check_operator(operand)
+        undefined_operator?(operand) &&
+          begin
+            message =
+              "operator '#{operator}' is not defined for " \
+              "#{operand.class.basename} type"
+            raise EvaluationError.new(message, position)
+          end
+      end
+
+      def undefined_operator?(operand)
+        !operand.respond_to?(:undefined_operator?) ||
+          operand.undefined_operator?(operator)
+      end
+
+      def check_key_operand(receiver, key)
+        invalid_key_operand?(receiver, key) &&
+          begin
+            message =
+              "invalid key operand type #{key.class.basename} is given " \
+              "for operator '#{operator}'"
+            raise EvaluationError.new(message, position)
+          end
+      end
+
+      def invalid_key_operand?(receiver, key)
+        receiver.respond_to?(:invalid_key_operand?) &&
+          receiver.invalid_key_operand?(key)
+      end
+
+      def check_r_operand(l_operand, r_operand)
+        invalid_r_operand?(l_operand, r_operand) &&
+          begin
+            message =
+              "invalid operand type #{r_operand.class.basename} is given " \
+              "for operator '#{operator}'"
+            raise EvaluationError.new(message, position)
+          end
+      end
+
+      def invalid_r_operand?(l_operand, r_operand)
+        if l_operand.respond_to?(:invalid_r_operand?)
+          l_operand.invalid_r_operand?(r_operand)
+        else
+          !r_operand.is_a?(l_operand.class)
+        end
+      end
+
+      def short_circuit?(l_operand)
+        l_operand.respond_to?(:short_circuit?) &&
+          l_operand.short_circuit?(operator)
+      end
+
+      def ruby_op
+        { '&&': :&, '||': :|, '~/': :/ }.fetch(operator, operator)
+      end
+
+      def create_op_result(result)
+        case result
+        when ::Integer then Integer.new(result, position)
+        when ::Float then Float.new(result, position)
+        when ::String then String.new(result, nil, position)
+        when ::TrueClass, ::FalseClass then Boolean.new(result, position)
+        end
+      end
+    end
+
+    class SubscriptOperation
+      include OperationCommon
+
+      def initialize(receiver, key, position)
+        @receiver = receiver
+        @key = key
+        @position = position
+      end
+
+      attr_reader :receiver
+      attr_reader :key
+      attr_reader :position
+
+      def operator
+        :[]
+      end
+
+      def evaluate(scopes)
+        s_op(scopes)
+      end
+    end
+
+    class UnaryOperation
+      include OperationCommon
+
+      def initialize(operator, operand, position)
+        @operator = operator
+        @operand = operand
+        @position = position
+      end
+
+      attr_reader :operator
+      attr_reader :operand
+      attr_reader :position
+
+      def evaluate(scopes)
+        u_op(scopes)
+      end
+    end
+
+    class BinaryOperation
+      include OperationCommon
+
+      def initialize(operator, l_operand, r_operand, position)
+        @operator = operator
+        @l_operand = l_operand
+        @r_operand = r_operand
+        @position = position
+      end
+
+      attr_reader :operator
+      attr_reader :l_operand
+      attr_reader :r_operand
+      attr_reader :position
+
+      def evaluate(scopes)
+        b_op(scopes)
+      end
+    end
+  end
+end

data/lib/rupkl/node/pkl_class.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class PklClassProperty
+      include PropertyEvaluator
+
+      def initialize(name, value, objects, position)
+        @name = name
+        @value = value
+        @objects = objects
+        @position = position
+      end
+
+      attr_reader :name
+      attr_reader :value
+      attr_reader :objects
+      attr_reader :position
+
+      def evaluate(scopes)
+        v = evaluate_property(value, objects, scopes)
+        self.class.new(name, v, nil, position)
+      end
+
+      def to_ruby(scopes)
+        [name.id, property_to_ruby(value, objects, scopes)]
+      end
+    end
+  end
+end

data/lib/rupkl/node/pkl_module.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class PklModule
+      include StructCommon
+
+      def initialize(items, position)
+        @position = position
+        items&.each do |item|
+          case item
+          when PklClassProperty then add_property(item)
+          end
+        end
+      end
+
+      attr_reader :properties
+      attr_reader :position
+
+      def evaluate(scopes)
+        push_scope(scopes) do |s|
+          self.class.new(evaluate_properties(s), position)
+        end
+      end
+
+      def to_ruby(scopes)
+        push_scope(scopes) do |s|
+          create_pkl_object(s, properties, nil, nil)
+        end
+      end
+
+      private
+
+      def add_property(property)
+        (@properties ||= []) << property
+      end
+
+      def evaluate_properties(scopes)
+        properties&.each_with_object([]) do |property, result|
+          property
+            .evaluate(scopes)
+            .then { add_hash_member(result, _1, :name) }
+        end
+      end
+    end
+  end
+end

data/lib/rupkl/node/string.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class String
+      include ValueCommon
+
+      def initialize(value, portions, position)
+        super(value, position)
+        @portions = portions
+      end
+
+      attr_reader :portions
+
+      def evaluate(scopes)
+        s = value || evaluate_portions(scopes) || ''
+        self.class.new(s, nil, position)
+      end
+
+      def to_pkl_string(scopes)
+        super(scopes)
+          .then { |s| escape(s) }
+          .then { |s| "\"#{s}\"" }
+      end
+
+      def undefined_operator?(operator)
+        [:[], :==, :'!=', :+].none?(operator)
+      end
+
+      def invalid_key_operand?(key)
+        !key.is_a?(Integer)
+      end
+
+      def find_by_key(key)
+        index = key.value
+        return nil unless (0...value.length).include?(index)
+
+        self.class.new(value[index], nil, portions)
+      end
+
+      private
+
+      def evaluate_portions(scopes)
+        portions
+          &.map { evaluate_portion(scopes, _1) }
+          &.join
+      end
+
+      def evaluate_portion(scopes, portion)
+        if portion.respond_to?(:to_string)
+          portion.to_string(scopes)
+        else
+          portion
+        end
+      end
+
+      def escape(string)
+        replace = {
+          "\t" => '\t', "\n" => '\n', "\r" => '\r',
+          '"' => '\"', '\\' => '\\\\'
+        }
+        string.gsub(/([\t\n\r"\\])/) { replace[_1] }
+      end
+    end
+  end
+end

data/lib/rupkl/node/struct_common.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module StructCommon
+      def to_string(_scopes)
+        "new #{self.class.basename} #{to_pkl_string(nil)}"
+      end
+
+      def coerce(_operator, r_operand)
+        [self, r_operand]
+      end
+
+      private
+
+      def push_scope(scopes)
+        yield([*scopes, self])
+      end
+
+      def add_hash_member(members, member, accessor)
+        duplicate_member?(members, member, accessor) &&
+          begin
+            message = 'duplicate definition of member'
+            raise EvaluationError.new(message, member.position)
+          end
+        members << member
+      end
+
+      def duplicate_member?(members, member, accessor)
+        members
+          .any? { _1.__send__(accessor) == member.__send__(accessor) }
+      end
+
+      def add_array_member(members, member)
+        members << member
+      end
+
+      def match_members?(lhs, rhs, match_order)
+        if !match_order && [lhs, rhs].all?(Array)
+          lhs.size == rhs.size &&
+            lhs.all? { rhs.include?(_1) } && rhs.all? { lhs.include?(_1) }
+        else
+          lhs == rhs
+        end
+      end
+
+      def merge_hash_members(lhs, rhs, accessor)
+        return nil unless lhs || rhs
+        return rhs unless lhs
+
+        rhs&.each do |r|
+          if (index = find_index(lhs, r, accessor))
+            lhs[index] = r
+          else
+            lhs << r
+          end
+        end
+
+        lhs
+      end
+
+      def find_index(lhs, rhs, accessor)
+        lhs.find_index { _1.__send__(accessor) == rhs.__send__(accessor) }
+      end
+
+      def merge_array_members(lhs, rhs)
+        return nil unless lhs || rhs
+        return rhs unless lhs
+        return lhs unless rhs
+
+        lhs.concat(rhs)
+      end
+
+      def create_pkl_object(scopes, properties, entries, elements)
+        RuPkl::PklObject.new(
+          to_ruby_hash_members(scopes, properties),
+          to_ruby_hash_members(scopes, entries),
+          to_ruby_array_members(scopes, elements)
+        )
+      end
+
+      def to_ruby_hash_members(scopes, members)
+        members
+          &.to_h { _1.to_ruby(scopes) }
+      end
+
+      def to_ruby_array_members(scopes, members)
+        members
+          &.map { _1.to_ruby(scopes) }
+      end
+
+      def to_pkl_string_object(*members)
+        return '{}' if members.empty?
+
+        members
+          .map { _1.to_pkl_string(nil) }
+          .join('; ')
+          .then { "{ #{_1} }" }
+      end
+    end
+  end
+end

data/lib/rupkl/node/value_common.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module ValueCommon
+      def initialize(value, position)
+        @value = value
+        @position = position
+      end
+
+      attr_reader :value
+      attr_reader :position
+
+      def to_ruby(scopes)
+        evaluate(scopes).value
+      end
+
+      def to_string(scopes)
+        to_ruby(scopes).to_s
+      end
+
+      def to_pkl_string(scopes)
+        to_string(scopes)
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) && value == other.value
+      end
+
+      def coerce(_operator, r_operand)
+        [value, r_operand.value]
+      end
+    end
+  end
+end

data/lib/rupkl/parser/expression.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    define_parser do
+      rule(:unqualified_member_ref) do
+        id.as(:unqualified_member_ref)
+      end
+
+      rule(:primary) do
+        [
+          float_literal, integer_literal, boolean_literal, string_literal,
+          unqualified_member_ref, bracketed(expression)
+        ].inject(:|)
+      end
+
+      rule(:qualified_member_ref) do
+        (
+          primary.as(:receiver) >>
+            (ws? >> str('.') >> ws? >> id).repeat(1).as(:member)
+        ).as(:qualified_member_ref) | primary
+      end
+
+      rule(:subscript_operation) do
+        (
+          qualified_member_ref.as(:receiver) >>
+            (
+              pure_ws? >> bracketed(expression, '[', ']') >>
+                (ws? >> str('=')).absent?
+            ).repeat(1).as(:key)
+        ).as(:subscript_operation) | qualified_member_ref
+      end
+
+      rule(:unary_operation) do
+        (
+          (str(:-) | str(:!)).as(:unary_operator) >>
+            ws? >> subscript_operation.as(:operand)
+        ) | subscript_operation
+      end
+
+      rule(:binary_operation) do
+        expression = unary_operation
+        operators = binary_operators
+        reducer = proc { |l, o, r| { binary_operator: o, l_operand: l, r_operand: r } }
+        infix_expression(expression, *operators, &reducer) | unary_operation
+      end
+
+      rule(:expression) do
+        binary_operation
+      end
+
+      private
+
+      def binary_operators
+        operators = {
+          '||': 1, '&&': 2,
+          '==': 3, '!=': 3,
+          '<': 4, '>': 4, '<=': 4, '>=': 4,
+          '+': 5, '-': 5,
+          '*': 6, '/': 6, '~/': 6, '%': 6,
+          '**': 7
+        }
+        operators
+          .sort_by { |op, _| op.length }.reverse
+          .map { |op, priority| binary_operator_element(op, priority) }
+      end
+
+      def binary_operator_element(operator, priority)
+        atom =
+          if operator == :-
+            pure_ws? >> str(operator) >> ws?
+          else
+            ws? >> str(operator) >> ws?
+          end
+        if operator == :**
+          [atom, priority, :right]
+        else
+          [atom, priority, :left]
+        end
+      end
+    end
+
+    define_transform do
+      rule(unqualified_member_ref: simple(:member)) do
+        Node::MemberReference.new(nil, member, member.position)
+      end
+
+      rule(
+        qualified_member_ref:
+          { receiver: simple(:receiver), member: sequence(:member) }
+      ) do
+        member.inject(receiver) do |r, m|
+          Node::MemberReference.new(r, m, r.position)
+        end
+      end
+
+      rule(
+        subscript_operation:
+          { receiver: simple(:receiver), key: sequence(:key) }
+      ) do
+        key.inject(receiver) do |r, k|
+          Node::SubscriptOperation.new(r, k, r.position)
+        end
+      end
+
+      rule(unary_operator: simple(:operator), operand: simple(:operand)) do
+        Node::UnaryOperation.new(operator.to_sym, operand, node_position(operator))
+      end
+
+      rule(
+        binary_operator: simple(:operator),
+        l_operand: simple(:l_operand), r_operand: simple(:r_operand)
+      ) do
+        Node::BinaryOperation.new(
+          operator.to_sym, l_operand, r_operand, l_operand.position
+        )
+      end
+    end
+  end
+end

data/lib/rupkl/parser/identifier.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    KEYWORDS = [
+      'abstract', 'amends', 'as', 'class', 'const', 'else', 'extends',
+      'external', 'false', 'fixed', 'for', 'function', 'hidden', 'if',
+      'import', 'import*', 'in', 'is', 'let', 'local', 'module', 'new',
+      'nothing', 'null', 'open', 'out', 'outer', 'read', 'read*', 'read?',
+      'super', 'this', 'throw', 'trace', 'true', 'typealias', 'unknown', 'when'
+    ].freeze
+
+    RESERVED_KEYWORDS = [
+      'protected', 'override', 'record', 'delete', 'case', 'switch', 'vararg'
+    ].freeze
+
+    define_parser do
+      [*KEYWORDS, *RESERVED_KEYWORDS].each do |kw|
+        rule(:"kw_#{kw}") do
+          str(kw) >> match('\\w').absent?
+        end
+      end
+
+      rule(:regular_identifier) do
+        (str('_') | str('$') | match('\p{XID_Start}')) >> match('\p{XID_Continue}').repeat
+      end
+
+      rule(:quoted_identifier) do
+        str('`') >> (str('`').absent? >> any).repeat(1) >> str('`')
+      end
+
+      rule(:id) do
+        regular_identifier.as(:regular_id) | quoted_identifier.as(:quoted_id)
+      end
+    end
+
+    define_transform do
+      rule(regular_id: simple(:id)) do
+        if keyword?(id)
+          message = "keyword '#{id}' is not allowed for identifier"
+          parse_error(message, node_position(id))
+        end
+
+        Node::Identifier.new(id.to_sym, node_position(id))
+      end
+
+      rule(quoted_id: simple(:id)) do
+        Node::Identifier.new(id.to_s[1..-2].to_sym, node_position(id))
+      end
+
+      private
+
+      def keyword?(id)
+        KEYWORDS.any?(id) || RESERVED_KEYWORDS.any?(id)
+      end
+    end
+  end
+end