rupkl 0.2.0 → 0.3.0

data/lib/rupkl/node/object.rb

@@ -21,30 +21,30 @@ module RuPkl
 
       attr_writer :visibility
 
+      def generated?
+        @generated
+      end
+
+      attr_writer :generated
+
       private
 
       def evaluate_value(evaluator, context)
         @value_evaluated = value.__send__(evaluator, context)
         value
       end
-
-      def copy_value
-        if @value_evaluated.respond_to?(:body)
-          @value_evaluated.copy
-        else
-          @value.copy
-        end
-      end
     end
 
     class ObjectProperty < ObjectMember
-      def initialize(parent, name, value, position)
-        super
+      def initialize(parent, name, value, modifiers, position)
+        super(parent, name, value, position)
         @name = name
         @value = value
+        @modifiers = modifiers
       end
 
       attr_reader :name
+      attr_reader :modifiers
 
       def evaluate(context = nil)
         evaluate_value(__method__, context)
@@ -71,11 +71,19 @@ module RuPkl
       end
 
       def ==(other)
-        name.id == other.name.id && value == other.value
+        name == other.name && value == other.value
       end
 
-      def copy(parent = nil)
-        self.class.new(parent, name.copy, copy_value, position)
+      def copy(parent = nil, position = @position)
+        self.class.new(parent, name.copy, value.copy, modifiers, position)
+      end
+
+      def local?
+        @modifiers&.[](:local) || false
+      end
+
+      def coexistable?(other)
+        name != other.name || local? != other.local? && !parent.equal?(other.parent)
       end
 
       private
@@ -128,8 +136,12 @@ module RuPkl
         key == other.key && value == other.value
       end
 
-      def copy(parent = nil)
-        self.class.new(parent, key, copy_value, position)
+      def copy(parent = nil, position = @position)
+        self.class.new(parent, key, value.copy, position)
+      end
+
+      def coexistable?(other)
+        key != other.key
       end
 
       private
@@ -175,8 +187,8 @@ module RuPkl
         value == other.value
       end
 
-      def copy(parent = nil)
-        self.class.new(parent, copy_value, position)
+      def copy(parent = nil, position = @position)
+        self.class.new(parent, value.copy, position)
       end
 
       private
@@ -186,39 +198,261 @@ module RuPkl
       end
     end
 
