chassis 0.1.0

data/chassis.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chassis/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "chassis"
+  spec.version       = Chassis::VERSION
+  spec.authors       = ["ahawkins"]
+  spec.email         = ["adam@hawkins.io"]
+  spec.description   = %q{A collection of modules and helpers for building mantainable Ruby applications}
+  spec.summary       = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sinatra"
+  spec.add_dependency "sinatra-contrib"
+  spec.add_dependency "rack-contrib"
+  spec.add_dependency "manifold"
+  spec.add_dependency "prox"
+  spec.add_dependency "harness"
+  spec.add_dependency "harness-rack"
+  spec.add_dependency "virtus"
+  spec.add_dependency "virtus-dirty_attribute"
+  spec.add_dependency "faraday", "~> 0.9.0"
+  spec.add_dependency "logger-better"
+  spec.add_dependency "breaker"
+  spec.add_dependency "interchange"
+  spec.add_dependency "tnt"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "redis"
+end

data/examples/repo.rb

@@ -0,0 +1,40 @@
+require 'chassis'
+
+class Post
+  attr_accessor :id, :title, :text
+end
+
+repo = Chassis::Repo.default
+
+puts repo.empty? Post #=> true
+
+post = Post.new
+post.title = 'Such Repos'
+post.text = 'Very wow. Much design.'
+
+repo.save post
+
+puts post.id #=> 1
+
+found_post = repo.find Post, post.id
+found_post == post #=> true (no difference between objects in memory)
+
+post.title = 'Such updates'
+post.text = 'Very easy. Wow'
+
+repo.save post
+
+repo.find(Post, post.id).text #=> 'Very easy. Wow.'
+
+class PostRepo
+  extend Chassis::Repo::Delegation
+end
+
+post = PostRepo.find post.id
+post.text #=> 'Very Easy. Wow'
+
+PostRepo.all #=> [post]
+# etc
+
+PostRepo.delete post
+PostRepo.empty? #=> true

data/lib/chassis.rb

@@ -0,0 +1,81 @@
+require "chassis/version"
+
+require 'logger-better'
+
+require 'sinatra'
+require 'manifold'
+require 'rack/contrib/bounce_favicon'
+require 'rack/contrib/post_body_content_type_parser'
+
+require 'harness'
+require 'harness/rack'
+
+require 'virtus'
+require 'virtus/dirty_attribute'
+
+require 'prox'
+
+require 'faraday'
+
+require 'breaker'
+
+require 'interchange'
+
+require 'tnt'
+
+module Chassis
+  Proxy = Prox
+
+  class << self
+    def stream
+      @stream
+    end
+
+    def stream=(stream)
+      @stream = stream
+    end
+  end
+end
+
+require_relative 'chassis/hash_utils'
+require_relative 'chassis/string_utils'
+require_relative 'chassis/array_utils'
+
+require_relative 'chassis/error'
+
+require_relative 'chassis/logger'
+
+require_relative 'chassis/faraday'
+
+require_relative 'chassis/form'
+
+require_relative 'chassis/persistence'
+
+require_relative 'chassis/initializable'
+
+require_relative 'chassis/serializable'
+
+require_relative 'chassis/observable'
+
+require_relative 'chassis/dirty_session'
+
+require_relative 'chassis/circuit_panel'
+
+require_relative 'chassis/registry'
+
+require_relative 'chassis/repo'
+
+require_relative 'chassis/delegate'
+
+require_relative 'chassis/rack/bouncer'
+require_relative 'chassis/rack/builder_shim_patch'
+require_relative 'chassis/rack/health_check'
+require_relative 'chassis/rack/instrumentation'
+require_relative 'chassis/rack/no_robots'
+require_relative 'chassis/rack/json_body_parser'
+
+require_relative 'chassis/web_service'
+
+Chassis.repo.register :memory, Chassis::MemoryRepo.new
+Chassis.repo.register :null, Chassis::NullRepo.new
+Chassis.repo.use :memory

data/lib/chassis/array_utils.rb

