cache_crispies 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bed703f9038261d6ff63e08465e7c0dccea1bcb6e2cb583de3ab154da562ef8f
+  data.tar.gz: ed55298237e61b9c6995a0194c61cd6ec221ea3cd62be176afa8842cb9d28c50
+SHA512:
+  metadata.gz: e6897a7621e75851e7d9b2092674a44ed0ff42f328c61876b9de82dfc984c1eb2a7379dbe60f336659552be6445798063a1df83941fab55aeb0537a67fea5718
+  data.tar.gz: 0a9ac99db021a8e5ac1d06547d55c84e346aa550f020598f716993a5b783c2f2f8bcf002fda92d113f1864da2083f03719a5a240ae3e8dbebf3e24df01e1a543

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/lib/cache_crispies/attribute.rb

@@ -0,0 +1,66 @@
+module CacheCrispies
+  class Attribute
+    class InvalidCoersionType < ArgumentError; end
+
+    def initialize(key, from: nil, with: nil, to: nil, nesting: [], conditions: [])
+      @key = key
+      @method_name = from || key || :itself
+      @serializer = with
+      @coerce_to = to
+      @nesting = Array(nesting)
+      @conditions = Array(conditions)
+    end
+
+    attr_reader :method_name, :key, :serializer, :coerce_to, :nesting, :conditions
+
+    def value_for(model, options)
+      value = model.public_send(method_name)
+
+      serializer ? serialize(value, options) : coerce(value)
+    end
+
+    private
+
+    def serialize(value, options)
+      plan = CacheCrispies::Plan.new(serializer, value, options)
+
+      if value.respond_to?(:each)
+        plan.cache { Collection.new(value, serializer, options).as_json }
+      else
+        plan.cache { serializer.new(value, options).as_json }
+      end
+    end
+
+    def coerce(value)
+      return value if coerce_to.nil?
+
+      case coerce_to.to_s.to_sym
+      when :String
+        value.to_s
+      when :Integer
+        try_coerce_via_string(value, :to_i)
+      when :Float
+        try_coerce_via_string(value, :to_f)
+      when :BigDecimal
+        BigDecimal(value)
+      when :Array
+        Array(value)
+      when :Hash
+        value.respond_to?(:to_h) ? value.to_h : value.to_hash
+      when :bool, :boolean, :TrueClass, :FalseClass
+        !!value
+      else
+        raise(
+          InvalidCoersionType,
+          "#{coerce_to} has no registered coercion strategy"
+        )
+      end
+    end
+
+    def try_coerce_via_string(value, method_name)
+      (
+        value.respond_to?(method_name) ? value : value.to_s
+      ).public_send(method_name)
+    end
+  end
+end

data/lib/cache_crispies/base.rb

@@ -0,0 +1,110 @@
+require 'digest'
+require 'rails'
+
+module CacheCrispies
+  class Base
+    attr_reader :model, :options
+
+    def initialize(model, options = {})
+      @model = model
+      @options = options
+    end
+
+    def as_json
+      HashBuilder.new(self).call
+    end
+
+    def self.do_caching?
+      false
+    end
+
+    def self.key
+      to_s.demodulize.chomp('Serializer').underscore.to_sym
+    end
+
+    def self.collection_key
+      return nil unless key
+
+      key.to_s.pluralize.to_sym
+    end
+
+    # Can be overridden in subclasses
+    # options: Hash of the same options that would be passed to the
+    #          individual serializer instances
+    def self.cache_key_addons(_options = {})
+      []
+    end
+
+    def self.cache_key_base
+      # TODO: we may need to get a cache key from nested serializers as well :(
+      @cache_key_base ||= "#{self}-#{file_hash}"
+    end
+
+    def self.attributes
+      @attributes || []
+    end
+    delegate :attributes, to: :class
+
+    private
+
+    def self.file_hash
+      @file_hash ||= Digest::MD5.file(path).to_s
+    end
+    private_class_method :file_hash
+
+    def self.path
+      @path ||= begin
+        parts = %w[app serializers]
+        parts += to_s.deconstantize.split('::').map(&:underscore)
+        parts << "#{to_s.demodulize.underscore}.rb"
+        Rails.root.join(*parts)
+      end
+    end
+    private_class_method :path
+
+    def self.nest_in(key, &block)
+      @nesting ||= []
+      @nesting << key
+
+      block.call
+
+      @nesting.pop
+    end
+    private_class_method :nest_in
+
+    def self.show_if(condition_proc, &block)
+      @conditions ||= []
+      @conditions << Condition.new(condition_proc)
+
+      block.call
+
+      @conditions.pop
+    end
+    private_class_method :show_if
+
+    def self.serialize(*attribute_names, from: nil, with: nil, to: nil)
+      @attributes ||= []
+
+      attribute_names.flatten.map { |att| att&.to_sym }.map do |attrib|
+        current_nesting = Array(@nesting).dup
+        current_conditions = Array(@conditions).dup
+
+        @attributes <<
+          Attribute.new(
+            attrib,
+            from: from,
+            with: with,
+            to: to,
+            nesting: current_nesting,
+            conditions: current_conditions
+          )
+      end
+    end
+    private_class_method :serialize
+
+    def self.merge(attribute = nil, with: nil)
+      serialize(nil, from: attribute, with: with)
+    end
+    private_class_method :merge
+  end
+end

