startback 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a7f631f93683bc9a9fe0705fc5e3f7df55fa782
+  data.tar.gz: 6335d0ff1b733355c96116ce19f9094adea45694
+SHA512:
+  metadata.gz: b1bec4146b344fac7d8ef51b130e149fb823e6d10ab5a3050be9165c877585f8dcf38092fa2548c884a8974d97868f0f161d7871908da0117af06fc851e5aaa1
+  data.tar.gz: f7482b4b5446cc1557841302cade907c4b597ff704b88ff8017ebf652a92809cf44d5ca24d9c59d0af63dd68b579eed30afd71b5deebc516b0ae94214f6e2cb2

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,13 @@
+# Startback - Got Your Ruby Back
+
+Yet another ruby framework, I'm afraid. Here, we srongly seperate between:
+
+1. the web layer, in charge of a quality HTTP handling
+2. the operations layer, in charge of the high-level software operations
+3. the database layer, abstracted using the Relations As First Class Citizen pattern
+
+Currently,
+
+1. is handled using extra support on top of Sinatra
+2. is handled using Startback specific classes
+3. is handled using Bmg

data/Rakefile

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+
+def shell(*cmds)
+  cmd = cmds.join("\n")
+  puts cmd
+  system cmd
+end
+
+#
+# Install all tasks found in tasks folder
+#
+# See .rake files there for complete documentation.
+#
+Dir["tasks/*.rake"].each do |taskfile|
+  load taskfile
+end
+
+task :default => :test

data/lib/startback.rb

@@ -0,0 +1,37 @@
+require 'sinatra'
+require 'rack/robustness'
+require 'finitio'
+require 'logger'
+# Provides a reusable backend framework for backend components written
+# in ruby.
+#
+# The framework installs conventions regarding:
+#
+# - The exposition of web service APIs (Framework::Api, on top of Sinatra)
+# - Operations (Framework::Operation)
+# - Error handling (Framework::Errors) and their handling in web APIs
+#   (based on Rack::Robustness)
+# - General code support (Framework::Support modules & classes).
+#
+# Please refer to the documentation of those main abstractions for details.
+#
+module Startback
+
+  # Simply checks that a path exists of raise an error
+  def self._!(path)
+    Path(path).tap do |p|
+      raise "Missing #{p.basename}." unless p.exists?
+    end
+  end
+
+  require_relative 'startback/ext'
+  require_relative 'startback/errors'
+  require_relative 'startback/support'
+  require_relative 'startback/context'
+  require_relative 'startback/operation'
+  require_relative 'startback/web'
+
+  # Logger instance to use for the application
+  LOGGER = ::Startback::Support::Logger.new
+
+end # module Startback

data/lib/startback/context.rb

@@ -0,0 +1,16 @@
+module Startback
+  #
+  # Defines an execution context for Startback applications.
+  #
+  # This class is aimed at being subclassed for application required
+  # extension.
+  #
+  # In web application, an instance of a context can be set on the Rack
+  # environment, using Context::Middleware.
+  #
+  class Context
+    attr_accessor :original_rack_env
+
+  end # class Context
+end # module Startback
+require_relative 'context/middleware'

data/lib/startback/context/middleware.rb

