barley 0.5 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4808cb10061c5a86be6edbf532a6fb041519e4b7b4a08b770e0d63854a5f61e1
-  data.tar.gz: 5ccb1ed50e9d440a0bb3e9c006280e970b70b5ecc64afb7b8660c0d326f58239
+  metadata.gz: 80e724f1d510a0774072dab90c06262278a06fd49adff8a77314852c2aafbe7f
+  data.tar.gz: a13898b638153e90c95c25d0558c54e63b2514c6095be81c5755fb5d92dbb544
 SHA512:
-  metadata.gz: 4562ae18d898be75d1abf2d2872bd5f79333f38e6a3e111548624ba6e4b19f4f7316087e36ff35f9103cac56a6b96e9d2f1fb32d1cfb1596430e1b81a1f68c2a
-  data.tar.gz: 13c86fbcb1d2678165bd128ea0e57ca80e1e4d63e3a3ccee09f9ac85838bab7cd0894d75cc832c7a513ac29fd697573039b8ee5a1621be1152e2a22c6525b5ce
+  metadata.gz: da037e1c4749228e9fa48db4dcc00a8b614ebac1acc5ba0646c61fce0b77a377e530581b7536bc08b3111747ed6303ce60d3a275ac4c8cef2231a1ef726d873b
+  data.tar.gz: 49b297c3db282da63110f28d9599157ac91f50c7fec42916e4a387c20ef0010ebfd3e4b4c53b03baa61985cdf17cdd7b79412eb388551d7c5a58d2c5f00b36b3

data/README.md

