knuckles 0.1.0

data/bench/profiling.rb

@@ -0,0 +1,14 @@
+require_relative "./bench_helper"
+
+require "fileutils"
+require "stackprof"
+
+FileUtils.mkdir_p("tmp")
+
+models = BenchHelper.submissions
+
+StackProf.run(mode: :wall, interval: 500, out: "tmp/stackprof-wall.dump") do
+  100.times do
+    Knuckles.new.call(models, view: SubmissionView)
+  end
+end

data/bench/realistic.rb

@@ -0,0 +1,9 @@
+require_relative "./bench_helper"
+
+models = BenchHelper.submissions
+
+Benchmark.ips do |x|
+  x.report("serialize.realistic") do
+    Knuckles.new.call(models, view: SubmissionView)
+  end
+end

data/bench/simple.rb

@@ -0,0 +1,25 @@
+require_relative "./bench_helper"
+
+Post = Struct.new(:id, :title, :updated_at)
+
+module PostView
+  extend Knuckles::View
+
+  def self.root
+    :posts
+  end
+
+  def self.data(object, _)
+    {id: object.id,
+     title: object.title,
+     updated_at: object.updated_at}
+  end
+end
+
+models = 100.times.map { |i| Post.new(i, "title", Time.new) }
+
+Benchmark.ips do |x|
+  x.report("serialize.main") do
+    Knuckles.new.call(models, view: PostView)
+  end
+end

data/bin/rspec

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/knuckles.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "knuckles/version"
+
+Gem::Specification.new do |spec|
+  spec.name     = "knuckles"
+  spec.version  = Knuckles::VERSION
+  spec.authors  = ["Parker Selbert"]
+  spec.email    = ["parker@sorentwo.com"]
+  spec.summary  = "Simple performance aware data serialization"
+  spec.homepage = ""
+  spec.license  = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "activesupport"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/knuckles/combiner.rb

@@ -0,0 +1,26 @@
+require "set"
+
+module Knuckles
+  module Combiner
+    extend self
+
+    def name
+      "combiner".freeze
+    end
+
+    def call(prepared, _)
+      prepared.each_with_object(set_backed_hash) do |hash, memo|
+        hash[:result].each do |root, values|
+          case values
+          when Hash  then memo[root] << values
+          when Array then memo[root] += values
+          end
+        end
+      end
+    end
+
+    def set_backed_hash
+      Hash.new { |hash, key| hash[key] = Set.new }
+    end
+  end
+end

data/lib/knuckles/dumper.rb

@@ -0,0 +1,21 @@
+module Knuckles
+  module Dumper
+    extend self
+
+    def name
+      "dumper".freeze
+    end
+
+    def call(objects, _options)
+      Knuckles.serializer.dump(keys_to_arrays(objects))
+    end
+
+    private
+
+    def keys_to_arrays(objects)
+      objects.each do |key, value|
+        objects[key] = value.to_a if value.is_a?(Set)
+      end
+    end
+  end
+end

data/lib/knuckles/fetcher.rb

@@ -0,0 +1,30 @@
+module Knuckles
+  module Fetcher
+    extend self
+
+    def name
+      "fetcher".freeze
+    end
+
+    def call(prepared, options)
+      results = get_cached(prepared, options)
+
+      prepared.each do |hash|
+        result = results[hash[:key]]
+        hash[:cached?] = !result.nil?
+        hash[:result] = result
+      end
+    end
+
+    private
+
+    def get_cached(prepared, options)
+      kgen = options.fetch(:keygen, Knuckles.keygen)
+      keys = prepared.map do |hash|
+        hash[:key] = kgen.expand_key(hash[:object])
+      end
+
+      Knuckles.cache.read_multi(*keys)
+    end
+  end
+end

data/lib/knuckles/hydrator.rb

@@ -0,0 +1,29 @@
+module Knuckles
+  module Hydrator
+    extend self
+
+    def name
+      "hydrator".freeze
+    end
+
+    def call(prepared, options)
+      hydrate = options[:hydrate]
+
+      if hydrate && any_missing?(prepared)
+        hydrate.call(hydratable(prepared))
+      end
+
+      prepared
+    end
+
+    private
+
+    def any_missing?(prepared)
+      prepared.any? { |hash| !hash[:cached?] }
+    end
+
+    def hydratable(prepared)
+      prepared.reject { |hash| hash[:cached?] }
+    end
+  end
+end