@@ -0,0 +1,53 @@
+module Startback
+  class Context
+    #
+    # Rack middleware that installs a particular context instance
+    # on the Rack environment.
+    #
+    # Examples:
+    #
+    #     # Use the default context class
+    #     Rack::Builder.new do
+    #       use Startback::Context::Middleware
+    #
+    #       run ->(env){
+    #         ctx = env[Startback::Context::Middleware::RACK_ENV_KEY]
+    #         ctx.is_a?(Startback::Context) # => true
+    #       }
+    #     end
+    #
+    #     # Use a user defined context class
+    #     Rack::Builder.new do
+    #       use Startback::Context::Middleware, context_class: MyContextClass
+    #
+    #       run ->(env){
+    #         ctx = env[Startback::Context::Middleware::RACK_ENV_KEY]
+    #         ctx.is_a?(MyContextClass)     # => true (your subclass)
+    #         ctx.is_a?(Startback::Context) # => true (required!)
+    #       }
+    #     end
+    #
+    class Middleware
+
+      RACK_ENV_KEY = 'SAMBACK_CONTEXT'
+
+      DEFAULT_OPTIONS = {
+        context_class: Context
+      }
+
+      def initialize(app, options = {})
+        @app = app
+        @options = DEFAULT_OPTIONS.merge(options || {})
+      end
+      attr_reader :options
+
+      def call(env)
+        env[RACK_ENV_KEY] ||= options[:context_class].new.tap{|c|
+          c.original_rack_env = env.dup
+        }
+        @app.call(env)
+      end
+
+    end # class Middleware
+  end # class Context
+end # module Startback

data/lib/startback/errors.rb

@@ -0,0 +1,91 @@
+module Startback
+  module Errors
+
+    class Error < StandardError
+      class << self
+
+        def status(code = nil)
+          @code = code || @code
+        end
+
+        def keep_error(keep = nil)
+          @keep_error = keep unless keep.nil?
+          @keep_error
+        end
+      end
+
+      def message
+        msg = super
+        return msg unless msg == self.class.name
+        parts = self.class.name.split('::').last.gsub(/[A-Z]/){|x|
+          " #{x.downcase}" 
+        }.strip.split(" ")
+        parts = parts[0...-1] unless self.class.keep_error
+        parts.join(" ").capitalize
+      end
+    end
+
+    class BadRequestError < Error
+      status 400
+    end
+
+      class UnauthorizedError < BadRequestError
+        status 401
+      end
+
+      class ForbiddenError < BadRequestError
+        status 403
+      end
+
+      class NotFoundError < BadRequestError
+        status 404
+      end
+
+      class MethodNotAllowedError < BadRequestError
+        status 405
+      end
+
+      class NotAcceptableError < BadRequestError
+        status 406
+      end
+
+      class ConflictError < BadRequestError
+        status 409
+      end
+
+      class GoneError < BadRequestError
+        status 410
+      end
+
+      class PreconditionFailedError < BadRequestError
+        status 412
+      end
+
+      class UnsupportedMediaTypeError < BadRequestError
+        status 415
+      end
+
+      class ExpectationFailedError < BadRequestError
+        status 417
+      end
+
+      class LockedError < BadRequestError
+        status 423
+      end
+
+      class PreconditionRequiredError < BadRequestError
+        status 428
+      end
+
+    class InternalServerError < Error
+      status 500
+      keep_error(true)
+    end
+
+      class NotImplementedError < InternalServerError
+        status 501
+      end
+
+  end # module Errors
+  include Errors
+end # module Klaro

data/lib/startback/ext.rb

@@ -0,0 +1,2 @@
+require_relative 'ext/date_time'
+require_relative 'ext/time'

data/lib/startback/ext/date_time.rb

@@ -0,0 +1,9 @@
+class DateTime
+
+  # Makes sure that DateTime are exported with ISO8601
+  # conventions when using to_json and to_csv
+  def to_s
+    iso8601
+  end
+
+end

data/lib/startback/ext/time.rb

@@ -0,0 +1,9 @@
+class Time
+
+  # Makes sure that Time are exported with ISO8601
+  # conventions when using to_json and to_csv
+  def to_s
+    iso8601
+  end
+
+end

data/lib/startback/operation.rb

@@ -0,0 +1,31 @@
+module Startback
+  class Operation
+    include Errors
+
+    attr_accessor :world
+
+    protected :world=
+
+    def bind(world)
+      return self unless world
+      dup.tap{|op|
+        op.world = world
+      }
+    end
+
+    def method_missing(name, *args, &bl)
+      return super unless args.empty? and bl.nil?
+      return super unless world
+      world.fetch(name){ super }
+    end
+
+  protected
+
+    def run(operation)
+      operation.bind(self.world).call
+    end
+
+  end # class Operation
+end # module Startback
+require_relative 'operation/error_operation'
+require_relative 'operation/multi_operation'

