startback-websocket 0.14.0 → 0.14.1

data/lib/startback/caching/entity_cache.rb

@@ -1,157 +0,0 @@
-module Startback
-  module Caching
-    #
-    # A overriable caching abstraction aiming at making Entity-based caching easy.
-    #
-    # This class MUST be overriden:
-    #
-    # * the `load_entity` protected method MUST be implemented to load data from
-    #   a primary & context unaware key.
-    #
-    # * the `primary_key` protected method MAY be implemented to convert candidate
-    #   keys (received from ultimate callers) to primary keys. The method is also
-    #   a good place to check and/or log the keys actually used by callers.
-    #
-    # * the `context_free_key` protected method MAY be overriden to provide
-    #   domain unrelated caching keys from primary keys, e.g. by encoding the
-    #   context into the caching key itself, if needed.
-    #
-    # * the `valid?` protected method MAY be overriden to check validity of data
-    #   extracted from the cache and force a refresh even if found.
-    #
-    # An EntityCache takes an actual store at construction. The object must meet the
-    # specification writtern in Store. The 'cache' ruby gem can be used in practice.
-    #
-    # Cache hits, outdated and miss are logged in debug, info, and info severity.
-    # The `cache_hit`, `cache_outdated`, `cache_miss` protected methods MAY be
-    # overriden to change that behavior.
-    #
-    class EntityCache
-      include Support::Robustness
-
-      class << self
-
-        # Default time to live, in seconds
-        attr_writer :default_ttl
-
-        def default_ttl
-          @default_ttl || (superclass.respond_to?(:default_ttl, true) && superclass.default_ttl) || 3600
-        end
-
-      end # class DSL
-
-      def initialize(store, context = nil)
-        @store = store
-        @context = context
-      end
-      attr_reader :store, :context
-
-      # Returns the entity corresponding to a given key.
-      #
-      # If the entity is not in cache, loads it and puts it in cache using
-      # the caching options passed as second parameter.
-      def get(candidate_key, caching_options = default_caching_options)
-        pkey = primary_key(candidate_key)
-        cache_key = encode_key(context_free_key(pkey))
-        if store.exist?(cache_key)
-          cached = store.get(cache_key)
-          if valid?(pkey, cached)
-            cache_hit(pkey, cached)
-            return cached
-          else
-            cache_outdated(pkey, cached)
-          end
-        end
-        cache_miss(pkey)
-        load_entity(pkey).tap{|to_cache|
-          store.set(cache_key, to_cache, caching_options)
-        }
-      end
-
-      # Invalidates the cache under a given key.
-      def invalidate(candidate_key)
-        pkey = primary_key(candidate_key)
-        cache_key = encode_key(context_free_key(pkey))
-        store.delete(cache_key)
-      end
-
-    protected
-
-      def cache_hit(pkey, cached)
-        log(:debug, self, "cache_hit", context, op_data: pkey)
-      end
-
-      def cache_outdated(pkey, cached)
-        log(:info, self, "cache_outdated", context, op_data: pkey)
-      end
-
-      def cache_miss(pkey)
-        log(:info, self, "cache_miss", context, op_data: pkey)
-      end
-
-      def default_caching_options
-        { ttl: self.class.default_ttl }
-      end
-
-      # Converts a candidate key to a primary key, so as to prevent
-      # cache duplicates if callers are allowed to request an entity
-      # through various keys.
-      #
-      # The default implementation returns the candidate key and MAY
-      # be overriden.
-      def primary_key(candidate_key)
-        candidate_key
-      end
-
-      # Encodes a context free key to an actual cache key.
-      #
-      # Default implementation uses JSON.fast_generate but MAY be
-      # overriden.
-      def encode_key(context_free_key)
-        JSON.fast_generate(context_free_key)
-      end
-
-      # Returns whether `cached` entity seems fresh enough to
-      # be returned as a cache hit.
-      #
-      # This method provides a way to check freshness using, e.g.
-      # `updated_at` or `etag` kind of entity fields. The default
-      # implementation returns true and MAY be overriden.
-      def valid?(primary_key, cached)
-        true
-      end
-
-      # Converts a primary_key to a context_free_key, using the
-      # context (instance variable) to encode the context itself
-      # into the actual cache key.
-      #
-      # The default implementation simply returns the primary key
-      # and MAY be overriden.
-      def context_free_key(primary_key)
-        full_key(primary_key)
-      end
-
-      # Deprecated, will be removed in 0.6.0. Use context_free_key
-      # instead.
-      def full_key(primary_key)
-        primary_key
-      end
-
-      # Actually loads the entity using the given primary key, and
-      # possibly the cache context.
-      #
-      # This method MUST be implemented and raises a NotImplementedError
-      # by default.
-      def load_entity(primary_key)
-        load_raw_data(primary_key)
-      end
-
-      # Deprecated, will be removed in 0.6.0. Use load_entity
-      # instead.
-      def load_raw_data(*args, &bl)
-        raise NotImplementedError, "#{self.class.name}#load_entity"
-      end
-
-    end # class EntityCache
-  end # module Caching
-end # module Startback

