rupkl 0.1.0 → 0.3.0

data/lib/rupkl/node/identifier.rb

@@ -3,17 +3,31 @@
 module RuPkl
   module Node
     class Identifier
-      def initialize(id, position)
+      include NodeCommon
+
+      def initialize(parent, id, position)
+        super(parent, position)
         @id = id
-        @position = position
+      end
+
+      attr_reader :id
+
+      def copy(parent = nil, position = @position)
+        self.class.new(parent, id, position)
       end
 
       def ==(other)
-        other.instance_of?(self.class) && id == other.id
+        id ==
+          if other.respond_to?(:id)
+            other.id
+          else
+            other
+          end
       end
 
-      attr_reader :id
-      attr_reader :position
+      def to_sym
+        id.to_sym
+      end
     end
   end
 end

data/lib/rupkl/node/if_expression.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class IfExpression
+      include NodeCommon
+
+      def condition
+        @children[0]
+      end
+
+      def if_expression
+        @children[1]
+      end
+
+      def else_expression
+        @children[2]
+      end
+
+      def evaluate(context = nil)
+        resolve_structure(context).evaluate(context)
+      end
+
+      def resolve_structure(context = nil)
+        @result ||=
+          if evaluate_condition(context)
+            if_expression
+          else
+            else_expression
+          end
+        @result.resolve_structure(context)
+      end
+
+      private
+
+      def evaluate_condition(context)
+        evaluated = condition.evaluate(context)
+        return evaluated.value if evaluated.is_a?(Boolean)
+
+        message = "expected type 'Boolean', but got type '#{evaluated.class_name}'"
+        raise EvaluationError.new(message, position)
+      end
+    end
+  end
+end

data/lib/rupkl/node/intseq.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class IntSeq < Any
+      include Operatable
+
+      uninstantiable_class
+
+      def initialize(parent, start, last, step, position)
+        super(parent, *[start, last, step].compact, position)
+      end
+
+      def start
+        children[0]
+      end
+
+      def last
+        children[1]
+      end
+
+      alias_method :end, :last
+
+      def step
+        children[2]
+      end
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(_context = nil)
+        to_array(self)
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        start_value, last_value, step_value = children.map { _1.to_pkl_string(context) }
+        if step && step.value != 1
+          "IntSeq(#{start_value}, #{last_value}).step(#{step_value})"
+        else
+          "IntSeq(#{start_value}, #{last_value})"
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          to_array(self) == to_array(other)
+      end
+
+      define_builtin_property(:start) do
+        Int.new(self, start.value, position)
+      end
+
+      define_builtin_property(:end) do
+        Int.new(self, last.value, position)
+      end
+
+      define_builtin_property(:step) do
+        Int.new(self, step&.value || 1, position)
+      end
+
+      define_builtin_method(:step, step: Int) do |args, parent, position|
+        step = args[:step]
+        if step.value.zero?
+          message = "expected a non zero number, but got '#{step.value}'"
+          raise EvaluationError.new(message, position)
+        end
+
+        IntSeq.new(parent, start, last, step, position)
+      end
+
+      private
+
+      def to_array(intseq)
+        start_value, last_value, step_value = intseq.children.map(&:value)
+        Range.new(start_value, last_value).step(step_value || 1).to_a
+      end
+    end
+  end
+end

data/lib/rupkl/node/listing.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Listing < Any
+      include Operatable
+      include StructCommon
+
+      def elements
+        @body&.elements
+      end
+
+      def to_ruby(context = nil)
+        to_ruby_object(context) do |_properties, _entries, elements|
+          replace_self_array(elements, elements) || []
+        end
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) &&
+          match_members?(elements, other.elements, true)
+      end
+
+      def find_by_key(key)
+        find_element(key)&.value
+      end
+
+      define_builtin_property(:isEmpty) do
+        result = elements.nil? || elements.empty?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:length) do
+        result = elements&.size || 0
+        Int.new(self, result, position)
+      end
+
+      define_builtin_property(:isDistinct) do
+        result =
+          elements.nil? ||
+          elements.all? { |lhs| elements.one? { |rhs| rhs == lhs } }
+        Boolean.new(self, result || elements.nil?, position)
+      end
+
+      define_builtin_property(:distinct) do
+        result =
+          elements
+            &.each_with_object([]) { |e, l| l << e unless l.include?(e) }
+        body = ObjectBody.new(nil, result, position)
+        Listing.new(self, body, position)
+      end
+
+      define_builtin_method(:join, separator: String) do |args, parent, position|
+        result =
+          elements
+            &.map { _1.value.to_string }
+            &.join(args[:separator].value)
+        String.new(parent, result || '', nil, position)
+      end
+
+      private
+
+      def elements_not_allowed?
+        false
+      end
+    end
+  end
+end

