Run formatter

Author: gpeairs

src/paths/channels.jl

@@ -14,34 +14,61 @@ function RouteChannel(pa::Path{T}, capacity=0) where {T}
 end
 
 # Return a node corresponding to the section of the channel that the segment actually runs through
-function segment_channel_section(ch::RouteChannel{T}, wireseg_start, wireseg_stop, prev_width, next_width; margin=zero(T)) where {T}
+function segment_channel_section(
+    ch::RouteChannel{T},
+    wireseg_start,
+    wireseg_stop,
+    prev_width,
+    next_width;
+    margin=zero(T)
+) where {T}
     d = wireseg_stop - wireseg_start
     # Adjust for margins and track vs channel direction to get the channel node section used by actual segment
-    if abs(d) <= 2*margin + prev_width + next_width
+    if abs(d) <= 2 * margin + prev_width + next_width
         # handle case where margin consumes entire segment
         # Just have a zero length Straight at the midpoint
-        track_mid = (wireseg_start + wireseg_stop)/2
+        track_mid = (wireseg_start + wireseg_stop) / 2
         midpoint = ch.node.seg(track_mid)
         middir = direction(ch.node.seg, track_mid)
-        channel_section = Node(Straight(zero(T), midpoint, middir), SimpleTrace(width(ch.node.sty, track_mid)))
+        channel_section = Node(
+            Straight(zero(T), midpoint, middir),
+            SimpleTrace(width(ch.node.sty, track_mid))
+        )
     elseif d > zero(d) # segment is along channel direction
-        channel_section = split(ch.node,
-            [wireseg_start + margin + prev_width/2,
-             wireseg_stop - margin - next_width/2])[2]
+        channel_section = split(
+            ch.node,
+            [
+                wireseg_start + margin + prev_width / 2,
+                wireseg_stop - margin - next_width / 2
+            ]
+        )[2]
     elseif d < zero(d) # segment is counter to channel direction
-        channel_section = reverse(split(ch.node,
-            [wireseg_stop + margin + next_width/2,
-             wireseg_start - margin - prev_width/2])[2])
+        channel_section = reverse(
+            split(
+                ch.node,
+                [
+                    wireseg_stop + margin + next_width / 2,
+                    wireseg_start - margin - prev_width / 2
+                ]
+            )[2]
+        )
     end
     return channel_section
 end
 
 function track_path_segment(n_tracks, channel_section, track_idx; reversed=false)
-    return offset(channel_section.seg,
-        track_section_offset(n_tracks, width(channel_section.sty), track_idx; reversed))
+    return offset(
+        channel_section.seg,
+        track_section_offset(n_tracks, width(channel_section.sty), track_idx; reversed)
+    )
 end
 
-function track_section_offset(n_tracks, section_width::Coordinate, track_idx; reversed=false)
+function track_section_offset(
+    n_tracks,
+    section_width::Coordinate,
+    track_idx;
+    reversed=false
+)
     # (spacing) * number of tracks away from middle track
     sgn = reversed ? -1 : 1
     spacing = section_width / (n_tracks + 1)
@@ -50,7 +77,10 @@ end
 
 function track_section_offset(n_tracks, section_width::Function, track_idx; reversed=false)
     # (spacing) * number of tracks away from middle track
-    return t -> (reversed ? -1 : 1) * (section_width(t) / (n_tracks + 1)) * (track_idx - (1 + n_tracks) / 2)
+    return t ->
+        (reversed ? -1 : 1) *
+        (section_width(t) / (n_tracks + 1)) *
+        (track_idx - (1 + n_tracks) / 2)
 end
 
 reverse(n::Node) = Paths.Node(reverse(n.seg), reverse(n.sty, pathlength(n.seg)))
@@ -67,7 +97,7 @@ function reverse(b::BSpline{T}) where {T}
     p1 = b.p0
     r = Interpolations.scale(
         interpolate(p, Interpolations.BSpline(Cubic(NeumannBC(t0, t1)))),
-        range(1-tmax, stop=1-tmin, length=length(p))
+        range(1 - tmax, stop=1 - tmin, length=length(p))
     )
     α0 = rotated_direction(b.α1, RotationPi())
     α1 = rotated_direction(b.α0, RotationPi())
