startback-websocket 0.14.0 → 0.14.1

data/lib/startback/support/transaction_policy.rb

@@ -1,33 +0,0 @@
-module Startback
-  module Support
-    module TransactionPolicy
-
-      # Returns the operation's transaction policy
-      def transaction_policy
-        @transaction_policy || :before_call
-      end
-
-      # Sets the transaction policy to use. Valid values are:
-      # - before_call : the transaction is started by the operation
-      #   runner, right before calling the #call method on operation
-      #   instance
-      # - within_call: the transaction is started by the operation
-      #   itself, as part of its internal logic.
-      def transaction_policy=(policy)
-        unless [:before_call, :within_call].include?(policy)
-          raise ArgumentError, "Unknown policy `#{policy}`"
-        end
-        @transaction_policy = policy
-      end
-
-      def after_commit(&bl)
-        after_call do
-          db.after_commit do
-            instance_exec(&bl)
-          end
-        end
-      end
-
-    end # module TransactionPolicy
-  end # module Support
-end # module Startback

data/lib/startback/support/world.rb

@@ -1,54 +0,0 @@
-module Startback
-  module Support
-    class World
-      include DataObject
-
-      attr_accessor :_factory
-      protected :_factory=
-
-      def factory(who, &block)
-        dup.tap do |x|
-          x._factory = (self._factory || {}).merge(who => block)
-        end
-      end
-
-      attr_accessor :_scope
-      protected :_scope=
-
-      def with_scope(scope)
-        dup.tap do |x|
-          x._scope = scope
-        end
-      end
-
-      def with(hash)
-        dup.tap do |x|
-          x._data = to_data.merge(hash)
-        end
-      end
-
-    private
-
-      def _data_allow_camelize
-        false
-      end
-
-      def _data_allow_query
-        false
-      end
-
-      def _data_key_not_found(key)
-        raise Startback::Error, "Scope must be defined" unless s = _scope
-
-        block = (_factory || {})[key]
-        if block
-          factored = s.instance_exec(&block)
-          @_data = @_data.dup.merge(key => factored).freeze
-          [key, false]
-        else
-          nil
-        end
-      end
-    end # class World
-  end # module Support
-end # module Startback

data/lib/startback/support.rb

@@ -1,26 +0,0 @@
-module Startback
-  module Support
-
-    def logger
-      Startback::LOGGER
-    end
-
-    def deep_merge(h1, h2)
-      h1.merge(h2){|k,v1,v2|
-        v1.is_a?(Hash) && v2.is_a?(Hash) ? deep_merge(v1, v2) : v2
-      }
-    end
-    module_function :deep_merge
-
-  end # module Support
-end # module Startback
-require_relative 'support/env'
-require_relative 'support/log_formatter'
-require_relative 'support/logger'
-require_relative 'support/robustness'
-require_relative 'support/hooks'
-require_relative 'support/operation_runner'
-require_relative 'support/transaction_policy'
-require_relative 'support/transaction_manager'
-require_relative 'support/data_object'
-require_relative 'support/world'

data/lib/startback/version.rb

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

data/lib/startback/web/api.rb

@@ -1,99 +0,0 @@
-module Startback
-  module Web
-    class Api < Sinatra::Base
-      include Support
-      include Errors
-
-      set :raise_errors, true
-      set :show_exceptions, false
-      set :dump_errors, false
-
-    protected
-
-      ###
-      ### Facade over context
-      ###
-
-      def context
-        env[Startback::Context::Middleware::RACK_ENV_KEY]
-      end
-
-      def with_context(ctx = nil)
-        old_context = self.context
-        new_context = ctx || self.context.dup
-        env[Startback::Context::Middleware::RACK_ENV_KEY] = new_context
-        result = ctx ? yield : yield(new_context)
-        env[Startback::Context::Middleware::RACK_ENV_KEY] = old_context
-        result
-      end
-
-      ###
-      ### Facade over third party tools
-      ###
-      include Support::OperationRunner
-
-      def operation_world(op)
-        { context: context }
-      end
-
-      ###
-      ### About the body / input
-      ###
-
-      def loaded_body
-        @loaded_body ||= case ctype = request.content_type
-        when /json/
-          json_body
-        when /multipart\/form-data/
-          file = params[:file]
-          file_body file, Path(file[:filename]).extname
-        else
-          unsupported_media_type_error!(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 = nil)
-        if entity.nil?
-          status 404
-          content_type :json
-          { description: "#{entity_description} not found" }.to_json
-        elsif entity.respond_to?(:to_dto)
-          ct, body = entity.to_dto(context).to(env['HTTP_ACCEPT'], ct)
-          content_type ct
-          _serve(body)
-        elsif entity.is_a?(Path)
-          _serve(entity)
-        else
-          content_type ct || "application/json"
-          entity.to_json
-        end
-      end
-
-      def _serve(body)
-        case body
-        when Path
-          send_file(body)
-        else
-          body
-        end
-      end
-
-    end # class Api
-  end # module Web
-end # module Startback

