barley 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9bc8bd44e2c9b9653aa196be4fed266d72f91cf9d9e48f9f3ed8a850d05055ec
+  data.tar.gz: 63417812f015521d1a266ec51fab95dbbc2a76629c095bf816ba741f30a0dc63
+SHA512:
+  metadata.gz: de4d7276205147c55ce71acf4e4c2936772fc687c2a1353c39d5260dee8ebf13b8f32329196932bde8649f208ab5c3b6c01206a05bc35bdd4aafddf7c140e0e0
+  data.tar.gz: c68bd133f4ef0457f206842b6d2e2493400f142835c362e286cc10ec559b6860381375f3aba050f4ae8ad746fa5db56f2e5da9b5e66ed2ee7b656905dc4bb7f6

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,332 @@
+![Barley loqo](./img/barley.png)
+
+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. 
+
+You don't believe us? Check out the [benchmarks](#benchmarks). 😎
+
+## Usage
+Add the `Barley::Serializable` module to your ActiveModel object.
+
+```ruby
+# /app/models/user.rb
+class User < ApplicationRecord
+  include Barley::Serializable
+end
+```
+
+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
+end
+```
+
+The just use the `as_json` method on your model.
+
+```ruby
+user = User.find(1)
+user.as_json
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "barley"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install barley
+```
+
+## Defining the serializer
+
+Barley uses the model name to find the serializer class. For example, if you have a `User` model, Barley will look for a `UserSerializer` class.
+
+You can also define the serializer class with the `serializer` macro.
+
+```ruby
+# /app/models/user.rb
+class User < ApplicationRecord
+  include Barley::Serializable
+  
+  serializer UserSerializer
+end
+```
+
+## DSL
+
+### Attributes
+You can define attributes with the `attributes` macro.
+
+```ruby
+  attributes :id, :name, :email, :created_at, :updated_at
+```
+
+You can also define attributes one by one, or a mix of both.
+
+```ruby
+  attributes :id, :name, :email
+  attribute :created_at
+  attribute :updated_at
+```
+
+You can also define a custom attribute with a block. You will have a `object` variable available in the block. It is the object you are serializing.
+
+```ruby
+  attribute :full_name do
+    "#{object.first_name} #{object.last_name}"
+  end
+```
+
+### Associations
+
+#### One-to-one
+You can define a one-to-one association with the `one` macro.
+
+```ruby
+  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.
+
+```ruby
+  one :group, serializer: CustomGroupSerializer, cache: { expires_in: 1.hour }
+```
+
+You can of course define serializers with inner classes for simple needs.
+
+```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
+end
+
+```
+end
+
+#### One-to-many
+You can define a one-to-many association with the `many` macro.
+
+```ruby
+  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.
+
+```ruby
+  many :posts do
+    object.posts.map(&:title)
+  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.
+
+```ruby
+  many :posts, serializer: CustomPostSerializer, cache: { expires_in: 1.hour }
+```
+
+## Generators
+You have two generators available. One to generate the serializer class:
+
+```shell
+rails generate barley:serializer User 
+# or
+rails generate barley:serializer User --name=CustomUserSerializer
+```
+
+And one to generate both the serializer class and add the module to the model:
+
+```shell
+rails generate barley:serializable User
+# or
+rails generate barley:serializable User --name=CustomUserSerializer
+```
+
+## Serialization options
+You can pass a hash of options to the `as_json` method.
+
+```ruby
+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.
+
+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.
+
+
+## Caching
+Barley supports caching out of the box. Just pass `cache: true` to the `serializer` macro.
+
+```ruby
+# /app/models/user.rb
+# ...
+serializer UserSerializer, cache: true
+```
+
+Or you can pass a hash of options to the `serializer` macro.
+
+```ruby
+# /app/models/user.rb
+# ...
+serializer UserSerializer, cache: { expires_in: 1.hour }
+```
+
+### Caching options
+Barley uses the MemoryStore by default. You can change the cache store with the `cache_store` option in an initializer.
+
+```ruby
+# /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
+```
+
+## Breakfast mode 🤡 (coming soon)
+You will soon be able to replace all occurrences of `Serializer` with `Cerealizer` in your codebase. Just for fun. And for free.
+
+```ruby
+# /app/models/user.rb
+class User < ApplicationRecord
+  include Barley::Cerealizable
+  
+  cerealizer UserCerealizer
+end
+
+# app/cerealizers/user_cerealizer.rb
+class UserCerealizer < Barley::Cerealizer
+  attributes :id, :name, :email, :created_at, :updated_at
+
+  many :posts
+  one :group
+end
+```
+
+```shell
+rails generate barley:cerealizer User
+# etc.
+```
+
+Ah ah ah. This is so funny.
+
+## 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.
+
+## 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.
+
+```shell
+bundle exec ruby benchmark.rb
+-- create_table("comments", {:force=>:cascade})
+-> 0.0128s
+-- create_table("posts", {:force=>:cascade})
+-> 0.0002s
+-- create_table("users", {:force=>:cascade})
+-> 0.0002s
+Warming up --------------------------------------
+ams                    3.000  i/100ms
+jsonapi-rb             9.000  i/100ms
+barley                 9.000  i/100ms
+barley-cache         460.000  i/100ms
+ams          eager     8.000  i/100ms
+jsonapi-rb   eager    33.000  i/100ms
+barley       eager    37.000  i/100ms
+barley-cache eager    70.000  i/100ms
+Calculating -------------------------------------
+ams                    67.770  (± 1.9%) i/s -    657.000  in  10.042270s
+jsonapi-rb            157.239  (± 2.3%) i/s -      1.521k in  10.010257s
+barley                 96.909  (± 2.4%) i/s -    945.000  in  10.036316s
+barley-cache            4.589k (± 2.8%) i/s -     44.620k in  10.010004s
+ams          eager     68.237  (± 6.2%) i/s -    592.000  in  10.087602s
+jsonapi-rb   eager    289.733  (± 3.7%) i/s -      2.805k in  10.033912s
+barley       eager    406.732  (± 3.2%) i/s -      3.922k in  10.020076s
+barley-cache eager    639.935  (± 2.4%) i/s -      6.300k in  10.053710s
+with 95.0% confidence
+
+Comparison:
+barley-cache      :     4589.3 i/s
+barley-cache eager:      639.9 i/s - 7.17x  (± 0.27) slower
+barley       eager:      406.7 i/s - 11.29x  (± 0.49) slower
+jsonapi-rb   eager:      289.7 i/s - 15.83x  (± 0.74) slower
+jsonapi-rb        :      157.2 i/s - 29.17x  (± 1.08) slower
+barley            :       96.9 i/s - 47.37x  (± 1.75) slower
+ams          eager:       68.2 i/s - 67.25x  (± 4.69) slower
+ams               :       67.8 i/s - 67.72x  (± 2.31) slower
+with 95.0% confidence
+
+Calculating -------------------------------------
+ams                    1.300M memsize (   246.338k retained)
+16.838k objects (     2.492k retained)
+50.000  strings (    50.000  retained)
+jsonapi-rb           926.082k memsize (   197.338k retained)
+9.565k objects (     1.776k retained)
+50.000  strings (    50.000  retained)
+barley                 1.102M memsize (   177.490k retained)
+12.930k objects (     1.876k retained)
+50.000  strings (    35.000  retained)
+barley-cache          46.090k memsize (     1.308k retained)
+502.000  objects (    17.000  retained)
+42.000  strings (     6.000  retained)
+ams          eager     1.068M memsize (   233.994k retained)
+13.723k objects (     2.308k retained)
+50.000  strings (    50.000  retained)
+jsonapi-rb   eager   694.430k memsize (   194.826k retained)
+6.450k objects (     1.651k retained)
+50.000  strings (    50.000  retained)
+barley       eager   354.326k memsize (   124.282k retained)
+3.694k objects (     1.208k retained)
+50.000  strings (    32.000  retained)
+barley-cache eager   216.790k memsize (   107.228k retained)
+2.376k objects (   956.000  retained)
+50.000  strings (    33.000  retained)
+
+Comparison:
+barley-cache      :      46090 allocated
+barley-cache eager:     216790 allocated - 4.70x more
+barley       eager:     354326 allocated - 7.69x more
+jsonapi-rb   eager:     694430 allocated - 15.07x more
+jsonapi-rb        :     926082 allocated - 20.09x more
+ams          eager:    1068038 allocated - 23.17x more
+barley            :    1102354 allocated - 23.92x more
+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).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/barley/cache.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Barley
+  class Cache
+    class << self
+      delegate :fetch, :delete, to: :new
+    end
+
+    def initialize
+      @cache_store = Barley.config.cache_store
+    end
+
+    def fetch(key, options = {}, &block)
+      @cache_store.fetch(key, options, &block)
+    end
+
+    def delete(key)
+      @cache_store.delete(key)
+    end
+  end
+end

