cached_serializer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 164738a352a3d55ad7ad7efe859c9b4f5840d54f0e21d1ebe5ecbfccbdf16cb8
+  data.tar.gz: b0b6bdbe968c74de5cd8ad85d772190fa465f5b5c971706c0eb00d409e90ef26
+SHA512:
+  metadata.gz: c86836b5aa5f676a4f39564f95565c4c3570fcc8063d7f85d0c22e28f78cf5f4acc3bfcd3f0c0594a38a5de5d78fbc774ce3caccb90130185c04f3b2173e5844
+  data.tar.gz: 275c53b05c3e82d78cdd4aa716b61c6c0465e480c96c22a3e1ca4b99875d2cb7705a6e78951973af07af5ebf463e55132ec7f7a1f53fcb6bc614fb3b503f15ad

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+# Declare your gem's dependencies in cached_serializer.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use a debugger
+# gem 'byebug', group: [:development, :test]

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Keegan Leitz
+
+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/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 Keegan Leitz
+
+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,121 @@
+# CachedSerializer
+
+A serializer for Rails models that prevents unnecessary lookups.
+
+## Usage
+
+The following example serializes a `User` model. By using certain macros, the
+author can specify what values should be cached or recomputed when serializing
+a model record. Serialized data is cached via `Rails.cache` (by the User's `id`
+and specified attribute keys) so the serializer doesn't have to hit the DB for
+every attribute. This can be desirable when some of the serialized data involves
+long-running queries, relationship-heavy calculations, etc.
+
+```rb
+class UserSerializer < CachedSerializer::Base
+  # Properties specified by `::columns` are called as-is on the model, and
+  # invalidated automatically when the model is saved with new values for these
+  # properties, by checking Rails' built-in `#email_changed?`/`#phone_changed?`
+  # /etc. dynamic methods on save. Allows you to serialize most simple straight-
+  # from-the-DB values without any extra effort.
+  columns :email, :phone
+
+  # Properties specified by `::constant` are are attributes that should never
+  # need to be recomputed. They will be cached ad infinitum (until the cache key
+  # is cleared, manually or otherwise).
+  #
+  # This will call `some_user.id` for the `:id` attribute, and
+  # `some_user.created_at` for the `:created_at` attribute. Consider the values
+  # for each to be cached FOREVER, and never recomputed.
+  constant :id, :created_at
+
+  # Alternatively, you can pass a block to `::constant`. This will use the
+  # result of the block as the value for the `:name` attribute. It will cache
+  # the value FOREVER, and never recompute it.
+  constant :name do |user|
+    "#{user.first_name} #{user.last_name}"
+  end
+
+  # Properties specified by `::volatile` are attributes that should always be
+  # recomputed every time a user is serialized, and will never be cached.
+  #
+  # This will call `some_user.token` for the `:token` attribute, and
+  # `some_user.updated_at` for the `:updated_at` attribute. It will ALWAYS
+  # recompute the values, EVERY time it serializes a user.
+  volatile :token, :updated_at
+
+  # Alternatively, you can pass a block to `::volatile`. This will use the
+  # result of the block as the value for the `:time_on_platform` attribute. It
+  # will ALWAYS recompute the value, EVERY time it serializes a user.
+  volatile :time_on_platform do |user|
+    Time.zone.now.to_i - user.created_at.to_i
+  end
+
+  # Properties specified by `::computed` are attributes that should either be
+  # recomputed by the given block or drawn from the cache based on rules that
+  # you specify.
+  #
+  # You can specify columns that it depends on, such that when any of the
+  # columns change it will invalidate the cache for this serialized property. In
+  # this case, `:address` will only be recomputed when any of the supplied
+  # attributes (`:address_1`, `:address_2`, `:city`, etc.) change on the user
+  # record.
+  computed :address, columns: [:address_1, :address_2, :city, :state, :zip] do |user|
+    "#{user.address_1} #{user.address_2}, #{user.city}, #{user.state} #{user.zip}"
+  end
+
+  # You can also specify a `:recompute_if` proc/lambda. It will run
+  # `:recompute_if` every time a model is being recomputed, and if it returns
+  # `true` then it will recompute. Otherwise, it will use the cached result.
+  computed :active, recompute_if: ->(u) { u.last_logged_in_at > 1.week.ago } do |user|
+    user.purchases.where(created_at: 1.week.ago..Time.zone.now).present?
+  end
+
+  # Additionally, you can specify an `:expires_in` expiration duration. This
+  # will cache the result for one day after the last time the
+  # `:revenue_generated` attribute was recomputed.
+  computed :revenue_generated, expires_in: 1.week do |user|
+    user.offers.accepted.reduce(0) { |total, offer| total + offer.total_price }
+  end
+
+  # You can use any number of these cache conditions with `:compute`. For
+  # example, this will cache the result until `:foo` changes on the user, `:bar`
+  # changes on the user, `u.silly?` is `true` at the time of serialization, or
+  # it has been more than 10 seconds since the last time the `:silly` attribute
+  # was recomputed.
+  computed :silly, columns: [:foo, :bar], recompute_if: ->(u) { u.silly? }, expires_in: 10.seconds do |user|
+    rand(100)
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's `Gemfile`:
+
+```ruby
+gem 'cached_serializer'
+```
+
+Then `cd` into your project's directory and run:
+
+```bash
+bundle install
+```
+
+## Bug reports
+
+If you encounter a bug, you can report it [here](https://github.com/kjleitz/cached_serializer/issues). Please include the following information, if possible:
+
+- your Ruby version (`ruby --version`; if using multiple Rubies via `rvm` or similar, make sure you're in your project's directory when you run `ruby --version`)
+- your Rails version (`cd` into your project's directory, then `bundle exec rails --version`)
+- example code (which demonstrates the issue)
+- your soul (for eating)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/kjleitz/cached_serializer](https://github.com/kjleitz/cached_serializer).
+
+## 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,27 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CachedSerializer'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/cached_serializer.rb

@@ -0,0 +1,5 @@
+require "cached_serializer/railtie"
+require "cached_serializer/base"
+
+module CachedSerializer
+end

data/lib/cached_serializer/attr_serializer.rb

@@ -0,0 +1,32 @@
+module CachedSerializer
+  class AttrSerializer
+    attr_accessor :attr_name, :recompute_ifs, :expires_in, :recompute
+
+    class << self
+      def cache_key(subject, attr_name)
+        "cached_serializer:#{subject.class.model_name.name.underscore}:#{subject.id}:#{attr_name}"
+      end
+    end
+
+    def initialize(attr_name, recompute_ifs = nil, :expires_in = nil, &recompute)
+      self.attr_name = attr_name
+      self.recompute_ifs = [recompute_ifs].flatten.compact
+      self.expires_in = expires_in
+      self.recompute = recompute || proc { |subj| subj.send(attr_name.to_sym) }
+    end
+
+    def serialize_for(subject)
+      { attr_name.to_sym => serialized_value_for(subject) }
+    end
+
+    private
+
+    def serialized_value_for(subject)
+      should_recompute = recompute_ifs.any? { |recompute_if| recompute_if.call(subject) }
+      cache_key = self.class.cache_key(subject, attr_name)
+      Rails.cache.fetch(cache_key, expires_in: expires_in, force: should_recompute) do
+        attr_serializer.recompute.call(subject)
+      end
+    end
+  end
+end

data/lib/cached_serializer/attr_serializer_collection.rb

@@ -0,0 +1,46 @@
+module CachedSerializer
+  class AttrSerializerCollection
+    attr_accessor :collection
+
+    def initialize(collection = [])
+      self.collection = collection
+    end
+
+    def add(*attr_serializers)
+      attr_serializers.each do |attr_serializer|
+        existing = collection.find { |serializer| serializer.attr_name == attr_serializer.attr_name }
+        if existing
+          existing.recompute_ifs.concat(attr_serializer.recompute_ifs)
+          existing.recompute = attr_serializer.recompute # shadowed attrs override the blocks of previously-declared ones
+          existing.expires_in = attr_serializer.expires_in # shadowed attrs override the expires_in of previously-declared ones
+        else
+          existing << attr_serializer
+        end
+      end
+    end
+
+    alias_method :push, :add
+
+    def <<(item)
+      add(item)
+    end
+
+    def concat(items)
+      add(*items)
+    end
+
+    def method_missing(method, *args, &block)
+      collection.send(method, *args, &block)
+    end
+
+    def respond_to?(method, *args)
+      collection.respond_to?(method, *args)
+    end
+
+    def serialize_for(subject)
+      collection.reduce({}) do |memo, attr_serializer|
+        memo.merge(attr_serializer.serialize_for(subject))
+      end
+    end
+  end
+end

data/lib/cached_serializer/base.rb

@@ -0,0 +1,160 @@
+require "json"
+require_relative "./attr_serializer"
+require_relative "./attr_serializer_collection"
+
+module CachedSerializer
+  class Base
+    attr_accessor :subject
+
+    @serializers = AttrSerializerCollection.new
+
+    class << self
+      def serializers
+        @serializers
+      end
+
+      # Example (in a UserSerializer):
+      #
+      #   columns :email, :phone
+      #
+      # This will call `some_user.email` for the `:email` attribute, and
+      # `some_user.phone` for the `:phone` attribute. It will cache the value
+      # for each, until the attribute changes on the record.
+      #
+      def columns(*column_names)
+        column_names.each do |column_name|
+          serializers << AttrSerializer.new(column_name)
+          add_column_changed_cache_invalidator_callback(column_name, column_name)
+        end
+      end
+
+      # Example (in a UserSerializer):
+      #
+      #   constant :email, :phone
+      #
+      # This will call `some_user.email` for the `:email` attribute, and
+      # `some_user.phone` for the `:phone` attribute. It will cache the value
+      # for each FOREVER, and never recompute it.
+      #
+      #   constant :name do |user|
+      #     "#{user.first_name} #{user.last_name}"
+      #   end
+      #
+      # This will use the result of the block as the value for the `:name`
+      # attribute. It will cache the value FOREVER, and never recompute it.
+      #
+      def constant(*attr_names, &recompute)
+        attr_names.each do |attr_name|
+          serializers << AttrSerializer.new(attr_name, &recompute)
+        end
+      end
+
+      # Example (in a UserSerializer):
+      #
+      #   volatile :email, :phone
+      #
+      # This will call `some_user.email` for the `:email` attribute, and
+      # `some_user.phone` for the `:phone` attribute. It will ALWAYS recompute
+      # the values, EVERY time it serializes a user.
+      #
+      #   volatile :name do |user|
+      #     "#{user.first_name} #{user.last_name}"
+      #   end
+      #
+      # This will use the result of the block as the value for the `:name`
+      # attribute. It will ALWAYS recompute the value, EVERY time it serializes
+      # a user.
+      #
+      def volatile(*attr_names, &recompute)
+        attr_names.each do |attr_name|
+          always_recompute = proc { |_subj| true }
+          serializers << AttrSerializer.new(attr_name, always_recompute, &recompute)
+        end
+      end
+
+      # Example (in a UserSerializer):
+      #
+      #   computed :name, columns: [:first_name, :last_name] do |user|
+      #     "#{user.first_name} #{user.last_name}"
+      #   end
+      #
+      # This will use the result of the block as the value for the `:name`
+      # attribute. It will cache the result until either `:first_name` or
+      # `:last_name` changes on the user record.
+      #
+      #   computed :active, recompute_if: ->(u) { u.last_logged_in_at > 1.week.ago } do |user|
+      #     user.purchases.where(created_at: 1.week.ago..Time.zone.now).present?
+      #   end
+      #
+      # This will use the result of the block as the value for the `:active`
+      # attribute. It will cache the result until the `recompute_if` proc/lambda
+      # returns `true`.
+      #
+      #   computed :purchase_count, expires_in: 1.day do |user|
+      #     user.purchases.count
+      #   end
+      #
+      # This will use the result of the block as the value for the
+      # `:purchase_count` attribute. It will cache the result for one day after
+      # the last time the `:purchase_count` attribute was recomputed.
+      #
+      #   computed :silly, columns: [:foo, :bar], recompute_if: ->(u) { u.silly? }, expires_in: 10.seconds do |user|
+      #     rand(100)
+      #   end
+      #
+      # This will use the result of the block as the value for the `:silly`
+      # attribute. It will cache the result until `:foo` changes on the user,
+      # `:bar` changes on the user, `u.silly?` at the time of serialization,
+      # or it has been more than 10 seconds since the last time the `:silly`
+      # attribute was recomputed.
+      #
+      def computed(attr_name, columns: [], recompute_if: nil, expires_in: nil, &recompute)
+        if (columns.empty? && !recompute_if && !expires_in)
+          raise ArgumentError, "Must provide :columns, :recompute_if, or :expires_in to a computed attribute setter"
+        end
+        serializers << AttrSerializer.new(attr_name, recompute_if, expires_in, &recompute)
+        columns.each do |column_name|
+          add_column_changed_cache_invalidator_callback(attr_name, column_name)
+        end
+      end
+
+      private
+
+      def subject_class
+        @subject_class ||= self.class.to_s.gsub(/[Ss]erializer\z/, '').constantize
+      end
+
+      def add_column_changed_cache_invalidator_callback(attr_name, dependent_attr_name)
+        @already_added_callback ||= {}
+        @already_added_callback[attr_name.to_sym] ||= {}
+        return if @already_added_callback[attr_name.to_sym][dependent_attr_name.to_sym]
+
+        subject_class.class_eval do
+          after_commit(on: :save) do
+            if changes[dependent_attr_name.to_s]
+              Rails.cache.delete(CachedSerializer::AttrSerializer.cache_key(subject, attr_name))
+            end
+          end
+        end
+
+        @already_added_callback[attr_name.to_sym][dependent_attr_name.to_sym] = true
+      end
+    end
+
+    def initialize(subject)
+      self.subject = subject
+    end
+
+    def to_h
+      self.class.serializers.serialize_for(subject)
+    end
+
+    def as_json
+      to_h
+    end
+
+    def to_json
+      JSON.generate(as_json)
+    end
+  end
+end

data/lib/cached_serializer/railtie.rb

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

data/lib/cached_serializer/version.rb

@@ -0,0 +1,3 @@
+module CachedSerializer
+  VERSION = '0.1.0'
+end

data/lib/tasks/cached_serializer_tasks.rake

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

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: cached_serializer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Keegan Leitz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A serializer for Rails models that prevents unnecessary lookups
+email:
+- keegan@openbay.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/cached_serializer.rb
+- lib/cached_serializer/attr_serializer.rb
+- lib/cached_serializer/attr_serializer_collection.rb
+- lib/cached_serializer/base.rb
+- lib/cached_serializer/railtie.rb
+- lib/cached_serializer/version.rb
+- lib/tasks/cached_serializer_tasks.rake
+homepage: https://github.com/kjleitz/cached_serializer
+licenses:
+- MIT
+metadata: {}
+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.0.6
+signing_key: 
+specification_version: 4
+summary: A serializer for Rails models that prevents unnecessary lookups
+test_files: []