data/lib/cache_crispies/collection.rb

@@ -0,0 +1,43 @@
+require 'rails'
+
+module CacheCrispies
+  class Collection
+    def initialize(collection, serializer, options = {})
+      @collection = collection
+      @serializer = serializer
+      @options = options
+    end
+
+    def as_json
+      if serializer.do_caching? && collection.respond_to?(:cache_key)
+        cached_json
+      else
+        uncached_json
+      end
+    end
+
+    private
+
+    attr_reader :collection, :serializer, :options
+
+    def uncached_json
+      collection.map do |model|
+        serializer.new(model, options).as_json
+      end
+    end
+
+    def cached_json
+      models_by_cache_key = collection.each_with_object({}) do |model, hash|
+        plan = Plan.new(serializer, model, options)
+
+        hash[plan.cache_key] = model
+      end
+
+      Rails.cache.fetch_multi(models_by_cache_key.keys) do |cache_key|
+        model = models_by_cache_key[cache_key]
+
+        serializer.new(model, options).as_json
+      end
+    end
+  end
+end

data/lib/cache_crispies/condition.rb

@@ -0,0 +1,30 @@
+module CacheCrispies
+  # Represents an instance of a conditional built by a show_if call
+  class Condition
+    def initialize(block)
+      @block = block
+    end
+
+    # Public: A system-wide unique ID used for memoizaiton
+    # Returns an Integer
+    def uid
+      # Just reusing the block's object_id seems to make sense
+      block.object_id
+    end
+
+    def true_for?(model, options = {})
+      !!case block.arity
+        when 0
+          block.call
+        when 1
+          block.call(model)
+        else
+          block.call(model, options)
+        end
+    end
+
+    private
+
+    attr_reader :block
+  end
+end

data/lib/cache_crispies/controller.rb

@@ -0,0 +1,26 @@
+module CacheCrispies
+  module Controller
+    extend ActiveSupport::Concern
+
+    OJ_MODE = :rails
+
+    def cache_render(serializer, cacheable, options = {})
+      plan = CacheCrispies::Plan.new(serializer, cacheable, options)
+
+      # TODO: It would probably be good to add configuration to etiher
+      # enable or disable this
+      response.weak_etag = plan.etag
+
+      serializer_json =
+        if plan.collection?
+          cacheable.map do |one_cacheable|
+            plan.cache { serializer.new(one_cacheable, options).as_json }
+          end
+        else
+          plan.cache { serializer.new(cacheable, options).as_json }
+        end
+
+      render json: Oj.dump(plan.wrap(serializer_json), mode: OJ_MODE)
+    end
+  end
+end

data/lib/cache_crispies/hash_builder.rb

