turf-ruby 0.8.1 → 1.0.0

data/lib/turf/helpers.rb

@@ -3,13 +3,12 @@
 # :nodoc:
 module Turf
   EARTH_RADIUS = 6_371_008.8
-  private_constant :EARTH_RADIUS
   FACTORS = {
     "centimeters" => EARTH_RADIUS * 100,
     "centimetres" => EARTH_RADIUS * 100,
-    "degrees" => EARTH_RADIUS / 111_325,
+    "degrees" => 360.0 / (2 * Math::PI),
     "feet" => EARTH_RADIUS * 3.28084,
-    "inches" => EARTH_RADIUS * 39.370,
+    "inches" => EARTH_RADIUS * 39.37,
     "kilometers" => EARTH_RADIUS / 1000,
     "kilometres" => EARTH_RADIUS / 1000,
     "meters" => EARTH_RADIUS,
@@ -19,9 +18,26 @@ module Turf
     "millimetres" => EARTH_RADIUS * 1000,
     "nauticalmiles" => EARTH_RADIUS / 1852,
     "radians" => 1.0,
-    "yards" => EARTH_RADIUS / 1.0936
+    "yards" => EARTH_RADIUS * 1.0936
+  }.freeze
+
+  AREA_FACTORS = {
+    "acres" => 0.000247105,
+    "centimeters" => 10_000.0,
+    "centimetres" => 10_000.0,
+    "feet" => 10.763910417,
+    "hectares" => 0.0001,
+    "inches" => 1550.003100006,
+    "kilometers" => 0.000001,
+    "kilometres" => 0.000001,
+    "meters" => 1.0,
+    "metres" => 1.0,
+    "miles" => 3.86e-7,
+    "nauticalmiles" => 2.9155334959812285e-7,
+    "millimeters" => 1_000_000.0,
+    "millimetres" => 1_000_000.0,
+    "yards" => 1.195990046
   }.freeze
-  private_constant :FACTORS
 
   # @!group Helper
 
@@ -32,14 +48,14 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string | number] Identifier associated with the Feature
   # @return [Feature] a GeoJSON Feature
-  def feature(geom, properties: {}, bbox: nil, id: nil)
+  def feature(geom, properties = nil, options = {})
     feat = {
       type: "Feature",
-      properties: properties,
+      properties: properties || {},
       geometry: geom
     }
-    feat[:id] = options[:id] if id
-    feat[:bbox] = options[:bbox] if bbox
+    feat[:id] = options[:id] if options[:id]
+    feat[:bbox] = options[:bbox] if options[:bbox]
 
     feat
   end
@@ -50,10 +66,10 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string | number] Identifier associated with the Feature
   # @return [FeatureCollection] FeatureCollection of Features
-  def feature_collection(features, bbox: nil, id: nil)
+  def feature_collection(features, options = {})
     fc = { type: "FeatureCollection" }
-    fc[:id] = options[:id] if id
-    fc[:bbox] = options[:bbox] if bbox
+    fc[:id] = options[:id] if options[:id]
+    fc[:bbox] = options[:bbox] if options[:bbox]
     fc[:features] = features
 
     fc
@@ -66,13 +82,13 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string|number] Identifier associated with the Feature
   # @return [Feature<GeometryCollection>] a GeoJSON GeometryCollection Feature
-  def geometry_collection(geometries, bbox: nil, id: nil, properties: {})
+  def geometry_collection(geometries, properties = nil, options = {})
     geom = {
       type: "GeometryCollection",
       geometries: geometries
     }
 
-    feature(geom, properties: properties, bbox: bbox, id: id)
+    feature(geom, properties, options)
   end
 
   # Creates a Feature based on a coordinate array. Properties can be added optionally.
@@ -81,13 +97,13 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string|number] Identifier associated with the Feature
   # @return [Feature<MultiPoint>] a MultiPoint feature
-  def multi_point(coordinates, properties: {}, bbox: nil, id: nil)
+  def multi_point(coordinates, properties = nil, options = {})
     geom = {
       type: "MultiPoint",
       coordinates: coordinates
     }
 
-    feature(geom, properties: properties, bbox: bbox, id: id)
+    feature(geom, properties, options)
   end
 
   # Creates a LineString Feature from an Array of Positions.
@@ -97,7 +113,7 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string|number] Identifier associated with the Feature
   # @return [Feature<LineString>] LineString Feature
-  def line_string(coordinates, properties: {}, bbox: nil, id: nil)
+  def line_string(coordinates, properties = nil, options = {})
     if coordinates.size < 2
       raise Error, "coordinates must be an array of two or more positions"
     end