data/lib/barley/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Barley
+  class Configuration
+    attr_accessor :cache_store
+
+    def initialize
+      @cache_store = default_cache_store
+    end
+
+    private
+
+    def default_cache_store
+      ActiveSupport::Cache::MemoryStore.new
+    end
+  end
+end

data/lib/barley/railtie.rb

@@ -0,0 +1,4 @@
+module Barley
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/barley/serializable.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Barley
+  # Makes a Model serializable
+  #
+  # * Allows setting a default model Serializer
+  # @example
+  #   class Item < ApplicationRecord
+  #     include Barley::Serializable
+  #
+  #    # optionally define the default serializer, otherwise defaults to ItemSerializer
+  #    serializer MyCustomItemSerializer, cache: true
+  #   end
+  #
+  #   #> Item.as_json
+  module Serializable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # @example without cache
+      #   serializer ItemSerializer
+      # @example with cache
+      #   serializer ItemSerializer, cache: true
+      # @example with cache and expires_in
+      #   serializer ItemSerializer, cache: {expires_in: 1.hour}
+      def serializer(klass, cache: false)
+        define_method(:serializer) do
+          klass.new(self, cache: cache)
+        end
+      end
+    end
+
+    included do
+      serializer "#{self}Serializer".constantize
+
+      def as_json(serializer: nil, cache: false)
+        serializer ||= self.serializer.class
+        serializer.new(self, cache: cache).as_json
+      end
+    end
+  end
+end

