fix documentation build

Author: bvdmitri

docs/src/developers_guide.md

@@ -112,19 +112,10 @@ GraphPPL.ResizableArray
 ```
 `ResizableArray` is a subtype of `AbstractArray`, and implements all the functions that are expected from an array. Note that `size` returns the largest size of the array across each dimension, so an array of size `(2, 3)` does not necessarily has to have an element stored at index `(2, 3)`, instead there exists a vector of length 3 along the second dimension.
 
-## Source code of the model
-
-The source code of a model can be accessed using the `source_code` function. This function returns a string representation of the model specification, which can be useful for debugging or documentation purposes.
-
-```@docs
-GraphPPL.source_code
-```
-
 ## Model creation engine internal 
 
 ```@docs
 GraphPPL.Context
-GraphPPL.ModelGenerator
 GraphPPL.FactorID
 GraphPPL.NodeData
 GraphPPL.NodeLabel
@@ -164,6 +155,11 @@ GraphPPL.hasextra
 GraphPPL.getextra
 GraphPPL.setextra!
 
+GraphPPL.ModelGenerator
+GraphPPL.with_plugins
+GraphPPL.with_backend
+GraphPPL.with_source
+
 GraphPPL.make_node!
 GraphPPL.add_atomic_factor_node!
 GraphPPL.add_toplevel_model!
@@ -200,7 +196,6 @@ GraphPPL.apply_pipeline
 GraphPPL.options_vector_to_named_tuple
 GraphPPL.get_created_by
 GraphPPL.convert_to_anonymous
-GraphPPL.get_source_code_function
 ```
 
 ## Auxiliary functionality 

docs/src/plugins/overview.md

@@ -24,11 +24,7 @@ The following plugins are available by default in `GraphPPL`:
 
 ## Using a plugin
 
-To use a plugin, call the `with_plugins` function when constructing a model:
-
-```@docs 
-GraphPPL.with_plugins
-```
+To use a plugin, call the [`GraphPPL.with_plugins`](@ref) function when constructing a model:
 
 The `PluginsCollection` is a collection of plugins that will be applied to the model. The order of plugins in the collection is important, as the `preprocess_plugin` and `postprocess_plugin` functions are called in the order of the plugins in the collection.
 

src/graph_engine.jl

@@ -2189,45 +2189,3 @@ function preprocess_plugins(
         return preprocess_plugin(plugin, model, context, label, nodedata, options)::Tuple{NodeLabel, NodeData}
     end::Tuple{NodeLabel, NodeData}
 end
-
-"""
-    source_code(backend, model_function, n_interfaces)
-  
-Returns the source code of the model function. The `n_interfaces` argument can be either an `Integer` or a `StaticInt` 
-specifying the total number of interfaces expected by the model.
-
-!!! note
-    The example below uses `DefaultBackend`, which is not necessarily the backend that is currently active.
-
-```jldoctest
-julia> import GraphPPL: @model, DefaultBackend
-
-julia> @model function beta_bernoulli(y)
-           θ ~ Beta(1, 1)
-           for i = eachindex(y)
-               y[i] ~ Bernoulli(θ)
-           end
-       end
-
-julia> println(GraphPPL.source_code(DefaultBackend(), beta_bernoulli, 1))
-function beta_bernoulli(y)
-    θ ~ Beta(1, 1)
-    for i = eachindex(y)
-        y[i] ~ Bernoulli(θ)
-    end
-end
-
-julia> println(GraphPPL.source_code(DefaultBackend(), beta_bernoulli, GraphPPL.static(1)))
-function beta_bernoulli(y)
-    θ ~ Beta(1, 1)
-    for i = eachindex(y)
-        y[i] ~ Bernoulli(θ)
-    end
-end
-```
-"""
-function source_code end
-
-source_code(backend, model_function, n_interfaces::Integer) = source_code(backend, model_function, GraphPPL.static(n_interfaces))
-source_code(backend, model_function, n_interfaces::StaticInt) =
-    error("Backend $backend must implement a method for `source_code` for `$(model_function)` with $(n_interfaces) interfaces.")

src/model_generator.jl

@@ -29,19 +29,14 @@ julia> @model function beta_bernoulli(y)
            end
        end
 
-# Create basic generator
-julia> generator = beta_bernoulli(y = rand(10))
+julia> generator = beta_bernoulli(y = rand(10));
 
-# Define custom backend
 julia> struct CustomBackend end
 
-# Create generator with custom backend
-julia> generator_with_backend = GraphPPL.with_backend(generator, CustomBackend())
+julia> generator_with_backend = GraphPPL.with_backend(generator, CustomBackend());
 
-# Create generator with additional plugins
-julia> generator_with_plugins = GraphPPL.with_plugins(generator, PluginsCollection())
+julia> generator_with_plugins = GraphPPL.with_plugins(generator, GraphPPL.PluginsCollection());
 
-# Retrieve source code
 julia> println(GraphPPL.getsource(generator))
 function beta_bernoulli(y)
     θ ~ Beta(1, 1)
@@ -50,15 +45,13 @@ function beta_bernoulli(y)
     end
 end
 
-# Override source code
-julia> generator_with_source = GraphPPL.with_source(generator, "Hello, world!")
+julia> generator_with_source = GraphPPL.with_source(generator, "Hello, world!");
 
-# Retrieve modified source code
-julia> println(GraphPPL.getsource(generator))
+julia> println(GraphPPL.getsource(generator_with_source))
 Hello, world!
 ```
 
-See also: [`with_plugins`](@ref), [`with_backend`](@ref), [`with_source`](@ref), [`source_code`](@ref)
+See also: [`with_plugins`](@ref), [`with_backend`](@ref), [`with_source`](@ref)
 """
 struct ModelGenerator{G, K, P, B, S}
     model::G