data/lib/startback/caching/no_store.rb

@@ -1,28 +0,0 @@
-module Startback
-  module Caching
-    #
-    # Caching store implementation that caches nothing at all.
-    #
-    class NoStore
-
-      def initialize
-      end
-
-      def exist?(key)
-        false
-      end
-
-      def get(key)
-        nil
-      end
-
-      def set(key, value, ttl)
-        value
-      end
-
-      def delete(key)
-      end
-
-    end # class NoStore
-  end # module Caching
-end # module Startback

data/lib/startback/caching/store.rb

@@ -1,34 +0,0 @@
-module Startback
-  module Caching
-    #
-    # Caching store specification & dummy implementation.
-    #
-    # This class should not be used in real project, as it implements
-    # See the 'cache' gem that provides conforming implementations.
-    #
-    class Store
-
-      def initialize
-        @saved = {}
-      end
-      attr_reader :saved
-
-      def exist?(key)
-        saved.has_key?(key)
-      end
-
-      def get(key)
-        saved[key]
-      end
-
-      def set(key, value, ttl)
-        saved[key] = value
-      end
-
-      def delete(key)
-        saved.delete(key)
-      end
-
-    end # class Store
-  end # module Caching
-end # module Startback

data/lib/startback/context/h_factory.rb

@@ -1,43 +0,0 @@
-module Startback
-  class Context
-    module HFactory
-
-      def h(hash)
-        h_factor!(self.new, hash)
-      end
-
-      def h_factor!(context, hash)
-        h_factories.each do |f|
-          f.call(context, hash)
-        end
-        context
-      end
-
-      def h_factories
-        @h_factories ||= []
-      end
-
-      def h_factory(&factory)
-        h_factories << factory
-      end
-
-      ###
-
-      def h_dump!(context, hash = {})
-        h_dumpers.each do |d|
-          context.instance_exec(hash, &d)
-        end
-        hash
-      end
-
-      def h_dumpers
-        @h_dumpers ||= []
-      end
-
-      def h_dump(&dumper)
-        h_dumpers << dumper
-      end
-
-    end # module HFactory
-  end # class Context
-end # module Startback

data/lib/startback/context/middleware.rb

@@ -1,53 +0,0 @@
-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, MyContextClass.new
-    #
-    #       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'
-
-      def initialize(app, context = Context.new)
-        @app = app
-        @context = context
-      end
-      attr_reader :context
-
-      def call(env)
-        env[RACK_ENV_KEY] ||= context.dup.tap{|c|
-          c.original_rack_env = env.dup
-        }
-        @app.call(env)
-      end
-
-      def self.context(env)
-        env[RACK_ENV_KEY]
-      end
-
-    end # class Middleware
-  end # class Context
-end # module Startback

data/lib/startback/context.rb

@@ -1,122 +0,0 @@
-module Startback
-  #
-  # Defines an execution context for Startback applications, and provides
-  # a cached factory for related abstractions (see `factor`), and an
-  # extensible world, statically and dynamically.
-  #
-  # In web application, an instance of a context can be set on the Rack
-  # environment, using Context::Middleware.
-  #
-  # This class SHOULD be subclassed for application required extensions
-  # to prevent touching the global Startback state itself.
-  #
-  # Also, for event handling in distributed architectures, a Context should
-  # be dumpable and reloadable to JSON. An `h` information contract if provided
-  # for that. Subclasses may contribute to the dumping and reloading process
-  # through the `h_dump` and `h_factory` methods
-  #
-  #     module MyApp
-  #       class Context < Startback::Context
-  #
-  #         attr_accessor :foo
-  #
-  #         h_dump do |h|
-  #           h.merge!("foo" => foo)
-  #         end
-  #
-  #         h_factor do |c,h|
-  #           c.foo = h["foo"]
-  #         end
-  #
-  #       end
-  #     end
-  #
-  class Context
-    attr_accessor :original_rack_env
-
-    # An error handler can be provided on the Context class. The latter
-    # MUST expose an API similar to ruby's Logger class. It can be a logger
-    # instance, simply.
-    #
-    # Fatal errors catched by Web::CatchAll are sent on `error_handler#fatal`
-    #
-    # Deprecated, use the logger below instead.
-    attr_accessor :error_handler
-
-    # A logger can be provided on the context, and will be used for everything
-    # related to logging, audit trailing and robustness. The logger receives
-    # object following the log & trail conventions of Startback, and must
-    # convert them to wathever log format is necessary.
-    attr_accessor :logger
-
-    require_relative 'context/h_factory'
-    extend(Context::HFactory)
-
-    def initialize
-      super
-      yield(self) if block_given?
-    end
-
-    attr_writer :_world
-    protected :_world=
-
-    def self.world(who, &block)
-      @_world ||= Support::World.new
-      @_world = @_world.factory(who, &block)
-    end
-
-    def self.factor_world(context)
-      @_world ||= Support::World.new
-      @_world.with_scope(context)
-    end
-
-    def world
-      @_world ||= self.class.factor_world(self)
-    end
-
-    def with_world(world)
-      dup do |ctx|
-        ctx._world = self.world.with(world)
-      end
-    end
-
-    # Factors an instance of `clazz`, which must be a Context-related
-    # abstraction (i.e. its constructor takes the context as last parameters).
-    #
-    # Factored abstractions are cached for a given context & arguments.
-    def factor(clazz, *args)
-      @factored ||= {}
-      key = args.empty? ? clazz : [clazz] + args
-      @factored[key] ||= clazz.new(*(args << self))
-    end
-
-    def clean_factored!
-      @factored = {}
-    end
-    private :clean_factored!
-
-    def to_h
-      self.class.h_dump!(self)
-    end
-
-    def to_json(*args, &bl)
-      to_h.to_json(*args, &bl)
-    end
-
-    def fork(h = nil)
-      dup.tap{|duped|
-        self.class.h_factor!(duped, h) if h
-        yield(duped) if block_given?
-      }
-    end
-
-    def dup
-      super.tap{|c|
-        c.send(:clean_factored!)
-        yield(c) if block_given?
-      }
-    end
-
-  end # class Context
-end # module Startback
-require_relative 'context/middleware'