@@ -0,0 +1,61 @@
+module CacheCrispies
+  class HashBuilder
+    def initialize(serializer)
+      @serializer = serializer
+      @condition_results = Memoizer.new
+    end
+
+    def call
+      hash = {}
+
+      serializer.attributes.each do |attrib|
+        next unless show?(attrib)
+
+        deepest_hash = hash
+
+        attrib.nesting.each do |key|
+          deepest_hash[key] ||= {}
+          deepest_hash = deepest_hash[key]
+        end
+
+        value = value_for(attrib)
+
+        if attrib.key
+          deepest_hash[attrib.key] = value
+        else
+          deepest_hash.merge! value
+        end
+      end
+
+      hash
+    end
+
+    private
+
+    attr_reader :serializer, :condition_results
+
+    def show?(attribute)
+      # Memoize conditions so they aren't executed for each attribute in a
+      # show_if block
+      attribute.conditions.all? do |cond|
+        condition_results.fetch(cond.uid) do
+          cond.true_for?(serializer.model, serializer.options)
+        end
+      end
+    end
+
+    def value_for(attribute)
+      meth = attribute.method_name
+
+      target =
+        if meth != :itself && serializer.respond_to?(meth)
+          serializer
+        else
+          serializer.model
+        end
+
+      # TODO: rescue NoMethodErrors here with something more telling
+      attribute.value_for(target, serializer.options)
+    end
+  end
+end

data/lib/cache_crispies/memoizer.rb

@@ -0,0 +1,18 @@
+module CacheCrispies
+  class Memoizer
+    def initialize
+      @cache = {}
+    end
+
+    def fetch(key, &_block)
+      # Avoid ||= because we need to memoize falsey values.
+      return cache[key] if cache.key?(key)
+
+      cache[key] = yield
+    end
+
+    private
+
+    attr_reader :cache
+  end
+end

data/lib/cache_crispies/plan.rb

@@ -0,0 +1,68 @@
+module CacheCrispies
+  class Plan
+    attr_reader :serializer, :cacheable, :options
+
+    def initialize(serializer, cacheable, options = {})
+      @serializer = serializer
+      @cacheable = cacheable
+      @key = options.delete(:key)
+      @options = options
+    end
+
+    def collection?
+      cacheable.respond_to?(:each)
+    end
+
+    def etag
+      Digest::MD5.hexdigest(cache_key)
+    end
+
+    def cache_key
+      @cache_key ||=
+        [
+          CACHE_KEY_PREFIX,
+          serializer.cache_key_base,
+          addons_key,
+          cacheable.cache_key
+        ].flatten.compact.join(CACHE_KEY_SEPARATOR)
+    end
+
+    def cache
+      if cache?
+        Rails.cache.fetch(cache_key) { yield }
+      else
+        yield
+      end
+    end
+
+    def wrap(json_hash)
+      return json_hash unless key?
+
+      { key => json_hash }
+    end
+
+    private
+
+    def key
+      return @key unless @key.nil?
+
+      (collection? ? serializer.collection_key : serializer.key)
+    end
+
+    def key?
+      !!key
+    end
+
+    def cache?
+      serializer.do_caching? && cacheable.respond_to?(:cache_key)
+    end
+
+    def addons_key
+      addons = serializer.cache_key_addons(options)
+
+      return nil if addons.compact.empty?
+
+      Digest::MD5.hexdigest(addons.join('|'))
+    end
+  end
+end

data/lib/cache_crispies/version.rb

@@ -0,0 +1,3 @@
+module CacheCrispies
+  VERSION = '0.1.0'.freeze
+end

data/lib/cache_crispies.rb

@@ -0,0 +1,18 @@
+require 'active_support/dependencies'
+require 'oj'
+
+module CacheCrispies
+  CACHE_KEY_PREFIX = 'cache-crispies'.freeze
+  CACHE_KEY_SEPARATOR = '+'.freeze
+
+  require 'cache_crispies/version'
+
+  autoload :Attribute,    'cache_crispies/attribute'
+  autoload :Base,         'cache_crispies/base'
+  autoload :Collection,   'cache_crispies/collection'
+  autoload :Condition,    'cache_crispies/condition'
+  autoload :HashBuilder,  'cache_crispies/hash_builder'
+  autoload :Memoizer,     'cache_crispies/memoizer'
+  autoload :Controller,   'cache_crispies/controller'
+  autoload :Plan,         'cache_crispies/plan'
+end