data/lib/startback/operation/error_operation.rb

@@ -0,0 +1,19 @@
+module Startback
+  class Operation
+    class ErrorOperation < Operation
+
+      def initialize(details)
+        @details = details
+      end
+      attr_reader :details
+
+      def call
+      end
+
+      def bind(world)
+        self
+      end
+
+    end # class ErrorOperation
+  end # class Operation
+end # module Startback

data/lib/startback/operation/multi_operation.rb

@@ -0,0 +1,28 @@
+module Startback
+  class Operation
+    class MultiOperation
+
+      def initialize(ops = [])
+        @ops = ops
+      end
+      attr_reader :ops
+
+      def size
+        ops.size
+      end
+
+      def +(other)
+        MultiOperation.new(@ops + Array(other))
+      end
+
+      def bind(world)
+        MultiOperation.new(ops.map{|op| op.bind(world) })
+      end
+
+      def call
+        ops.map{|op| op.call }
+      end
+
+    end # class MultiOperation
+  end # class Operation
+end # module Startback

data/lib/startback/support.rb

@@ -0,0 +1,10 @@
+module Startback
+  module Support
+
+    def logger
+      Startback::LOGGER
+    end
+
+  end # module Support
+end # module Startback
+require_relative 'support/logger'

data/lib/startback/support/logger.rb

@@ -0,0 +1,34 @@
+module Startback
+  module Support
+    #
+    # A Logger extension that sends info and debug messages to STDOUT
+    # and other messages to STDERR. This is not configurable.
+    #
+    class Logger < ::Logger
+
+      def initialize
+        super(STDOUT)
+        @err_logger = ::Logger.new(STDERR)
+      end
+
+      def self.level=(level)
+        super.tap{
+          @err_logger.level = level
+        }
+      end
+
+      def warn(*args, &bl)
+        @err_logger.warn(*args, &bl)
+      end
+
+      def error(*args, &bl)
+        @err_logger.error(*args, &bl)
+      end
+
+      def fatal(*args, &bl)
+        @err_logger.fatal(*args, &bl)
+      end
+
+    end # class Logger
+  end # module Support
+end # module Startback

data/lib/startback/version.rb

@@ -0,0 +1,8 @@
+module Startback
+  module Version
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+  end
+  VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
+end

data/lib/startback/web.rb

@@ -0,0 +1,4 @@
+require_relative 'web/shield'
+require_relative 'web/catch_all'
+require_relative 'web/health_check'
+require_relative 'web/api'

data/lib/startback/web/api.rb

@@ -0,0 +1,74 @@
+module Startback
+  module Web
+    class Api < Sinatra::Base
+      include Support
+      include Errors
+
+      set :raise_errors, true
+      set :show_exceptions, false
+
+    protected
+
+      ###
+      ### Facade over context
+      ###
+
+      def context
+        env[Startback::Context::Middleware::RACK_ENV_KEY]
+      end
+
+      ###
+      ### Facade over third party tools
+      ###
+
+      def run(operation)
+        operation
+          .bind({ context: context })
+          .call
+      end
+
+      ###
+      ### About the body / input
+      ###
+
+      def loaded_body
+        @loaded_body ||= case ctype = request.content_type
+        when /json/
+          json_body
+        when /multipart\/form-data/
+          file_body params[:file], Path(file[:filename]).extname
+        else
+          unsupported_content_type(ctype)
+        end
+      end
+
+      def json_body(body = request.body.read)
+        JSON.load(body)
+      end
+
+      def file_body(file, ctype)
+        raise UnsupportedMediaTypeError, "Unable to use `#{ctype}` as input data"
+      end
+
+      ###
+      ### Various reusable responses
+      ###
+
+      def serve_nothing
+        [ 204, {}, [] ]
+      end
+
+      def serve(entity_description, entity, ct = :json)
+        if entity.nil?
+          status 404
+          content_type :json
+          { description: "#{entity_description} not found" }.to_json
+        else
+          content_type ct
+          entity.to_json
+        end
+      end
+
+    end # class Api
+  end # module Web
+end # module Startback