data/lib/rupkl/node/map.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Map < Any
+      MapEntry = Struct.new(:key, :value) do
+        def match_key?(other_key)
+          key == other_key
+        end
+      end
+
+      include Operatable
+      include MemberFinder
+      undef_method :pkl_method
+
+      uninstantiable_class
+
+      def initialize(parent, entries, position)
+        @entries = compose_entries(entries, position)
+        super(parent, *@entries&.flat_map(&:to_a), position)
+      end
+
+      attr_reader :entries
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(context = nil)
+        entries&.to_h { |e| e.map { _1.to_ruby(context) } } || {}
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        entry_string =
+          entries
+            &.flat_map { |entry| entry.map { _1.to_pkl_string(context) } }
+            &.join(', ')
+        "Map(#{entry_string})"
+      end
+
+      def b_op_add(r_operand, position)
+        result =
+          if entries && r_operand.entries
+            entries + r_operand.entries
+          else
+            entries || r_operand.entries
+          end
+        self.class.new(nil, result&.flat_map(&:to_a), position)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        return false unless entries&.size == other.entries&.size
+        return true unless entries
+
+        entries
+          .all? { |entry| entry.value == other.find_by_key(entry.key) }
+      end
+
+      def find_by_key(key)
+        find_entry(key)&.value
+      end
+
+      define_builtin_property(:isEmpty) do
+        result = entries.nil? || entries.empty?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:length) do
+        result = entries&.length || 0
+        Int.new(self, result, position)
+      end
+
+      define_builtin_property(:keys) do
+        keys = entries&.map(&:key)
+        Set.new(self, keys, position)
+      end
+
+      define_builtin_property(:values) do
+        values = entries&.map(&:value)
+        List.new(self, values, position)
+      end
+
+      define_builtin_property(:entries) do
+        key_value_pairs =
+          entries&.map { |e| Pair.new(nil, e.key, e.value, position) }
+        List.new(self, key_value_pairs, position)
+      end
+
+      private
+
+      def compose_entries(entries, position)
+        return if entries.nil? || entries.empty?
+
+        check_arity(entries, position)
+        entries.each_slice(2)&.with_object([]) do |(k, v), result|
+          index =
+            result.find_index { _1.match_key?(k) } ||
+            result.size
+          result[index] = MapEntry.new(k, v)
+        end
+      end
+
+      def check_arity(entries, position)
+        return if ((entries&.size || 0) % 2).zero?
+
+        m = 'number of arguments must be a multiple of two'
+        raise EvaluationError.new(m, position)
+      end
+
+      def defined_operator?(operator)
+        [:[], :+].any?(operator)
+      end
+    end
+  end
+end

data/lib/rupkl/node/mapping.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Mapping < Any
+      include Operatable
+      include StructCommon
+
+      def entries
+        @body&.entries
+      end
+
+      def to_ruby(context = nil)
+        to_ruby_object(context) do |_properties, entries, _elements|
+          replace_self_hash(entries, entries) || {}
+        end
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) &&
+          match_members?(entries, other.entries, false)
+      end
+
+      def find_by_key(key)
+        find_entry(key)&.value
+      end
+
+      define_builtin_property(:isEmpty) do
+        result = entries.nil? || entries.empty?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:length) do
+        result = entries&.size || 0
+        Int.new(self, result, position)
+      end
+
+      define_builtin_method(:containsKey, key: Any) do |args, parent, position|
+        result = find_entry(args[:key]) && true || false
+        Boolean.new(parent, result, position)
+      end
+
+      define_builtin_method(:getOrNull, key: Any) do |args, parent, position|
+        find_entry(args[:key])&.value || Null.new(parent, position)
+      end
+
+      private
+
+      def entries_not_allowed?
+        false
+      end
+    end
+  end
+end