@@ -0,0 +1,8 @@
+module Chassis
+  module ArrayUtils
+    def extract_options!(array)
+      array.last.is_a?(Hash) ? array.pop : { }
+    end
+    module_function :extract_options!
+  end
+end

data/lib/chassis/circuit_panel.rb

@@ -0,0 +1,22 @@
+module Chassis
+  class CircuitPanel
+    class << self
+      def build(&block)
+        raise ArgumentError, "block required" unless block
+        Class.new self, &block
+      end
+
+      def circuit(name, options = {})
+        define_method name do
+          Breaker.circuit name, options
+        end
+      end
+    end
+  end
+
+  class << self
+    def circuit_panel(&block)
+      CircuitPanel.build &block
+    end
+  end
+end

data/lib/chassis/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def extract_options!
+    Chassis::ArrayUtils.extract_options! self
+  end
+end

data/lib/chassis/core_ext/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def symbolize
+    Chassis::HashUtils.symbolize self
+  end
+end

data/lib/chassis/core_ext/string.rb

@@ -0,0 +1,13 @@
+class String
+  def constantize
+    Chassis::StringUtils.constantize self
+  end
+
+  def demodulize
+    Chassis::StringUtils.demodulize self
+  end
+
+  def underscore
+    Chassis::StringUtils.underscore self
+  end
+end

data/lib/chassis/delegate.rb

@@ -0,0 +1,29 @@
+module Chassis
+  DelegationError = Chassis.error do |method, delegate|
+    "Cannot delegate #{method} without #{delegate}"
+  end
+
+  class Delegation < Module
+    def initialize(*methods)
+      options = methods.last.is_a?(Hash) ? methods.pop : { }
+
+      delegate = options.fetch :to do
+        fail ArgumentError, ":to not given"
+      end
+
+      methods.each do |method|
+        define_method method do |*args, &block|
+          object = send delegate
+          fail DelegationError.new method, delegate unless object
+          object.send(method, *args, &block)
+        end
+      end
+    end
+  end
+
+  class << self
+    def delegate(*methods)
+      Delegation.new *methods
+    end
+  end
+end

data/lib/chassis/dirty_session.rb

@@ -0,0 +1,105 @@
+require 'set'
+
+module Chassis
+  class DirtySession < Proxy
+    def initialize(*args)
+      super
+      @original_values  = { }
+      @new_values = { }
+    end
+
+    def clean?
+      new_values.empty?
+    end
+
+    def dirty?
+      !clean?
+    end
+
+    def original_values
+      @original_values
+    end
+
+    def new_values
+      @new_values
+    end
+
+    def changes
+      Set.new original_values.keys
+    end
+
+    def reset!
+      original_values.clear
+      new_values.clear
+    end
+
+    def method_missing(name, *args, &block)
+      raise MissingObject, name unless __getobj__
+
+      if writer_method?(name)
+        handle_writer_method name, *args, &block
+      elsif changed_method?(name)
+        handle_changed_method name
+      elsif original_method?(name)
+        handle_original_method name
+      else
+        __getobj__.send name, *args, &block
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      if changed_method?(name) || original_method?(name)
+        __getobj__.respond_to? reader_method(name)
+      else
+        super
+      end
+    end
+
+    private
+    def handle_writer_method(name, *args, &block)
+      method_key = reader_method name
+
+      original_value = __getobj__.send method_key
+      new_value = __getobj__.send name, *args, &block
+
+      if new_value != original_value
+        original_values[method_key] = original_value unless original_values.key? method_key
+        new_values[method_key] = new_value
+      end
+
+      new_value
+    end
+
+    def writer_method?(name)
+      name =~ /=$/
+    end
+
+    def reader_method(name)
+      method_name = name.to_s
+
+      if writer_method? method_name
+        method_name.match(/(.+)=$/)[1].to_sym
+      elsif changed_method? method_name
+        method_name.match(/(.+)_changed\?$/)[1].to_sym
+      elsif original_method? method_name
+        method_name.match(/original_(.+)$/)[1].to_sym
+      end
+    end
+
+    def original_method?(name)
+      name =~ /original_.+$/
+    end
+
+    def changed_method?(name)
+      name =~ /_changed\?$/
+    end
+
+    def handle_changed_method(name)
+      original_values.key? reader_method(name)
+    end
+
+    def handle_original_method(name)
+      original_values[reader_method(name)]
+    end
+  end
+end