data/lib/startback/errors.rb

@@ -1,197 +0,0 @@
-module Startback
-  module Errors
-
-    class Error < StandardError
-      def initialize(message = nil, causes = nil)
-        super(message)
-        @causes = Array(causes)
-      end
-      attr_reader :causes
-
-      class << self
-        def status(code = nil)
-          if code.nil?
-            @code || (superclass.respond_to?(:status) ? superclass.status : 500)
-          else
-            @code = code || @code
-          end
-        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
-
-      def has_causes?
-        causes && !causes.empty?
-      end
-
-      def cause
-        causes&.first
-      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
-
-    ### Helper methods
-
-      def bad_request_error!(msg = nil)
-        raise Startback::Errors::BadRequestError, msg
-      end
-      module_function :bad_request_error!
-
-      def unauthorized_error!(msg = nil)
-        raise Startback::Errors::UnauthorizedError, msg
-      end
-      module_function :unauthorized_error!
-
-      def forbidden_error!(msg = nil)
-        raise Startback::Errors::ForbiddenError, msg
-      end
-      module_function :forbidden_error!
-
-      def not_found_error!(msg = nil)
-        raise Startback::Errors::NotFoundError, "#{msg} not found"
-      end
-      module_function :not_found_error!
-
-      def method_not_allowed_error!(msg = nil)
-        raise Startback::Errors::MethodNotAllowedError, msg
-      end
-      module_function :method_not_allowed_error!
-
-      def not_acceptable_error!(msg = nil)
-        raise Startback::Errors::NotAcceptableError, msg
-      end
-      module_function :not_acceptable_error!
-
-      def conflict_error!(msg = nil)
-        raise Startback::Errors::ConflictError, msg
-      end
-      module_function :conflict_error!
-
-      def gone_error!(msg = nil)
-        raise Startback::Errors::GoneError, msg
-      end
-      module_function :gone_error!
-
-      def precondition_failed_error!(msg = nil)
-        raise Startback::Errors::PreconditionFailedError, msg
-      end
-      module_function :precondition_failed_error!
-
-      def unsupported_media_type_error!(media)
-        raise Startback::Errors::UnsupportedMediaTypeError, "Unable to use `#{media}` as input data"
-      end
-      module_function :unsupported_media_type_error!
-
-      def expectation_failed_error!(msg = nil)
-        raise Startback::Errors::ExpectationFailedError, msg
-      end
-      module_function :expectation_failed_error!
-
-      def locked_error!(msg = nil)
-        raise Startback::Errors::LockedError, msg
-      end
-      module_function :locked_error!
-
-      def precondition_required_error!(msg = nil)
-        raise Startback::Errors::PreconditionRequiredError, msg
-      end
-      module_function :precondition_required_error!
-
-      def internal_server_error!(msg = nil)
-        raise Startback::Errors::InternalServerError, msg
-      end
-      module_function :internal_server_error!
-
-      def not_implemented_error!(msg = nil)
-        raise Startback::Errors::NotImplementedError, msg
-      end
-      module_function :not_implemented_error!
-
-  # Aliases
-
-      def user_error!(msg = nil)
-        raise Startback::Errors::BadRequestError, msg
-      end
-      module_function :user_error!
-
-      def server_error!(msg = nil)
-        raise Startback::Errors::InternalServerError, msg
-      end
-      module_function :server_error!
-
-  end # module Errors
-  include Errors
-end # module Startback