data/lib/rupkl/node/member_finder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module MemberFinder
+      def property(name)
+        value = find_property(name)&.value
+        return value if value
+
+        super if self.class <= Any
+      end
+
+      def pkl_method(name)
+        method = find_pkl_method(name)
+        return method if method
+
+        super if self.class <= Any
+      end
+
+      private
+
+      def find_property(name)
+        return unless respond_to?(:properties)
+
+        properties&.find { _1.name == name }
+      end
+
+      def find_entry(key)
+        return unless respond_to?(:entries)
+
+        entries&.find { _1.key == key }
+      end
+
+      def find_element(index)
+        return unless respond_to?(:elements)
+        return unless elements
+        return unless index.value.is_a?(::Integer)
+
+        elements.find.with_index { |_, i| i == index.value }
+      end
+
+      def find_pkl_method(name)
+        return unless respond_to?(:pkl_methods)
+
+        pkl_methods&.find { _1.name == name }
+      end
+    end
+  end
+end

data/lib/rupkl/node/member_reference.rb

@@ -3,43 +3,68 @@
 module RuPkl
   module Node
     class MemberReference
-      def initialize(receiver, member, position)
+      include NodeCommon
+      include ReferenceResolver
+
+      def initialize(parent, receiver, member, nullable, position)
+        super(parent, receiver, member, position)
         @receiver = receiver
         @member = member
-        @position = position
+        @nullable = nullable
       end
 
       attr_reader :receiver
       attr_reader :member
-      attr_reader :position
 
-      def evaluate(scopes)
-        member_node =
-          if receiver
-            find_member([receiver.evaluate(scopes)])
-          else
-            find_member(scopes)
-          end
-        member_node.evaluate(scopes).value
+      def nullable?
+        @nullable
       end
 
-      def to_string(scopes)
-        evaluate(scopes).to_string(nil)
+      def evaluate(context = nil)
+        do_evaluate do
+          result = resolve_member_reference(context, member, receiver, nullable?)
+          result.evaluate
+        end
       end
 
-      def to_pkl_string(scopes)
-        evaluate(scopes).to_pkl_string(nil)
+      def resolve_reference(context = nil)
+        do_evaluate do
+          result = resolve_member_reference(context, member, receiver, nullable?)
+          result.resolve_reference
+        end
+      end
+
+      def copy(parent = nil, position = @position)
+        self
+          .class.new(parent, receiver&.copy, member&.copy, nullable?, position)
+          .tap { copy_scope_index(_1) }
       end
 
       private
 
-      def find_member(scopes)
-        scopes.reverse_each do |scope|
-          node = scope&.properties&.find { _1.name.id == member.id }
-          return node if node
-        end
+      def do_evaluate
+        @evaluating &&
+          (raise EvaluationError.new('circular reference is detected', position))
+
+        @evaluating = true
+        result = yield
+        @evaluating = false
+
+        result
+      end
+
+      def ifnone_value(receiver)
+        receiver
+      end
+
+      def get_member_node(scope, target)
+        return unless scope.respond_to?(:property)
+
+        scope.property(target)
+      end
 
-        raise EvaluationError.new("cannot find property '#{member.id}'", position)
+      def unresolve_reference_error(target)
+        EvaluationError.new("cannot find property '#{target.id}'", position)
       end
     end
   end

data/lib/rupkl/node/method_call.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class MethodCall
+      include NodeCommon
+      include ReferenceResolver
+
+      def initialize(parent, receiver, method_name, arguments, nullable, position)
+        super(parent, receiver, method_name, *arguments, position)
+        @receiver = receiver
+        @method_name = method_name
+        @arguments = arguments
+        @nullable = nullable
+      end
+
+      attr_reader :receiver
+      attr_reader :method_name
+      attr_reader :arguments
+
+      def nullable?
+        @nullable
+      end
+
+      def evaluate(context = nil)
+        exec_on(context) do |c|
+          r = evaluate_receiver(receiver, c)
+          m = resolve_member_reference(c, method_name, r, nullable?)
+          m && execute_method(m, r, c) || r
+        end
+      end
+
+      def copy(parent = nil, position = @position)
+        copied_args = arguments&.map(&:copy)
+        self.class
+          .new(parent, receiver&.copy, method_name, copied_args, nullable?, position)
+          .tap { copy_scope_index(_1) }
+      end
+
+      private
+
+      def ifnone_value(_)
+        nil
+      end
+
+      def get_member_node(scope, target)
+        return unless scope.respond_to?(:pkl_method)
+
+        scope.pkl_method(target)
+      end
+
+      def unresolve_reference_error(target)
+        m = "cannot find method '#{target.id}'"
+        raise EvaluationError.new(m, position)
+      end
+
+      def execute_method(pkl_method, receiver, context)
+        pkl_method
+          .call(receiver, arguments, context, parent, position)
+      end
+    end
+  end
+end