@@ -106,7 +122,7 @@ module Turf
       type: "LineString",
       coordinates: coordinates
     }
-    feature(geom, properties: properties, bbox: bbox, id: id)
+    feature(geom, properties, options)
   end
 
   # Creates a Point Feature from a Position.
@@ -116,12 +132,12 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string | number] Identifier associated with the Feature
   # @return [Feature<Point>] a Point feature
-  def point(coordinates, properties: {}, id: nil, bbox: nil)
+  def point(coordinates, properties = nil, options = {})
     geom = {
       type: "Point",
       coordinates: coordinates
     }
-    feature(geom, properties: properties, id: id, bbox: bbox)
+    feature(geom, properties, options)
   end
 
   # Creates a Polygon Feature from an Array of LinearRings.
@@ -131,7 +147,7 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string | number] Identifier associated with the Feature
   # @return [Feature<Polygon>] Polygon feature
-  def polygon(coordinates, properties: {}, bbox: nil, id: nil)
+  def polygon(coordinates, properties = nil, options = {})
     coordinates.each do |ring|
       if ring.size < 4
         raise(
@@ -150,7 +166,7 @@ module Turf
       type: "Polygon",
       coordinates: coordinates
     }
-    feature(geom, properties: properties, id: id, bbox: bbox)
+    feature(geom, properties, options)
   end
 
   # Creates a Feature<MultiPolygon> based on a coordinate array. Properties can be added optionally.
@@ -160,12 +176,12 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string|number] Identifier associated with the Feature
   # @return [Feature<MultiPolygon>] a multipolygon feature
-  def multi_polygon(coordinates, properties: {}, bbox: nil, id: nil)
+  def multi_polygon(coordinates, properties = nil, options = {})
     geom = {
       type: "MultiPolygon",
       coordinates: coordinates
     }
-    feature(geom, properties: properties, id: id, bbox: bbox)
+    feature(geom, properties, options)
   end
 
   # Creates a Feature<MultiLineString> based on a coordinate array. Properties can be added optionally.
@@ -175,12 +191,12 @@ module Turf
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
   # @param id [string|number] Identifier associated with the Feature
   # @return [Feature<MultiLineString>] a MultiLineString feature
-  def multi_line_string(coordinates, properties: {}, bbox: nil, id: nil)
+  def multi_line_string(coordinates, properties = nil, options = {})
     geom = {
       type: "MultiLineString",
       coordinates: coordinates
     }
-    feature(geom, properties: properties, id: id, bbox: bbox)
+    feature(geom, properties, options)
   end
 
   # @!group Unit Conversion
@@ -230,4 +246,128 @@ module Turf
 
     distance / factor
   end
