pliny 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 18bf67cc7da9438b4f46b8a0265edbfb4253484f
+  data.tar.gz: 09a5892f943e2aedea7fda831a85924212902deb
+SHA512:
+  metadata.gz: b415fc1bb35256ee85dd80bde4bf4fcdfb1995839646c59cfb1cc162bed23b76cbbc0e1cf7bb9155b85971156747c4b3c238a3b900d8f8ccc923c1b1d46a272d
+  data.tar.gz: 55aa879eec76133b9c01e979a92a332e99ea1a7af61ec3eab861488a3187aee134b7875271d9ddb91248618a060dac70afcce77847ab7688256e33decea4263d

data/bin/pliny-generate

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler"
+Bundler.require
+
+Pliny::Commands::Generator.run(ARGV.dup)

data/lib/pliny.rb

@@ -0,0 +1,21 @@
+require "multi_json"
+require "sinatra/base"
+
+require "pliny/version"
+require "pliny/commands/generator"
+require "pliny/errors"
+require "pliny/extensions/instruments"
+require "pliny/log"
+require "pliny/request_store"
+require "pliny/router"
+require "pliny/utils"
+require "pliny/middleware/cors"
+require "pliny/middleware/request_id"
+require "pliny/middleware/request_store"
+require "pliny/middleware/rescue_errors"
+require "pliny/middleware/timeout"
+require "pliny/middleware/versioning"
+
+module Pliny
+  extend Log
+end

data/lib/pliny/commands/generator.rb

