barley 0.4.1 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d882b89bf1bf77259eda96813c4732ef1b286142ecb29fcb945837b743e089c9
-  data.tar.gz: 87dc3b213a614957a668c08865b87eb44f805cf76b79a60c710025a7d18257d8
+  metadata.gz: 4143d89558b7c17c5c0ca1c0fc3fc20083b178a79ecdbc957e6cc3a0dc170189
+  data.tar.gz: 0d3c0c2c74ea618a5df4a4ed29155f625ee58836024112816aa5055c3c064531
 SHA512:
-  metadata.gz: a7eb159a6e40374364504f5c828d7e1f82e7a581bd89fe374182916b0dbc6863caaea779acf409e58c8fe60ff3614acdfa944bb3f74dbd808957925db146dded
-  data.tar.gz: d84b0157c80e83cfa28dbafda0fd300f2774c4362b5e1e47f9fc0381fb0cd8713dce2f1b27f4cfb9896af2c11d354d92b8df0dcfaee6a94bb69e6aca738e45b2
+  metadata.gz: 68d5f3bd3ba0a85e4d9365fa928fe425323bd469fc11e68e60ecbc8d3f52f078c2a449109446668c18750d18633b9de6ce3f4478d82db41c0847b1ec49289236
+  data.tar.gz: 7ab87897947545f171ce458042c63deecfb6e22555cfc97e508d2233215360ac78d804a32d8bf46bd73e9edac3104622e3831203263056cf70a1085401d908cb

data/README.md

@@ -4,7 +4,7 @@
 [![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. 
 
@@ -36,6 +36,10 @@ class UserSerializer < Barley::Serializer
 
   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
@@ -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.
 
@@ -200,6 +215,51 @@ Feel like using a block to define your associations? You can do that too.
   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. It is also available in nested serializers.
+
+```ruby
+class PostSerializer < Barley::Serializer
+  attributes :id, :title, :body
+
+  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:
 

data/lib/barley/serializer.rb

@@ -3,6 +3,7 @@
 module Barley
   class Serializer
     attr_accessor :object
+    attr_accessor :context
 
     class << self
       attr_accessor :defined_attributes
@@ -127,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
@@ -160,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] 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
@@ -177,7 +186,7 @@ module Barley
           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
@@ -192,8 +201,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]]
@@ -224,6 +235,25 @@ module Barley
       Barley::Cache.delete(key)
     end
 
+    # Sets the context object for the serializer
+    #
+    # The context object is a Struct built from the given arguments.
+    # It can be used to pass additional data to the serializer. The context object is accessible in the serializer with the `context` attribute.
+    # @example
+    #   serializer.with_context(current_user: current_user, locale: I18n.locale)
+    #   # => #<Barley::Serializer:0x00007f8f3b8b3e08 @object=#<Product id: 1, name: "Product 1">, @context=#<struct current_user=1, locale=:en>>
+    #   # In the serializer:
+    #   attribute :name do
+    #     "#{object.name[context.locale]}" # Will use the locale from the context
+    #   end
+    # @param args [Hash] the context object attributes
+    # @return [Barley::Serializer] the serializer
+    def with_context(**args)
+      @context = Struct.new(*args.keys).new(*args.values)
+
+      self
+    end
+
     private
 
     # @api private
@@ -247,15 +277,15 @@ module Barley
     # Serializes the object
     #
     # @api private
+    # @raise [Barley::Error] if no attribute or relation is defined in the serializer
     #
     # @return [Hash] the serializable hash
     def _serializable_hash
-      hash = {}
+      raise Barley::Error, "No attribute or relation defined in #{self.class}" if defined_attributes.blank?
 
-      defined_attributes.each do |key|
-        hash[key] = send(key)
+      hash = defined_attributes.each_with_object({}) do |key, result|
+        result[key] = send(key)
       end
-
       @root ? {root_key => hash} : hash
     end
 

data/lib/barley/version.rb

@@ -1,3 +1,3 @@
 module Barley
-  VERSION = "0.4.1"
+  VERSION = "0.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: barley
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: '0.6'
 platform: ruby
 authors:
 - Cedric Delalande
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-27 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.