+
+  # Creates a FeatureCollection from an Array of LineString coordinates.
+  # @see https://turfjs.org/docs/#lineStrings
+  # @param coordinates [Array<Array<Array<number>>>] an array of LinearRings
+  # @param properties [Hash] a Hash of key-value pairs to add as properties
+  # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the FeatureCollection
+  # @param id [string|number] Identifier associated with the FeatureCollection
+  # @return [FeatureCollection<LineString>] LineString FeatureCollection
+  def line_strings(coordinates, properties = nil, options = {})
+    features = coordinates.map { |coords| line_string(coords, properties) }
+    feature_collection(features, options)
+  end
+
+  # Creates a Point FeatureCollection from an Array of Point coordinates.
+  # @see https://turfjs.org/docs/#points
+  # @param coordinates [Array<Array<number>>] an array of Points
+  # @param properties [Hash] a Hash of key-value pairs to add as properties
+  # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the FeatureCollection
+  # @param id [string|number] Identifier associated with the FeatureCollection
+  # @return [FeatureCollection<Point>] Point FeatureCollection
+  def points(coordinates, properties = nil, options = {})
+    features = coordinates.map { |coords| point(coords, properties) }
+    feature_collection(features, options)
+  end
+
+  # Creates a Polygon FeatureCollection from an Array of Polygon coordinates.
+  # @see https://turfjs.org/docs/#polygons
+  # @param coordinates [Array<Array<Array<Array<number>>>>] an array of Polygon coordinates
+  # @param properties [Hash] a Hash of key-value pairs to add as properties
+  # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the FeatureCollection
+  # @param id [string|number] Identifier associated with the FeatureCollection
+  # @return [FeatureCollection<Polygon>] Polygon FeatureCollection
+  def polygons(coordinates, properties = nil, options = {})
+    features = coordinates.map { |coords| polygon(coords, properties) }
+    feature_collection(features, options)
+  end
+
+  # Checks if the input is a number.
+  # @see https://turfjs.org/docs/#isNumber
+  # @param num [Object] Number to validate
+  # @return [boolean] true/false
+  def is_number(num)
+    num.is_a?(Numeric)
+  end
+
+  # Checks if the input is an object.
+  # @see https://turfjs.org/docs/#isObject
+  # @param input [Object] variable to validate
+  # @return [boolean] true/false, including false for Arrays and Functions
+  def is_object(input)
+    input.is_a?(Hash) && !input.is_a?(Array)
+  end
+
+  # Converts any azimuth angle from the north line direction (positive clockwise)
+  # and returns an angle between -180 and +180 degrees (positive clockwise), 0 being the north line
+  # @see https://turfjs.org/docs/#azimuthToBearing
+  # @param angle [number] between 0 and 360 degrees
+  # @return [number] bearing between -180 and +180 degrees
+  def azimuth_to_bearing(angle)
+    angle = angle.remainder(360)
+    angle -= 360 if angle > 180
+    angle += 360 if angle < -180
+    angle
+  end
+
+  # Converts any bearing angle from the north line direction (positive clockwise)
+  # and returns an angle between 0-360 degrees (positive clockwise), 0 being the north line
+  # @see https://turfjs.org/docs/#bearingToAzimuth
+  # @param bearing [number] angle, between -180 and +180 degrees
+  # @return [number] angle between 0 and 360 degrees
+  def bearing_to_azimuth(bearing)
+    angle = bearing.remainder(360)
+    angle += 360 if angle < 0
+    angle
+  end
+
+  # Rounds a number to a specified precision
+  # @see https://turfjs.org/docs/#round
+  # @param num [number] Number to round
+  # @param precision [number] Precision
+  # @return [number] rounded number
+  def round(num, precision = 0)
+    if !precision.is_a?(Numeric) || precision < 0
+      raise Error, "invalid precision"
+    end
+
+    num.round(precision)
+  end
+
+  # Converts an area from one unit to another.
+  # @see https://turfjs.org/docs/#convertArea
+  # @param area [number] Area to be converted
+  # @param original_unit [string] Input area unit
+  # @param final_unit [string] Returned area unit
+  # @return [number] The converted length
+  def convert_area(area, original_unit = nil, final_unit = nil)
+    original_unit ||= "meters"
+    final_unit ||= "kilometers"
+
+    raise Error, "area must be a positive number" unless area >= 0
+
+    start_factor = AREA_FACTORS[original_unit]
+    raise Error, "invalid original units" unless start_factor
+
+    final_factor = AREA_FACTORS[final_unit]
+    raise Error, "invalid final units" unless final_factor
+
+    (area / start_factor) * final_factor
+  end
+
+  # Converts a length from one unit to another.
+  # @see https://turfjs.org/docs/#convertLength
+  # @param length [number] Length to be converted
+  # @param original_unit [string] Input length unit
+  # @param final_unit [string] Returned length unit
+  # @return [number] The converted length
+  def convert_length(length, original_unit = nil, final_unit = nil)
+    original_unit ||= "kilometers"
+    final_unit ||= "kilometers"
+
+    raise Error, "length must be a positive number" unless length >= 0
+
+    radians_to_length(length_to_radians(length, original_unit), final_unit)
+  end
 end