data/lib/chassis/error.rb

@@ -0,0 +1,7 @@
+module Chassis
+  class << self
+    def error(*args, &block)
+      Tnt.boom *args, &block
+    end
+  end
+end

data/lib/chassis/faraday.rb

@@ -0,0 +1,226 @@
+module Chassis
+  class HttpRequestFailedError < StandardError
+    def initialize(env)
+      @env = env
+    end
+
+    def to_s
+      "#{status} - #{description} : #{method} #{url}"
+    end
+
+    def method
+      env.fetch(:method).upcase
+    end
+
+    def body
+      env.fetch :body
+    end
+
+    def url
+      env.fetch(:url)
+    end
+
+    def status
+      env.fetch :status
+    end
+
+    def description
+      ::Rack::Utils::HTTP_STATUS_CODES.fetch status, 'UNKOWN'
+    end
+
+    private
+    def env
+      @env
+    end
+  end
+
+  # 4xx errors
+  HttpClientError = Class.new HttpRequestFailedError
+  HttpBadRequestError = Class.new HttpClientError
+  HttpUnauthorizedError = Class.new HttpClientError
+  HttpPaymentRequiredError = Class.new HttpClientError
+  HttpForbiddenError = Class.new HttpClientError
+  HttpNotFoundError = Class.new HttpClientError
+  HttpMethodNotAllowedError = Class.new HttpClientError
+  HttpNotAcceptableError = Class.new HttpClientError
+  HttpProxyAuthenticationRequiredError = Class.new HttpClientError
+  HttpRequestTimeoutError = Class.new HttpClientError
+  HttpConflictError = Class.new HttpClientError
+  HttpGoneError = Class.new HttpClientError
+  HttpLengthRequiredError = Class.new HttpClientError
+  HttpPreconditionFailedError = Class.new HttpClientError
+  HttpRequestEntityTooLargeError = Class.new HttpClientError
+  HttpRequestUriTooLongError = Class.new HttpClientError
+  HttpUnsupportedMediaTypeError = Class.new HttpClientError
+  HttpRequestRangeNotSatisfiableError = Class.new HttpClientError
+  HttpExpectationFailedError = Class.new HttpClientError
+  HttpUnprocessableEntityError = Class.new HttpClientError
+  HttpLockedError = Class.new HttpClientError
+  HttpFailedDependencyError = Class.new HttpClientError
+  HttpUpgradeRequiredError = Class.new HttpClientError
+
+  # 5xx errors
+  HttpServerError = Class.new HttpRequestFailedError
+  HttpInternalServerError = Class.new HttpServerError
+  HttpNotImplementedError = Class.new HttpServerError
+  HttpBadGatewayError = Class.new HttpServerError
+  HttpServiceUnavailableError = Class.new HttpServerError
+  HttpGatewayTimeoutError = Class.new HttpServerError
+  HttpVersionNotSupportedError = Class.new HttpServerError
+  HttpInsufficientStorageError = Class.new HttpServerError
+  HttpNotExtendedError = Class.new HttpServerError
+
+  HTTP_STATUS_CODE_ERROR_MAP = {
+    400 => HttpBadRequestError,
+    401 => HttpUnauthorizedError,
+    402 => HttpPaymentRequiredError,
+    403 => HttpForbiddenError,
+    404 => HttpNotFoundError,
+    405 => HttpMethodNotAllowedError,
+    406 => HttpNotAcceptableError,
+    407 => HttpProxyAuthenticationRequiredError,
+    408 => HttpRequestTimeoutError,
+    409 => HttpConflictError,
+    410 => HttpGoneError,
+    411 => HttpLengthRequiredError,
+    412 => HttpPreconditionFailedError,
+    413 => HttpRequestEntityTooLargeError,
+    414 => HttpRequestUriTooLongError,
+    415 => HttpUnsupportedMediaTypeError,
+    416 => HttpRequestRangeNotSatisfiableError,
+    417 => HttpExpectationFailedError,
+    422 => HttpUnprocessableEntityError,
+    423 => HttpLockedError,
+    424 => HttpFailedDependencyError,
+    426 => HttpUpgradeRequiredError,
+
+    # 5xx errors
+    500 => HttpInternalServerError,
+    501 => HttpNotImplementedError,
+    502 => HttpBadGatewayError,
+    503 => HttpServiceUnavailableError,
+    504 => HttpGatewayTimeoutError,
+    505 => HttpVersionNotSupportedError,
+    507 => HttpInsufficientStorageError,
+    510 => HttpNotExtendedError
+  }
+
+  class ServerErrorHandler < ::Faraday::Response::Middleware
+    def on_complete(env)
+      status = env.fetch :status
+      return unless (400..600).include? status
+      raise HTTP_STATUS_CODE_ERROR_MAP.fetch(status), env
+    end
+  end
+
+  class ParseJson < ::Faraday::Response::Middleware
+    def on_complete(env)
+      return if [204, 304].include? env.fetch(:status)
+
+      content_type = env.fetch(:response_headers).fetch('Content-Type', nil)
+
+      return unless content_type
+      return unless content_type =~ /json/
+
+      body = env.body
+
+      return unless body.respond_to? :to_str
+
+      content = body.to_str.strip
+
+      return if content.empty?
+
+      env[:body] = JSON.load content
+    end
+  end
+
+  class Instrumentation < ::Faraday::Middleware
+    include Harness::Instrumentation
+
+    def initialize(app, progname = 'faraday')
+      @app, @progname = app, progname
+    end
+
+    def call(env)
+      time "#{@progname}.#{env.method}" do
+        @app.call env
+      end
+    end
+  end
+
+  class EncodeJson < ::Faraday::Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env.body
+        env[:request_headers]['Content-Type'] = 'application/json'
+        env.body = JSON.dump env.body
+      end
+
+      @app.call env
+    end
+  end
+
+  class Logging < ::Faraday::Response::Middleware
+    def initialize(app, logger)
+      @app, @logger = app, logger
+    end
+
+    def call(env)
+      dump_request env
+      super
+    end
+
+    def on_complete(env)
+      dump_response env
+    end
+
+    private
+    def dump_request(env)
+      request_line = "> #{env.fetch(:method).to_s.upcase} #{env.fetch(:url)}"
+      headers = env.fetch(:request_headers).map do |name, value|
+        "> #{name}: #{value}"
+      end.join("\n")
+
+      @logger.debug [request_line, headers, env.body].compact.join("\n")
+    end
+
+    def dump_response(env)
+      status = env.fetch :status
+      status_text = ::Rack::Utils::HTTP_STATUS_CODES.fetch status, 'Unknown'
+      request_line = "> #{status.to_s.upcase} #{status_text}"
+      headers = env.fetch(:response_headers).map do |name, value|
+        "> #{name}: #{value}"
+      end.join("\n")
+
+      @logger.debug [request_line, headers, env.body].compact.join("\n")
+    end
+  end
+
+  ::Faraday::Request.register_middleware instrumentation: Instrumentation
+  ::Faraday::Request.register_middleware encode_json: EncodeJson
+
+  ::Faraday::Response.register_middleware parse_json: ParseJson
+  ::Faraday::Response.register_middleware server_error_handler: ServerErrorHandler
+  ::Faraday::Response.register_middleware logging: Logging
+
+  class << self
+    def faraday(host, options = {})
+      namespace = options.delete :namespace
+      logger = options.delete(:logger) || Logger.new.tap { |l| l.progname = 'faraday' }
+
+      Faraday.new host, options do |conn|
+        conn.request :instrumentation, namespace
+        conn.request :encode_json
+
+        conn.response :parse_json
+        conn.response :server_error_handler
+        conn.response :logging, logger
+
+        yield conn if block_given?
+      end
+    end
+  end
+end