data/lib/startback/web/auto_caching.rb

@@ -1,85 +0,0 @@
-module Startback
-  module Web
-    #
-    # This rack middleware automatically mark response as non being cacheable
-    # in development, and being cacheble in production.
-    #
-    # The headers to set in development and production can be passed at
-    # construction, as well as whether the development environment must be
-    # forced. This class may also be configured through environment variables:
-    #
-    # - RACK_ENV: when "production" use the production headers, otherwise use
-    #     the development ones
-    # - STARTBACK_AUTOCACHING_DEVELOPMENT_CACHE_CONTROL: Cache-Control header
-    #     to use in development mode
-    # - STARTBACK_AUTOCACHING_PRODUCTION_CACHE_CONTROL: Cache-Control header
-    #     to use in production mode
-    #
-    # Example:
-    #
-    #     # Default configuration
-    #     use Autocaching
-    #
-    #     # Force development mode
-    #     use Autocaching, true
-    #
-    #     # Force production mode
-    #     use Autocaching, false
-    #
-    #     # Set production headers manually
-    #     use Autocaching, { :production => "public, no-cache, no-store" }
-    #
-    class AutoCaching
-
-      # Cache-Control header to use in development mode
-      DEVELOPMENT_CACHE_CONTROL = ENV['STARTBACK_AUTOCACHING_DEVELOPMENT_CACHE_CONTROL'] || \
-                                  "no-cache, no-store, max-age=0, must-revalidate"
-
-      # Cache-Control header to use in produdction mode
-      PRODUCTION_CACHE_CONTROL = ENV['STARTBACK_AUTOCACHING_PRODUCTION_CACHE_CONTROL'] ||\
-                                 "public, must-revalidate, max-age=3600, s-max-age=3600"
-
-      def initialize(app, development = nil, cache_headers = {})
-        development, cache_headers = nil, development if development.is_a?(Hash)
-        @app = app
-        @development = development.nil? ? infer_is_development : development
-        @cache_headers = default_headers.merge(normalize_headers(cache_headers))
-      end
-
-      def call(env)
-        status, headers, body = @app.call(env)
-        [status, patch_response_headers(headers), body]
-      end
-
-    protected
-
-      def patch_response_headers(hs)
-        (development? ? @cache_headers[:development] : @cache_headers[:production]).merge(hs)
-      end
-
-      def development?
-        !!@development
-      end
-
-      def infer_is_development
-        ENV['RACK_ENV'] != "production"
-      end
-
-      def default_headers
-        {
-          development: {
-            "Cache-Control" => DEVELOPMENT_CACHE_CONTROL
-          },
-          production: {
-            "Cache-Control" => PRODUCTION_CACHE_CONTROL
-          }
-        }
-      end
-
-      def normalize_headers(h)
-        Hash[h.map{|k,v| [k, v.is_a?(Hash) ? v : {"Cache-Control" => v} ] }]
-      end
-
-    end # class AutoCaching
-  end # module Web
-end # module Startback

data/lib/startback/web/catch_all.rb

@@ -1,52 +0,0 @@
-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.
-    #
-    # Fatal error cached are also sent as a `fatal` messange, on the error
-    # handler provided on Context#error_handler.fatal, if any.
-    #
-    # Examples:
-    #
-    #     Rack::Builder.new do
-    #       use Startback::Web::CatchAll
-    #     end
-    #
-    class CatchAll < Rack::Robustness
-      include Errors
-      include Support::Robustness
-
-      FATAL_ERROR = {
-        code: "Startback::Errors::InternalServerError",
-        description: "An error occured, sorry"
-      }.to_json
-
-      self.catch_all
-      self.on(Exception)
-      self.status 500
-      self.content_type 'application/json'
-      self.body FATAL_ERROR
-
-      self.ensure(true) do |ex|
-        context = env[Context::Middleware::RACK_ENV_KEY]
-        begin
-          if context && context.respond_to?(:error_handler, true) && context.error_handler
-            context.error_handler.fatal(ex)
-          else
-            log(:fatal, self, "ensure", context, error: ex)
-          end
-        rescue => ex2
-          STDERR.puts(ex2.message)
-          STDERR.puts(ex2.backtrace[0..10].join("\n"))
-          raise
-        end
-      end
-
-    end # class CatchAll
-  end # class Web
-end # module Startback