data/lib/turf/hex_grid.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def hex_grid(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/interpolate.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def interpolate(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/intersect.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def intersect(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/invariant.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "helpers"
+
 # :nodoc:
 module Turf
   # @!group Meta
@@ -22,7 +24,7 @@ module Turf
       coord = deep_symbolize_keys(coord)
 
       is_feature = coord[:type] == "Feature"
-      if is_feature && coord.fetch(:geometry, {})[:type] == "Point"
+      if is_feature && coord.dig(:geometry, :type) == "Point"
         return coord[:geometry][:coordinates]
       end
 
@@ -44,4 +46,128 @@ module Turf
 
     geojson
   end
+
+  # Unwrap coordinates from a Feature, Geometry Object or an Array
+  # @see https://turfjs.org/docs/#getCoords
+  # @param coords [Array|Geometry|Feature] Feature, Geometry Object or an Array
+  # @return [Array] coordinates
+  def get_coords(coords)
+    if coords.is_a?(Array)
+      return coords
+    end
+
+    coords = deep_symbolize_keys coords
+
+    # Feature
+    if coords.is_a?(Hash) && coords[:type] == "Feature"
+      if coords[:geometry]
+        return coords[:geometry][:coordinates]
+      end
+    elsif coords.is_a?(Hash) && coords[:coordinates]
+      # Geometry
+      return coords[:coordinates]
+    end
+
+    raise Error, "coords must be GeoJSON Feature, Geometry Object or an Array"
+  end
+
+  # Checks if coordinates contains a number
+  # @see https://turfjs.org/docs/#containsNumber
+  # @param coordinates [Array] GeoJSON Coordinates
+  # @return [Boolean] true if Array contains a number
+  def contains_number(coordinates)
+    if coordinates.length > 1 && coordinates[0].is_a?(Numeric) && coordinates[1].is_a?(Numeric)
+      return true
+    end
+
+    if coordinates[0].is_a?(Array) && !coordinates[0].empty?
+      return contains_number(coordinates[0])
+    end
+
+    raise Error, "coordinates must only contain numbers"
+  end
+
+  # Enforce expectations about types of GeoJSON objects for Turf.
+  # @see https://turfjs.org/docs/#geojsonType
+  # @param value [GeoJSON] any GeoJSON object
+  # @param type [String] expected GeoJSON type
+  # @param name [String] name of calling function
+  # @raise [Error] if value is not the expected type.
+  def geojson_type(value = nil, type = nil, name = nil)
+    if !type || !name
+      raise Error, "type and name required"
+    end
+
+    return unless !value || value[:type] != type
+
+    raise Error, "Invalid input to #{name}: must be a #{type}, given #{value[:type]}"
+  end
+
+  # Enforce expectations about types of Feature inputs for Turf.
+  # @see https://turfjs.org/docs/#featureOf
+  # @param feature [Feature] a feature with an expected geometry type
+  # @param type [String] expected GeoJSON type
+  # @param name [String] name of calling function
+  # @raise [Error] error if value is not the expected type.
+  def feature_of(feature = nil, type = nil, name = nil)
+    if !feature
+      raise Error, "No feature passed"
+    end
+    if !name
+      raise Error, ".featureOf() requires a name"
+    end
+    if !feature || feature[:type] != "Feature" || !feature[:geometry]
+      raise Error, "Invalid input to #{name}, Feature with geometry required"
+    end
+    return unless feature[:geometry][:type] != type
+
+    raise Error, "Invalid input to #{name}: must be a #{type}, given #{feature[:geometry][:type]}"
+  end
+
+  # Enforce expectations about types of FeatureCollection inputs for Turf.
+  # @see https://turfjs.org/docs/#collectionOf
+  # @param feature_collection [FeatureCollection] a FeatureCollection for which features will be judged
+  # @param type [String] expected GeoJSON type
+  # @param name [String] name of calling function
+  # @raise [Error] if value is not the expected type.
+  def collection_of(feature_collection, type, name = nil)
+    if !feature_collection
+      raise Error, "No featureCollection passed"
+    end
+    if !name
+      raise Error, ".collectionOf() requires a name"
+    end
+    if feature_collection[:type] != "FeatureCollection"
+      raise Error, "Invalid input to #{name}, FeatureCollection required"
+    end
+
+    feature_collection[:features].each do |feature|
+      if !feature || feature[:type] != "Feature" || !feature[:geometry]
+        raise Error, "Invalid input to #{name}, Feature with geometry required"
+      end
+      if feature[:geometry][:type] != type
+        raise Error, "Invalid input to #{name}: must be a #{type}, given #{feature[:geometry][:type]}"
+      end
+    end
+  end
+
+  # Get GeoJSON object's type, Geometry type is prioritize.
+  # @see https://turfjs.org/docs/#getType
+  # @param geojson [GeoJSON] GeoJSON object
+  # @param _name [String] name of the variable to display in error message (unused)
+  # @return [String] GeoJSON type
+  def get_type(geojson, _name = "geojson")
+    geojson = deep_symbolize_keys geojson
+    if geojson[:type] == "FeatureCollection"
+      return "FeatureCollection"
+    end
+    if geojson[:type] == "GeometryCollection"
+      return "GeometryCollection"
+    end
+    if geojson[:type] == "Feature" && geojson[:geometry]
+      return geojson[:geometry][:type]
+    end
+
+    geojson[:type]
+  end
 end

data/lib/turf/isobands.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def isobands(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/isolines.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def isolines(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/kinks.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def kinks(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/length.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "distance"
+require_relative "meta"
+
 # :nodoc:
 module Turf
   # @!group Measurement
@@ -9,13 +12,13 @@ module Turf
   # @param geojson [Feature<LineString|MultiLinestring>] GeoJSON to measure
   # @param units [string] can be degrees, radians, miles, or kilometers (optional, default "kilometers")
   # @return [number] length of GeoJSON
-  def length(geojson, units: "kilometers")
+  def length(geojson, options = {})
     geojson = deep_symbolize_keys(geojson)
     geojson = feature(geojson) if geojson[:geometry].nil?
-    segment_reduce(geojson, initial_value: 0) do |previous_value, segment|
+    segment_reduce(geojson, 0) do |previous_value, segment|
       previous_value ||= 0
       coords = segment.dig(:geometry, :coordinates)
-      previous_value + Turf.distance(coords[0], coords[1], units: units)
+      previous_value + Turf.distance(coords[0], coords[1], options)
     end
   end
 end

data/lib/turf/lib/lineclip.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Turf
+  # :nodoc:
+  module Lineclip
+    # Cohen-Sutherland line clipping algorithm, adapted to efficiently
+    # handle polylines rather than just segments.
+    def self.lineclip(points, bbox, result = [])
+      len = points.length
+      code_a = bit_code(points[0], bbox)
+      part = []
+      a = nil
+      b = nil
+
+      (1...len).each do |i|
+        a = points[i - 1]
+        b = points[i]
+        code_b = last_code = bit_code(b, bbox)
+
+        loop do
+          if (code_a | code_b).zero?
+            # accept
+            part << a
+
+            if code_b != last_code
+              # segment went outside
+              part << b
+
+              if i < len - 1
+                # start a new line
+                result << part
+                part = []
+              end
+            elsif i == len - 1
+              part << b
+            end
+            break
+          elsif code_a.anybits?(code_b)
+            # trivial reject
+            break
+          elsif code_a != 0
+            # a outside, intersect with clip edge
+            a = intersect(a, b, code_a, bbox)
+            code_a = bit_code(a, bbox)
+          else
+            # b outside
+            b = intersect(a, b, code_b, bbox)
+            code_b = bit_code(b, bbox)
+          end
+        end
+
+        code_a = last_code
+      end
+
+      result << part unless part.empty?
+
+      result
+    end
+
+    # Sutherland-Hodgeman polygon clipping algorithm
+    def self.polygonclip(points, bbox)
+      result = []
+      prev = nil
+      prev_inside = nil
+
+      # clip against each side of the clip rectangle
+      [8, 4, 2, 1].each do |edge|
+        result = []
+        prev = points.last
+        prev_inside = bit_code(prev, bbox).nobits?(edge)
+
+        points.each do |p|
+          inside = bit_code(p, bbox).nobits?(edge)
+
+          # if segment goes through the clip window, add an intersection
+          result << intersect(prev, p, edge, bbox) if inside != prev_inside
+
+          result << p if inside # add a point if it's inside
+
+          prev = p
+          prev_inside = inside
+        end
+
+        points = result
+        break if points.empty?
+      end
+
+      result
+    end
+
+    # intersect a segment against one of the 4 lines that make up the bbox
+    def self.intersect(a, b, edge, bbox) # rubocop:disable Naming/MethodParameterName
+      if edge.anybits?(8)
+        [a[0] + (((b[0] - a[0]) * (bbox[3] - a[1]).to_f) / (b[1] - a[1])), bbox[3]]
+      elsif edge.anybits?(4)
+        [a[0] + (((b[0] - a[0]) * (bbox[1] - a[1]).to_f) / (b[1] - a[1])), bbox[1]]
+      elsif edge.anybits?(2)
+        [bbox[2], a[1] + (((b[1] - a[1]) * (bbox[2] - a[0]).to_f) / (b[0] - a[0]))]
+      elsif edge.anybits?(1)
+        [bbox[0], a[1] + (((b[1] - a[1]) * (bbox[0] - a[0]).to_f) / (b[0] - a[0]))]
+      end
+    end
+
+    # bit code reflects the point position relative to the bbox:
+    #         left  mid  right
+    #    top  1001  1000  1010
+    #    mid  0001  0000  0010
+    # bottom  0101  0100  0110
+    def self.bit_code(p, bbox) # rubocop:disable Naming/MethodParameterName
+      code = 0
+      code |= 1 if p[0] < bbox[0] # left
+      code |= 2 if p[0] > bbox[2] # right
+      code |= 4 if p[1] < bbox[1] # bottom
+      code |= 8 if p[1] > bbox[3] # top
+      code
+    end
+  end
+end

data/lib/turf/line_arc.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_arc(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_chunk.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_chunk(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_intersect.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_intersect(*args)
+    raise NotImplementedError
+  end
+end