data/lib/startback/web/catch_all.rb

@@ -0,0 +1,36 @@
+module Startback
+  module Web
+    #
+    # This Rack middleware catches all exceptions that are raised by sublayers
+    # in the Rack chain. It converts them to correct 500 Errors, with a generic
+    # exception message encoded in json.
+    #
+    # This class aims at being used as top level of a Rack chain. It is not
+    # aimed at being subclassed.
+    #
+    # Examples:
+    #
+    #     Rack::Builder.new do
+    #       use Startback::Web::CatchAll
+    #     end
+    #
+    class CatchAll < Rack::Robustness
+      include Errors
+
+      FATAL_ERROR = {
+        code: "Gybr::Errors::ServerError",
+        description: "An error occured, sorry"
+      }.to_json
+
+      self.catch_all
+      self.status 500
+      self.content_type 'application/json'
+      self.body FATAL_ERROR.to_json
+
+      self.ensure(true) do |ex|
+        Startback::LOGGER.fatal(ex)
+      end
+
+    end # class CatchAll
+  end # class Web
+end # module Startback

data/lib/startback/web/health_check.rb

@@ -0,0 +1,49 @@
+module Startback
+  module Web
+    #
+    # Can be used to easily implement a HealthCheck web service inside a Startback
+    # application.
+    #
+    # Examples:
+    #
+    #     # Returns a 204 with no body
+    #     run Startback::Web::HealthCheck.new
+    #
+    #     # Returns a 204 with no body
+    #     run Startback::Web::HealthCheck.new { nil }
+    #
+    #     # Returns a 200 with Ok in plain text
+    #     run Startback::Web::HealthCheck.new { "Ok" }
+    #
+    #     # Re-raises the exception
+    #     run Startback::Web::HealthCheck.new { raise "Something bad" }
+    #
+    # Please note that this rack app is not 100% Rack compliant, since it raises
+    # any error that the block itself raises. This class aims at being backed up
+    # by a Shield and/or CatchAll middleware.
+    #
+    # This class is not aimed at being subclassed.
+    #
+    class HealthCheck
+
+      def initialize(&bl)
+        @checker = bl
+      end
+
+      def call(env)
+        if debug_msg = check!(env)
+          [ 200, { "Content-Type" => "text/plain" }, debug_msg ]
+        else
+          [ 204, {}, "" ]
+        end
+      end
+
+    protected
+
+      def check!(env)
+        @checker.call if @checker
+      end
+
+    end # class HealthCheck
+  end # module Web
+end # module Startback

data/lib/startback/web/shield.rb

@@ -0,0 +1,40 @@
+module Startback
+  module Web
+    #
+    # This Rack middleware catches all known exceptions raised by sublayers
+    # in the Rack chain. Those exceptions are converted to proper HTTP error
+    # codes and friendly error messages encoded in json.
+    #
+    # Please check the Errors module about status codes used for each Startback
+    # error.
+    #
+    # This class aims at being used as top level of a Rack chain.
+    #
+    # Examples:
+    #
+    #     Rack::Builder.new do
+    #       use Startback::Web::Shield
+    #     end
+    #
+    class Shield < Rack::Robustness
+      include Errors
+
+      self.no_catch_all
+      self.content_type 'application/json'
+
+      # Decoding errors from json and csv are considered user's fault
+      self.on(Finitio::TypeError)  { 400 }
+
+      # Various other codes for the framework specific error classes
+      self.on(Startback::Errors::Error) {|ex| ex.class.status }
+
+      # A bit of logic to choose the best error message for the user
+      # according to the error class
+      self.body{|ex|
+        ex = ex.root_cause if ex.is_a?(Finitio::TypeError)
+        { code: ex.class.name, description: ex.message }.to_json
+      }
+
+    end # class Shield
+  end # module Web
+end # module Startback

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'startback'
+require 'rack/test'
+
+module SpecHelpers
+end
+
+RSpec.configure do |c|
+  c.include SpecHelpers
+end

