chore: minor cleanup for clarity

Removed the one-line, one-use policy_default_init_flag method,
and changed the argument order of merge_policy to match the hash
merge (i.e. computed, explicit instead of the opposite)

Author: doudou

lib/syskit/network_generation/dataflow_dynamics.rb

@@ -553,13 +553,15 @@ def compute_connection_policies
                 policy_graph
             end
 
-            def merge_policy(explicit_policy, computed_policy)
-                merged_policy = computed_policy.merge(explicit_policy)
-
-                if merged_policy[:type] == :data
-                    merged_policy.delete(:size)
-                end
-
+            # Merges two connection policies
+            #
+            # @param [Hash] default_policy the policy that has the lowest
+            #   priority
+            # @param [Hash] explicit_policy the policy that has the highest
+            #   priority
+            def merge_policy(default_policy, explicit_policy)
+                merged_policy = default_policy.merge(explicit_policy)
+                merged_policy.delete(:size) if merged_policy[:type] == :data
                 merged_policy
             end
 
@@ -583,10 +585,6 @@ def compute_policies_from(connection_graph, source_task, policy_graph = {})
                 policy_graph
             end
 
-            def policy_default_init_flag(policy, model)
-                policy.merge(init: model.init_policy?)
-            end
-
             def policy_compute_data_element(
                 source_task, source_port_name, sink_task, sink_port_name, fallback_policy
             )