@@ -0,0 +1,197 @@
+require "erb"
+require "fileutils"
+require "ostruct"
+require "active_support/inflector"
+require "prmd"
+
+module Pliny::Commands
+  class Generator
+    attr_accessor :args, :stream
+
+    def self.run(args, stream=$stdout)
+      new(args).run!
+    end
+
+    def initialize(args={}, stream=$stdout)
+      @args = args
+      @stream = stream
+    end
+
+    def run!
+      unless type
+        raise "Missing type of object to generate"
+      end
+      unless name
+        raise "Missing #{type} name"
+      end
+
+      case type
+      when "endpoint"
+        create_endpoint(scaffold: false)
+        create_endpoint_test
+        create_endpoint_acceptance_test(scaffold: false)
+      when "mediator"
+        create_mediator
+        create_mediator_test
+      when "migration"
+        create_migration
+      when "model"
+        create_model
+        create_model_migration
+        create_model_test
+      when "scaffold"
+        create_endpoint(scaffold: true)
+        create_endpoint_test
+        create_endpoint_acceptance_test(scaffold: true)
+        create_model
+        create_model_migration
+        create_model_test
+        create_schema
+        rebuild_schema
+      when "schema"
+        create_schema
+        rebuild_schema
+      else
+        abort("Don't know how to generate '#{type}'.")
+      end
+    end
+
+    def type
+      args.first
+    end
+
+    def name
+      args[1]
+    end
+
+    def singular_class_name
+      name.singularize.camelize
+    end
+
+    def plural_class_name
+      name.pluralize.camelize
+    end
+
+    def field_name
+      name.tableize.singularize
+    end
+
+    def table_name
+      name.tableize
+    end
+
+    def display(msg)
+      stream.puts msg
+    end
+
+    def create_endpoint(options = {})
+      endpoint = "./lib/endpoints/#{name.pluralize}.rb"
+      template = options[:scaffold] ? "endpoint_scaffold.erb" : "endpoint.erb"
+      render_template(template, endpoint, {
+        plural_class_name: plural_class_name,
+        singular_class_name: singular_class_name,
+        field_name: field_name,
+        url_path:   url_path,
+      })
+      display "created endpoint file #{endpoint}"
+      display "add the following to lib/routes.rb:"
+      display "  mount Endpoints::#{plural_class_name}"
+    end
+
+    def create_endpoint_test
+      test = "./spec/endpoints/#{name.pluralize}_spec.rb"
+      render_template("endpoint_test.erb", test, {
+        plural_class_name: plural_class_name,
+        singular_class_name: singular_class_name,
+        url_path:   url_path,
+      })
+      display "created test #{test}"
+    end
+
+    def create_endpoint_acceptance_test(options = {})
+      test = "./spec/acceptance/#{name.pluralize}_spec.rb"
+      template = options[:scaffold] ? "endpoint_scaffold_acceptance_test.erb" :
+        "endpoint_acceptance_test.erb"
+      render_template(template, test, {
+        plural_class_name: plural_class_name,
+        field_name: field_name,
+        singular_class_name: singular_class_name,
+        url_path:   url_path,
+      })
+      display "created test #{test}"
+    end
+
+    def create_mediator
+      mediator = "./lib/mediators/#{name}.rb"
+      render_template("mediator.erb", mediator, plural_class_name: plural_class_name)
+      display "created mediator file #{mediator}"
+    end
+
+    def create_mediator_test
+      test = "./spec/mediators/#{name}_spec.rb"
+      render_template("mediator_test.erb", test, plural_class_name: plural_class_name)
+      display "created test #{test}"
+    end
+
+    def create_migration
+      migration = "./db/migrate/#{Time.now.to_i}_#{name}.rb"
+      render_template("migration.erb", migration)
+      display "created migration #{migration}"
+    end
+
+    def create_model
+      model = "./lib/models/#{name}.rb"
+      render_template("model.erb", model, singular_class_name: singular_class_name)
+      display "created model file #{model}"
+    end
+
+    def create_model_migration
+      migration = "./db/migrate/#{Time.now.to_i}_create_#{table_name}.rb"
+      render_template("model_migration.erb", migration,
+        table_name: table_name)
+      display "created migration #{migration}"
+    end
+
+    def create_model_test
+      test = "./spec/models/#{name}_spec.rb"
+      render_template("model_test.erb", test, singular_class_name: singular_class_name)
+      display "created test #{test}"
+    end
+
+    def create_schema
+      schema = "./docs/schema/schemata/#{name.singularize}.yaml"
+      write_file(schema) do
+        Prmd.init(name.singularize, yaml: true)
+      end
+      display "created schema file #{schema}"
+    end
+
+    def rebuild_schema
+      schemata = "./docs/schema.json"
+      write_file(schemata) do
+        Prmd.combine("./docs/schema/schemata", meta: "./docs/schema/meta.json")
+      end
+      display "rebuilt #{schemata}"
+    end
+
+    def render_template(template_file, destination_path, vars={})
+      template_path = File.dirname(__FILE__) + "/../templates/#{template_file}"
+      template = ERB.new(File.read(template_path), 0, ">")
+      context = OpenStruct.new(vars)
+      write_file(destination_path) do
+        template.result(context.instance_eval { binding })
+      end
+    end
+
+    def url_path
+      "/" + name.pluralize.gsub(/_/, '-')
+    end
+
+    def write_file(destination_path)
+      FileUtils.mkdir_p(File.dirname(destination_path))
+      File.open(destination_path, "w") do |f|
+        f.puts yield
+      end
+    end
+  end
+end

data/lib/pliny/config_helpers.rb

@@ -0,0 +1,24 @@
+module Pliny
+  module ConfigHelpers
+    def optional(*attrs)
+      attrs.each do |attr|
+        instance_eval "def #{attr}; @#{attr} ||= ENV['#{attr.upcase}'] end", __FILE__, __LINE__
+      end
+    end
+
+    def mandatory(*attrs)
+      attrs.each do |attr|
+        instance_eval "def #{attr}; @#{attr} ||= ENV['#{attr.upcase}'] || raise('missing=#{attr.upcase}') end", __FILE__, __LINE__
+      end
+    end
+
+    def override(attrs)
+      attrs.each do |attr, value|
+        instance_eval "def #{attr}; @#{attr} ||= ENV['#{attr.upcase}'] || '#{value}'.to_s end", __FILE__, __LINE__
+      end
+    end
+  end
+end
+
+# Supress the "use RbConfig instead" warning.
+Object.send :remove_const, :Config

data/lib/pliny/errors.rb