data/spec/unit/context/test_middleware.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Startback
+  class Context
+
+    class MyContextSubClass < Context
+    end
+
+    describe Middleware do
+      include Rack::Test::Methods
+
+      def app
+        opts = middleware_options
+        Rack::Builder.new do
+          use Middleware, opts
+          run ->(env){
+            ctx = env[Startback::Context::Middleware::RACK_ENV_KEY] 
+            [200, {}, ctx.class.to_s]
+          }
+        end
+      end
+
+      context 'when used without option' do
+        let(:middleware_options){ nil }
+
+        it 'sets the default context class' do
+          get '/'
+          expect(last_response.status).to eql(200)
+          expect(last_response.body).to eql("Startback::Context")
+        end
+      end
+
+      context 'when specifying the context class' do
+        let(:middleware_options){{
+          context_class: MyContextSubClass
+        }}
+
+        it 'sets the default context class' do
+          get '/'
+          expect(last_response.status).to eql(200)
+          expect(last_response.body).to eql("Startback::Context::MyContextSubClass")
+        end
+      end
+
+    end
+  end # module Web
+end # module Startback

data/spec/unit/test_operation.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Startback
+  describe Operation do
+
+    class FooOp < Operation
+
+      def initialize(foo = :bar)
+        @foo = foo
+      end
+      attr_accessor :foo
+
+      def call
+        @foo
+      end
+
+    end
+
+    it 'can be bound, which returns a new operation' do
+      foo1 = FooOp.new
+      foo1.foo = :bar1
+
+      foo2 = foo1.bind({ db: :bar })
+      expect(foo1 == foo2).to eql(false)
+      expect(foo2.foo).to eql(:bar1)
+
+      expect(->(){ foo1.db }).to raise_error(NoMethodError)
+      expect(foo2.db).to eql(:bar)
+    end
+
+  end
+
+  describe Operation::MultiOperation do
+
+    it 'lets chain with +' do
+      mop = Operation::MultiOperation.new
+      mop2 = (mop + FooOp.new)
+
+      expect(mop == mop2).to eql(false)
+      expect(mop.size).to eql(0)
+      expect(mop2.size).to eql(1)
+    end
+
+    it 'calls and collects the result on call' do
+      mop = Operation::MultiOperation.new + FooOp.new(:hello) + FooOp.new(:world)
+      expect(mop.call).to eql([:hello, :world])
+    end
+
+    it 'binds every sub operation recursively' do
+      mop = Operation::MultiOperation.new + FooOp.new(:hello) + FooOp.new(:world)
+      mop2 = mop.bind({requester: :bar})
+
+      expect(mop == mop2).to eql(false)
+      expect(mop2.ops.all?{|op| op.requester == :bar })        
+    end
+
+  end
+end # module Startback

data/spec/unit/test_support.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+module Startback
+  describe Support do
+    include Support
+
+  end
+end

