barley 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bc8bd44e2c9b9653aa196be4fed266d72f91cf9d9e48f9f3ed8a850d05055ec
-  data.tar.gz: 63417812f015521d1a266ec51fab95dbbc2a76629c095bf816ba741f30a0dc63
+  metadata.gz: be82895a01fc1f0be3170a9a105b7fdf20b7e98d31a77c74c5d9f67068814dec
+  data.tar.gz: 276dcc80814079aed898b1e4d1d9e5b6bf3bc4b8b6b86f2b5cff701961d2b877
 SHA512:
-  metadata.gz: de4d7276205147c55ce71acf4e4c2936772fc687c2a1353c39d5260dee8ebf13b8f32329196932bde8649f208ab5c3b6c01206a05bc35bdd4aafddf7c140e0e0
-  data.tar.gz: c68bd133f4ef0457f206842b6d2e2493400f142835c362e286cc10ec559b6860381375f3aba050f4ae8ad746fa5db56f2e5da9b5e66ed2ee7b656905dc4bb7f6
+  metadata.gz: 9f3482dc0562669991a64403c9c5cee510d61cc5ec79affa3715eb203ac1a48f1f15c676778d380eccbfe6efc57281eae6c179ab4378a62d35c31b0fd65529ea
+  data.tar.gz: b9d2a98edf8704acf8b8466042b924b771384e1756fd06f9d23939f9bd0fb4368a4934303057edd0a53d0c8f487dc93c10649e39fe17b3031189f383a668ec54

data/README.md

@@ -2,7 +2,7 @@
 
 Barley is a dead simple, fast, and efficient ActiveModel JSON serializer.
 
-Cerealize your ActiveModel objects into flat JSON objects with a dead simple DSL. 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 baked in. Our daily bread is to make your API faster. 
 
 You don't believe us? Check out the [benchmarks](#benchmarks). 😎
 
@@ -21,10 +21,19 @@ Then define your attributes and associations in a serializer class.
 ```ruby
 # /app/serializers/user_serializer.rb
 class UserSerializer < Barley::Serializer
-  attributes :id, :name, :email, :created_at, :updated_at
-
-  many :posts
-  one :group
+  attributes :id, :name,
+  attribute :email # single attribute
+
+  many :posts # relations
+  one :group, serializer: CustomGroupSerializer # custom serializer
+  many :related_users, key: :friends, cache: true # custom key, and caching
+  one :profile, cache: { expires_in: 1.day } do # cache definition, and block (on associations) for nested, on-the-fly serializer
+    attributes :avatar, :social_url
+    attribute :badges do
+      object.badges.map(&:display_name) # use object in a block to return custom code
+    end
+  end
+    
 end
 ```
 
@@ -92,6 +101,12 @@ You can also define a custom attribute with a block. You will have a `object` va
   end
 ```
 
+You can also set a custom key name for the attribute with the `key_name` option.
+
+```ruby
+  attribute :updated_at, key: :last_change
+```
+
 ### Associations
 
 #### One-to-one
@@ -101,14 +116,6 @@ You can define a one-to-one association with the `one` macro.
   one :group
 ```
 
-You can also define a custom association with a block. You will have a `object` variable available in the block. It is the object you are serializing.
-
-```ruby
-  one :group do
-    object.group.name
-  end
-```
-
 ##### Custom serializer and caching
 You can define a custom serializer for the association with the `serializer` option, and / or caching options with the `cache` option.
 
@@ -128,9 +135,15 @@ class UserSerializer < Barley::Serializer
         attributes :id, :name
     end
 end
+```
+
+##### Key name
 
+You can also pass a key name for the association with the `key_name` option.
+
+```ruby
+  one :group, key_name: :team
 ```
-end
 
 #### One-to-many
 You can define a one-to-many association with the `many` macro.
@@ -139,20 +152,38 @@ You can define a one-to-many association with the `many` macro.
   many :posts
 ```
 
-You can also define a custom association with a block. You will have a `object` variable available in the block. It is the object you are serializing.
+##### Custom serializer and caching
+
+You can define a custom serializer for the association with the `serializer` option, and / or caching options with the `cache` option.
 
 ```ruby
-  many :posts do
-    object.posts.map(&:title)
-  end
+  many :posts, serializer: CustomPostSerializer, cache: { expires_in: 1.hour }
 ```
 