data/lib/knuckles/keygen.rb

@@ -0,0 +1,13 @@
+module Knuckles
+  module Keygen
+    extend self
+
+    def expand_key(object)
+      if object.respond_to?(:cache_key)
+        object.cache_key
+      else
+        "#{object.class.name}/#{object.id}/#{object.updated_at.to_i}"
+      end
+    end
+  end
+end

data/lib/knuckles/pipeline.rb

@@ -0,0 +1,56 @@
+module Knuckles
+  class Pipeline
+    def self.default_stages
+      [Knuckles::Fetcher,
+       Knuckles::Hydrator,
+       Knuckles::Renderer,
+       Knuckles::Writer,
+       Knuckles::Combiner,
+       Knuckles::Dumper]
+    end
+
+    attr_reader :stages
+
+    def initialize(stages: self.class.default_stages)
+      @stages = stages
+    end
+
+    def delete(stage)
+      stages.delete(stage)
+    end
+
+    def insert_after(stage, new_stage)
+      index = stages.index(stage)
+
+      stages.insert(index + 1, new_stage)
+    end
+
+    def insert_before(stage, new_stage)
+      index = stages.index(stage)
+
+      stages.insert(index, new_stage)
+    end
+
+    def call(objects, options)
+      prepared = prepare(objects)
+
+      stages.reduce(prepared) do |results, stage|
+        instrument("knuckles.stage", stage: stage.name) do
+          stage.call(results, options)
+        end
+      end
+    end
+
+    def prepare(objects)
+      objects.map do |object|
+        {object: object, key: nil, cached?: false, result: nil}
+      end
+    end
+
+    private
+
+    def instrument(operation, payload, &block)
+      Knuckles.notifications.instrument(operation, payload, &block)
+    end
+  end
+end

data/lib/knuckles/renderer.rb

@@ -0,0 +1,27 @@
+module Knuckles
+  module Renderer
+    extend self
+
+    def name
+      "renderer".freeze
+    end
+
+    def call(objects, options)
+      view = options.fetch(:view)
+
+      objects.each do |hash|
+        unless hash[:cached?]
+          hash[:result] = do_render(hash[:object], view, options)
+        end
+      end
+    end
+
+    private
+
+    def do_render(object, view, options)
+      view.relations(object, options).merge!(
+        view.root => [view.data(object, options)]
+      )
+    end
+  end
+end

data/lib/knuckles/version.rb

@@ -0,0 +1,3 @@
+module Knuckles
+  VERSION = "0.1.0".freeze
+end

data/lib/knuckles/view.rb

@@ -0,0 +1,28 @@
+module Knuckles
+  module View
+    extend self
+
+    ## Callbacks
+
+    def root
+    end
+
+    def data(_object, _options = {})
+      {}
+    end
+
+    def relations(_object, _options = {})
+      {}
+    end
+
+    ## Relations
+
+    def has_one(object, view, options = {})
+      [view.data(object, options)]
+    end
+
+    def has_many(objects, view, options = {})
+      objects.map { |object| view.data(object, options) }
+    end
+  end
+end

data/lib/knuckles/writer.rb

@@ -0,0 +1,41 @@
+module Knuckles
+  module Writer
+    extend self
+
+    def name
+      "writer".freeze
+    end
+
+    def call(objects, _)
+      if cache.respond_to?(:write_multi)
+        write_multi(objects)
+      else
+        write_each(objects)
+      end
+
+      objects
+    end
+
+    private
+
+    def cache
+      Knuckles.cache
+    end
+
+    def write_each(objects)
+      objects.each do |hash|
+        cache.write(hash[:key], hash[:result]) unless hash[:cached?]
+      end
+    end
+
+    def write_multi(objects)
+      writable = objects.each_with_object({}) do |hash, memo|
+        next if hash[:cached?]
+
+        memo[hash[:key]] = hash[:result]
+      end
+
+      cache.write_multi(writable) if writable.any?
+    end
+  end
+end

data/lib/knuckles.rb

