panko_serializer 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e04b05a5a9a72ce68ad0768dd84b403e4adb6cefa8226f89c30a09d480993481
-  data.tar.gz: 1d7ff5f7b035a497e4b7d48e9749bfc13c3861cfb067b53b167b54c2ce5c8822
+  metadata.gz: 7b4397a54b1f806131ee07ccaaa4062bba8eb5490c3810e5c6c3cc405b7167ec
+  data.tar.gz: 8f3127a38fe93844c3a82aa8e2a30ea82312ef1b0ebdf66f86bcd4761c392749
 SHA512:
-  metadata.gz: 9bcb10f0e30eb48277dcdc9eea463dd475e892ed6eca37818d0d21eb9978cabeb1d0c7b1b8989ff69c1dc5c9b958fe8d0d073f0861d4b7207054e33677d615e7
-  data.tar.gz: 98846622471bed88140fe737f12144e9221e8a439c181c45d3e4ae1cd95aef265e640dd5bb4fda1d6beb8f4fc1f6eecc016620d31b9ec2a51fec6cc214683830
+  metadata.gz: 626bf9689a4be25a166a7ee3fe3b2274cfcc9b7bb17d57398d87301aca1c8039835d02ef37de647d62d3fa5c102cc22f752b2400e10240fa992d2007eaf9344c
+  data.tar.gz: 9a0048188abc83c9a064a0bb7721cc94a7f3965338f62a84fe4382a7b98f52941c1a1914f25dfee3bc7ed80168a1bb47f7def51954b9b1250029e4784f6f0a5d

data/.github/workflows/database_matrix.yml

@@ -0,0 +1,85 @@
+name: Database Tests
+
+on: [push, pull_request]
+
+jobs:
+  database-matrix:
+    runs-on: ubuntu-latest
+    
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["3.4"]
+        rails: ["7.2.0", "8.0.0"]
+        database: ["sqlite", "postgresql", "mysql"]
+    
+    services:
+      postgres:
+        image: postgres:17
+        env:
+          POSTGRES_DB: panko_test
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: password
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+          
+      mysql:
+        image: mysql:8.0
+        env:
+          MYSQL_DATABASE: panko_test
+          MYSQL_ROOT_PASSWORD: password
+        options: >-
+          --health-cmd="mysqladmin ping"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=3
+        ports:
+          - 3306:3306
+
+    steps:
+      - name: Install system dependencies
+        run: |
+          sudo apt update -y
+          sudo apt install -y libsqlite3-dev libpq-dev libmysqlclient-dev
+
+      - uses: actions/checkout@v5
+      
+      - name: Configure MySQL authentication
+        if: matrix.database == 'mysql'
+        run: |
+          # Configure MySQL to use mysql_native_password for Trilogy compatibility
+          mysql -h 127.0.0.1 -P 3306 -u root -ppassword -e "
+            ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
+            ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'password';
+            FLUSH PRIVILEGES;
+          "
+        
+      - name: Set up Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+          working-directory: .
+        env:
+          BUNDLE_GEMFILE: gemfiles/${{ matrix.rails }}.gemfile
+          DB: ${{ matrix.database }}
+
+      - name: Compile & test
+        env:
+          BUNDLE_GEMFILE: gemfiles/${{ matrix.rails }}.gemfile
+          DB: ${{ matrix.database }}
+          POSTGRES_HOST: localhost
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: password
+          POSTGRES_PORT: 5432
+          MYSQL_HOST: localhost
+          MYSQL_USER: root
+          MYSQL_PASSWORD: password
+          MYSQL_PORT: 3306
+        run: |
+          bundle exec rake

data/.github/workflows/docs.yml

@@ -15,7 +15,7 @@ jobs:
       working_directory: 'docs/'
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Use Node.js ${{ matrix.node-version }}
       uses: actions/setup-node@v4
       with:

data/.github/workflows/lint.yml

@@ -3,11 +3,11 @@ name: Lint
 on: [push, pull_request]
 
 jobs:
-  build:
+  lint:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Install deps
         run: |
@@ -23,7 +23,7 @@ jobs:
           bundle exec rake rubocop
 
       - name: Lint C
-        uses: jidicula/clang-format-action@v4.13.0
+        uses: jidicula/clang-format-action@v4.16.0
         with:
           clang-format-version: "16"
           check-path: "ext/panko_serializer"

data/.github/workflows/tests.yml