data/spec/unit/web/test_healthcheck.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Startback
+  module Web
+    describe HealthCheck do
+      include Rack::Test::Methods
+
+      context 'when used without a block and no failure' do
+        def app
+          HealthCheck.new
+        end
+
+        it 'returns a 204 when ok' do
+          get '/'
+          expect(last_response.status).to eql(204)
+          expect(last_response.body).to be_empty
+        end
+      end
+
+      context 'when used without a block a failure' do
+        def app
+          app = HealthCheck.new
+          def app.check!(env)
+            raise "Hello error"
+          end
+          app
+        end
+
+        it 'raises when ko' do
+          expect(->(){ get '/' }).to raise_error("Hello error")
+        end
+      end
+
+      context 'when used with a block returning a debug message' do
+        def app
+          HealthCheck.new{ "Hello world" }
+        end
+
+        it 'returns a 200 with plain text message' do
+          get '/'
+          expect(last_response.status).to eql(200)
+          expect(last_response.body).to eql("Hello world")
+        end
+      end
+
+      context 'when used with a block raising an exception' do
+        def app
+          HealthCheck.new{ raise("Hello error") }
+        end
+
+        it 're-raises it' do
+          expect(->(){ get '/' }).to raise_error("Hello error")
+        end
+      end
+
+    end
+  end # module Web
+end # module Startback

data/tasks/gem.rake

@@ -0,0 +1,39 @@
+require 'rubygems/package_task'
+
+# Dynamically load the gem spec
+gemspec_file = File.expand_path('../../startback.gemspec', __FILE__)
+gemspec      = Kernel.eval(File.read(gemspec_file))
+
+Gem::PackageTask.new(gemspec) do |t|
+
+  # Name of the package
+  t.name = gemspec.name
+
+  # Version of the package
+  t.version = gemspec.version
+
+  # Directory used to store the package files
+  t.package_dir = "pkg"
+
+  # True if a gzipped tar file (tgz) should be produced
+  t.need_tar = false
+
+  # True if a gzipped tar file (tar.gz) should be produced
+  t.need_tar_gz = false
+
+  # True if a bzip2'd tar file (tar.bz2) should be produced
+  t.need_tar_bz2 = false
+
+  # True if a zip file should be produced (default is false)
+  t.need_zip = false
+
+  # List of files to be included in the package.
+  t.package_files = gemspec.files
+
+  # Tar command for gzipped or bzip2ed archives.
+  t.tar_command = "tar"
+
+  # Zip command for zipped archives.
+  t.zip_command = "zip"
+
+end

data/tasks/test.rake

@@ -0,0 +1,17 @@
+namespace :test do
+
+  desc "Run RSpec unit tests"
+  task :unit do
+    system("rspec -Ilib -Ispec --pattern 'spec/unit/**/test_*.rb' --color --backtrace --fail-fast")
+  end
+
+  desc "Run the tests in the examples folder"
+  task :example do
+    Bundler.with_original_env do
+      system("cd example && bundle exec rake")
+    end
+  end
+
+  task :all => [:unit, :example]
+end
+task :test => :'test:all'

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: startback
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Bernard Lambeau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rack-robustness
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: finitio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: path
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Yet another ruby backend framework, I'm afraid
+email: blambeau@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- lib/startback.rb
+- lib/startback/context.rb
+- lib/startback/context/middleware.rb
+- lib/startback/errors.rb
+- lib/startback/ext.rb
+- lib/startback/ext/date_time.rb
+- lib/startback/ext/time.rb
+- lib/startback/operation.rb
+- lib/startback/operation/error_operation.rb
+- lib/startback/operation/multi_operation.rb
+- lib/startback/support.rb
+- lib/startback/support/logger.rb
+- lib/startback/version.rb
+- lib/startback/web.rb
+- lib/startback/web/api.rb
+- lib/startback/web/catch_all.rb
+- lib/startback/web/health_check.rb
+- lib/startback/web/shield.rb
+- spec/spec_helper.rb
+- spec/unit/context/test_middleware.rb
+- spec/unit/test_operation.rb
+- spec/unit/test_support.rb
+- spec/unit/web/test_healthcheck.rb
+- tasks/gem.rake
+- tasks/test.rake
+homepage: http://www.enspirit.be
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Got Your Ruby Back
+test_files: []