-##### Custom serializer and caching
+##### Key name
+You can also pass a key name for the association with the `key_name` option.
 
-You can define a custom serializer for the association with the `serializer` option, and / or caching options with the `cache` option.
+```ruby
+  many :posts, key_name: :articles
+```
+
+### Associations with blocks
+Feel like using a block to define your associations? You can do that too.
 
 ```ruby
-  many :posts, serializer: CustomPostSerializer, cache: { expires_in: 1.hour }
+  one :group do
+    attributes :id, :name
+  end
+```
+
+```ruby
+  many :posts do
+    attributes :id, :title, :body
+  
+    one :author do
+      attributes :name, :email
+    end
+  end
 ```
 
 ## Generators
@@ -209,9 +240,6 @@ Barley uses the MemoryStore by default. You can change the cache store with the
 # /config/initializers/barley.rb
 Barley.configure do |config|
   config.cache_store = ActiveSupport::Cache::RedisCacheStore.new
-  # config.cache_store = ActiveSupport::Cache::MemoryStore.new
-  # config.cache_store = ActiveSupport::Cache::FileStore.new
-  # config.cache_store = Rails.cache
 end
 ```
 
@@ -242,15 +270,17 @@ rails generate barley:cerealizer User
 
 Ah ah ah. This is so funny.
 
+*Note: we are thinking about adding a `Surrealizer` class for the most advanced users. Stay tuned.*
+
 ## JSON:API
-No. Not yet. Maybe never. We don't know. We don't care. We don't use it. We don't like it. We don't want to. We don't have time. We don't have money. We don't have a life. We don't have a girlfriend. We don't have a boyfriend. We don't have a dog. We don't have a cat. We are generating this readme with Copilot.
+Barley does not serialize to the JSON:API standard. We prefer to keep it simple and fast.
 
 ## Benchmarks
 This gem is blazing fast and efficient. It is 2 to 3 times faster than [ActiveModel::Serializer](https://github.com/rails-api/active_model_serializers) and twice as fast as [FastJsonapi](https://github.com/Netflix/fast_jsonapi). Memory object allocation is also much lower.
 
 With caching enabled, it is just mind-blowing. We think. *Disclaimer: we do not serialize to the JSON:API standard, so that might be the reason why we are so fast.*
 
-This is the result we get with the benchmark script used in the AMS repo on an Apple Silicon M1Pro processor. We will push this benchmark as soon as possible so you can see for yourself.
+This is the result we get with the benchmark script used in the AMS repo on an Apple Silicon M1Pro processor. [Check it out for yourself here](https://github.com/MoskitoHero/active_model_serializers/tree/benchmarks).
 
 ```shell
 bundle exec ruby benchmark.rb