@@ -4,9 +4,9 @@
 [![Gem Version](https://badge.fury.io/rb/barley.svg)](https://badge.fury.io/rb/barley)
 ![Static Badge](https://img.shields.io/badge/Cereal%20-%20100%25%20-%20darklime)
 
-Barley is a dead simple, fast, and efficient ActiveModel serializer.
+Barley is a fast and efficient ActiveModel serializer.
 
-Cerealize your ActiveModel objects into flat hashes with a dead simple, yet versatile DSL, and caching and type-checking baked in. Our daily bread is to make your API faster. 
+Cerealize your ActiveModel objects into flat hashes with a dead simple, yet versatile DSL, and caching and type-checking baked in. Our daily bread is to make your API faster.
 
 You don't believe us? Check out the [benchmarks](#benchmarks). 😎
 
@@ -28,26 +28,30 @@ Then define your attributes and associations in a serializer class.
 ```ruby
 # /app/serializers/user_serializer.rb
 class UserSerializer < Barley::Serializer
-  
+
   attributes id: Types::Strict::Integer, :name
-  
+
   attribute :email
   attribute :value, type: Types::Coercible::Integer
 
   many :posts
-  
+
+  many :posts, key_name: :featured, scope: :featured
+
+  many :posts, key_name: :popular, scope: -> { where("views > 10_000").limit(3) }
+
   one :group, serializer: CustomGroupSerializer
-  
+
   many :related_users, key: :friends, cache: true
-  
+
   one :profile, cache: { expires_in: 1.day } do
     attributes :avatar, :social_url
-    
+
     attribute :badges do
       object.badges.map(&:display_name)
     end
   end
-    
+
 end
 ```
 
@@ -85,7 +89,7 @@ You can also define the serializer class with the `serializer` macro.
 # /app/models/user.rb
 class User < ApplicationRecord
   include Barley::Serializable
-  
+
   serializer UserSerializer
 end
 ```
@@ -139,12 +143,12 @@ You can define a custom serializer for the association with the `serializer` opt
 
 You can of course define serializers with inner classes for simple needs.
 
-```ruby 
+```ruby
 class UserSerializer < Barley::Serializer
   attributes :id, :name, :email, :created_at, :updated_at
 
   one :group, serializer: LocalGroupSerializer
-  
+
     class LocalGroupSerializer < Barley::Serializer
         attributes :id, :name
     end
@@ -174,6 +178,17 @@ You can define a custom serializer for the association with the `serializer` opt
   many :posts, serializer: CustomPostSerializer, cache: { expires_in: 1.hour }
 ```
 
+##### Scope
+You can pass a scope to the association with the `scope` option. It can either be a symbol referencing a named scope on your associated model, or a lambda.
+
+```ruby
+  many :posts, scope: :published # given you have a scope named `published` on your Post model
+```
+
+```ruby
+  many :posts, scope: -> { where(published: true).limit(4) }
+```
+
 ##### Key name
 You can also pass a key name for the association with the `key_name` option.
 
@@ -193,21 +208,30 @@ Feel like using a block to define your associations? You can do that too.
 ```ruby
   many :posts do
     attributes :id, :title, :body
-  
+
     one :author do
       attributes :name, :email
     end
   end
 ```
 
+Of course, all the options available for the `one` and `many` macros are also available for the block syntax.
+
+```ruby
+  many :posts, key_name: :featured do
+    attributes :id, :title, :body
+  end
+```
+
 ## Context
+
 You can pass a context to the serializer with the `with_context` method.
 
 ```ruby
 serializer = PostSerializer.new(Post.last).with_context(current_user: current_user)
 ```
 
-This context will be available in the serializer with the `context` method.
+This context will be available in the serializer with the `context` method. It is also available in nested serializers.
 
 ```ruby
 class PostSerializer < Barley::Serializer
@@ -216,14 +240,31 @@ class PostSerializer < Barley::Serializer
   attribute :is_owner do
     object.user == context.current_user
   end
+
+  many :comments do
+    many :likes do
+      attribute :is_owner do
+        object.user == context.current_user # context is here too!
+      end
+    end
+  end
 end
 ```
 
+### Using a custom context object
+Barley generates a Struct from the context hash you pass to the with_context method. But you can also pass a custom context object directly in the initializer instead.
+
+```ruby
+my_context = Struct.new(:current_user).new(current_user)
+
+serializer = PostSerializer.new(Post.last, context: my_context)
+```
+
 ## Generators
 You have two generators available. One to generate the serializer class:
 
 ```shell
-rails generate barley:serializer User 
+rails generate barley:serializer User
 # or
 rails generate barley:serializer User --name=CustomUserSerializer
 ```
@@ -277,7 +318,7 @@ end
 ```
 
 ## Type checking
-Barley can check the type of the object you are serializing with the [dry-types](https://dry-rb.org/gems/dry-types/main/) gem. 
+Barley can check the type of the object you are serializing with the [dry-types](https://dry-rb.org/gems/dry-types/main/) gem.
 
 It will raise an error if the object is not of the expected type, or coerce it to the correct type and perform constraints checks.
 
@@ -304,7 +345,7 @@ You will soon be able to replace all occurrences of `Serializer` with `Cerealize
 # /app/models/user.rb
 class User < ApplicationRecord
   include Barley::Cerealizable
-  
+
   cerealizer UserCerealizer
 end
 

data/lib/barley/serializer.rb

@@ -128,7 +128,7 @@ module Barley
           return {} if element.nil?
 
           el_serializer = serializer || element.serializer.class
-          el_serializer.new(element, cache: cache).serializable_hash
+          el_serializer.new(element, cache: cache, context: @context).serializable_hash
         end
         self.defined_attributes = (defined_attributes || []) << key_name
       end
@@ -161,12 +161,20 @@ module Barley
       #   many :groups, cache: {expires_in: 1.hour}
       #   # => {groups: [{id: 1234, name: "Group 1"}, {id: 5678, name: "Group 2"}]}
       #
+      # @example using a named scope
+      #   many :groups, scope: :active # given the scope `active` is defined in the Group model
+      #   # => {groups: [{id: 5678, name: "Group 2"}]}
+      #
+      # @example using a lambda scope
+      #   many :groups, scope: -> { order(id: :asc).limit(1) }
+      #   # => {groups: [{id: 1234, name: "Group 1"}]}
       # @param key [Symbol] the association name
       # @param key_name [Symbol] the key name in the hash
       # @param serializer [Class] the serializer to use
       # @param cache [Boolean, Hash<Symbol, ActiveSupport::Duration>] whether to cache the result, or a hash with options for the cache
+      # @param scope [Symbol, Proc] the scope to use to fetch the elements
       # @param block [Proc] a block to use to define the serializer inline
-      def many(key, key_name: nil, serializer: nil, cache: false, &block)
+      def many(key, key_name: nil, serializer: nil, cache: false, scope: nil, &block)
         key_name ||= key
         if block
           serializer = Class.new(Barley::Serializer) do
@@ -175,10 +183,15 @@ module Barley
         end
         define_method(key_name) do
           elements = object.send(key)
+          if scope.is_a?(Symbol)
+            elements = elements.send(scope)
+          elsif scope.is_a?(Proc)
+            elements = elements.instance_exec(&scope)
+          end
           return [] if elements.empty?
 
           el_serializer = serializer || elements.first.serializer.class
-          elements.map { |element| el_serializer.new(element, cache: cache).serializable_hash }.reject(&:blank?)
+          elements.map { |element| el_serializer.new(element, cache: cache, context: @context).serializable_hash }.reject(&:blank?)
         end
         self.defined_attributes = (defined_attributes || []) << key_name
       end
@@ -193,8 +206,10 @@ module Barley
     # @param object [Object] the object to serialize
     # @param cache [Boolean, Hash<Symbol, ActiveSupport::Duration>] a boolean to cache the result, or a hash with options for the cache
     # @param root [Boolean] whether to include the root key in the hash
-    def initialize(object, cache: false, root: false)
+    # @param context [Object] an optional context object to pass additional data to the serializer
+    def initialize(object, cache: false, root: false, context: nil)
       @object = object
+      @context = context
       @root = root
       @cache, @expires_in = if cache.is_a?(Hash)
         [true, cache[:expires_in]]

data/lib/barley/version.rb

@@ -1,3 +1,3 @@
 module Barley
-  VERSION = "0.5"
+  VERSION = "0.6.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: barley
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: 0.6.1
 platform: ruby
 authors:
 - Cedric Delalande
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-19 00:00:00.000000000 Z
+date: 2024-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.27
 signing_key: 
 specification_version: 4
 summary: Barley is a dead simple, fast, and efficient ActiveModel serializer.