@@ -80,23 +110,35 @@ reverse(s::TaperTrace{T}, l) where {T} = TaperTrace{T}(s.width_end, s.width_star
 reverse(s::SimpleTrace, l) = s
 reverse(s::GeneralTrace, l) = GeneralTrace(t -> width(s, l - t))
 # Define methods for CPW even though they're not allowed for channels
-reverse(s::TaperCPW{T}, l) where {T} = TaperCPW{T}(s.trace_end, s.gap_end, s.trace_start, s.gap_start, s.length)
+reverse(s::TaperCPW{T}, l) where {T} =
+    TaperCPW{T}(s.trace_end, s.gap_end, s.trace_start, s.gap_start, s.length)
 reverse(s::SimpleCPW, l) = s
 reverse(s::GeneralCPW, l) = GeneralCPW(t -> trace(s, l - t), t -> gap(s, l - t))
 # For compound segments, reverse the individual sections and reverse their order
 # Keep the same tag so if a compound segment/style pair matched before they will still match
 reverse(s::CompoundSegment) = CompoundSegment(reverse(reverse.(s.segments)), s.tag)
 function reverse(s::CompoundStyle{T}, l) where {T}
     lengths = reverse(diff(s.tgrid))
-    CompoundStyle{T}(reverse(reverse.(s.styles, lengths)), cumsum(reverse(lengths)), s.tag)
+    return CompoundStyle{T}(
+        reverse(reverse.(s.styles, lengths)),
+        cumsum(reverse(lengths)),
+        s.tag
+    )
 end
 
 abstract type AbstractMultiRouting <: RouteRule end
 
 abstract type AbstractChannelRouting <: AbstractMultiRouting end
 
-function _route!(p::Path{T}, p1::Point, α1, rule::AbstractChannelRouting, 
-                    sty, waypoints, waydirs) where {T}
+function _route!(
+    p::Path{T},
+    p1::Point,
+    α1,
+    rule::AbstractChannelRouting,
+    sty,
+    waypoints,
+    waydirs
+) where {T}
     # Track segments for each channel
     track_path_segs = track_path_segments(rule, p, p1)
     waypoints = Point{T}[] # Segments too short for margins will just become waypoints for transitions
@@ -105,14 +147,21 @@ function _route!(p::Path{T}, p1::Point, α1, rule::AbstractChannelRouting,
         if iszero(pathlength(track_path_seg)) # Was too short for margins
             push!(waypoints, p0(track_path_seg))
         else
-            route!(p, p0(track_path_seg), α0(track_path_seg), next_entry_rule, sty; waypoints)
+            route!(
+                p,
+                p0(track_path_seg),
+                α0(track_path_seg),
+                next_entry_rule,
+                sty;
+                waypoints
+            )
             push!(p, Node(track_path_seg, sty), reconcile=false) # p0, α0 reconciled by construction
-            p[end-1].next = p[end]
-            p[end].prev = p[end-1]
+            p[end - 1].next = p[end]
+            p[end].prev = p[end - 1]
             # Note `auto_curvature` BSpline uses curvature from end of previous segment
             # and is not reconciled with the new node
             # But we can do this ourselves
-            _reconcile_curvature!(p[end-1], next_entry_rule)
+            _reconcile_curvature!(p[end - 1], next_entry_rule)
             empty!(waypoints)
         end
     end
@@ -132,7 +181,7 @@ function _reconcile_curvature!(n::Node{T}, rule::BSplineRouting) where {T}
     end
     κ1 = if n.next === n
         0.0 / oneunit(T)
-    else 
+    else
         signed_curvature(segment(n.next), zero(coordinatetype(n)))
     end
     _set_endpoints_curvature!(segment(n), κ0, κ1)
@@ -145,8 +194,8 @@ end
 
 struct SingleChannelRouting{T} <: AbstractChannelRouting
     channel::RouteChannel{T}
-    transition_rules::Tuple{<:RouteRule,<:RouteRule}
-    transition_margins::Tuple{T,T}
+    transition_rules::Tuple{<:RouteRule, <:RouteRule}
+    transition_margins::Tuple{T, T}
     segment_tracks::Dict{Path{T}, Int}
 end
 function SingleChannelRouting(ch::RouteChannel{T}, rule::RouteRule, margin::T) where {T}
@@ -159,18 +208,34 @@ exit_margin(scr::SingleChannelRouting) = last(scr.transition_margins)
 num_tracks(scr::SingleChannelRouting) = maximum(values(scr.segment_tracks))
 track_idx(scr, pa) = scr.segment_tracks[pa]
 function set_track!(scr, pa, track_idx)
-    scr.segment_tracks[pa] = track_idx
+    return scr.segment_tracks[pa] = track_idx
 end
 
 function track_path_segments(rule::SingleChannelRouting, pa::Path, endpt)
     wireseg_start = pathlength_nearest(rule.channel.node.seg, p1(pa))
     wireseg_stop = pathlength_nearest(rule.channel.node.seg, endpt)
-    return [track_path_segment(num_tracks(rule),
-        segment_channel_section(rule.channel, wireseg_start, wireseg_stop, 2*entry_margin(rule), 2*exit_margin(rule)),
+    return [
+        track_path_segment(
+            num_tracks(rule),
+            segment_channel_section(
+                rule.channel,
+                wireseg_start,
+                wireseg_stop,
+                2 * entry_margin(rule),
+                2 * exit_margin(rule)
+            ),
             track_idx(rule, pa),
-            reversed=wireseg_start > wireseg_stop)]
+            reversed=wireseg_start > wireseg_stop
+        )
+    ]
 end
 
-function _update_with_graph!(rule::SingleChannelRouting, route_node, graph; track=num_tracks(rule)+1, kwargs...)
-    set_track!(rule, route_node.component._path, track)
-end
+function _update_with_graph!(
+    rule::SingleChannelRouting,
+    route_node,
+    graph;
+    track=num_tracks(rule) + 1,
+    kwargs...
+)
+    return set_track!(rule, route_node.component._path, track)
+end

src/paths/routes.jl

@@ -612,4 +612,4 @@ function _route_leg!(
 end
 
 function _update_with_plan!(rule::RouteRule, route_node, schematic) end
-function _update_with_graph!(rule::RouteRule, route_node, graph; kwargs...) end
+function _update_with_graph!(rule::RouteRule, route_node, graph; kwargs...) end

src/polygons.jl

@@ -1485,7 +1485,7 @@ struct Ray{T} <: D1{T}
 end
 Ray(p0::Point{S}, p1::Point{T}) where {S, T} = Ray(promote(p0, p1)...)
 Ray(p0::Point{S}, dir) where {S} =
-    Ray(promote(p0, p0 + Point(cos(dir), sin(dir))*oneunit(S))...)
+    Ray(promote(p0, p0 + Point(cos(dir), sin(dir)) * oneunit(S))...)
 
 struct Line{T} <: D1{T}
     p0::Point{T}

src/render/cpw.jl

@@ -45,12 +45,16 @@ function to_polygons(f, len, s::Paths.CPW; kwargs...)
     return [Polygon(uniquepoints(ppts)), Polygon(uniquepoints(mpts))]
 end
 
-function to_polygons(seg::Paths.OffsetSegment{T}, s::Paths.CPW; atol=DeviceLayout.onenanometer(T), kwargs...) where {T}
+function to_polygons(
+    seg::Paths.OffsetSegment{T},
+    s::Paths.CPW;
+    atol=DeviceLayout.onenanometer(T),
+    kwargs...
+) where {T}
     bsp = Paths.bspline_approximation(seg; atol)
     return to_polygons(bsp, s; atol, kwargs...)
 end
 
-
 function to_polygons(f::Paths.Straight{T}, s::Paths.SimpleCPW; kwargs...) where {T}
     g = cpw_points(f, s)
 

src/render/trace.jl

@@ -13,7 +13,12 @@ function to_polygons(f, len, s::Paths.Trace; kwargs...)
     return Polygon(uniquepoints(pts))
 end
 
-function to_polygons(seg::Paths.OffsetSegment{T}, s::Paths.Trace; atol=DeviceLayout.onenanometer(T), kwargs...) where {T}
+function to_polygons(
+    seg::Paths.OffsetSegment{T},
+    s::Paths.Trace;
+    atol=DeviceLayout.onenanometer(T),
+    kwargs...
+) where {T}
     bsp = Paths.bspline_approximation(seg; atol)
     return to_polygons(bsp, s; atol, kwargs...)
 end

src/schematics/SchematicDrivenLayout.jl

@@ -58,7 +58,8 @@ import DeviceLayout:
     transform,
     transformation,
     _geometry!
-import ..Paths: setα0p0!, setp0!, Route, RouteRule, route!, _update_with_plan!, _update_with_graph!
+import ..Paths:
+    setα0p0!, setp0!, Route, RouteRule, route!, _update_with_plan!, _update_with_graph!
 import ..CoordinateSystems: append_coordsys!
 
 export Component,