data/lib/startback/web/cors_headers.rb

@@ -1,80 +0,0 @@
-module Startback
-  module Web
-    #
-    # Sets Cross-Origin Response Headers on requests specifying an Origin
-    # HTTP header, according configuration passed at construction and/or
-    # environment variables.
-    #
-    # Example:
-    #
-    #     # Default configuration, using environment variables when set
-    #     use CorsHeaders
-    #
-    #     # Force a bouncing of the origin, using the Origin request header
-    #     # as Access-Control-Allow-Origin response header
-    #     use CorsHeaders, bounce: true
-    #
-    #     # Overrides a specific header
-    #     use CorsHeaders, headers: { 'Access-Control-Allow-Methods' => 'POST' }
-    #
-    class CorsHeaders
-
-      ALLOW_ORIGIN = ENV['STARTBACK_CORS_ALLOW_ORIGIN'] || '*'
-
-      ALLOW_METHODS = ENV['STARTBACK_CORS_ALLOW_METHODS'] || 'OPTIONS, HEAD, GET, POST, PUT, PATCH, DELETE'
-
-      ALLOW_CREDENTIALS = ENV['STARTBACK_CORS_ALLOW_CREDENTIALS'] || 'true'
-
-      MAX_AGE = ENV['STARTBACK_CORS_MAX_AGE'] || '1728000'
-
-      ALLOW_HEADERS = ENV['STARTBACK_CORS_ALLOW_HEADERS'] || 'Authorization, Content-Type, Origin, Accept, If-Modified-Since, If-Match, If-None-Match'
-
-      EXPOSE_HEADERS = ENV['STARTBACK_CORS_EXPOSE_HEADERS'] || 'Location, ETag, Last-Modified, Content-Type'
-
-      DEFAULT_CORS_HEADERS = {
-        'Access-Control-Allow-Origin' => ALLOW_ORIGIN,
-        'Access-Control-Allow-Methods' => ALLOW_METHODS,
-        'Access-Control-Allow-Credentials' => ALLOW_CREDENTIALS,
-        'Access-Control-Max-Age' => MAX_AGE,
-        'Access-Control-Allow-Headers' => ALLOW_HEADERS,
-        'Access-Control-Expose-Headers' => EXPOSE_HEADERS
-      }
-
-      DEFAULT_OPTIONS = {
-        :headers => DEFAULT_CORS_HEADERS
-      }
-
-      def initialize(app, options = {})
-        @app = app
-        @options = Startback::Support.deep_merge(DEFAULT_OPTIONS, options)
-      end
-
-      def call(env)
-        status, headers, body = @app.call(env)
-        if origin = env['HTTP_ORIGIN']
-          headers = cors_headers(origin).merge(headers)
-        end
-        if env['REQUEST_METHOD'] == 'OPTIONS'
-          headers['Content-Length'] = '0'
-          status, headers, body = [204, headers, []]
-        end
-        [status, headers, body]
-      end
-
-    private
-
-      def cors_headers(origin)
-        headers = @options[:headers].dup
-        if bounce?
-          headers['Access-Control-Allow-Origin'] = origin
-        end
-        headers
-      end
-
-      def bounce?
-        @options[:bounce]
-      end
-
-    end # class AllowCors
-  end # class CorsHeaders
-end # module Samback

data/lib/startback/web/health_check.rb

@@ -1,49 +0,0 @@
-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" }, Array(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/magic_assets/ng_html_transformer.rb

