panko_serializer 0.8.4 → 1.0.0

data/docs/docs/getting-started.md

@@ -1,70 +0,0 @@
----
-id: getting-started
-title: Getting Started
-sidebar_label: Getting Started
----
-## Installation
-
-To install Panko, all you need is to add it to your Gemfile:
-
-```ruby
-
-gem "panko_serializer"
-
-```
-
-Then, install it on the command line:
-
-```
-
- bundle install
-
-```
-
-## Creating your first serializer
-
-Let's create a serializer and use it inside of a Rails controller:
-
-```ruby
-class PostSerializer < Panko::Serializer
-  attributes :title
-end
-
-class UserSerializer < Panko::Serializer
-  attributes :id, :name, :age
-
-  has_many :posts, serializer: PostSerializer
-end
-```
-
-### Serializing an object
-
-And now serialize a single object:
-
-```ruby
-
-# Using Oj serializer
-PostSerializer.new.serialize_to_json(Post.first)
-
-# or, similar to #serializable_hash
-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.
-To utilize the `UserSerializer` inside a Rails controller and serialize some users, all we need to do is:
-
-```ruby
-
-class UsersController < ApplicationController
- def index
-   users = User.includes(:posts).all
-   render json: Panko::ArraySerializer.new(users, each_serializer: UserSerializer).to_json
- end
-end
-
-```
-
-And voila, we have an endpoint which serializes users using Panko!

data/docs/docs/introduction.md

@@ -1,13 +0,0 @@
----
-id: index
-title: Introduction
-sidebar_label: Introduction
-slug: /
----
-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/performance/):
-
--   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 itself, instead of relying on ActiveRecord.

data/docs/docs/performance.md

@@ -1,32 +0,0 @@
----
-id: performance
-title: Performance
-sidebar_label: Performance
----
-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.
-
-| Benchmark         | AMS ip/s | Panko ip/s |
-| ----------------- | -------- | ---------- |
-| Simple_Posts_2300 | 11.72    | 523.05     |
-| Simple_Posts_50   | 557.29   | 23,011.9   |
-| HasOne_Posts_2300 | 5.91     | 233.44     |
-| HasOne_Posts_50   | 285.8    | 10,362.79  |
-
-## Real-world benchmark
-
-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 |
-| ------------------ | ----- | ----- |
-| Avg Response Time  | 4.89s | 1.48s |
-| Max Response Time  | 5.42s | 1.83s |
-| 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._

data/docs/docs/response-bag.md

@@ -1,83 +0,0 @@
----
-id: response-bag
-title: Response
-sidebar_label: Response
----
-Let's say you have some JSON payload which is constructed using Panko serialization result,
-like this:
-
-```ruby
-
-class PostsController < ApplicationController
-  def index
-   posts = Post.all
-   render json: {
-     success: true,
-     total_count: posts.count,
-     posts: Panko::ArraySerializer.new(posts, each_serializer: PostSerializer).to_json
-   }
-  end
-end
-
-```
-
-The output of the above will be a JSON string (for `posts`) inside a JSON string and this were `Panko::Response` shines.
-
-```ruby
-
-class PostsController < ApplicationController
-  def index
-   posts = Post.all
-   render json: Panko::Response.new(
-     success: true,
-     total_count: posts.count,
-     posts: Panko::ArraySerializer.new(posts, each_serializer: PostSerializer)
-   )
-  end
-end
-
-```
-
-And everything will work as expected!
-
-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
-
-class PostsController < ApplicationController
-  def show
-    post = Post.find(params[:id])
-
-    render(
-      json: Panko::Response.create do |r|
-        {
-          success: true,
-          post: r.serializer(post, PostSerializer)
-        }
-      end
-    )
-  end
-end
-
-```
-
-## JsonValue
-
-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
-
-class PostsController < ApplicationController
-  def index
-   posts = Cache.get("/posts")
-
-   render json: Panko::Response.new(
-     success: true,
-     total_count: posts.count,
-     posts: Panko::JsonValue.from(posts)
-   )
-  end
-end
-
-```

data/docs/docusaurus.config.js

@@ -1,86 +0,0 @@
-module.exports = {
-  "title": "Panko Serializers",
-  "tagline": "High Performance JSON Serialization for ActiveRecord & Ruby Objects",
-  "url": "https://panko.dev",
-  "baseUrl": "/",
-  "organizationName": "yosiat",
-  "projectName": "panko_serializer",
-  "favicon": "favicon.ico",
-  "customFields": {
-    "repoPath": "yosiat/panko_serializer",
-    "repoUrl": "https://github.com/yosiat/panko_serializer",
-  },
-  "onBrokenLinks": "log",
-  "onBrokenMarkdownLinks": "log",
-  "presets": [
-    [
-      "@docusaurus/preset-classic",
-      {
-        "docs": {
-          "path": "./docs",
-          "showLastUpdateAuthor": false,
-          "showLastUpdateTime": false,
-          "sidebarPath": "./sidebars.json",
-          "routeBasePath": process.env.NODE_ENV === 'production' ? '/docs' : '/',
-        },
-        "blog": false,
-        "pages": false,
-        "theme": {
-          "customCss": "./src/css/customTheme.css"
-        }
-      }
-    ]
-  ],
-  "plugins": [],
-  "themeConfig": {
-    colorMode: {
-      defaultMode: 'light',
-      disableSwitch: true,
-    },
-    "navbar": {
-      "title": "Panko Serializers",
-      "items": [
-        {
-          "to": "introduction",
-          "label": "Docs",
-          "position": "left"
-        }
-      ]
-    },
-    "image": "img/undraw_online.svg",
-    "footer": {
-      "links": [
-        {
-          title: "GitHub",
-          items: [
-            {
-              label: "Repository",
-              href: "https://github.com/yosiat/panko_serializer"
-            },
-            {
-              label: "Discussions",
-              href: "https://github.com/yosiat/panko_serializer/discussions"
-            },
-            {
-              label: "Issues",
-              href: "https://github.com/yosiat/panko_serializer/issues"
-            },
-            {
-              "html": `
-                  <iframe
-                    src="https://ghbtns.com/github-btn.html?user=yosiat&amp;repo=panko_serializer&amp;type=star&amp;count=true&amp;size=medium"
-                    title="GitHub Stars"
-                  />`
-            }
-          ]
-        }
-      ],
-      "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
-      additionalLanguages: ['ruby'], // Add Ruby as an additional language
-    },
-  }
-}