@@ -0,0 +1,50 @@
+require "active_support/notifications"
+require "active_support/cache"
+require "json"
+
+module Knuckles
+  autoload :Combiner, "knuckles/combiner"
+  autoload :Dumper, "knuckles/dumper"
+  autoload :Fetcher, "knuckles/fetcher"
+  autoload :Hydrator, "knuckles/hydrator"
+  autoload :Keygen, "knuckles/keygen"
+  autoload :Pipeline, "knuckles/pipeline"
+  autoload :Renderer, "knuckles/renderer"
+  autoload :View, "knuckles/view"
+  autoload :Writer, "knuckles/writer"
+
+  extend self
+
+  attr_writer :cache, :keygen, :notifications, :serializer
+
+  def new(*args)
+    Knuckles::Pipeline.new(*args)
+  end
+
+  def cache
+    @cache ||= ActiveSupport::Cache::MemoryStore.new
+  end
+
+  def keygen
+    @keygen ||= Knuckles::Keygen
+  end
+
+  def notifications
+    @notifications ||= ActiveSupport::Notifications
+  end
+
+  def serializer
+    @serializer ||= JSON
+  end
+
+  def configure
+    yield self
+  end
+
+  def reset!
+    @cache = nil
+    @keygen = nil
+    @notifications = nil
+    @serializer = nil
+  end
+end

data/spec/knuckles/combiner_spec.rb

@@ -0,0 +1,36 @@
+RSpec.describe Knuckles::Combiner do
+  describe ".call" do
+    it "merges all results into a single object" do
+      prepared = [
+        {
+          result: {
+            author: {id: 1, name: "Michael"},
+            posts: [{id: 1, title: "hello", tag_ids: [1, 2]}],
+            tags: [{id: 1, name: "alpha"}, {id: 2, name: "gamma"}]
+          }
+        }, {
+          result: {
+            posts: [{id: 2, title: "there", tag_ids: [1]}],
+            tags: [{id: 1, name: "alpha"}]
+          }
+        }
+      ]
+
+      combined = Knuckles::Combiner.call(prepared, {})
+
+      expect(combined).to eq(
+        author: Set.new([
+          {id: 1, name: "Michael"}
+        ]),
+        posts: Set.new([
+          {id: 1, title: "hello", tag_ids: [1, 2]},
+          {id: 2, title: "there", tag_ids: [1]}
+        ]),
+        tags: Set.new([
+          {id: 1, name: "alpha"},
+          {id: 2, name: "gamma"}
+        ])
+      )
+    end
+  end
+end

data/spec/knuckles/dumper_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe Knuckles::Dumper do
+  describe ".call" do
+    it "dumps a tree of objects" do
+      objects = {
+        author: {id: 1, name: "Ernest"},
+        posts: Set.new([
+          {id: 1, title: "great"},
+          {id: 2, title: "stuff"}
+        ]),
+        tags: Set.new([
+          {id: 1, name: "alpha"},
+          {id: 2, name: "gamma"}
+        ])
+      }
+
+      dumped = Knuckles::Dumper.call(objects, {})
+
+      expect(dumped).to eq(
+        JSON.dump(
+          author: {id: 1, name: "Ernest"},
+          posts: [
+            {id: 1, title: "great"},
+            {id: 2, title: "stuff"}
+          ],
+          tags: [
+            {id: 1, name: "alpha"},
+            {id: 2, name: "gamma"}
+          ]
+        )
+      )
+    end
+  end
+end

data/spec/knuckles/fetcher_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Knuckles::Fetcher do
+  describe ".call" do
+    it "fetches all cached data for top level objects" do
+      objects = [Tag.new(1, "alpha"), Tag.new(2, "gamma")]
+
+      Knuckles.cache.write(Knuckles.keygen.expand_key(objects.first), "result")
+
+      objects = prepare(objects)
+      results = Knuckles::Fetcher.call(objects, {})
+
+      expect(pluck(results, :result)).to eq(["result", nil])
+      expect(pluck(results, :cached?)).to eq([true, false])
+    end
+
+    it "allows passing a custom keygen" do
+      keygen = Module.new do
+        def self.expand_key(object)
+          object.name
+        end
+      end
+
+      objects = prepare([Tag.new(1, "alpha")])
+      results = Knuckles::Fetcher.call(objects, keygen: keygen)
+
+      expect(pluck(results, :key)).to eq(["alpha"])
+    end
+  end
+
+  def pluck(enum, key)
+    enum.map { |hash| hash[key] }
+  end
+end