data/lib/barley/serializer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+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]
+      end
+    end
+
+    def self.attributes(*keys)
+      keys.each do |key|
+        define_method(key) do
+          object.send(key)
+        end
+        set_class_iv(:@defined_attributes, key)
+      end
+    end
+
+    def self.attribute(key, &block)
+      if block
+        define_method(key) do
+          instance_eval(&block)
+        end
+      else
+        define_method(key) do
+          object.send(key)
+        end
+      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 self.one(key, serializer: nil, cache: false)
+      define_method(key) do
+        element = object.send(key)
+        return {} if element.nil?
+
+        el_serializer = serializer || element.serializer.class
+        el_serializer.new(element, cache: cache).as_json
+      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?)
+      end
+      set_class_iv(:@defined_attributes, key)
+    end
+
+    def as_json
+      if @cache
+        cache_key = cache_base_key
+        Barley::Cache.fetch(cache_key, expires_in: @expires_in) do
+          _as_json
+        end
+      else
+        _as_json
+      end
+    end
+
+    def clear_cache(key: cache_base_key)
+      Barley::Cache.delete(key)
+    end
+
+    private
+
+    def cache_base_key
+      "#{self.class.name.underscore}/#{object.id}/#{object.updated_at.to_i}/as_json/"
+    end
+
+    def defined_attributes
+      self.class.instance_variable_get(:@defined_attributes)
+    end
+
+    def _as_json
+      hash = {}
+
+      defined_attributes.each do |key|
+        hash[key] = send(key)
+      end
+
+      hash
+    end
+  end
+end

data/lib/barley/version.rb

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

data/lib/barley.rb

@@ -0,0 +1,19 @@
+require "barley/version"
+require "barley/railtie"
+require "barley/configuration"
+
+module Barley
+  mattr_accessor :config
+
+  self.config = Configuration.new
+
+  def self.configure
+    self.config ||= Configuration.new
+    yield(config)
+  end
+
+  autoload :Cache, "barley/cache"
+  autoload :Error, "barley/error"
+  autoload :Serializable, "barley/serializable"
+  autoload :Serializer, "barley/serializer"
+end

data/lib/generators/serializable/USAGE

@@ -0,0 +1,22 @@
+Description:
+    Explain the generator
+
+Example:
+    bin/rails generate serializable Thing
+
+    This will create:
+      app/serializers/thing_serializer.rb
+        spec/serializers/thing_serializer_spec.rb # if rspec is installed
+        test/serializers/thing_serializer_test.rb # if minitest is installed
+    And update:
+      app/models/thing.rb
+
+Example:
+    bin/rails generate serializable Thing --name=CustomThingSerializer
+
+    This will create:
+      app/serializers/custom_thing_serializer.rb
+        spec/serializers/custom_thing_serializer_spec.rb # if rspec is installed
+        test/serializers/custom_thing_serializer_test.rb # if minitest is installed
+    And update:
+        app/models/thing.rb