data/spec/attribute_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe CacheCrispies::Attribute do
+  class NameSerializer < CacheCrispies::Base
+    serialize :spanish
+  end
+
+  class ToHashClass
+    def to_hash
+      { portuguese: 'Capitão Crise' }
+    end
+  end
+
+  let(:key) { :name }
+  let(:from) { nil }
+  let(:with) { nil }
+  let(:to) { nil }
+  let(:nesting) { [] }
+  let(:conditions) { [] }
+  let(:instance) {
+    described_class.new(
+      key,
+      from: from,
+      with: with,
+      to: to,
+      nesting: nesting,
+      conditions: conditions
+    )
+  }
+
+  subject { instance }
+
+  describe '#value_for' do
+    let(:name) { "Cap'n Crunch" }
+    let(:model) { OpenStruct.new(name: name) }
+    let(:options) { {} }
+
+    subject { instance.value_for(model, options) }
+
+    it 'returns the value' do
+      expect(subject).to eq name
+    end
+
+    context 'with a from: argument' do
+      let(:key) { :nombre }
+      let(:from) { :name }
+
+      it 'returns the value using the from: attribute' do
+        expect(subject).to eq name
+      end
+    end
+
+    context 'with a with: argument' do
+      let(:spanish_name) { 'Capitán Crujido' }
+      let(:name) { OpenStruct.new(spanish: spanish_name)}
+      let(:with) { NameSerializer }
+
+      it 'returns the value using the from attribute' do
+        expect(subject).to eq spanish: spanish_name
+      end
+    end
+
+    context 'with a to: argument' do
+      context 'when corecing to a String' do
+        let(:name) { 1138 }
+        let(:to) { String }
+
+        it 'returns a String' do
+          expect(subject).to eq '1138'
+        end
+      end
+
+      context 'when corecing to an Integer' do
+        let(:name) { '1138' }
+        let(:to) { Integer }
+
+        it 'returns a String' do
+          expect(subject).to eq 1138
+        end
+      end
+
+      context 'when corecing to an Float' do
+        let(:name) { '1138' }
+        let(:to) { Float }
+
+        it 'returns a String' do
+          expect(subject).to eq 1138.0
+        end
+      end
+
+      context 'when corecing to an BigDecimal' do
+        let(:name) { '1138' }
+        let(:to) { BigDecimal }
+
+        it 'returns a String' do
+          expect(subject).to eq BigDecimal(1138)
+        end
+      end
+
+      context 'when corecing to an Array' do
+        let(:name) { 1138 }
+        let(:to) { Array }
+
+        it 'returns an Array' do
+          expect(subject).to eq [1138]
+        end
+      end
+
+      context 'when corecing to a Hash' do
+        let(:to) { Hash }
+
+        context 'that responds to to_h' do
+          let(:french_name) { 'capitaine croquer' }
+          let(:name) { OpenStruct.new(french: french_name) }
+
+          it 'returns a Hash' do
+            expect(subject).to eq french: french_name
+          end
+        end
+
+        context 'that responds to to_hash' do
+          let(:name) { ToHashClass.new }
+
+          it 'returns a Hash' do
+            expect(subject).to eq portuguese: 'Capitão Crise'
+          end
+        end
+      end
+
+      context 'when corecing to an boolean' do
+        let(:to) { :boolean }
+
+        context 'when value is falsey' do
+          let(:name) { nil }
+
+          it 'returns false' do
+            expect(subject).to be false
+          end
+        end
+
+        context 'when value is truthy' do
+          let(:name) { 'true' }
+
+          it 'returns true' do
+            expect(subject).to be true
+          end
+        end
+      end
+
+      context 'when corercing to an invalid type' do
+        let(:to) { OpenStruct }
+
+        it 'raises an exception' do
+          expect { subject }.to raise_exception CacheCrispies::Attribute::InvalidCoersionType
+        end
+      end
+    end
+  end
+end