rack-reducer 0.1.0

data/lib/rack/reducer/reduction.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'refinements'
+require_relative 'parser'
+
+module Rack
+  module Reducer
+    # call `reduce` on a params hash, filtering data via lambdas with
+    # matching keyword arguments
+    class Reduction
+      using Refinements # augment Hash & Proc inside this scope
+
+      DEFAULTS = {
+        dataset: [],
+        filters: [],
+        key: 'rack.reduction',
+        params: nil
+      }.freeze
+
+      def initialize(app, props)
+        @app = app
+        @props = DEFAULTS.merge(props)
+      end
+
+      # when mounted as middleware, set env[@props[:key]] to the output
+      # of self.reduce, then call the next app in the middleware stack
+      def call(env)
+        @params = Rack::Request.new(env).params.symbolize_keys
+        @app.call env.merge(@props[:key] => reduce)
+      end
+
+      def reduce
+        @props[:filters].reduce(@props[:dataset], &method(:apply_filter))
+      end
+
+      private
+
+      def params
+        @params ||= Parser.call(@props[:params]).symbolize_keys
+      end
+
+      def apply_filter(data, fn)
+        requirements = fn.required_argument_names.to_set
+        return data unless params.satisfies?(requirements)
+        data.instance_exec(params.slice(*fn.all_argument_names), &fn)
+      end
+    end
+  end
+end

data/lib/rack/reducer/refinements.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rack
+  module Reducer
+    # refine a few core classes in Rack::Reducer's scope only
+    module Refinements
+      refine Hash do
+        def symbolize_keys
+          each_with_object({}) do |(key, val), hash|
+            hash[key.to_sym] = val.is_a?(Hash) ? val.symbolize_keys : val
+          end
+        end
+
+        def satisfies?(requirements)
+          slice(*requirements).keys.to_set == requirements
+        end
+      end
+
+      refine Proc do
+        def required_argument_names
+          parameters.select { |arg| arg[0] == :keyreq }.map(&:last)
+        end
+
+        def all_argument_names
+          parameters.map(&:last)
+        end
+      end
+    end
+  end
+end

data/spec/behavior.rb

@@ -0,0 +1,44 @@
+shared_examples_for Rack::Reducer do
+  let(:app) { described_class }
+
+  it 'responds with unfiltered data when filter params are empty' do
+    get('/artists') do |res|
+      ARTISTS.each { |artist| expect(res.body).to include(artist[:name]) }
+    end
+  end
+
+  it 'filters by a single param, e.g. name' do
+    get('/artists?name=Blake') do |response|
+      expect(response.body).to include('Blake Mills')
+      expect(response.body).to include('James Blake')
+      expect(response.body).not_to include('SZA')
+    end
+  end
+
+  it 'filters by a single param, e.g. genre' do
+    get('/artists?genre=electronic') do |response|
+      expect(response.body).to include('Björk')
+      expect(response.body).to include('James Blake')
+      expect(response.body).not_to include('Blake Mills')
+    end
+
+    get '/artists?genre=soul' do |response|
+      expect(response.body).to include('Janelle Monae')
+      expect(response.body).not_to include('Björk')
+    end
+  end
+
+  it 'chains multiple filters' do
+    get('/artists?genre=electronic&name=blake') do |response|
+      expect(response.body).to include('James Blake')
+      expect(response.body).not_to include('Blake Mills')
+    end
+  end
+
+  it 'can sort as well as filter' do
+    get '/artists?order=genre' do |response|
+      genre = JSON.parse(response.body).dig(0, 'genre')
+      expect(genre).to eq('alt-soul')
+    end
+  end
+end

data/spec/benchmarks.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require_relative 'fixtures'
+require 'sinatra/base'
+require 'json'
+require 'benchmark/ips'
+
+class App < Sinatra::Base
+  get '/conditionals' do
+    @artists = DB[:artists]
+    if (genre = params[:genre])
+      @artists = @artists.grep(:genre, "%#{genre}%", case_insensitive: true)
+    end
+    if (name = params[:name])
+      @artists = @artists.grep(:name, "%#{name}%", case_insensitive: true)
+    end
+
+    @artists.to_json
+  end
+
+  get '/reduction' do
+    @artists = Rack::Reducer.call(params, dataset: DB[:artists], filters: [
+      ->(genre:) { grep(:genre, "%#{genre}%", case_insensitive: true) },
+      ->(name:) { grep(:name, "%#{name}%", case_insensitive: true) },
+    ])
+
+    @artists.to_json
+  end
+end
+
+describe 'Performance' do
+  let(:app) { App }
+
+  it 'compares favorably to spaghetti code when params are empty' do
+    Benchmark.ips(3) do |bm|
+      bm.report('conditionals, empty params') do
+        get '/conditionals'
+      end
+      bm.report('reduction, empty params') do
+        get '/reduction'
+      end
+      bm.compare!
+    end
+  end
+
+  it 'compares favorably to spaghetti code when params are full' do
+    Benchmark.ips(3) do |bm|
+      bm.report('conditionals, full params') do
+        get '/conditionals?name=blake&genre=electronic'
+      end
+      bm.report('reduction, full params') do
+        get '/reduction?name=blake&genre=electronic'
+      end
+      bm.compare!
+    end
+  end
+end