@@ -0,0 +1,34 @@
+name: Panko Serializer CI
+
+on: [push, pull_request]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["3.2", "3.3", "3.4"]
+        rails: ["7.2.0", "8.0.0", "8.1.0"]
+
+    steps:
+      - name: Install deps
+        run: |
+          sudo apt update -y
+          sudo apt install -y libsqlite3-dev
+
+      - uses: actions/checkout@v5
+      - name: Set up Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+          working-directory: .
+        env:
+          BUNDLE_GEMFILE: gemfiles/${{ matrix.rails }}.gemfile
+
+      - name: Compile & test
+        env:
+          BUNDLE_GEMFILE: gemfiles/${{ matrix.rails }}.gemfile
+        run: |
+          bundle exec rake

data/Appraisals

@@ -1,29 +1,28 @@
 # frozen_string_literal: true
 
-appraise "7.0.0" do
-  gem "sqlite3", "~> 1.4"
-  gem "activesupport", "~> 7.0.0"
-  gem "activemodel", "~> 7.0.0"
-  gem "activerecord", "~> 7.0.0", group: :test
-end
-
-appraise "7.1.0" do
-  gem "sqlite3", "~> 1.4"
-  gem "activesupport", "~> 7.1.5"
-  gem "activemodel", "~> 7.1.5"
-  gem "activerecord", "~> 7.1.5", group: :test
-end
-
 appraise "7.2.0" do
-  gem "sqlite3", "~> 1.4"
   gem "activesupport", "~> 7.2.0"
   gem "activemodel", "~> 7.2.0"
   gem "activerecord", "~> 7.2.0", group: :test
+
+  gem "trilogy"
+  gem "sqlite3", "~> 1.4"
 end
 
 appraise "8.0.0" do
-  gem "sqlite3", ">= 2.1"
   gem "activesupport", "~> 8.0.0"
   gem "activemodel", "~> 8.0.0"
   gem "activerecord", "~> 8.0.0", group: :test
+
+  gem "trilogy"
+  gem "sqlite3", ">= 2.1"
+end
+
+appraise "8.1.0" do
+  gem "activesupport", "~> 8.1.0"
+  gem "activemodel", "~> 8.1.0"
+  gem "activerecord", "~> 8.1.0", group: :test
+
+  gem "trilogy"
+  gem "sqlite3", ">= 2.1"
 end

data/Gemfile

@@ -17,6 +17,7 @@ end
 
 group :test do
   gem "faker"
+  gem "temping"
 end
 
 group :development do

data/README.md

@@ -4,20 +4,20 @@
 
 Panko is a library which is inspired by ActiveModelSerializers 0.9 for serializing ActiveRecord/Ruby objects to JSON strings, fast.
 
