Restore GeoInterfaceRecipes as empty stub package

GeoInterfaceRecipes/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Julia Computing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

GeoInterfaceRecipes/Project.toml

@@ -0,0 +1,20 @@
+name = "GeoInterfaceRecipes"
+uuid = "0329782f-3d07-4b52-b9f6-d3137cf03c7a"
+version = "1.0.3"
+authors = ["JuliaGeo and contributors"]
+
+[deps]
+GeoInterface = "cf35fbd7-0cd7-5166-be24-54bfbe79505f"
+RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
+
+[compat]
+GeoInterface = "1.5"
+RecipesBase = "1"
+julia = "1.9"
+
+[extras]
+Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["Plots", "Test"]

GeoInterfaceRecipes/README.md

@@ -0,0 +1,22 @@
+# GeoInterfaceRecipes.jl
+
+**This package is deprecated.**
+
+Plotting recipes for GeoInterface geometries are now built directly into [GeoInterface.jl](https://github.com/JuliaGeo/GeoInterface.jl) as package extensions:
+
+- **Plots.jl support**: Load `GeoInterface` with `Plots` and recipes work automatically
+- **Makie.jl support**: Load `GeoInterface` with `Makie` and `GeometryBasics` for Makie plotting
+
+## Migration
+
+No action is needed. Simply remove `GeoInterfaceRecipes` from your dependencies and use `GeoInterface` directly with your preferred plotting package.
+
+```julia
+using GeoInterface
+using Plots  # or using Makie
+
+# Plotting just works
+plot(my_geometry)
+```
+
+This empty package exists only to provide a smooth upgrade path for users who had GeoInterfaceRecipes.jl in their dependencies.

GeoInterfaceRecipes/src/GeoInterfaceRecipes.jl

@@ -0,0 +1,25 @@
+module GeoInterfaceRecipes
+using RecipesBase
+using GeoInterface
+
+export @enable_geo_plots
+
+# This package is deprecated. Plotting recipes are now built into GeoInterface.jl
+# as package extensions. See:
+# - GeoInterfaceRecipesBaseExt for Plots.jl support
+# - GeoInterfaceMakieExt for Makie.jl support
+
+# This stub package exists only to allow smooth upgrades for users who had
+# GeoInterfaceRecipes.jl installed. No action is needed - simply load
+# GeoInterface with Plots or Makie and the recipes will work automatically.
+
+macro enable(typ)
+    :(GeoInterface.@enable_plots RecipesBase $(esc(typ)))
+end
+
+# Compat
+macro enable_geo_plots(typ)
+    :(GeoInterface.@enable_plots RecipesBase $(esc(typ)))
+end
+
+end

GeoInterfaceRecipes/test/runtests.jl

@@ -0,0 +1,97 @@
+using GeoInterfaceRecipes
+using GeoInterface
+using Plots
+using Test
+
+
+abstract type MyAbstractGeom{N} end
+# Implement interface
+struct MyPoint{N} <: MyAbstractGeom{N} end
+struct MyCurve{N} <: MyAbstractGeom{N} end
+struct MyLinearRing{N} <: MyAbstractGeom{N} end
+struct MyLineString{N} <: MyAbstractGeom{N} end
+struct MyPolygon{N} <: MyAbstractGeom{N} end
+struct MyMultiPoint{N} <: MyAbstractGeom{N} end
+struct MyMultiCurve{N} <: MyAbstractGeom{N} end
+struct MyMultiPolygon{N} <: MyAbstractGeom{N} end
+struct MyCollection{N} <: MyAbstractGeom{N} end
+struct MyFeature end
+struct MyFeatureCollection end
+
+GeoInterfaceRecipes.@enable MyAbstractGeom
+GeoInterfaceRecipes.@enable MyFeature
+# Test legacy interface
+GeoInterfaceRecipes.@enable_geo_plots MyFeatureCollection
+
+GeoInterface.isgeometry(::MyAbstractGeom) = true
+GeoInterface.is3d(::GeoInterface.AbstractGeometryTrait, ::MyAbstractGeom{N}) where {N} = N == 3
+GeoInterface.ncoord(::GeoInterface.AbstractGeometryTrait, geom::MyAbstractGeom{N}) where {N} = N
+GeoInterface.coordnames(::GeoInterface.AbstractGeometryTrait, ::MyAbstractGeom{2}) = (:X, :Y)
+GeoInterface.coordnames(::GeoInterface.AbstractGeometryTrait, ::MyAbstractGeom{3}) = (:X, :Y, :Z)
+
+GeoInterface.geomtrait(::MyPoint) = GeoInterface.PointTrait()
+GeoInterface.getcoord(::GeoInterface.PointTrait, geom::MyPoint{2}, i::Integer) = (rand(1:10), rand(11:20))[i]
+GeoInterface.getcoord(::GeoInterface.PointTrait, geom::MyPoint{3}, i::Integer) = (rand(1:10), rand(11:20), rand(21:30))[i]
+
+GeoInterface.geomtrait(::MyCurve) = GeoInterface.LineStringTrait()
+GeoInterface.ngeom(::GeoInterface.LineStringTrait, geom::MyCurve) = 3
+GeoInterface.getgeom(::GeoInterface.LineStringTrait, geom::MyCurve{N}, i) where {N} = MyPoint{N}()
+GeoInterface.convert(::Type{MyCurve}, ::GeoInterface.LineStringTrait, geom) = geom
+
+GeoInterface.geomtrait(::MyLinearRing) = GeoInterface.LinearRingTrait()
+GeoInterface.ngeom(::GeoInterface.LinearRingTrait, geom::MyLinearRing) = 3
+GeoInterface.getgeom(::GeoInterface.LinearRingTrait, geom::MyLinearRing{N}, i) where {N} = MyPoint{N}()
+GeoInterface.convert(::Type{MyLinearRing}, ::GeoInterface.LinearRingTrait, geom) = geom
+
+GeoInterface.geomtrait(::MyLineString) = GeoInterface.LineStringTrait()
+GeoInterface.ngeom(::GeoInterface.LineStringTrait, geom::MyLineString) = 3
+GeoInterface.getgeom(::GeoInterface.LineStringTrait, geom::MyLineString{N}, i) where {N} = MyPoint{N}()
+GeoInterface.convert(::Type{MyLineString}, ::GeoInterface.LineStringTrait, geom) = geom
+
+GeoInterface.geomtrait(::MyPolygon) = GeoInterface.PolygonTrait()
+GeoInterface.ngeom(::GeoInterface.PolygonTrait, geom::MyPolygon) = 2
+GeoInterface.getgeom(::GeoInterface.PolygonTrait, geom::MyPolygon{N}, i) where {N} = MyCurve{N}()
+
+GeoInterface.geomtrait(::MyMultiPolygon) = GeoInterface.MultiPolygonTrait()
+GeoInterface.ngeom(::GeoInterface.MultiPolygonTrait, geom::MyMultiPolygon) = 2
+GeoInterface.getgeom(::GeoInterface.MultiPolygonTrait, geom::MyMultiPolygon{N}, i) where {N} = MyPolygon{N}()
+
+GeoInterface.geomtrait(::MyMultiPoint) = GeoInterface.MultiPointTrait()
+GeoInterface.ngeom(::GeoInterface.MultiPointTrait, geom::MyMultiPoint) = 10
+GeoInterface.getgeom(::GeoInterface.MultiPointTrait, geom::MyMultiPoint{N}, i) where {N} = MyPoint{N}()
+
+GeoInterface.geomtrait(geom::MyCollection) = GeoInterface.GeometryCollectionTrait()
+GeoInterface.ncoord(::GeoInterface.GeometryCollectionTrait, geom::MyCollection{N}) where {N} = N
+GeoInterface.ngeom(::GeoInterface.GeometryCollectionTrait, geom::MyCollection) = 4
+GeoInterface.getgeom(::GeoInterface.GeometryCollectionTrait, geom::MyCollection{N}, i) where {N} = MyMultiPolygon{N}()
+
+GeoInterface.trait(::MyFeature) = FeatureTrait()
+GeoInterface.trait(::MyFeatureCollection) = FeatureCollectionTrait()
+GeoInterface.getfeature(::GeoInterface.FeatureCollectionTrait, geom::MyFeatureCollection, i) = MyFeature()
+GeoInterface.getfeature(::GeoInterface.FeatureCollectionTrait, geom::MyFeatureCollection) = [MyFeature(), MyFeature()]
+GeoInterface.geometry(geom::MyFeature) = rand((MyPolygon{2}(), MyMultiPolygon{2}()))
+GeoInterface.nfeature(::GeoInterface.FeatureTrait, geom::MyFeature) = 1
+
+@testset "plot" begin
+    # We just check if they actually run
+    # 2d
+    plot(MyPoint{2}())
+    plot(MyCurve{2}())
+    plot(MyLinearRing{2}())
+    plot(MyLineString{2}())
+    plot(MyMultiPoint{2}())
+    plot(MyPolygon{2}())
+    plot(MyMultiPolygon{2}())
+    plot(MyCollection{2}())
+    # 3d
+    plot(MyPoint{3}())
+    plot(MyCurve{3}())
+    plot(MyLinearRing{3}())
+    plot(MyLineString{3}())
+    plot(MyMultiPoint{3}())
+    plot(MyPolygon{3}())
+    plot(MyMultiPolygon{3}())
+    plot(MyCollection{3}())
+    plot(MyFeature())
+    plot(MyFeatureCollection())
+end