@@ -0,0 +1,109 @@
+module Pliny
+  module Errors
+    class Error < StandardError
+      attr_accessor :id
+
+      def initialize(message, id)
+        @id = id
+        super(message)
+      end
+    end
+
+    class HTTPStatusError < Error
+      attr_reader :status
+
+      def initialize(message = nil, id = nil, status = nil)
+        meta    = Pliny::Errors::META[self.class]
+        message = message || meta[1] + "."
+        id      = id || meta[1].downcase.gsub(/ /, '_').to_sym
+        @status = status || meta[0]
+        super(message, id)
+      end
+    end
+
+    class Continue < HTTPStatusError; end                     # 100
+    class SwitchingProtocols < HTTPStatusError; end           # 101
+    class OK < HTTPStatusError; end                           # 200
+    class Created < HTTPStatusError; end                      # 201
+    class Accepted < HTTPStatusError; end                     # 202
+    class NonAuthoritativeInformation < HTTPStatusError; end  # 203
+    class NoContent < HTTPStatusError; end                    # 204
+    class ResetContent < HTTPStatusError; end                 # 205
+    class PartialContent < HTTPStatusError; end               # 206
+    class MultipleChoices < HTTPStatusError; end              # 300
+    class MovedPermanently < HTTPStatusError; end             # 301
+    class Found < HTTPStatusError; end                        # 302
+    class SeeOther < HTTPStatusError; end                     # 303
+    class NotModified < HTTPStatusError; end                  # 304
+    class UseProxy < HTTPStatusError; end                     # 305
+    class TemporaryRedirect < HTTPStatusError; end            # 307
+    class BadRequest < HTTPStatusError; end                   # 400
+    class Unauthorized < HTTPStatusError; end                 # 401
+    class PaymentRequired < HTTPStatusError; end              # 402
+    class Forbidden < HTTPStatusError; end                    # 403
+    class NotFound < HTTPStatusError; end                     # 404
+    class MethodNotAllowed < HTTPStatusError; end             # 405
+    class NotAcceptable < HTTPStatusError; end                # 406
+    class ProxyAuthenticationRequired < HTTPStatusError; end  # 407
+    class RequestTimeout < HTTPStatusError; end               # 408
+    class Conflict < HTTPStatusError; end                     # 409
+    class Gone < HTTPStatusError; end                         # 410
+    class LengthRequired < HTTPStatusError; end               # 411
+    class PreconditionFailed < HTTPStatusError; end           # 412
+    class RequestEntityTooLarge < HTTPStatusError; end        # 413
+    class RequestURITooLong < HTTPStatusError; end            # 414
+    class UnsupportedMediaType < HTTPStatusError; end         # 415
+    class RequestedRangeNotSatisfiable < HTTPStatusError; end # 416
+    class ExpectationFailed < HTTPStatusError; end            # 417
+    class UnprocessableEntity < HTTPStatusError; end          # 422
+    class InternalServerError < HTTPStatusError; end          # 500
+    class NotImplemented < HTTPStatusError; end               # 501
+    class BadGateway < HTTPStatusError; end                   # 502
+    class ServiceUnavailable < HTTPStatusError; end           # 503
+    class GatewayTimeout < HTTPStatusError; end               # 504
+
+    # Messages for nicer exceptions, from rfc2616
+    META = {
+      Continue                     => [100, 'Continue'],
+      SwitchingProtocols           => [101, 'Switching protocols'],
+      OK                           => [200, 'OK'],
+      Created                      => [201, 'Created'],
+      Accepted                     => [202, 'Accepted'],
+      NonAuthoritativeInformation  => [203, 'Non-authoritative information'],
+      NoContent                    => [204, 'No content'],
+      ResetContent                 => [205, 'Reset content'],
+      PartialContent               => [206, 'Partial content'],
+      MultipleChoices              => [300, 'Multiple choices'],
+      MovedPermanently             => [301, 'Moved permanently'],
+      Found                        => [302, 'Found'],
+      SeeOther                     => [303, 'See other'],
+      NotModified                  => [304, 'Not modified'],
+      UseProxy                     => [305, 'Use proxy'],
+      TemporaryRedirect            => [307, 'Temporary redirect'],
+      BadRequest                   => [400, 'Bad request'],
+      Unauthorized                 => [401, 'Unauthorized'],
+      PaymentRequired              => [402, 'Payment required'],
+      Forbidden                    => [403, 'Forbidden'],
+      NotFound                     => [404, 'Not found'],
+      MethodNotAllowed             => [405, 'Method not allowed'],
+      NotAcceptable                => [406, 'Not acceptable'],
+      ProxyAuthenticationRequired  => [407, 'Proxy authentication required'],
+      RequestTimeout               => [408, 'Request timeout'],
+      Conflict                     => [409, 'Conflict'],
+      Gone                         => [410, 'Gone'],
+      LengthRequired               => [411, 'Length required'],
+      PreconditionFailed           => [412, 'Precondition failed'],
+      RequestEntityTooLarge        => [413, 'Request entity too large'],
+      RequestURITooLong            => [414, 'Request-URI too long'],
+      UnsupportedMediaType         => [415, 'Unsupported media type'],
+      RequestedRangeNotSatisfiable => [416, 'Requested range not satisfiable'],
+      ExpectationFailed            => [417, 'Expectation failed'],
+      UnprocessableEntity          => [422, 'Unprocessable entity'],
+      InternalServerError          => [500, 'Internal server error'],
+      NotImplemented               => [501, 'Not implemented'],
+      BadGateway                   => [502, 'Bad gateway'],
+      ServiceUnavailable           => [503, 'Service unavailable'],
+      GatewayTimeout               => [504, 'Gateway timeout'],
+    }.freeze
+  end
+end