+    class WhenGenerator
+      include NodeCommon
+
+      def initialize(parent, condition, when_body, else_body, result, position)
+        super
+        @condition = condition
+        @when_body = when_body
+        @else_body = else_body
+        @result = result if result
+      end
+
+      attr_reader :condition
+      attr_reader :when_body
+      attr_reader :else_body
+
+      def resolve_generator(context = nil)
+        unless instance_variable_defined?(:@result)
+          @result =
+            if evaluate_condition(context)
+              when_body.resolve_generator(context)
+            else
+              else_body&.resolve_generator(context)
+            end
+        end
+
+        self
+      end
+
+      def copy(parent = nil, position = @position)
+        if result
+          self.class.new(parent, nil, nil, nil, result.copy, position)
+        else
+          copies = [condition, when_body, else_body].map { _1&.copy }
+          self.class.new(parent, *copies, nil, position)
+        end
+      end
+
+      def collect_members(klass)
+        result&.collect_members(klass)
+      end
+
+      private
+
+      attr_reader :result
+
+      def evaluate_condition(context)
+        result =
+          (context || current_context.pop).then do |c|
+            condition.evaluate(c)
+          end
+        return result.value if result.is_a?(Boolean)
+
+        message =
+          'expected type \'Boolean\', ' \
+          "but got type '#{result.class_name}'"
+        raise EvaluationError.new(message, position)
+      end
+    end
+
+    class ForGenerator
+      include NodeCommon
+
+      def initialize(parent, key_name, value_name, iterable, body, results, position)
+        super(parent, key_name, value_name, iterable, body, *results, position)
+        @key_name = key_name
+        @value_name = value_name
+        @iterable = iterable
+        @body = body
+        @results = results&.map { _1.items.last }
+      end
+
+      attr_reader :key_name
+      attr_reader :value_name
+      attr_reader :iterable
+      attr_reader :body
+
+      def resolve_generator(context = nil)
+        @results ||= iterate_body(context)
+        self
+      end
+
+      def copy(parent = nil, position = @position)
+        if results
+          self.class.new(parent, key_name, value_name, nil, nil, copy_result, position)
+        else
+          copies = [iterable, body].map { _1&.copy }
+          self.class.new(parent, key_name, value_name, *copies, nil, position)
+        end
+      end
+
+      def collect_members(klass)
+        results
+          &.flat_map { collect_members_from_body(_1, klass) }
+          &.compact
+      end
+
+      private
+
+      attr_reader :results
+
+      def copy_result
+        results.map { _1.parent.copy }
+      end
+
+      ITERATION_METHODS = {
+        IntSeq => :iterate_intseq,
+        List => :iterate_collection,
+        Set => :iterate_collection,
+        Map => :iterate_map,
+        Listing => :iterate_listing,
+        Mapping => :iterate_mapping,
+        Dynamic => :iterate_dynamic
+      }.freeze
+
+      def iterate_body(context)
+        iterable_object = evaluate_iterable(context)
+        if (method = ITERATION_METHODS[iterable_object.class])
+          __send__(method, iterable_object)&.map do |(k, v)|
+            resolve_body(k, v)
+          end
+        else
+          message =
+            "cannot iterate over value of type '#{iterable_object.class_name}'"
+          raise EvaluationError.new(message, position)
+        end
+      end
+
+      def evaluate_iterable(context)
+        (context || current_context.pop).then do |c|
+          iterable.evaluate(c)
+        end
+      end
+
+      def iterate_intseq(intseq)
+        intseq.to_ruby.map.with_index do |v, i|
+          [Int.new(nil, i, nil), Int.new(nil, v, nil)]
+        end
+      end
+
+      def iterate_collection(collection)
+        collection.elements.map.with_index do |e, i|
+          [Int.new(nil, i, nil), e]
+        end
+      end
+
+      def iterate_map(map)
+        map.entries.map do |e|
+          [e.key, e.value]
+        end
+      end
+
+      def iterate_listing(listing)
+        listing.elements&.map&.with_index do |e, i|
+          [Int.new(nil, i, nil), e.value]
+        end
+      end
+
+      def iterate_mapping(mapping)
+        mapping.entries&.map do |e|
+          [e.key, e.value]
+        end
+      end
+
+      def iterate_properties(dynamic)
+        dynamic.properties&.map do |p|
+          [String.new(nil, p.name.id.to_s, nil, nil), p.value]
+        end
+      end
+
+      def iterate_dynamic(dynamic)
+        [
+          *iterate_properties(dynamic),
+          *iterate_mapping(dynamic),
+          *iterate_listing(dynamic)
+        ]
+      end
+
+      def resolve_body(key, value)
+        env = create_evaluation_env(key, value)
+        body
+          .copy(env)
+          .tap { _1.resolve_generator(_1.current_context) }
+      end
+
+      def create_evaluation_env(key, value)
+        iterators = []
+        iterators << create_iterator(key_name, key) if key_name
+        iterators << create_iterator(value_name, value)
+        ObjectBody.new(self, iterators, position)
+      end
+
+      def create_iterator(name, value)
+        ObjectProperty.new(nil, name, value, { local: true }, name.position)
+      end
+
+      def collect_members_from_body(body, klass)
+        body
+          .collect_members(klass)
+          &.tap { |members| check_no_properties(members, klass) }
+      end
+
+      def check_no_properties(members, klass)
+        return if members.empty? || klass != ObjectProperty
+
+        message = 'cannot generate object properties'
+        raise EvaluationError.new(message, position)
+      end
+    end
+
     class ObjectBody
       include NodeCommon
       include MemberFinder
 
-      def initialize(parent, members, position)
-        super(parent, position)
-        members&.each { add_member(_1) }
+      def initialize(parent, items, position)
+        super(parent, *items, position)
       end
 
-      attr_reader :entries
-      attr_reader :elements
-      attr_reader :pkl_methods
       attr_reader :pkl_classes
 
-      def properties(visibility: :lexical)
-        if visibility == :lexical
+      alias_method :items, :children
+
+      def properties(visibility: :lexical, all: false)
+        @properties ||= collect_members(ObjectProperty)
+
+        if all
           @properties
-            &.select { _1.visibility == :lexical || _1.parent.equal?(self) }
+        elsif visibility == :lexical
+          @properties&.select { _1.visibility == :lexical || _1.parent.equal?(self) }
         else
-          @properties
+          @properties&.select { !_1.local? }
         end
       end
 
-      def fields
-        [*properties, *entries, *elements]
+      def entries
+        @entries ||= collect_members(ObjectEntry)
+      end
+
+      def elements
+        @elements ||= collect_members(ObjectElement)
+      end
+
+      def pkl_methods
+        @pkl_methods ||= collect_members(MethodDefinition)
+      end
+
+      def fields(visibility: :lexical)
+        [*properties(visibility: visibility), *entries, *elements]
       end
 
       def definitions
         [*pkl_methods, *pkl_classes]
       end
 
-      def members
-        [*fields, *definitions]
+      def members(visibility: :lexical)
+        [*fields(visibility: visibility), *definitions]
       end
 
       def evaluate(context = nil)
@@ -226,11 +460,12 @@ module RuPkl
       end
 
       def resolve_structure(context = nil)
+        resolve_generator(context)
         do_evaluation(__method__, context)
       end
 
-      def copy(parent = nil)
-        copied_members = members.map(&:copy)
+      def copy(parent = nil, position = @position)
+        copied_members = items&.map(&:copy)
         self.class.new(parent, copied_members, position)
       end
 