-To achieve its [performance](https://panko.dev/docs/performance/):
+To achieve its [performance](https://panko.dev/performance/):
 
 * Oj - Panko relies on Oj since it's fast and allows for incremental serialization using `Oj::StringWriter`
 * Serialization Descriptor - Panko computes most of the metadata ahead of time, to save time later in serialization.
 * Type casting — Panko does type casting by itself, instead of relying on ActiveRecord.
 
-To dig deeper about the performance choices, read [Design Choices](https://panko.dev/docs/design-choices/).
+To dig deeper about the performance choices, read [Design Choices](https://panko.dev/design-choices/).
 
 
 Support
 -------
 
-- [Documentation](https://panko.dev/docs)
-- [Getting Started](https://panko.dev/docs/getting-started/)
+- [Documentation](https://panko.dev/)
+- [Getting Started](https://panko.dev/getting-started/)
 
 License
 -------

data/docs/docs/associations.md

@@ -3,7 +3,7 @@ id: associations
 title: Associations
 sidebar_label: Associations
 ---
-A serializer can define it's own associations - both `has_many` and `has_one` to serializer under the context of the object.
+A serializer can define it's own associations - both `has_many` and `has_one` to serialize under the context of the object.
 
 For example:
 
@@ -38,8 +38,8 @@ end
 
 ### Inference
 
-Panko can find the type of the serializer by looking at the realtionship name, so instead specifying
-the serializer at the above example, we can -
+Panko can find the type of the serializer by looking at the relationship name, so instead of specifying
+the serializer at the above example, we can:
 
 ```ruby
 
@@ -52,19 +52,19 @@ end
 
 ```
 
-The logic of inferencing is -
+The logic of inferencing is:
 
--   Take the name of the relationship (for example - `:author` / `:comments`) singularize and camelize it
--   Look for const defined with the name aboe and "Serializer" suffix (by using `Object.const_get`)
+-   Take the name of the relationship (for example - `:author` / `:comments`) singularize and camelize it.
+-   Look for const defined with the name above and "Serializer" suffix (by using `Object.const_get`).
 
-> If Panko can't find the serializer it will throw an error on startup time, for example: `Can't find serializer for PostSerializer.author has_one relationship`
+> If Panko can't find the serializer it will throw an error on startup time, for example: `Can't find serializer for PostSerializer.author has_one relationship`.
 
 ## Nested Filters
 
 As talked before, Panko allows you to filter the attributes of a serializer.
-But Panko let you take that step further, and filters the attributes of you associations so you can re-use your serializers in your application.
+But Panko lets you take that step further, and filters the attributes of you associations so you can re-use your serializers in your application.
 
-For example, let's say one portion of the application needs to serializer list of posts and serializer their - `title`, `body`, author's id and comments id.
+For example, let's say one portion of the application needs to serialize a list of posts but only with their - `title`, `body`, author's id and comments id.
 
 We can declare tailored serializer for this, or we can re-use the above defined serializer - `PostSerializer` and use nested filters.
 
@@ -80,14 +80,14 @@ Panko::ArraySerializer.new(posts, each_serializer: PostSerializer, only: {
 
 ```
 
-Let's dissect `only` option we passed -
+Let's dissect the `only` option we passed:
 
--   `instance` - list of attributes (and associations) we want to serializer for current instance of the serializer, in this case - `PostSerializer`.
+-   `instance` - list of attributes (and associations) we want to serialize for the current instance of the serializer, in this case - `PostSerializer`.
 -   `author`, `comments` - here we specify the list of attributes we want to serialize for each association.
 
-It's important to note that Nested Filters, are recursive, in other words, we can filter the association's associations.
+It's important to note that Nested Filters are recursive, in other words, we can filter the association's associations.
 
-For example, `CommentSerializer` have has_one association `Author`, and for each `comments.author` we only it's name.
+For example, `CommentSerializer` has an `has_one` association `Author`, and for each `comments.author` we can only serialize it's name.
 
 ```ruby
 

data/docs/docs/attributes.md

@@ -3,7 +3,8 @@ id: attributes
 title: Attributes
 sidebar_label: Attributes
 ---
-Attributes allow you to specify which record attributes you want to serialize,
+Attributes allow you to specify which record attributes you want to serialize.
+
 There are two types of attributes:
 
 -   Field - simple columns defined on the record it self.
@@ -25,13 +26,13 @@ end
 
 Using field attributes you can control which columns of the given ActiveRecord object you want to serialize.
 
-Instead of relying ActiveRecord to do it's type casting, Panko does on it's own for performance reasons (read more in [Design Choices](design-choices.md#type-casting)).
+Instead of relying on ActiveRecord to do it's type casting, Panko does on it's own for performance reasons (read more in [Design Choices](design-choices.md#type-casting)).
 
 ## Method Attributes
 
 Method attributes are used when your serialized values can be derived from the object you are serializing.
 
-The serializer's attribute methods can access the object being serialized as `object` -
+The serializer's attribute methods can access the object being serialized as `object`:
 
 ```ruby
 
@@ -45,7 +46,7 @@ end
 
 ```
 
-Another useful, thing you can pass your serializer is `context`, a `context` is a bag of data whom your serializer may need.
+Another useful thing you can pass your serializer is `context`, a `context` is a bag of data whom your serializer may need.
 
 For example, here we will pass feature flags:
 
@@ -73,8 +74,8 @@ Filters allows us to reduce the amount of attributes we can serialize, therefore
 
 There are two types of filters:
 
--   only - use those attributes **only** and nothing else
--   except - all attributes **except** those attributes
+-   only - use those attributes **only** and nothing else.
+-   except - all attributes **except** those attributes.
 
 Usage example:
 
@@ -92,15 +93,13 @@ UserSerializer.new(except: [:name]).serialize(User.first)
 
 ```
 
-> **Note** that if you want to user filter on an associations, the `:name`
-> property is not taken into account.
-> If you have a `has_many :state_transitions, name: :history` association
-> defined, the key to use in filters is `:state_transitions`
-> (e.g. `{ except: [:state_transitions] }`)
+> **Note** that if you want to user filter on an associations, the `:name` property is not taken into account.
+If you have a `has_many :state_transitions, name: :history` association defined, the key to use in filters is 
+`:state_transitions` (e.g. `{ except: [:state_transitions] }`).
 
 ## Filters For
 
-Sometimes you find yourself have the same filtering logic in actions in order to
+Sometimes you find yourself having the same filtering logic in actions. In order to
 solve this duplication, Panko allows you to write the filters in the serializer.
 
 ```ruby
@@ -120,24 +119,32 @@ UserSerializer.serialize(User.first)
 
 ```
 
-> See discussion in: https:
+> See discussion in: [https:](https://github.com/yosiat/panko_serializer/issues/16)
 
 ## Aliases
 
-Let's say we have attribute name that we want to expose to client as different name, the current way of doing so is using method attribute, for example:
+Let's say we have an attribute name that we want to expose to client as different name, the current way of doing so is using method attribute, for example:
 
 ```ruby
 
+class PostSerializer < Panko::Serializer
+  attributes :published_at
 
+  def published_at
+    object.created_at
+  end
+end
 
 ```
 
-The downside of this approach is that `` skips Panko's type casting, therefore we get direct hit on performance.
+The downside of this approach is that `created_at` skips Panko's type casting, therefore we get a direct hit on performance.
 
-To fix this, we can use aliases -
+To fix this, we can use aliases:
 
 ```ruby
 
-
+class PostSerializer < Panko::Serializer
+  aliases created_at: :published_at
+end
 
 ```

data/docs/docs/design-choices.md

@@ -3,7 +3,7 @@ id: design-choices
 title: Design Choices
 sidebar_label: Design Choices
 ---
-In short, Panko, is a serializer for ActiveRecord objects (it can't serialize any other object), which strives for high performance & simple API (which is inspired by ActiveModelSerializers).
+In short, Panko is a serializer for ActiveRecord objects (it can't serialize any other object), which strives for high performance & simple API (which is inspired by ActiveModelSerializers).
 
 Its performance is achieved by:
 
@@ -13,7 +13,7 @@ Its performance is achieved by:
 
 ## Serialization overview
 
-First, let's start with overview. Let's say we want to serialize `User` object, which has
+First, let's start with an overview. Let's say we want to serialize an `User` object, which has
 `first_name`, `last_name`, `age`, and `email` properties.
 
 The serializer definition will be something like this:
@@ -46,14 +46,14 @@ serializer.serialize_to_json(user)
 ```
 
 Let's go over the steps that Panko will execute behind the scenes for this flow.
-_I will skip the serializer definition part, because it's fairly simple and straightforward (see `lib/panko/serializer.rb`)_
+_I will skip the serializer definition part, because it's fairly simple and straightforward (see `lib/panko/serializer.rb`)._
 
 First step, while initializing the UserSerializer, we will create a **Serialization Descriptor** for this class.
 Serialization Descriptor's goal is to answer those questions:
 
--   Which fields do we have? In our case, `:age`, `:email`
--   Which method fields do we have? In our case `:name`
--   Which associations do we have (and their serialization descriptors)
+-   Which fields do we have? In our case, `:age`, `:email`.
+-   Which method fields do we have? In our case `:name`.
+-   Which associations do we have (and their serialization descriptors)?
 
 The serialization description is also responsible for filtering the attributes (`only` \\ `except`).
 
@@ -65,7 +65,7 @@ In C land, we take the `user` object and the serialization descriptor, and start
 -   Serializing Method Fields - creating (a cached) serializer instance, setting its `@object` and `@context`, calling all the method fields and writing them to the writer.
 -   Serializing associations — this is simple, once we have fields + method fields, we just repeat the process.
 
-Once this is finished, we have nice JSON string.
+Once this is finished, we have a nice JSON string.
 Now let's dig deeper.
 
 ## Interesting parts
@@ -74,36 +74,36 @@ Now let's dig deeper.
 
 If you read the code of ActiveRecord serialization code in Ruby, you will observe this flow:
 
-1.  Get an array of ActiveRecord objects (`User.all` for example)
-2.  Build new array of hashes where each hash is `User` with the attributes we selected
-3.  The JSON serializer, takes this array of hashes and loop them, and converts it to JSON string
+1.  Get an array of ActiveRecord objects (`User.all` for example).
+2.  Build a new array of hashes where each hash is an `User` with the attributes we selected.
+3.  The JSON serializer, takes this array of hashes and loop them, and converts it to a JSON string.
 
 This entire process is expensive in terms of Memory & CPU, and this where the combination of Panko and Oj::StringWriter really shines. 
 
 In Panko, the serialization process of the above is:
 
-1.  Get an array of ActiveRecord objects (`User.all` for example)
+1.  Get an array of ActiveRecord objects (`User.all` for example).
 2.  Create `Oj::StringWriter` and feed the values to it, via `push_value` / `push_object` / `push_object` and behind the scene, `Oj::StringWriter` will serialize the objects incrementally into a string.
 3.  Get from `Oj::StringWriter` the completed JSON string — which is a no-op, since `Oj::StringWriter` already built the string.
 
 ### Figuring out the metadata, ahead of time.
 
-Another observation I noticed in the ruby serializers is that they ask and do a lot in a serialization loop: 
+Another observation I noticed in the Ruby serializers is that they ask and do a lot in a serialization loop: 
 
 -   Is this field a method? is it a property?
--   Which fields and associations do I need for the serializer to consider the `only` and `except` options
+-   Which fields and associations do I need for the serializer to consider the `only` and `except` options?
 -   What is the serializer of this has_one association?
 
 Panko tries to ask the bare minimum in serialization by building `Serialization Descriptor` for each serialization and caching it.
 
-The Serialization Descriptor will do the filtering of `only` and `except` and will check if a field is a method or not (therefore Panko doesn't have list of `attributes`)
+The Serialization Descriptor will do the filtering of `only` and `except` and will check if a field is a method or not (therefore Panko doesn't have list of `attributes`).
 
 ### Type Casting
 
 This is the final part, which helped yield most of the performance improvements.
-In ActiveRecord, when we read a value of attribute, it does type casting of the DB value to its real ruby type.
+In ActiveRecord, when we read the value of an attribute, it does type casting of the DB value to its real Ruby type.
 
-For example, time strings are converted to Time objects, Strings are duplicated, and Integers are converts from their values to Number.
+For example, time strings are converted to Time objects, Strings are duplicated, and Integers are converted from their values to Number.
 
 This type casting is really expensive, as it's responsible for most of the allocations in the serialization flow and most of them can be "relaxed".
 
@@ -123,5 +123,5 @@ The idea behind the time type casting code relies on the end result of JSON type
 The time type casting works as follows:
 
 -   If it's a string that ends with `Z`, and the strings matches the UTC ISO8601 regex, then we just return the string.
--   If it's a string and it doesn't follow the rules above, we check if it's a timestamp in database format and convert it via regex + string concat to UTC ISO8601 - Yes, there is huge assumption here, that the database returns UTC timestamps — this will be configureable (before Panko official release).
+-   If it's a string and it doesn't follow the rules above, we check if it's a timestamp in database format and convert it via regex + string concat to UTC ISO8601 - Yes, there is huge assumption here, that the database returns UTC timestamps — this will be configurable (before Panko official release).
 -   If it's none of the above, I will let ActiveRecord type casting do it's magic.

data/docs/docs/getting-started.md

@@ -23,7 +23,7 @@ Then, install it on the command line:
 
 ## Creating your first serializer
 
-Let's create serializer and use it inside Rails controller.
+Let's create a serializer and use it inside of a Rails controller:
 
 ```ruby
 class PostSerializer < Panko::Serializer
@@ -39,7 +39,7 @@ end
 
 ### Serializing an object
 
-And now serialize a single object
+And now serialize a single object:
 
 ```ruby
 
@@ -53,7 +53,7 @@ PostSerializer.new.serialize(Post.first).to_json
 
 ### Using the serializers in a controller
 
-As you can see, defining serializers is simple and resembles ActiveModelSerializers 0.9,
+As you can see, defining serializers is simple and resembles ActiveModelSerializers 0.9.
 To utilize the `UserSerializer` inside a Rails controller and serialize some users, all we need to do is:
 
 ```ruby
@@ -67,4 +67,4 @@ end
 
 ```
 
-And voila, we have endpoint which serialize users using Panko!
+And voila, we have an endpoint which serializes users using Panko!

data/docs/docs/introduction.md

@@ -4,10 +4,10 @@ title: Introduction
 sidebar_label: Introduction
 slug: /
 ---
-Panko is library which is inspired by ActiveModelSerializers 0.9 for serializing ActiveRecord/Ruby objects to JSON strings, fast.
+Panko is a library which is inspired by ActiveModelSerializers 0.9 for serializing ActiveRecord/Ruby objects to JSON strings, fast.
 
-To achieve it's [performance](https://panko.dev/docs/performance/):
+To achieve it's [performance](https://panko.dev/performance/):
 
--   Oj - Panko relies Oj since it's fast and allow to serialize incrementally using `Oj::StringWriter`
+-   Oj - Panko relies on Oj since it's fast and allow to serialize incrementally using `Oj::StringWriter`.
 -   Serialization Descriptor - Panko computes most of the metadata ahead of time, to save time later in serialization.
--   Type casting — Panko does type casting by it's self, instead of relying ActiveRecord.
+-   Type casting — Panko does type casting by itself, instead of relying on ActiveRecord.

data/docs/docs/performance.md

@@ -8,7 +8,7 @@ The performance of Panko is measured using microbenchmarks and load testing.
 ## Microbenchmarks
 
 The following microbenchmarks are run on MacBook Pro (16-inch, 2021, M1 Max), Ruby 3.2.0 with Rails 7.0.5
-demonstrating the performance of ActiveModelSerializers 0.10.13 and Panko 0.8.0
+demonstrating the performance of ActiveModelSerializers 0.10.13 and Panko 0.8.0.
 
 | Benchmark         | AMS ip/s | Panko ip/s |
 | ----------------- | -------- | ---------- |
@@ -19,8 +19,8 @@ demonstrating the performance of ActiveModelSerializers 0.10.13 and Panko 0.8.0
 
 ## Real-world benchmark
 
-The real-world benchmark here is endpoint which serializes 7,884 entries with 48 attributes and no associations.
-The benchmark took place in environment that simulates production environment and run using `wrk` from machine on the same cluster.
+The real-world benchmark here is an endpoint which serializes 7,884 entries with 48 attributes and no associations.
+The benchmark took place in an environment that simulates production environment and run using `wrk` from machine on the same cluster.
 
 | Metric             | AMS   | Panko |
 | ------------------ | ----- | ----- |
@@ -29,4 +29,4 @@ The benchmark took place in environment that simulates production environment an
 | 99th Response Time | 5.42s | 1.74s |
 | Total Requests     | 61    | 202   |
 
-_Thanks to [Bringg](https://www.bringg.com) for providing the infrastructure for the benchmarks_
+_Thanks to [Bringg](https://www.bringg.com) for providing the infrastructure for the benchmarks._

data/docs/docs/response-bag.md

@@ -3,7 +3,7 @@ id: response-bag
 title: Response
 sidebar_label: Response
 ---
-Let's say you have some JSON payload which can is constructed using Panko serialization result,
+Let's say you have some JSON payload which is constructed using Panko serialization result,
 like this:
 
 ```ruby
@@ -21,7 +21,7 @@ end
 
 ```
 
-The output of the above will be json string (for `posts`) inside json string and this were `Panko::Response` shines.
+The output of the above will be a JSON string (for `posts`) inside a JSON string and this were `Panko::Response` shines.
 
 ```ruby
 
@@ -40,7 +40,7 @@ end
 
 And everything will work as expected!
 
-For a single object serialization, we need to use a different API (since `Panko::Serializer` don't accept an object in it's constructor):
+For a single object serialization, we need to use a different API (since `Panko::Serializer` doesn't accept an object in it's constructor):
 
 ```ruby
 
@@ -63,8 +63,8 @@ end
 
 ## JsonValue
 
-Let's take the above example further, we serialized the posts and cached it as JSON string in our Cache.
-Now, you can wrap the cached value with `Panko::JsonValue`, like here -
+Let's take the above example further, we will serialize the posts and cache it as JSON string in our Cache.
+Now, you can wrap the cached value with `Panko::JsonValue`, like here:
 
 ```ruby
 

data/docs/docusaurus.config.js

@@ -78,8 +78,8 @@ module.exports = {
       "copyright": `Copyright © ${new Date().getFullYear()} Panko Serializer`,
     },
     prism: {
-      theme: require('prism-react-renderer/themes/github'), // Optional: Customize theme
-      darkTheme: require('prism-react-renderer/themes/dracula'), // Optional: Dark theme
+      theme: require('prism-react-renderer').themes.github, // Optional: Customize theme
+      darkTheme: require('prism-react-renderer').themes.dracula, // Optional: Dark theme
       additionalLanguages: ['ruby'], // Add Ruby as an additional language
     },
   }