@@ -330,3 +360,8 @@ ams               :    1299674 allocated - 28.20x more
 
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Credits
+Barley is brought to you by the developer team from [StockPro](https://www.stock-pro.fr/).
+
+[![Barley is brought to you by StockPro](img/stockpro.png)](https://www.stock-pro.fr/)

data/lib/barley/serializable.rb

@@ -33,9 +33,9 @@ module Barley
     included do
       serializer "#{self}Serializer".constantize
 
-      def as_json(serializer: nil, cache: false)
+      def as_json(serializer: nil, cache: false, root: false)
         serializer ||= self.serializer.class
-        serializer.new(self, cache: cache).as_json
+        serializer.new(self, cache: cache, root: root).serializable_hash
       end
     end
   end

data/lib/barley/serializer.rb

@@ -4,75 +4,90 @@ module Barley
   class Serializer
     attr_accessor :object
 
-    # @example with cache
-    #   Barley::Serializer.new(object, cache: true)
-    # @example with cache and expires_in
-    #   Barley::Serializer.new(object, cache: {expires_in: 1.hour})
-    def initialize(object, cache: false)
-      @object = object
-      @cache, @expires_in = if cache.is_a?(Hash)
-        [true, cache[:expires_in]]
-      else
-        [cache, nil]
+    class << self
+      def attributes(*keys)
+        keys.each do |key|
+          define_method(key) do
+            object.send(key)
+          end
+          set_class_iv(:@defined_attributes, key)
+        end
       end
-    end
 
-    def self.attributes(*keys)
-      keys.each do |key|
-        define_method(key) do
-          object.send(key)
+      def attribute(key, key_name: nil, &block)
+        key_name ||= key
+        if block
+          define_method(key_name) do
+            instance_eval(&block)
+          end
+        else
+          define_method(key_name) do
+            object.send(key)
+          end
         end
-        set_class_iv(:@defined_attributes, key)
+        set_class_iv(:@defined_attributes, key_name)
       end
-    end
 
-    def self.attribute(key, &block)
-      if block
-        define_method(key) do
-          instance_eval(&block)
+      def one(key, key_name: nil, serializer: nil, cache: false, &block)
+        key_name ||= key
+        if block
+          serializer = Class.new(Barley::Serializer) do
+            instance_eval(&block)
+          end
         end
-      else
-        define_method(key) do
-          object.send(key)
+        define_method(key_name) do
+          element = object.send(key)
+          return {} if element.nil?
+
+          el_serializer = serializer || element.serializer.class
+          el_serializer.new(element, cache: cache).serializable_hash
         end
+        set_class_iv(:@defined_attributes, key_name)
       end
-      set_class_iv(:@defined_attributes, key)
-    end
 
-    def self.set_class_iv(iv, key)
-      instance_variable_defined?(iv) ? instance_variable_get(iv) << key : instance_variable_set(iv, [key])
-    end
+      def many(key, key_name: nil, serializer: nil, cache: false, &block)
+        key_name ||= key
+        if block
+          serializer = Class.new(Barley::Serializer) do
+            instance_eval(&block)
+          end
+        end
+        define_method(key_name) do
+          elements = object.send(key)
+          return [] if elements.empty?
 
-    def self.one(key, serializer: nil, cache: false)
-      define_method(key) do
-        element = object.send(key)
-        return {} if element.nil?
+          el_serializer = serializer || elements.first.serializer.class
+          elements.map { |element| el_serializer.new(element, cache: cache).serializable_hash }.reject(&:blank?)
+        end
+        set_class_iv(:@defined_attributes, key_name)
+      end
 
-        el_serializer = serializer || element.serializer.class
-        el_serializer.new(element, cache: cache).as_json
+      def set_class_iv(iv, key)
+        instance_variable_defined?(iv) ? instance_variable_get(iv) << key : instance_variable_set(iv, [key])
       end
-      set_class_iv(:@defined_attributes, key)
     end
 
-    def self.many(key, serializer: nil, cache: false)
-      define_method(key) do
-        elements = object.send(key)
-        return [] if elements.empty?
-
-        el_serializer = serializer || elements.first.serializer.class
-        elements.map { |element| el_serializer.new(element, cache: cache).as_json }.reject(&:blank?)
+    # @example with cache
+    #   Barley::Serializer.new(object, cache: true)
+    # @example with cache and expires_in
+    #   Barley::Serializer.new(object, cache: {expires_in: 1.hour})
+    def initialize(object, cache: false, root: false)
+      @object = object
+      @root = root
+      @cache, @expires_in = if cache.is_a?(Hash)
+        [true, cache[:expires_in]]
+      else
+        [cache, nil]
       end
-      set_class_iv(:@defined_attributes, key)
     end
 
-    def as_json
+    def serializable_hash
       if @cache
-        cache_key = cache_base_key
-        Barley::Cache.fetch(cache_key, expires_in: @expires_in) do
-          _as_json
+        Barley::Cache.fetch(cache_base_key, expires_in: @expires_in) do
+          _serializable_hash
         end
       else
-        _as_json
+        _serializable_hash
       end
     end
 
@@ -83,21 +98,29 @@ module Barley
     private
 
     def cache_base_key
-      "#{self.class.name.underscore}/#{object.id}/#{object.updated_at.to_i}/as_json/"
+      if 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/"
+      end
     end
 
     def defined_attributes
       self.class.instance_variable_get(:@defined_attributes)
     end
 
-    def _as_json
+    def _serializable_hash
       hash = {}
 
       defined_attributes.each do |key|
         hash[key] = send(key)
       end
 
-      hash
+      @root ? {root_key => hash} : hash
+    end
+
+    def root_key
+      object.class.name.underscore.to_sym
     end
   end
 end

data/lib/barley/version.rb

@@ -1,3 +1,3 @@
 module Barley
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: barley
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Cedric Delalande
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-10 00:00:00.000000000 Z
+date: 2023-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails