barley 0.8 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6da2835a5aa80d5ad8df847a595c104a92d1b0a34146f648368acfc95d98712f
-  data.tar.gz: 1c2b3c65b17e99f95d80f2842b2a7e99a73d93cdecd91b62943f1c9a6ff3e463
+  metadata.gz: 65659a284da526170cf31f02c88e4e1f8a9739bd2a74db1efcaed57c6a142ed1
+  data.tar.gz: 0d23f80698d7f723a9e86bc7bbf9930a18d999fe7c2b923ec3bcff4cf08b6223
 SHA512:
-  metadata.gz: 5feba636b2205ce2b1be958e00d62e04509bec4d441405fcb669b76c455cd2209bddce0fc8ceedfa3a44f7251f22d1449b5315b6abcbf96cc0d85ac6924f903e
-  data.tar.gz: '08010326d833ba31944fddc5cf90c82db6a8002c0d8c2ae1f22dc2c137b1169b2f2841e58ec64daff403583ed08dacc4b2ad33dffa75a2ff5b270d69b67c1687'
+  metadata.gz: 7c1783516b1805df6d02a424791d6148852d429e987f3c0d090345ed01085a7e1777c0748791efa8a0d79fc55711fb27c209d61aa1e1724c49ee34f2b0cbd488
+  data.tar.gz: f4de8fb9cfdb8f034dae1d64e0cc4732e2a00a6d308848070b27c79d52a6ae8d23faf65be6dc420c9971b823a70b6227561e507e997dddd5396f5f200e640936

data/README.md