data/spec/knuckles/hydrator_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Knuckles::Hydrator do
+  describe ".call" do
+    it "is a noop without a hydrate lambda" do
+      objects = [Tag.new(1, "alpha")]
+
+      expect(Knuckles::Hydrator.call(objects, {})).to eq(objects)
+    end
+
+    it "refines the object collection using hydrate" do
+      objects = [Tag.new(1, "alpha"), Tag.new(2, "gamma")]
+      prepared = prepare(objects)
+
+      hydrate = lambda do |hashes|
+        hashes.each { |hash| hash[:object] = :updated }
+      end
+
+      hydrated = Knuckles::Hydrator.call(prepared, hydrate: hydrate)
+
+      expect(hydrated.map { |hash| hash[:object] }).to eq([:updated, :updated])
+    end
+  end
+end

data/spec/knuckles/keygen_spec.rb

@@ -0,0 +1,19 @@
+RSpec.describe Knuckles::Keygen do
+  FakeKeyModel = Struct.new(:id, :updated_at)
+
+  describe ".cache_key" do
+    it "provides a simple default cache key" do
+      cache_key = Knuckles::Keygen.expand_key(FakeKeyModel.new(123, Time.now))
+
+      expect(cache_key).to match(%r{FakeKeyModel/123/\d+})
+    end
+
+    it "respects an object with a cache_key method" do
+      model = double(:model, cache_key: "abcdefg")
+
+      cache_key = Knuckles::Keygen.expand_key(model)
+
+      expect(cache_key).to eq("abcdefg")
+    end
+  end
+end

data/spec/knuckles/pipeline_spec.rb

@@ -0,0 +1,96 @@
+RSpec.describe Knuckles::Pipeline do
+  describe "#stages" do
+    it "sets the default stages" do
+      pipeline = Knuckles::Pipeline.new
+
+      expect(pipeline.stages).not_to be_empty
+    end
+
+    it "allows stages to be customeized on initialization" do
+      pipeline = Knuckles::Pipeline.new(stages: [])
+
+      expect(pipeline.stages).to be_empty
+    end
+  end
+
+  describe "#delete" do
+    it "removes an existing stage" do
+      pipeline = Knuckles::Pipeline.new
+
+      pipeline.delete(Knuckles::Writer)
+
+      expect(pipeline.stages).not_to include(Knuckles::Writer)
+    end
+  end
+
+  describe "#insert_after" do
+    it "adds a stage after an existing stage" do
+      custom = Module.new
+      pipeline = Knuckles::Pipeline.new
+
+      pipeline.insert_after(Knuckles::Fetcher, custom)
+
+      expect(pipeline.stages).to include(custom)
+      expect(pipeline.stages.take(2)).to eq([
+        Knuckles::Fetcher,
+        custom
+      ])
+    end
+  end
+
+  describe "#insert_before" do
+    it "adds a stage after an existing stage" do
+      custom = Module.new
+      pipeline = Knuckles::Pipeline.new
+
+      pipeline.insert_before(Knuckles::Fetcher, custom)
+
+      expect(pipeline.stages).to include(custom)
+      expect(pipeline.stages.take(2)).to eq([
+        custom,
+        Knuckles::Fetcher
+      ])
+    end
+  end
+
+  describe "#call" do
+    it "aggregates the result of all stages" do
+      filter_a = Module.new do
+        def self.name
+          "strip"
+        end
+
+        def self.call(objects, _)
+          objects.each { |hash| hash[:object].strip! }
+        end
+      end
+
+      filter_b = Module.new do
+        def self.name
+          "downcase"
+        end
+
+        def self.call(objects, _)
+          objects.each { |hash| hash[:object].downcase! }
+        end
+      end
+
+      pipeline = Knuckles::Pipeline.new(stages: [filter_a, filter_b])
+
+      expect(pipeline.call([" KNUCKLES "], {}))
+        .to eq([{object: "knuckles", cached?: false, key: nil, result: nil}])
+    end
+  end
+
+  describe "#prepare" do
+    it "wraps all objects in entities" do
+      object = Object.new
+      prepared, = Knuckles::Pipeline.new.prepare([object])
+
+      expect(prepared[:object]).to be(object)
+      expect(prepared[:key]).to be_nil
+      expect(prepared[:result]).to be_nil
+      expect(prepared[:cached?]).to be_falsey
+    end
+  end
+end