@@ -645,9 +643,9 @@ def policy_for(
                     end
 
                 model = source_task.find_output_port(source_port_name).model
-                computed_policy = policy_default_init_flag(computed_policy, model)
+                computed_policy[:init] = model.init_policy
 
-                merge_policy(explicit_policy, computed_policy)
+                merge_policy(computed_policy, explicit_policy)
             end
 
             def compute_reliable_connection_policy(

test/network_generation/test_dataflow_dynamics.rb

@@ -414,33 +414,33 @@ module NetworkGeneration
                 it "merges policies by preferring explicit values over " \
                    "computed values" do
                     explicit_policy = { type: :buffer, size: 20, init: true }
-                    computed_policy = { type: :buffer, size: 10, init: true }
+                    computed_policy = { type: :buffer, size: 10, init: false }
 
                     merged_policy =
-                        @dynamics.merge_policy(explicit_policy, computed_policy)
+                        @dynamics.merge_policy(computed_policy, explicit_policy)
 
                     assert_equal({ type: :buffer, size: 20, init: true }, merged_policy)
                 end
 
                 it "removes the size value when the type is set to :data" do
                     explicit_policy = { type: :data, init: true }
-                    computed_policy = { type: :buffer, size: 10, init: true }
+                    computed_policy = { type: :buffer, size: 10, init: false }
 
                     merged_policy =
-                        @dynamics.merge_policy(explicit_policy, computed_policy)
+                        @dynamics.merge_policy(computed_policy, explicit_policy)
 
                     assert_equal({ type: :data, init: true }, merged_policy)
                 end
 
                 it "falls back to computed values when explicit values " \
                    "are not provided" do
-                    explicit_policy = {}
+                    explicit_policy = { init: false }
                     computed_policy = { type: :buffer, size: 10, init: true }
 
                     merged_policy =
-                        @dynamics.merge_policy(explicit_policy, computed_policy)
+                        @dynamics.merge_policy(computed_policy, explicit_policy)
 
-                    assert_equal({ type: :buffer, size: 10, init: true }, merged_policy)
+                    assert_equal({ type: :buffer, size: 10, init: false }, merged_policy)
                 end
             end
 
@@ -506,31 +506,6 @@ module NetworkGeneration
                 end
             end
 
-            describe "#policy_default_init_flag" do
-                before do
-                    @task_m = Syskit::TaskContext.new_submodel do
-                        input_port "in", "/double"
-                        output_port "out", "/double"
-                    end
-                    @source_task_m = @task_m.new_submodel
-                    @sink_task_m = @task_m.new_submodel
-                    plan.add(@source_t = @source_task_m.new)
-                    plan.add(@sink_t = @sink_task_m.new)
-                end
-
-                it "merges the init flag from the source port's model" do
-                    flexmock(@source_t.out_port.model)
-                        .should_receive(:init_policy?).explicitly
-                        .and_return(true)
-
-                    policy = { type: :data }
-                    updated_policy = @dynamics.policy_default_init_flag(
-                        policy, @source_t.out_port.model
-                    )
-                    assert updated_policy[:init]
-                end
-            end
-
             describe "#policy_for" do
                 before do
                     @task_m = Syskit::TaskContext.new_submodel do
@@ -588,71 +563,34 @@ module NetworkGeneration
                 it "returns the value from compute_reliable_connection_policy if " \
                    "the sink port is marked as needs_reliable_connection" do
                     @sink_task_m.in_port.needs_reliable_connection
-                    fallback_policy = flexmock
-                    connection_policy = flexmock
-                    computed_policy = flexmock
-                    merged_policy = flexmock
-
-                    flexmock(@dynamics)
-                        .should_receive(:merge_policy)
-                        .with({}, computed_policy)
-                        .and_return(merged_policy)
-
-                    flexmock(@dynamics)
-                        .should_receive(:policy_default_init_flag)
-                        .with(connection_policy, @source_t.out_port.model)
-                        .once.and_return(computed_policy)
-
                     flexmock(@dynamics)
                         .should_receive(:compute_reliable_connection_policy)
-                        .with(@source_t.out_port, @sink_t.in_port, fallback_policy)
-                        .once.and_return(connection_policy)
+                        .with(@source_t.out_port, @sink_t.in_port, { stage: "fallback" })
+                        .once.and_return({ stage: "reliable" })
 
                     policy = @dynamics.policy_for(
-                        @source_t, "out", "in", @sink_t, fallback_policy
+                        @source_t, "out", "in", @sink_t, { stage: "fallback" }
                     )
-                    assert_equal merged_policy, policy
+                    assert_equal({ stage: "reliable", init: nil }, policy)
                 end
 
-                it "merges init policy when sink requires reliable connection" do
-                    @sink_task_m.in_port.needs_reliable_connection
-                    @source_t.out_port.model.init_policy(true)
-                    fallback_policy = flexmock
-
-                    flexmock(@dynamics)
-                        .should_receive(:compute_reliable_connection_policy)
-                        .with(@source_t.out_port, @sink_t.in_port, fallback_policy)
-                        .once.and_return({})
-
-                    policy = @dynamics.policy_for(
-                        @source_t, "out", "in", @sink_t, fallback_policy
-                    )
-
-                    assert policy[:init]
-                end
-
-                it "merges init policy when sink requires 'buffer' connection type" do
-                    @sink_task_m.in_port.needs_buffered_connection
-
+                it "uses the init flag from the source port's model by default" do
                     flexmock(@source_t.out_port.model)
                         .should_receive(:init_policy?).explicitly
                         .and_return(true)
 
-                    @source_t.out_port.model.init_policy(true)
-                    policy = @dynamics.policy_for(@source_t, "out", "in", @sink_t, nil)
-
+                    policy = @dynamics.policy_for(
+                        @source_t, "out", "in", @sink_t, nil
+                    )
                     assert policy[:init]
                 end
 
-                it "always applies the init flag from the source port's model" do
-                    flexmock(@source_t.out_port.model)
-                        .should_receive(:init_policy?).explicitly
-                        .and_return(true)
-
+                it "uses the explicitly given init flag over the one from the port model" do
+                    @source_t.out_port.model.init_policy(true)
                     policy = @dynamics.policy_for(
-                        @source_t, "out", "in", @sink_t, nil
+                        @source_t, "out", "in", @sink_t, {}, { init: false }
                     )
-                    assert policy[:init]
+                    refute policy[:init]
                 end
             end