data/lib/pliny/extensions/instruments.rb

@@ -0,0 +1,38 @@
+module Pliny::Extensions
+  module Instruments
+    def self.registered(app)
+      app.before do
+        @request_start = Time.now
+        Pliny.log(
+          instrumentation: true,
+          at:              "start",
+          method:          request.request_method,
+          path:            request.path_info,
+        )
+      end
+
+      app.after do
+        Pliny.log(
+          instrumentation: true,
+          at:              "finish",
+          method:          request.request_method,
+          path:            request.path_info,
+          route_signature: route_signature,
+          status:          status,
+          elapsed:         (Time.now - @request_start).to_f
+        )
+      end
+
+      app.helpers do
+        def route_signature
+          env["ROUTE_SIGNATURE"]
+        end
+      end
+    end
+
+    def route(verb, path, *)
+      condition { env["ROUTE_SIGNATURE"] = path.to_s }
+      super
+    end
+  end
+end

data/lib/pliny/log.rb

@@ -0,0 +1,84 @@
+module Pliny
+  module Log
+    def log(data, &block)
+      data = log_context.merge(data)
+      log_to_stream(stdout || $stdout, data, &block)
+    end
+
+    def stdout=(stream)
+      @stdout = stream
+    end
+
+    def stdout
+      @stdout
+    end
+
+    private
+
+    def log_context
+      RequestStore.store[:log_context] || {}
+    end
+
+    def log_to_stream(stream, data, &block)
+      unless block
+        str = unparse(data)
+        if RUBY_PLATFORM == "java"
+          stream.puts str
+        else
+          mtx.synchronize { stream.puts str }
+        end
+      else
+        data = data.dup
+        start = Time.now
+        log_to_stream(stream, data.merge(at: "start"))
+        begin
+          res = yield
+          log_to_stream(stream, data.merge(
+            at: "finish", elapsed: (Time.now - start).to_f))
+          res
+        rescue
+          log_to_stream(stream, data.merge(
+            at: "exception", elapsed: (Time.now - start).to_f))
+          raise
+        end
+      end
+    end
+
+    def mtx
+      @mtx ||= Mutex.new
+    end
+
+    def quote_string(k, v)
+      # try to find a quote style that fits
+      if !v.include?('"')
+        %{#{k}="#{v}"}
+      elsif !v.include?("'")
+        %{#{k}='#{v}'}
+      else
+        %{#{k}="#{v.gsub(/"/, '\\"')}"}
+      end
+    end
+
+    def unparse(attrs)
+      attrs.map { |k, v| unparse_pair(k, v) }.compact.join(" ")
+    end
+
+    def unparse_pair(k, v)
+      v = v.call if v.is_a?(Proc)
+      # only quote strings if they include whitespace
+      if v == nil
+        nil
+      elsif v == true
+        k
+      elsif v.is_a?(Float)
+        "#{k}=#{format("%.3f", v)}"
+      elsif v.is_a?(String) && v =~ /\s/
+        quote_string(k, v)
+      elsif v.is_a?(Time)
+        "#{k}=#{v.iso8601}"
+      else
+        "#{k}=#{v}"
+      end
+    end
+  end
+end