@@ -238,6 +473,17 @@ module RuPkl
         super&.push_scope(self)
       end
 
+      def resolve_generator(context = nil)
+        generators&.each { _1.resolve_generator(context) }
+        self
+      end
+
+      def collect_members(klass)
+        items
+          &.each_with_object([], &member_collector(klass))
+          &.then { !_1.empty? && _1 || nil }
+      end
+
       def merge!(*others)
         others.each { do_merge(_1) }
         self
@@ -245,58 +491,68 @@ module RuPkl
 
       private
 
-      def add_member(member)
-        add_child(member)
+      GENERATOR_CLASSES = [
+        WhenGenerator,
+        ForGenerator
+      ].freeze
 
-        varialbe_name = member_variable_name(member)
-        unless instance_variable_defined?(varialbe_name)
-          instance_variable_set(varialbe_name, [])
-        end
-        instance_variable_get(varialbe_name) << member
+      def generator?(item)
+        GENERATOR_CLASSES.any? { item.is_a?(_1) }
       end
 
-      def member_variable_name(member)
-        {
-          ObjectProperty => :@properties,
-          ObjectEntry => :@entries,
-          ObjectElement => :@elements,
-          MethodDefinition => :@pkl_methods
-        }[member.class]
+      def generators
+        items&.select { generator?(_1) }
       end
 
       def do_evaluation(evaluator, context)
         (context&.push_scope(self) || current_context).then do |c|
-          fields.each { |f| f.__send__(evaluator, c) }
+          fields&.each do |field|
+            if field.generated?
+              field.__send__(evaluator)
+            else
+              field.__send__(evaluator, c)
+            end
+          end
           check_duplication
           self
         end
       end
 
       def check_duplication
-        check_duplication_members(@properties, :name)
-        check_duplication_members(@entries, :key)
-        check_duplication_members(@pkl_methods, :name)
+        check_duplication_members(properties(all: true))
+        check_duplication_members(entries)
+        check_duplication_members(pkl_methods)
       end
 
-      def check_duplication_members(members, accessor)
+      def check_duplication_members(members)
         members&.each do |member|
-          duplicate_member?(members, member, accessor) &&
+          duplicate_member?(members, member) &&
             (raise EvaluationError.new('duplicate definition of member', member.position))
         end
       end
 
-      def duplicate_member?(members, member, accessor)
-        count =
-          members
-            .count { _1.__send__(accessor) == member.__send__(accessor) }
+      def duplicate_member?(members, member)
+        count = members.count { !_1.coexistable?(member) }
         count > 1
       end
 
+      def member_collector(klass)
+        proc do |item, members|
+          if generator?(item)
+            items = item.collect_members(klass)
+            items && members.concat(items.each { _1.generated = true })
+          elsif item.is_a?(klass)
+            members << item
+          end
+        end
+      end
+
       def do_merge(rhs)
+        rhs_properties = rhs.properties(visibility: :object)
         rhs_entries, rhs_amend = split_entries(rhs.entries)
-        @properties = merge_hash_members(@properties, rhs.properties, :name)
-        @entries = merge_hash_members(@entries, rhs_entries, :key)
-        @elements = merge_array_members(@elements, rhs.elements, rhs_amend, :key)
+        @properties = merge_hash_members(properties(all: true), rhs_properties)
+        @entries = merge_hash_members(entries, rhs_entries)
+        @elements = merge_array_members(elements, rhs.elements, rhs_amend, :key)
       end
 
       def split_entries(entries)
@@ -313,12 +569,12 @@ module RuPkl
         node.instance_of?(Node::Int) && node.value < elements_size
       end
 
-      def merge_hash_members(lhs, rhs, accessor)
+      def merge_hash_members(lhs, rhs)
         return nil unless lhs || rhs
         return rhs unless lhs
 
         rhs&.each do |r|
-          if (index = find_member_index(lhs, r, accessor))
+          if (index = find_member_index(lhs, r))
             lhs[index] = merge_hash_value(lhs[index], r)
           else
             r.visibility = :object
@@ -331,15 +587,15 @@ module RuPkl
 
       def merge_hash_value(lhs, rhs)
         if [lhs.value, rhs.value].all? { _1.respond_to?(:body) }
-          lhs.value.merge!(rhs.value)
+          lhs.value.merge!(rhs.value.body)
           lhs
         else
           rhs
         end
       end
 
-      def find_member_index(lhs, rhs, accessor)
-        lhs.find_index { _1.__send__(accessor) == rhs.__send__(accessor) }
+      def find_member_index(lhs, rhs)
+        lhs.find_index { !_1.coexistable?(rhs) }
       end
 
       def merge_array_members(lhs_array, rhs_array, rhs_hash, accessor)
@@ -398,7 +654,7 @@ module RuPkl
         true
       end
 
-      def copy(parent = nil)
+      def copy(parent = nil, position = @position)
         self.class.new(parent, type, bodies, position)
       end