Here is my concept for a single method that would take multiple point arguments.

It wraps the splitting in an undo operation. Fully commented.

(Tested with a simple 100 inch edge lying along the x axis.)

…

```
# Split an edge given multiple points. Returns an array of the new edges
# along with the original now shorter edge (in no particular order.)
# @param edge [Sketchup::Edge] the edge to split.
# @param points [Array<Geom::Point3d,Array<Float,Float,Float>]
# @return [Array<Sketchup::Edge>] an array of the edges with the original.
def split_multiple(edge,*points)
# Convert any 3 element Float arrays to a Geom::Point3d:
points.map! do |pt|
next pt if pt.is_a?(Geom::Point3d)
next Geom::Point3d.new(pt[0..2]) if pt.is_a?(Array)
nil
end
points.compact! # Remove any nils
# Remove any points not on the edge's line:
eline = edge.line
points.delete_if {|pt|
next true if !pt.on_line?(eline)
Geom::point_in_polygon_2D(
pt, [edge.start.position, edge.end.position], true
) ? false : true
}
# Sort the points using the API's < method which is based upon ORIGIN
# Use a transformation to the ORIGIN within the sort block:
t = edge.start.position.vector_to(ORIGIN)
points.sort! do |a,b|
a = a.transform(t)
b = b.transform(t)
a == b ? 0 : a < b ? -1 : 1
end
unless points.empty?
# Take an array snapshot of the existing entities edges:
before = edge.parent.entities.grep(Sketchup::Edge)
# Split the edge using the sorted points in reverse order:
Sketchup.active_model.start_operation("MultiSplit Edge",true)
#
points.reverse.each do |point|
edge.split(point)
end
#
Sketchup.active_model.commit_operation
# Remove the target edge's reference from the before array:
before.delete(edge)
# Return an array of the edge and it's split off edges:
edge.parent.entities.grep(Sketchup::Edge) - before
else
# Just return an array with the original edge:
[edge]
end
end
```

And here is a slightly modified edition that returns the edge array in edge joined order (the now shortened original edge first.)

```
# Split an edge given multiple points. Returns an array of the new edges
# along with the original now shorter edge first (in edge joined order.)
# @param edge [Sketchup::Edge] the edge to split.
# @param points [Array<Geom::Point3d,Array<Float,Float,Float>]
# @return [Array<Sketchup::Edge>] an array of the edges with the original.
def split_multiple_ordered(edge,*points)
# Convert any 3 element Float arrays to a Geom::Point3d:
points.map! do |pt|
next pt if pt.is_a?(Geom::Point3d)
next Geom::Point3d.new(pt[0..2]) if pt.is_a?(Array)
nil
end
points.compact! # Remove any nils
# Remove any points not on the edge's line:
eline = edge.line
points.delete_if {|pt|
next true if !pt.on_line?(eline)
Geom::point_in_polygon_2D(
pt, [edge.start.position, edge.end.position], true
) ? false : true
}
# Sort the points using the API's < method which is based upon ORIGIN
# Use a transformation to the ORIGIN within the sort block:
t = edge.start.position.vector_to(ORIGIN)
points.sort! do |a,b|
a = a.transform(t)
b = b.transform(t)
a == b ? 0 : a < b ? -1 : 1
end
unless points.empty?
# The edge array to return:
edges = []
# Split the edge using the sorted points in reverse order:
Sketchup.active_model.start_operation("MultiSplit Edge",true)
#
points.reverse.each do |point|
edges << edge.split(point)
end
#
Sketchup.active_model.commit_operation
# Return an array of the edge and it's split off edges:
edges << edge
# Reverse and remove any nils returned by edge.split
edges.reverse.compact
else
# Just return an array with the original edge:
[edge]
end
end
```

**Retested** and **edited** several times to deal with issues, like when the args result in no valid points, the undo operation needs to be skipped, and when the split method returns `nil`

these need to be removed from the result array.