data/lib/generators/serializable/serializable_generator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class SerializableGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path("templates", __dir__)
+
+  class_option :name, type: :string, desc: "Custom serializer name"
+
+  def modify_model_file
+    inject_into_class File.join("app/models", class_path, "#{class_name.underscore}.rb"), class_name do
+      "  include Barley::Serializable\n"
+    end
+  end
+
+  def create_serializer_file
+    @serializer_name = options[:name] || "#{class_name}Serializer"
+    file_name = @serializer_name.underscore
+    template "serializer.erb", File.join("app/serializers", class_path, "#{file_name}.rb")
+  end
+
+  def create_test_file
+    @serializer_name = options[:name] || "#{class_name}Serializer"
+    (Bundler.load.specs.find { |s| s.name == "rspec-rails" }) ? create_rspec_test_file : create_minitest_test_file
+  end
+
+  private
+
+  def create_rspec_test_file
+    file_name = @serializer_name.underscore
+    template "serializer_spec.erb", File.join("spec/serializers", class_path, "#{file_name}_spec.rb")
+  end
+
+  def create_minitest_test_file
+    file_name = @serializer_name.underscore
+    template "serializer_test.erb", File.join("test/serializers", class_path, "#{file_name}_test.rb")
+  end
+end

data/lib/generators/serializable/templates/serializer.erb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class <%= @serializer_name %> < Barley::Serializer
+end

data/lib/generators/serializable/templates/serializer_spec.erb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe <%= @serializer_name %> do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/lib/generators/serializable/templates/serializer_test.erb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+class <%= @serializer_name %>Test < ActiveSupport::TestCase
+  def "test serializer" do
+    skip "Add test"
+  end
+end

data/lib/generators/serializer/USAGE

@@ -0,0 +1,18 @@
+Description:
+    Explain the generator
+
+Example:
+    bin/rails generate serializer Thing
+
+    This will create:
+      app/serializers/thing_serializer.rb
+        spec/serializers/thing_serializer_spec.rb # if rspec is installed
+        test/serializers/thing_serializer_test.rb # if minitest is installed
+
+Example:
+    bin/rails generate serializer Thing --name=CustomThingSerializer
+
+    This will create:
+      app/serializers/custom_thing_serializer.rb
+        spec/serializers/custom_thing_serializer_spec.rb # if rspec is installed
+        test/serializers/custom_thing_serializer_test.rb # if minitest is installed

data/lib/generators/serializer/serializer_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class SerializerGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path("templates", __dir__)
+
+  class_option :name, type: :string, desc: "Custom serializer name"
+
+  def create_serializer_file
+    @serializer_name = options[:name] || "#{class_name}Serializer"
+    file_name = @serializer_name.underscore
+    template "serializer.erb", File.join("app/serializers", class_path, "#{file_name}.rb")
+  end
+
+  def create_test_file
+    @serializer_name = options[:name] || "#{class_name}Serializer"
+    (Bundler.load.specs.find { |s| s.name == "rspec-rails" }) ? create_rspec_test_file : create_minitest_test_file
+  end
+
+  private
+
+  def create_rspec_test_file
+    file_name = @serializer_name.underscore
+    template "serializer_spec.erb", File.join("spec/serializers", class_path, "#{file_name}_spec.rb")
+  end
+
+  def create_minitest_test_file
+    file_name = @serializer_name.underscore
+    template "serializer_test.erb", File.join("test/serializers", class_path, "#{file_name}_test.rb")
+  end
+end

data/lib/generators/serializer/templates/serializer.erb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class <%= @serializer_name %> < Barley::Serializer
+end

data/lib/generators/serializer/templates/serializer_spec.erb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe <%= @serializer_name %> do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/lib/generators/serializer/templates/serializer_test.erb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+class <%= @serializer_name %>Test < ActiveSupport::TestCase
+  def "test serializer" do
+    skip "Add test"
+  end
+end

data/lib/tasks/barley_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :barley do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: barley
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cedric Delalande
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+description: Cerealize your ActiveModel objects into flat JSON objects with a dead
+  simple DSL. Our daily bread is to make your API faster.
+email:
+- weengs@moskitohero.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/barley.rb
+- lib/barley/cache.rb
+- lib/barley/configuration.rb
+- lib/barley/railtie.rb
+- lib/barley/serializable.rb
+- lib/barley/serializer.rb
+- lib/barley/version.rb
+- lib/generators/serializable/USAGE
+- lib/generators/serializable/serializable_generator.rb
+- lib/generators/serializable/templates/serializer.erb
+- lib/generators/serializable/templates/serializer_spec.erb
+- lib/generators/serializable/templates/serializer_test.erb
+- lib/generators/serializer/USAGE
+- lib/generators/serializer/serializer_generator.rb
+- lib/generators/serializer/templates/serializer.erb
+- lib/generators/serializer/templates/serializer_spec.erb
+- lib/generators/serializer/templates/serializer_test.erb
+- lib/tasks/barley_tasks.rake
+homepage: https://github.com/moskitohero/barley
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/moskitohero/barley
+  source_code_uri: https://github.com/moskitohero/barley
+  changelog_uri: https://github.com/moskitohero/barley/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Barley is a dead simple, fast, and efficient ActiveModel JSON serializer.
+test_files: []