@@ -299,7 +299,7 @@ user = User.find(1)
 user.as_json(serializer: CustomUserSerializer, cache: { expires_in: 1.hour })
 ```
 
-Beware, this gem overrides the `as_json` method on your model. Calling `as_json` with `include`, `only`, or `except` options will not work.
+Beware, this gem overrides the `as_json` method on your model. Calling `as_json` with `include`, `only`, or `except` options will not work as expected.
 
 Why? We believe it defeats the purpose of this gem. If you want to customize the serialization of your model, you should use a serializer class.
 

data/lib/barley/railtie.rb

@@ -1,3 +1,4 @@
+require "rails/engine"
 module Barley
   class Railtie < ::Rails::Railtie
   end

data/lib/barley/serializable.rb

@@ -65,7 +65,8 @@ module Barley
         cache = options[:cache] || false
         root = options[:root] || false
         begin
-          serializer.new(self, cache: cache, root: root, only: options[:only], except: options[:except]).serializable_hash
+          serializer.new(self, cache: cache, root: root).serializable_hash
+            .as_json(only: options[:only], except: options[:except])
         rescue NameError
           raise Barley::Error, "Could not find serializer for #{self}. Please define a #{serializer} class."
         end

data/lib/barley/serializer.rb

@@ -2,8 +2,10 @@
 
 module Barley
   class Serializer
-    attr_accessor :object
-    attr_accessor :context
+    EMPTY_ARRAY = [].freeze
+    EMPTY_HASH = {}.freeze
+
+    attr_accessor :object, :context
 
     class << self
       attr_accessor :defined_attributes
@@ -81,7 +83,10 @@ module Barley
           if type.nil?
             value
           else
-            raise Barley::InvalidAttributeError, "Invalid value type found for attribute #{key_name}::#{type.name}: #{value}::#{value.class}" unless type.valid?(value)
+            unless type.valid?(value)
+              raise Barley::InvalidAttributeError,
+                    "Invalid value type found for attribute #{key_name}::#{type.name}: #{value}::#{value.class}"
+            end
 
             type[value]
           end
@@ -125,19 +130,21 @@ module Barley
       # @param block [Proc] a block to use to define the serializer inline
       def one(key, key_name: nil, serializer: nil, cache: false, &block)
         key_name ||= key
-        if block
-          serializer = Class.new(Barley::Serializer) do
+        resolved_serializer = serializer
+        resolved_serializer_from_block = nil
+        if block && !serializer
+          resolved_serializer_from_block = Class.new(Barley::Serializer) do
             instance_eval(&block)
           end
         end
+
         define_method(key_name) do
           element = object.send(key)
-          return {} if element.nil?
+          return EMPTY_HASH if element.nil?
 
-          el_serializer = serializer || element.serializer.class
-          only = @only.find { |k| k.is_a?(Hash) && k.key?(key) }.slice(key).values.first if @only.present?
-          except = @except.find { |k| k.is_a?(Hash) && k.key?(key) }.slice(key).values.first if @except.present?
-          el_serializer.new(element, cache: cache, context: @context, only: only, except: except).serializable_hash
+          el_serializer = resolved_serializer || resolved_serializer_from_block || element.serializer.class
+
+          el_serializer.new(element, cache: cache, context: @context).serializable_hash
         end
         self.defined_attributes = (defined_attributes || []) << key_name
       end
@@ -185,28 +192,47 @@ module Barley
       # @param block [Proc] a block to use to define the serializer inline
       def many(key, key_name: nil, serializer: nil, cache: false, scope: nil, &block)
         key_name ||= key
-        if block
-          serializer = Class.new(Barley::Serializer) do
+        resolved_serializer = serializer
+        resolved_serializer_from_block = nil
+        if block && !serializer
+          resolved_serializer_from_block = Class.new(Barley::Serializer) do
             instance_eval(&block)
           end
         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 = if scope.arity == 1
-              elements.instance_exec(@context, &scope)
-            else
-              elements.instance_exec(&scope)
-            end
+          return EMPTY_ARRAY if elements.nil? || (elements.respond_to?(:empty?) && elements.empty?)
+
+          if scope
+            elements = if scope.is_a?(Symbol)
+                         elements.send(scope)
+                       else
+                         (if scope.arity == 1
+                            elements.instance_exec(@context, &scope)
+                          else
+                            elements.instance_exec(&scope)
+                          end)
+                       end
+          end
+          return EMPTY_ARRAY if elements.empty?
+
+          el_serializer_class = resolved_serializer || resolved_serializer_from_block || element.serializer.class
+          serializer_instance = el_serializer_class.new(nil, cache: cache, context: @context)
+
+          result = []
+          elements.each do |element|
+            serializer_instance.object = element
+            # This assumes _serializable_hash primarily depends on @object,
+            # @context, and @effective_options (set during its own init).
+            serialized = serializer_instance.send(:_serializable_hash) # Use send for private method
+
+            next if serialized.nil? || (serialized.respond_to?(:empty?) && serialized.empty?)
+
+            result << serialized
           end
-          return [] if elements.empty?
 
-          el_serializer = serializer || elements.first.serializer.class
-          only = @only.find { |k| k.is_a?(Hash) && k.key?(key) }.slice(key).values.first if @only.present?
-          except = @except.find { |k| k.is_a?(Hash) && k.key?(key) }.slice(key).values.first if @except.present?
-          elements.map { |element| el_serializer.new(element, cache: cache, context: @context, only: only, except: except).serializable_hash }.reject(&:blank?)
+          result
         end
         self.defined_attributes = (defined_attributes || []) << key_name
       end
@@ -222,41 +248,29 @@ module Barley
     # @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
     # @param context [Object] an optional context object to pass additional data to the serializer
-    # @param only [Array<Symbol>] an array of attributes to include
-    # @param except [Array<Symbol>] an array of attributes to exclude
-    def initialize(object, cache: false, root: false, context: nil, only: nil, except: nil)
+    def initialize(object, cache: false, root: false, context: nil)
       @object = object
       @context = context
       @root = root
-      @only = only
-      @except = except
       @cache, @expires_in = if cache.is_a?(Hash)
-        [true, cache[:expires_in]]
-      else
-        [cache, nil]
-      end
+                              [true, cache[:expires_in]]
+                            else
+                              [cache, nil]
+                            end
     end
 
     # Serializes the object
     #
     # @return [Hash] the serializable hash
     def serializable_hash
-      hash = if @cache
+      # Cache check first
+      if @cache
         Barley::Cache.fetch(cache_base_key, expires_in: @expires_in) do
           _serializable_hash
         end
       else
         _serializable_hash
       end
-      if @only.present?
-        only = @only.map { |k| k.is_a?(Hash) ? k.keys.first : k }
-        hash.slice!(*only)
-      end
-      if @except.present?
-        except = @except.reject { |k| k.is_a?(Hash) }
-        hash.except!(*except)
-      end
-      hash
     end
 
     # Clears the cache for the object
@@ -293,7 +307,7 @@ module Barley
     #
     # @return [String] the cache key
     def cache_base_key
-      if object.updated_at.present?
+      if object.respond_to?(:updated_at) && object.updated_at.present?
         "#{object.class.name&.underscore}/#{object.id}/#{object.updated_at&.to_i}/barley_cache/"
       else
         "#{object.class.name&.underscore}/#{object.id}/barley_cache/"
@@ -314,19 +328,25 @@ module Barley
     #
     # @return [Hash] the serializable hash
     def _serializable_hash
-      raise Barley::Error, "No attribute or relation defined in #{self.class}" if defined_attributes.blank?
+      attrs = defined_attributes
+      raise Barley::Error, 'No attribute or relation defined in the serializer' if attrs.nil?
 
-      hash = defined_attributes.each_with_object({}) do |key, result|
-        result[key] = send(key)
+      return @root ? { root_key => EMPTY_HASH } : EMPTY_HASH if attrs.nil? || attrs.empty?
+
+      hash = {}
+      attrs.each do |key|
+        value = send(key)
+        hash[key] = value unless value.nil?
       end
-      @root ? {root_key => hash} : hash
+
+      @root ? { root_key => hash } : hash
     end
 
     # @api private
     #
     # @return [Symbol] the root key, based on the class name
     def root_key
-      object.class.name.underscore.to_sym
+      @root_key = object_class.name.underscore.to_sym
     end
   end
 end

data/lib/barley/version.rb

@@ -1,3 +1,3 @@
 module Barley
-  VERSION = '0.8'
+  VERSION = "0.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: barley
 version: !ruby/object:Gem::Version
-  version: '0.8'
+  version: 0.9.0
 platform: ruby
 authors:
 - Cedric Delalande
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-25 00:00:00.000000000 Z
+date: 2025-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-types