@@ -1,80 +0,0 @@
-module Startback
-  module Web
-    class MagicAssets
-      #
-      # Plugin for MagicAssets that compiles .html angular templates in the
-      # assets structure to javascript files filling angular's template cache.
-      #
-      # Heavily inspired, yet over-simplified version, of angular-rails-templates
-      # See https://github.com/pitr/angular-rails-templates, licensed under MIT
-      #
-      # Example:
-      #
-      #   use Startback::Web::MagicAssets, {
-      #     plugins: [Startback::Web::MagicAssets::NgHtmlTransfomer.new]
-      #   }
-      #
-      class NgHtmlTransformer
-
-        DEFAULT_OPTIONS = {
-          :path       => '/assets',
-          :ng_module  => 'templates',
-          :mime_type  => 'text/ng-html',
-          :extensions => [".html"]
-        }
-
-        def initialize(options = {})
-          @options = DEFAULT_OPTIONS.merge(options)
-        end
-        attr_reader :options
-
-        def install(sprockets)
-          sprockets.register_mime_type options[:mime_type], extensions: options[:extensions]
-          sprockets.register_transformer options[:mime_type], 'application/javascript', self
-        end
-
-TPL = <<-EOF
-angular.module("<%= ng_module %>").run(["$templateCache", function($templateCache) {
-  $templateCache.put("<%= angular_template_name %>", <%= html %>)
-}]);
-EOF
-
-        # inspired by Rails' action_view/helpers/javascript_helper.rb
-        JS_ESCAPE_MAP = {
-          '\\'    => '\\\\',
-          "\r\n"  => '\n',
-          "\n"    => '\n',
-          "\r"    => '\n',
-          '"'     => '\\"',
-          "'"     => "\\'"
-        }
-
-        # We want to deliver the shortist valid javascript escaped string
-        # Count the number of " vs '
-        # If more ', escape "
-        # If more ", escape '
-        # If equal, prefer to escape "
-
-        def escape_javascript(raw)
-          if raw
-            quote = raw.count(%{'}) >= raw.count(%{"}) ? %{"} : %{'}
-            escaped = raw.gsub(/(\\|\r\n|[\n\r#{quote}])/u) {|match| JS_ESCAPE_MAP[match] }
-            "#{quote}#{escaped}#{quote}"
-          else
-            '""'
-          end
-        end
-
-        def call(input)
-          file_path = input[:filename]
-          angular_template_name = "#{options[:path]}/#{input[:name]}.html"
-          source_file = file_path
-          ng_module = options[:ng_module]
-          html = escape_javascript(input[:data].chomp)
-          ERB.new(TPL).result(binding)
-        end
-
-      end # class NgHtmlTransformer
-    end # class MagicAssets
-  end # module Web
-end # module Startback

data/lib/startback/web/magic_assets/rake_tasks.rb

@@ -1,64 +0,0 @@
-module Startback
-  module Web
-    class MagicAssets
-      class RakeTasks
-
-        DEFAULT_OPTIONS = {
-          :namespace => :assets
-        }
-
-        def initialize(rake, options)
-          @rake = rake
-          @options = DEFAULT_OPTIONS.merge(options)
-          install
-        end
-        attr_reader :rake, :options
-
-      private
-
-        def install
-          require 'securerandom'
-
-          ns = options[:namespace]
-          target_folder = options[:target]
-          assets = options[:assets]
-          assets = MagicAssets.new(assets) if assets.is_a?(Hash)
-          version = SecureRandom.urlsafe_base64
-
-          rake.instance_exec do
-            namespace(ns) do
-
-              desc 'Cleans generated assets'
-              task :clean do
-                FileUtils.rm_rf target_folder
-              end
-
-              task :prepare do
-                FileUtils.mkdir_p target_folder
-                (target_folder/"VERSION").write(version)
-              end
-
-              desc 'compile javascript assets'
-              task :compile_js do
-                assets['vendor.js'].write_to(target_folder/"vendor-#{version}.min.js")
-                assets['app.js'].write_to(target_folder/"app-#{version}.min.js")
-                puts "successfully compiled js assets"
-              end
-
-              desc 'compile css assets'
-              task :compile_css do
-                assets['vendor.css'].write_to(target_folder/"vendor-#{version}.min.css")
-                assets['app.css'].write_to(target_folder/"app-#{version}.min.css")
-                puts "successfully compiled css assets"
-              end
-
-              desc 'compile assets'
-              task :compile => [:clean, :prepare, :compile_js, :compile_css]
-            end
-          end
-        end
-
-      end
-    end # class MagicAssets
-  end # module Web
-end # module Startback