data/spec/fixtures.rb

@@ -0,0 +1,19 @@
+# hash fixture data
+ARTISTS = [
+  { name: 'Blake Mills', genre: 'alternative' },
+  { name: 'Björk', genre: 'electronic' },
+  { name: 'James Blake', genre: 'electronic' },
+  { name: 'Janelle Monae', genre: 'alt-soul' },
+  { name: 'SZA', genre: 'alt-soul' },
+].freeze
+
+require 'sequel'
+DB = Sequel.sqlite
+
+DB.create_table :artists do
+  String :name
+  String :genre
+end
+
+# put the hash fixtures into an in-memory SQLite database
+ARTISTS.each { |artist| DB[:artists].insert(artist) }

data/spec/middleware_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require_relative 'fixtures'
+require 'json'
+
+# mount Rack::Reducer as middleware, let it filter data into env['rack.reduction'],
+# and respond with env['rack.reduction'].to_json
+module MiddlewareTest
+  def self.app
+    Rack::Builder.new do
+      use Rack::Reducer, dataset: ARTISTS, filters: [
+        ->(genre:) { select { |item| item[:genre].match(/#{genre}/i) } },
+        ->(name:) { select { |item| item[:name].match(/#{name}/i) } },
+        ->(order:) { sort_by { |item| item[order.to_sym] } }
+      ]
+      run ->(env) { [200, {}, [env['rack.reduction'].to_json]] }
+    end
+  end
+end
+
+describe MiddlewareTest.app do
+  it_behaves_like Rack::Reducer
+end

data/spec/rails_example/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/spec/rails_example/app/channels/application_cable/connection.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/spec/rails_example/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::API
+end

data/spec/rails_example/app/controllers/artists_controller.rb

@@ -0,0 +1,53 @@
+class ArtistsController < ApplicationController
+  before_action :set_artist, only: [:show, :update, :destroy]
+
+  # GET /artists
+  def index
+    @artists = Artist.reduce(params)
+
+    render json: @artists
+  end
+
+  # GET /artists/1
+  def show
+    render json: @artist
+  end
+
+  # POST /artists
+  def create
+    @artist = Artist.new(artist_params)
+
+    if @artist.save
+      render json: @artist, status: :created, location: @artist
+    else
+      render json: @artist.errors, status: :unprocessable_entity
+    end
+  end
+
+  # PATCH/PUT /artists/1
+  def update
+    if @artist.update(artist_params)
+      render json: @artist
+    else
+      render json: @artist.errors, status: :unprocessable_entity
+    end
+  end
+
+  # DELETE /artists/1
+  def destroy
+    @artist.destroy
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_artist
+      @artist = Artist.find(params[:id])
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def artist_params
+      params.require(:artist).permit(:name, :genre, :last_release)
+    end
+end
+      #filters: [:search_genre, :search_name].map { |m| method(m).to_proc },
+

data/spec/rails_example/app/jobs/application_job.rb

@@ -0,0 +1,2 @@
+class ApplicationJob < ActiveJob::Base
+end

data/spec/rails_example/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+end

data/spec/rails_example/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/spec/rails_example/app/models/artist.rb

@@ -0,0 +1,18 @@
+class Artist < ApplicationRecord
+  scope :by_name, lambda { |name|
+    where('lower(name) like ?', "%#{name.downcase}%")
+  }
+  def self.search_genre(genre)
+    where('lower(genre) like ?', "%#{genre.downcase}%")
+  end
+
+  extend Rack::Reducer
+  reduces all, filters: [
+    # filters can call class methods...
+    ->(genre:) { search_genre(genre) },
+    # or scopes...
+    ->(name:) { by_name(name) },
+    # or inline ActiveRecord queries
+    ->(order:) { order(order.to_sym) }
+  ]
+end

data/spec/rails_example/config/application.rb

@@ -0,0 +1,35 @@
+require_relative 'boot'
+
+require "rails"
+# Pick the frameworks you want:
+require "active_model/railtie"
+#require "active_job/railtie"
+require "active_record/railtie"
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+#require "action_cable/engine"
+# require "sprockets/railtie"
+#require "rails/test_unit/railtie"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module ExRails
+  class Application < Rails::Application
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults 5.1
+
+
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Only loads a smaller set of middleware suitable for API only apps.
+    # Middleware like session, flash, cookies can be added back manually.
+    # Skip views, helpers and assets when generating a new resource.
+    config.api_only = true
+
+  end
+end

data/spec/rails_example/config/boot.rb

@@ -0,0 +1,3 @@
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+
+require 'bundler/setup' # Set up gems listed in the Gemfile.

data/spec/rails_example/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative 'application'
+
+# Initialize the Rails application.
+Rails.application.initialize!

data/spec/rails_example/config/environments/development.rb

@@ -0,0 +1,47 @@
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # In the development environment your application's code is reloaded on
+  # every request. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Do not eager load code on boot.
+  config.eager_load = false
+
+  # Show full error reports.
+  config.consider_all_requests_local = true
+
+  # Enable/disable caching. By default caching is disabled.
+  if Rails.root.join('tmp/caching-dev.txt').exist?
+    config.action_controller.perform_caching = true
+
+    config.cache_store = :memory_store
+    config.public_file_server.headers = {
+      'Cache-Control' => "public, max-age=#{2.days.seconds.to_i}"
+    }
+  else
+    config.action_controller.perform_caching = false
+
+    config.cache_store = :null_store
+  end
+
+  # Don't care if the mailer can't send.
+  config.action_mailer.raise_delivery_errors = false
+
+  config.action_mailer.perform_caching = false
+
+  # Print deprecation notices to the Rails logger.
+  config.active_support.deprecation = :log
+
+  # Raise an error on page load if there are pending migrations.
+  config.active_record.migration_error = :page_load
+
+
+  # Raises error for missing translations
+  # config.action_view.raise_on_missing_translations = true
+
+  # Use an evented file watcher to asynchronously detect changes in source code,
+  # routes, locales, etc. This feature depends on the listen gem.
+  config.file_watcher = ActiveSupport::EventedFileUpdateChecker
+end

data/spec/rails_example/config/environments/production.rb

@@ -0,0 +1,83 @@
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # Code is not reloaded between requests.
+  config.cache_classes = true
+
+  # Eager load code on boot. This eager loads most of Rails and
+  # your application in memory, allowing both threaded web servers
+  # and those relying on copy on write to perform better.
+  # Rake tasks automatically ignore this option for performance.
+  config.eager_load = true
+
+  # Full error reports are disabled and caching is turned on.
+  config.consider_all_requests_local       = false
+  config.action_controller.perform_caching = true
+
+  # Attempt to read encrypted secrets from `config/secrets.yml.enc`.
+  # Requires an encryption key in `ENV["RAILS_MASTER_KEY"]` or
+  # `config/secrets.yml.key`.
+  config.read_encrypted_secrets = true
+
+  # Disable serving static files from the `/public` folder by default since
+  # Apache or NGINX already handles this.
+  config.public_file_server.enabled = ENV['RAILS_SERVE_STATIC_FILES'].present?
+
+
+  # Enable serving of images, stylesheets, and JavaScripts from an asset server.
+  # config.action_controller.asset_host = 'http://assets.example.com'
+
+  # Specifies the header that your server uses for sending files.
+  # config.action_dispatch.x_sendfile_header = 'X-Sendfile' # for Apache
+  # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for NGINX
+
+  # Mount Action Cable outside main process or domain
+  # config.action_cable.mount_path = nil
+  # config.action_cable.url = 'wss://example.com/cable'
+  # config.action_cable.allowed_request_origins = [ 'http://example.com', /http:\/\/example.*/ ]
+
+  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  # config.force_ssl = true
+
+  # Use the lowest log level to ensure availability of diagnostic information
+  # when problems arise.
+  config.log_level = :debug
+
+  # Prepend all log lines with the following tags.
+  config.log_tags = [ :request_id ]
+
+  # Use a different cache store in production.
+  # config.cache_store = :mem_cache_store
+
+  # Use a real queuing backend for Active Job (and separate queues per environment)
+  # config.active_job.queue_adapter     = :resque
+  # config.active_job.queue_name_prefix = "ex_rails_#{Rails.env}"
+  config.action_mailer.perform_caching = false
+
+  # Ignore bad email addresses and do not raise email delivery errors.
+  # Set this to true and configure the email server for immediate delivery to raise delivery errors.
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
+  # the I18n.default_locale when a translation cannot be found).
+  config.i18n.fallbacks = true
+
+  # Send deprecation notices to registered listeners.
+  config.active_support.deprecation = :notify
+
+  # Use default logging formatter so that PID and timestamp are not suppressed.
+  config.log_formatter = ::Logger::Formatter.new
+
+  # Use a different logger for distributed setups.
+  # require 'syslog/logger'
+  # config.logger = ActiveSupport::TaggedLogging.new(Syslog::Logger.new 'app-name')
+
+  if ENV["RAILS_LOG_TO_STDOUT"].present?
+    logger           = ActiveSupport::Logger.new(STDOUT)
+    logger.formatter = config.log_formatter
+    config.logger    = ActiveSupport::TaggedLogging.new(logger)
+  end
+
+  # Do not dump schema after migrations.
+  config.active_record.dump_schema_after_migration = false
+end