rest_framework 0.9.4 → 0.9.6

data/docs/_guide/2_controllers.md

@@ -1,342 +0,0 @@
----
-layout: default
-title: Controllers
-position: 2
-slug: controllers
----
-# Controllers
-
-This is the core of the REST Framework. Generally speaking, projects already have an existing
-controller inheritance hierarchy, so we want developers to be able to maintain that project
-structure while leveraging the power of the REST Framework. Also, different controllers which
-inherit from the same parent often need different REST Framework functionality and behavior. For
-these reasons, REST Framework provides the controller functionality as modules that you mix into
-your controllers.
-
-Here is a graph of the controller mixins (all exist within the `RESTFramework` namespace), with
-supplementary mixins shown as well:
-
-```shell
-BaseControllerMixin
-BaseModelControllerMixin (includes BaseControllerMixin)
-ModelControllerMixin (includes BaseModelControllerMixin)
-├── ListModelMixin
-├── ShowModelMixin
-├── CreateModelMixin
-├── UpdateModelMixin
-└── DestroyModelMixin
-ReadOnlyModelControllerMixin (includes BaseModelControllerMixin)
-├── ListModelMixin
-└── ShowModelMixin
-BulkModelControllerMixin (includes ModelControllerMixin)
-├── BulkCreateModelMixin
-├── BulkUpdateModelMixin
-└── BulkDestroyModelMixin
-```
-
-All API controllers should include at least one of these top-level controller mixins, and can
-include any of the supplementary mixins to add additional functionality. For example, if you want to
-permit create but not update or destroy, then you could do this:
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::BaseModelControllerMixin
-  include RESTFramework::CreateModelMixin
-end
-```
-
-## BaseControllerMixin
-
-To transform a controller into the simplest possible RESTful controller, you can include
-`BaseControllerMixin`, which provides a simple `root` action so it can be used at the API root.
-
-```ruby
-class ApiController < ApplicationController
-  include RESTFramework::BaseControllerMixin
-end
-```
-
-### Response Rendering
-
-A fundamental feature that REST Framework provides is the ability to render a browsable API. This
-allows developers to discover and interact with the API's functionality, while also providing faster
-and more lightweight JSON/XML formats for consumption by the systems these developers create.
-
-The `api_response` method is how this is accomplished. The first argument is the data to be
-rendered (often an array or hash), and keyword arguments can be provided to customize the response
-(e.g., setting the HTTP status code). Using this method instead of the classic Rails helpers, such
-as `render`, will automatically provide the browsable API as well as JSON/XML rendering.
-
-Here is a simple example of rendering a hash with a `message` key:
-
-```ruby
-class ApiController < ApplicationController
-  include RESTFramework::BaseControllerMixin
-  self.extra_actions = {test: :get}
-
-  def test
-    api_response({message: "Test successful!"})
-  end
-end
-```
-
-### Routing Extra Actions
-
-The `extra_actions` property defines extra actions on the controller to be routed. It is a hash of
-`endpoint -> method(s)` (where `method(s)` can be a method symbol or an array of method symbols).
-
-```ruby
-class ApiController < ApplicationController
-  include RESTFramework::BaseControllerMixin
-  self.extra_actions = {test: :get}
-
-  def test
-    api_response({message: "Test successful!"})
-  end
-end
-```
-
-Or with multiple methods:
-
-```ruby
-class ApiController < ApplicationController
-  include RESTFramework::BaseControllerMixin
-  self.extra_actions = {test: [:get, :post]}
-
-  def test
-    api_response({message: "Test successful!"})
-  end
-end
-```
-
-If your action conflicts with a builtin method, then you can also override the path:
-
-```ruby
-class ApiController < ApplicationController
-  include RESTFramework::BaseControllerMixin
-
-  # This will route `test_action` to `/test`, in case there is already a `test` method that cannot
-  # be overridden.
-  self.extra_actions = {test_action: {path: :test, methods: :get}}
-
-  def test_action
-    api_response({message: "Test successful!"})
-  end
-end
-```
-
-## ModelControllerMixin
-
-`ModelControllerMixin` assists with providing the standard model CRUD (create, read, update,
-destroy) for your controller. This is the most commonly used mixin since it provides default
-behavior for models which matches Rails' resourceful routing.
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-end
-```
-
-By default, all columns and associations are included in the controller's `fields`, which can be
-helpful when developing an administrative API. For most APIs, however, `fields` should be explicitly
-defined. See [Specifying the Fields](#specifying-the-fields) for more information.
-
-### Defining the Model
-
-The `model` property allows you to define the model if it is not derivable from the controller name.
-
-```ruby
-class Api::CoolMoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  self.model = Movie
-end
-```
-
-### Specifying the Recordset
-
-The `recordset` property allows you to define the set of records this API should be limited to. If
-you need to change the recordset based on properties of the request, then you can override the
-`get_recordset` method.
-
-```ruby
-class Api::CoolMoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  self.recordset = Movie.where(cool: true).order({id: :asc})
-end
-```
-
-If you override `get_recordset`, you should ensure you also set the `model` property if it's not
-derivable from the controller name.
-
-```ruby
-class Api::CoolMoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  self.model = Movie
-
-  def get_recordset
-    return Movie.where(cool: true).order({id: :asc})
-  end
-end
-```
-
-### Specifying Extra Member Actions
-
-While `extra_actions` (and the synonym `extra_collection_actions`) allows you to define additional
-actions on the controller, `extra_member_actions` allows you to define additional member actions on
-the controller, which require a record ID to be provided as a path param.
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  self.extra_member_actions = {disable: :patch}
-
-  def disable
-    # REST Framework will rescue ActiveRecord::RecordNotFound.
-    @record = self.get_record
-
-    # REST Framework will rescue ActiveRecord::RecordInvalid or ActiveRecord::RecordNotSaved.
-    @record.update!(enabled: false)
-
-    return api_response(@record)
-  end
-end
-```
-
-### Specifying the Fields
-
-The `fields` property defines the fields available for things like serialization and allowed
-parameters in body or query params. If `fields` is not set, then it will default to all columns and
-associations, which is helpful when developing an administrative API. For most APIs, however,
-`fields` should be explicitly defined.
-
-While you can also define per-request fields by overriding `get_fields`, you should also define a
-set of fields on the controller which is used for things like the `OPTIONS` metadata.
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  self.fields = [:id, :name]
-end
-```
-
-You can also mutate the default set of fields by removing existing columns/associations, and even
-adding methods. The framework will automatically detect if the given field is a column, association,
- or method, and will handle it appropriately.
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  # This will include all columns, all associations except `owners`, and the `is_featured` method.
-  self.fields = {
-    exclude: [:owners],
-    include: [:is_featured],
-  }
-end
-```
-
-### Specifying the Serializer Configuration
-
-For most cases, the default serializer configuration is sufficient, and can be modified by adjusting
-the `fields` property on the controller. However, there are cases where you may want to define a
-serializer configuation, such as when you want to customize nested associations, or if you want to
-remove certain fields (like methods) when serializing multiple records.
-
-The property  `native_serializer_config` defines the serializer configuration if you are using the
-default serializer. You can also specify serializers for singular/plural data.
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  self.native_serializer_config = {
-    only: [:id, :name],
-    methods: [:active, :some_expensive_computed_property],
-    include: {cast_members: { only: [:id, :name], methods: [:net_worth] }},
-  }
-
-  # Or you could configure a default and a plural serializer:
-  self.native_serializer_config = {
-    only: [:id, :name],
-    methods: [:active, :some_expensive_computed_property],
-    include: {cast_members: { only: [:id, :name], methods: [:net_worth] }},
-  }
-  self.native_serializer_plural_config = {
-    only: [:id, :name],
-    methods: [:active],
-    include: {cast_members: { only: [:id, :name], methods: [:net_worth] }},
-  }
-
-  # Or you could configure a default and a singular serializer:
-  self.native_serializer_config = {
-    only: [:id, :name],
-    methods: [:active],
-    include: {cast_members: { only: [:id, :name], methods: [:net_worth] }},
-  }
-  self.native_serializer_singular_config = {
-    only: [:id, :name],
-    methods: [:active, :some_expensive_computed_property],
-    include: {cast_members: { only: [:id, :name], methods: [:net_worth] }},
-  }
-end
-```
-
-### Specifying Allowed Parameters
-
-The `allowed_parameters` property defines the allowed parameters for create/update actions. The
-framework uses strong parameters to execute this filtering.
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  self.allowed_parameters = [:name]
-end
-```
-
-If you want different allowed parameters for create/update actions, or if you need stronger control
-over what request body parameters get passed to create/update, then you can also override the
-`get_create_params` or `get_update_params` methods.
-
-### Controlling Create Behavior
-
-The `create_from_recordset` attribute (`true` by default) is a boolean to control the behavior in
-the `create` action. If it is disabled, records will not be created from the filtered recordset, but
-rather will be created directly from the model interface.
-
-For example, if this is your controller:
-
-```ruby
-class Api::CoolMoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  # Notice that `cool` is read-only with the following two configurations:
-  self.fields = [:id, :name]
-  self.native_serializer_config = {only: [:id, :name, :cool]}
-
-  # New records created from this controller will have `cool` set to `true`.
-  def get_recordset
-    return Movie.where(cool: true)
-  end
-end
-```
-
-Then if you hit the `create` action with the payload `{name: "Superman"}`, it will also set `cool`
-to `true` on the new record, because that property is inherited from the recordset.
-
-## ReadOnlyModelControllerMixin
-
-`ReadOnlyModelControllerMixin` only enables list/show actions.
-
-```ruby
-class Api::ReadOnlyMoviesController < ApiController
-  include RESTFramework::ReadOnlyModelControllerMixin
-
-  self.model = Movie
-end
-```

data/docs/_guide/3_serializers.md

@@ -1,60 +0,0 @@
----
-layout: default
-title: Serializers
-position: 3
-slug: serializers
----
-# Serializers
-
-Serializers allow complex objects to be converted to Ruby primitives (`Array` and `Hash` objects),
-which can then be converted to JSON or XML.
-
-## NativeSerializer
-
-This serializer uses Rails' native `ActiveModel::Serialization.serializable_hash` method to convert
-records/recordsets to Ruby primitives (`Array` and `Hash`).
-
-This is the default serializer, you can configure it using the controller class attributes
-`native_serializer_config` (or `native_serializer_singular_config` /
-`native_serializer_plural_config`):
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  self.native_serializer_config = {
-    only: [:id, :name],
-    methods: [:active, :some_expensive_computed_property],
-    include: {cast_members: { only: [:id, :name] }},
-  }
-end
-```
-
-If you want to re-use a serializer, then you can define it as a standalone class, and you can even
-nest them. You can also define separate configurations for serializing individual records vs
-recordsets using `singular_config` and `plural_config`, respectively.
-
-```ruby
-class Api::MoviesController < ApiController
-  include RESTFramework::ModelControllerMixin
-
-  class CastMemberSerializer < RESTFramework::NativeSerializer
-    self.config = { only: [:id, :name], methods: [:net_worth] }
-    self.plural_config = { only: [:id, :name] }
-  end
-
-  class MovieSerializer < RESTFramework::NativeSerializer
-    self.config = {
-      only: [:id, :name],
-      include: {cast_members: CastMemberSerializer.new(many: true)},
-    }
-    self.singular_config = {
-      only: [:id, :name],
-      methods: [:active, :some_expensive_computed_property],
-      include: {cast_members: CastMemberSerializer.new(many: true)},
-    }
-  end
-
-  self.serializer_class = MovieSerializer
-end
-```

data/docs/_guide/4_filtering_and_ordering.md

@@ -1,41 +0,0 @@
----
-layout: default
-title: Filtering / Ordering
-position: 4
-slug: filtering-and-ordering
----
-# Filtering and Ordering
-
-While you can control the recordset that the API exposes, sometimes you want the user to control the
-records they want to see, or the order of those records. Both filtering and ordering are
-accomplished through a generic mechanism called "filters". To control the filter backends that a
-controller uses, you can either adjust the `filter_backends` controller attribute or you can
-override the `get_filter_backends()` method.
-
-## ModelQueryFilter
-
-This filter provides basic user-controllable filtering of the recordset using query params. For
-example, a request to `/api/movies?cool=true` would return movies where `cool` is `true`.
-
-If you include `ModelControllerMixin` into your controller, `ModelQueryFilter` is included in the filter
-backends by default.
-
-## ModelOrderingFilter
-
-This filter provides basic user-controllable ordering of the recordset using query params. For
-example, a request to `/api/movies?ordering=name` could order the movies by `name` rather than `id`.
-`ordering=-name` would invert the ordering. You can also order with multiple parameters with a comma
-separated list, like: `ordering=director,-name`.
-
-If you include `ModelControllerMixin` into your controller, `ModelOrderingFilter` is included in the
-filter backends by default. You can use `ordering_fields` to controller which fields are allowed to
-be ordered by. To adjust the parameter that the user passes, adjust `ordering_query_param`; the
-default is `"ordering"`.
-
-## ModelSearchFilter
-
-This filter provides basic user-controllable searching of the recordset using the `search` query
-parameter (adjustable with the `search_query_param`). For example, a request to
-`/api/movies?search=Star` could return movies where `name` contains the string `Star`. The search is
-performed against the `search_fields` attribute, but if that is not set, then the search is
-performed against a configurable default set of fields (`search_columns`).

data/docs/_guide/5_pagination.md

@@ -1,21 +0,0 @@
----
-layout: default
-title: Pagination
-position: 5
-slug: pagination
----
-# Pagination
-
-For large result sets, you may need to provide pagination. You can configure the paginator for a
-controller by setting the `paginator_class` to the paginator you want to use.
-
-## PageNumberPaginator
-
-This is a simple paginator which splits a recordset into pages and allows the user to select the
-desired page using the `page` query parameter (e.g., `/api/movies?page=3`). To adjust this query
-parameter, set the `page_query_param` controller attribute.
-
-By default the user can adjust the page size using the `page_size` query param. To adjust this query
-parameter, you can set the `page_size_query_param` controller attribute, or set it to `nil` to
-disable this functionality. By default, there is no upper limit to the size of a page a user can
-request. To enforce an upper limit, set the `max_page_size` controller attribute.

data/docs/_includes/anchor_headings.html

@@ -1,144 +0,0 @@
-{% capture headingsWorkspace %}
-  {% comment %}
-    Copyright (c) 2018 Vladimir "allejo" Jimenez
-
-    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.
-  {% endcomment %}
-  {% comment %}
-    Version 1.0.7
-      https://github.com/allejo/jekyll-anchor-headings
-
-    "Be the pull request you wish to see in the world." ~Ben Balter
-
-    Usage:
-      {% include anchor_headings.html html=content anchorBody="#" %}
-
-    Parameters:
-      * html          (string) - the HTML of compiled markdown generated by kramdown in Jekyll
-
-    Optional Parameters:
-      * beforeHeading (bool)   : false  - Set to true if the anchor should be placed _before_ the heading's content
-      * anchorAttrs   (string) :  ''    - Any custom HTML attributes that will be added to the `<a>` tag; you may NOT use `href`, `class` or `title`;
-                                          the `%heading%` and `%html_id%` placeholders are available
-      * anchorBody    (string) :  ''    - The content that will be placed inside the anchor; the `%heading%` placeholder is available
-      * anchorClass   (string) :  ''    - The class(es) that will be used for each anchor. Separate multiple classes with a space
-      * anchorTitle   (string) :  ''    - The `title` attribute that will be used for anchors
-      * h_min         (int)    :  1     - The minimum header level to build an anchor for; any header lower than this value will be ignored
-      * h_max         (int)    :  6     - The maximum header level to build an anchor for; any header greater than this value will be ignored
-      * bodyPrefix    (string) :  ''    - Anything that should be inserted inside of the heading tag _before_ its anchor and content
-      * bodySuffix    (string) :  ''    - Anything that should be inserted inside of the heading tag _after_ its anchor and content
-
-    Output:
-      The original HTML with the addition of anchors inside of all of the h1-h6 headings.
-  {% endcomment %}
-
-  {% assign minHeader = include.h_min | default: 1 %}
-  {% assign maxHeader = include.h_max | default: 6 %}
-  {% assign beforeHeading = include.beforeHeading %}
-  {% assign nodes = include.html | split: '<h' %}
-
-  {% capture edited_headings %}{% endcapture %}
-
-  {% for _node in nodes %}
-    {% capture node %}{{ _node | strip }}{% endcapture %}
-
-    {% if node == "" %}
-      {% continue %}
-    {% endif %}
-
-    {% assign nextChar = node | replace: '"', '' | strip | slice: 0, 1 %}
-    {% assign headerLevel = nextChar | times: 1 %}
-
-    <!-- If the level is cast to 0, it means it's not a h1-h6 tag, so let's see if we need to fix it -->
-    {% if headerLevel == 0 %}
-      <!-- Split up the node based on closing angle brackets and get the first one. -->
-      {% assign firstChunk = node | split: '>' | first %}
-
-      <!-- If the first chunk does NOT contain a '<', that means we've broken another HTML tag that starts with 'h' -->
-      {% unless firstChunk contains '<' %}
-        {% capture node %}<h{{ node }}{% endcapture %}
-      {% endunless %}
-
-      {% capture edited_headings %}{{ edited_headings }}{{ node }}{% endcapture %}
-      {% continue %}
-    {% endif %}
-
-    {% capture _closingTag %}</h{{ headerLevel }}>{% endcapture %}
-    {% assign _workspace = node | split: _closingTag %}
-    {% assign _idWorkspace = _workspace[0] | split: 'id="' %}
-    {% assign _idWorkspace = _idWorkspace[1] | split: '"' %}
-    {% assign html_id = _idWorkspace[0] %}
-
-    {% capture _hAttrToStrip %}{{ _workspace[0] | split: '>' | first }}>{% endcapture %}
-    {% assign header = _workspace[0] | replace: _hAttrToStrip, '' %}
-
-    <!-- Build the anchor to inject for our heading -->
-    {% capture anchor %}{% endcapture %}
-
-    {% if html_id and headerLevel >= minHeader and headerLevel <= maxHeader %}
-      {% capture anchor %}href="#{{ html_id }}"{% endcapture %}
-
-      {% if include.anchorClass %}
-        {% capture anchor %}{{ anchor }} class="{{ include.anchorClass }}"{% endcapture %}
-      {% endif %}
-
-      {% if include.anchorTitle %}
-        {% capture anchor %}{{ anchor }} title="{{ include.anchorTitle | replace: '%heading%', header }}"{% endcapture %}
-      {% endif %}
-
-      {% if include.anchorAttrs %}
-        {% capture anchor %}{{ anchor }} {{ include.anchorAttrs | replace: '%heading%', header | replace: '%html_id%', html_id }}{% endcapture %}
-      {% endif %}
-
-      {% capture anchor %}<a {{ anchor }}>{{ include.anchorBody | replace: '%heading%', header | default: '' }}</a>{% endcapture %}
-
-      <!-- In order to prevent adding extra space after a heading, we'll let the 'anchor' value contain it -->
-      {% if beforeHeading %}
-        {% capture anchor %}{{ anchor }} {% endcapture %}
-      {% else %}
-        {% capture anchor %} {{ anchor }}{% endcapture %}
-      {% endif %}
-    {% endif %}
-
-    {% capture new_heading %}
-      <h{{ _hAttrToStrip }}
-        {{ include.bodyPrefix }}
-        {% if beforeHeading %}
-          {{ anchor }}{{ header }}
-        {% else %}
-          {{ header }}{{ anchor }}
-        {% endif %}
-        {{ include.bodySuffix }}
-      </h{{ headerLevel }}>
-    {% endcapture %}
-
-    <!--
-    If we have content after the `</hX>` tag, then we'll want to append that here so we don't lost any content.
-    -->
-    {% assign chunkCount = _workspace | size %}
-    {% if chunkCount > 1 %}
-      {% capture new_heading %}{{ new_heading }}{{ _workspace | last }}{% endcapture %}
-    {% endif %}
-
-    {% capture edited_headings %}{{ edited_headings }}{{ new_heading }}{% endcapture %}
-  {% endfor %}
-{% endcapture %}{% assign headingsWorkspace = '' %}{{ edited_headings | strip }}

data/docs/_includes/external.html

@@ -1,9 +0,0 @@
-<!-- AUTOGENERATED -->
-<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha2/dist/css/bootstrap.min.css" integrity="sha384-aFq/bzH65dt+w6FI2ooMVUpc+21e0SRygnTpmBvdBgSdnuTN7QbdgL+OapgHtvPp" crossorigin="anonymous">
-<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha2/dist/js/bootstrap.bundle.min.js" integrity="sha384-qKXV1j0HvMUeCBQ+QVp7JcfGl760yU08IQ+GpUo5hlbpg51QRiuqHAJz8+BrxE/N" crossorigin="anonymous" referrerpolicy="no-referrer" defer="defer"></script>
-<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.4/font/bootstrap-icons.min.css" crossorigin="anonymous">
-<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/highlight.min.js" integrity="sha512-bgHRAiTjGrzHzLyKOnpFvaEpGzJet3z4tZnXGjpsCcqOnAH6VGUx9frc5bcIhKTVLEiCO6vEhNAgx5jtLUYrfA==" crossorigin="anonymous" referrerpolicy="no-referrer" defer="defer"></script>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/languages/json.min.js" integrity="sha512-0xYvyncS9OLE7GOpNBZFnwyh9+bq4HVgk4yVVYI678xRvE22ASicF1v6fZ1UiST+M6pn17MzFZdvVCI3jTHSyw==" crossorigin="anonymous" referrerpolicy="no-referrer" defer="defer"></script>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/languages/xml.min.js" integrity="sha512-5zBcw+OKRkaNyvUEPlTSfYylVzgpi7KpncY36b0gRudfxIYIH0q0kl2j26uCUB3YBRM6ytQQEZSgRg+ZlBTmdA==" crossorigin="anonymous" referrerpolicy="no-referrer" defer="defer"></script>
-<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/styles/a11y-dark.min.css" integrity="sha512-Vj6gPCk8EZlqnoveEyuGyYaWZ1+jyjMPg8g4shwyyNlRQl6d3L9At02ZHQr5K6s5duZl/+YKMnM3/8pDhoUphg==" crossorigin="anonymous" class="rrf-dark-mode">
-<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/styles/a11y-light.min.css" integrity="sha512-WDk6RzwygsN9KecRHAfm9HTN87LQjqdygDmkHSJxVkVI7ErCZ8ZWxP6T8RvBujY1n2/E4Ac+bn2ChXnp5rnnHA==" crossorigin="anonymous" class="rrf-light-mode">