startback 0.12.2 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f4770d1267ad944224e11f6c10ddaae3f2c3666860ef31c05ea3323282dda34
-  data.tar.gz: ec1a61367ab0947be2088dae981c6956359a26bc2517282a464e44e6449331b4
+  metadata.gz: 3d5d880b8e9dfdeecdd68e78400468a2765dffbcf39866860daef9ac86a8096d
+  data.tar.gz: 6bf01ece248ca741ed4a590ab5458c8f94bda465c315951cfb0797fa49ae4fe9
 SHA512:
-  metadata.gz: 19813029ac9f81b1aed96f69a8e6ddd45e509d87e5b3bd05859f0b9155c16c5a05035cf2a28ff7df2df28f467a368702fa83180c24a62caf498337c3dde6d7da
-  data.tar.gz: 57abc7390c595f5c024276ed07ccb3580312d2de76a6a622e0a3284afefb38244b000b26e9f005d4516de67f3afccdc4789988466ffbb220f106cce3514f83b4
+  metadata.gz: 7f21d629f5733aea63bdfd21199aae51208d16751e398a373cef0a72cf4fcbceb083046c7f1ec61f9ed4791c2e4621a787229f438622a35a28a9ca2591ec5f90
+  data.tar.gz: c77c9f93fc437a8c803782d226bd6f9c30497f1eb238a6244526262fd5c24e148b322d01d46ed8bd81d907b9851a9789e1774abaec5dccd63fefc8a0da50eeb1

data/lib/startback/context/h_factory.rb

@@ -0,0 +1,43 @@
+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.rb

@@ -1,7 +1,8 @@
 module Startback
   #
   # Defines an execution context for Startback applications, and provides
-  # a cached factory for related abstractions (see `factor`).
+  # 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.
@@ -48,46 +49,36 @@ module Startback
     # convert them to wathever log format is necessary.
     attr_accessor :logger
 
-    # Implementation of the `h` information contract
-    class << self
+    require_relative 'context/h_factory'
+    extend(Context::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 initialize
+      super
+      yield(self) if block_given?
+    end
 
-      def h_factory(&factory)
-        h_factories << factory
-      end
+    attr_writer :_world
+    protected :_world=
 
-      ###
+    def self.world(who, &block)
+      @_world ||= Support::World.new
+      @_world = @_world.factory(who, &block)
+    end
 
-      def h_dump!(context, hash = {})
-        h_dumpers.each do |d|
-          context.instance_exec(hash, &d)
-        end
-        hash
-      end
+    def self.factor_world(context)
+      @_world ||= Support::World.new
+      @_world.with_scope(context)
+    end
 
-      def h_dumpers
-        @h_dumpers ||= []
-      end
+    def world
+      @_world ||= self.class.factor_world(self)
+    end
 
-      def h_dump(&dumper)
-        h_dumpers << dumper
+    def with_world(world)
+      dup do |ctx|
+        ctx._world = self.world.with(world)
       end
-
-    end # class << self
+    end
 
     # Factors an instance of `clazz`, which must be a Context-related
     # abstraction (i.e. its constructor takes the context as last parameters).

data/lib/startback/event/agent.rb

@@ -76,7 +76,7 @@ module Startback
       end
 
       def operation_world(op)
-        super(op).merge(context: ctx)
+        super(op).merge(context: context)
       end
 
     end # class Agent

data/lib/startback/event/engine.rb

@@ -1,18 +1,14 @@
 require 'rack'
-require 'webrick'
 require 'startback'
 module Startback
   class Event
     #
     # This class is the starting point of event handling in
     # Startback. It holds a Bus instance to which emitters
-    # and listeners can connect, and the possibility for the
-    # the listening part to start an infinite loop (ServerEngine).
+    # and listeners can connect.
     #
-    # The Engine automatically runs a Webrick small webapp
-    # with a /healthcheck webservice. The class can be extended
-    # and method `on_health_check` overriden to run specific
-    # checks.
+    # The Engine exposes a rack app (.rack_app) with a /healthcheck webservice.
+    # It is supposed to be mounted to a webserver such as puma.
     #
     # This class goes hand in hand with the `startback:engine`
     # docker image. It can be extended by subclasses to override
@@ -22,15 +18,13 @@ module Startback
     #   - on_health_check to check specific health conditions
     #   - create_agents to instantiate all listening agents
     #     (unless auto_create_agents is used)
+    #   - rack_app if you want to customize the API running
     #
     class Engine
       include Support::Robustness
 
       DEFAULT_OPTIONS = {
 
-        # To be passed to ServerEngine
-        server_engine: {}
-
       }
 
       def initialize(options = {}, context = Context.new)
@@ -60,7 +54,7 @@ module Startback
       end
 
       def bus
-        ::Startback::Event::Bus.new
+        @bus ||= ::Startback::Event::Bus.new
       end
 
       def connect
@@ -68,20 +62,12 @@ module Startback
         bus.connect
       end
 
-      def run(options = {})
-        connect
-
-        log(:info, self, "Running agents and server engine!")
-        create_agents
-        Runner.new(self, options[:server_engine] || {}).run
-      end
-
       def create_agents
         return unless parent = self.class.auto_create_agents
 
         ObjectSpace
           .each_object(Class)
-          .select { |klass| klass < parent }
+          .select { |klass| klass <= parent }
           .each { |klass| klass.new(self) }
       end
 
@@ -89,88 +75,20 @@ module Startback
         Event.json(event_data, context)
       end
 
-      class Runner
-
-        DEFAULT_SERVER_ENGINE_OPTIONS = {
-          daemonize: false,
-          worker_type: 'process',
-          workers: 1
-        }
-
-        def initialize(engine, options = {})
-          raise ArgumentError if engine.nil?
-
-          @engine = engine
-          @options = DEFAULT_SERVER_ENGINE_OPTIONS.merge(options)
-          require 'serverengine'
-        end
-        attr_reader :engine, :options
-
-        def run(options = {})
-          health = self.class.build_health_check(engine)
-          worker = self.class.build_worker(engine, health)
-          se = ServerEngine.create(nil, worker, options)
-          se.run
-          se
-        end
-
-        class << self
-          def run(*args, &bl)
-            new.run(*args, &bl)
-          end
+      def rack_app
+        engine = self
+        Rack::Builder.new do
+          use Startback::Web::CatchAll
 
-          def build_health_check(engine)
-            Rack::Builder.new do
-              map '/health-check' do
-                health = Startback::Web::HealthCheck.new {
-                  engine.on_health_check
-                }
-                run(health)
-              end
-            end
+          map '/health-check' do
+            health = Startback::Web::HealthCheck.new {
+              engine.on_health_check
+            }
+            run(health)
           end
+        end
+      end
 
-          def build_worker(engine, health)
-            Module.new do
-              include Support::Env
-
-              def initialize
-                @stop_flag = ServerEngine::BlockingFlag.new
-              end
-
-              define_method(:health) do
-                health
-              end
-
-              define_method(:engine) do
-                engine
-              end
-
-              def run
-                ran = false
-                until @stop_flag.set?
-                  if ran
-                    engine.send(:log, :warn, engine, "Restarting internal loop")
-                  else
-                    engine.send(:log, :info, engine, "Starting internal loop")
-                  end
-                  Rack::Handler::WEBrick.run(health, {
-                    :Port => env('STARTBACK_ENGINE_PORT', '3000').to_i,
-                    :Host => env('STARTBACK_ENGINE_LISTEN', '0.0.0.0')
-                  })
-                  ran = true
-                end
-              end
-
-              def stop
-                engine.send(:log, :info, engine, "Stopping internal loop")
-                @stop_flag.set!
-                Rack::Handler::WEBrick.shutdown
-              end
-            end
-          end
-        end # class << self
-      end # class Runner
     end # class Engine
   end # class Event
 end # module Startback

data/lib/startback/event.rb

@@ -21,6 +21,8 @@ module Startback
     attr_reader :context, :type, :data
 
     def self.json(src, context)
+      return src if src.is_a?(Event)
+
       parsed = JSON.parse(src)
       klass = Kernel.const_get(parsed['type'])
       context = context.fork(parsed['context']) if context

data/lib/startback/model.rb

@@ -0,0 +1,6 @@
+module Startback
+  class Model
+    include Support::DataObject
+
+  end # class Model
+end # module Startback

data/lib/startback/operation.rb

@@ -37,6 +37,11 @@ module Startback
     attr_accessor :world
     protected :world=
 
+    def initialize(input = {})
+      @input = input
+    end
+    attr_reader :input
+
     def bind(world)
       return self unless world
       self.world = world

data/lib/startback/services.rb

@@ -0,0 +1,11 @@
+module Startback
+  class Services
+    include Startback::Errors
+
+    def initialize(context)
+      @context = context
+    end
+    attr_reader :context
+
+  end # class Services
+end # module Startback

data/lib/startback/support/data_object.rb

@@ -0,0 +1,71 @@
+module Startback
+  module Support
+    module DataObject
+
+      def initialize(data = {})
+        @_data = data.dup.freeze
+      end
+
+      attr_writer :_data
+      protected :_data=
+
+      def method_missing(name, *args, &bl)
+        return super unless args.empty? && bl.nil?
+        return super unless pair = _data_key_for(name)
+
+        pair.last ? !!@_data[pair.first] : @_data[pair.first]
+      end
+
+      def [](name)
+        return nil unless pair = _data_key_for(name, false, false)
+
+        @_data[pair.first]
+      end
+
+      def respond_to?(name)
+        super || !_data_key_for(name).nil?
+      end
+
+      def to_data
+        @_data
+      end
+      alias :to_h :to_data
+
+      def to_json(*args, &bl)
+        to_data.to_json(*args, &bl)
+      end
+
+    private
+
+      def _data_key_for(key, try_camelize = _data_allow_camelize, try_query = _data_allow_query)
+        if @_data.key?(key)
+          [key, false]
+        elsif @_data.key?(key.to_s)
+          [key.to_s, false]
+        elsif key.is_a?(String) && @_data.key?(key.to_sym)
+          [key.to_sym, false]
+        elsif try_camelize
+          cam = key.to_s.gsub(/_([a-z])/){ $1.upcase }.to_sym
+          _data_key_for(cam, false, true)
+        elsif try_query && key.to_s =~ /\?$/
+          got = _data_key_for(key[0...-1].to_sym, false, false)
+          got ? [got.first, true] : _data_key_not_found(key)
+        else
+          _data_key_not_found(key)
+        end
+      end
+
+      def _data_allow_camelize
+        true
+      end
+
+      def _data_allow_query
+        true
+      end
+
+      def _data_key_not_found(key)
+        nil
+      end
+    end # module DataObject
+  end # module Support
+end # module Startback

data/lib/startback/support/world.rb

@@ -0,0 +1,54 @@
+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

@@ -22,3 +22,5 @@ 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 +1,8 @@
 module Startback
   module Version
     MAJOR = 0
-    MINOR = 12
-    TINY  = 2
+    MINOR = 14
+    TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/lib/startback.rb

@@ -32,8 +32,10 @@ module Startback
   require_relative 'startback/ext'
   require_relative 'startback/errors'
   require_relative 'startback/support'
+  require_relative 'startback/model'
   require_relative 'startback/context'
   require_relative 'startback/operation'
+  require_relative 'startback/services'
 
   # Logger instance to use for the application
   LOGGER = ::Startback::Support::Logger.new

data/spec/spec_helper.rb

@@ -1,8 +1,8 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'startback'
 require 'startback/event'
 require 'startback/support/fake_logger'
 require 'rack/test'
+require 'ostruct'
 
 module SpecHelpers
 end
@@ -12,23 +12,35 @@ RSpec.configure do |c|
 end
 
 class SubContext < Startback::Context
+
   attr_accessor :foo
+
   h_factory do |c,h|
     c.foo = h["foo"]
   end
+
   h_dump do |h|
     h.merge!("foo" => foo)
   end
+
+  world(:partner) do
+    Object.new
+  end
+
 end
 
 class SubContext
+
   attr_accessor :bar
+
   h_factory do |c,h|
     c.bar = h["bar"]
   end
+
   h_dump do |h|
     h.merge!("bar" => bar)
   end
+
 end
 
 class User

data/spec/unit/context/test_fork.rb

@@ -8,8 +8,7 @@ module Startback
       context.foo = ['hello']
 
       forked = context.fork
-      puts "Forked: #{forked.inspect}"
-      expect(fork).not_to be(context)
+      expect(forked).not_to be(context)
       expect(forked.foo).to eql(['hello'])
       expect(forked.foo).to be(context.foo)
     end
@@ -19,7 +18,7 @@ module Startback
 
       seen = false
       context.fork({ 'foo' => 'hello' }) do |forked|
-        expect(fork).not_to be(context)
+        expect(forked).not_to be(context)
         expect(forked.foo).to eql('hello')
         seen = true
       end
@@ -30,7 +29,7 @@ module Startback
       context = SubContext.new
 
       forked = context.fork({ 'foo' => 'hello' })
-      expect(fork).not_to be(context)
+      expect(forked).not_to be(context)
       expect(forked.foo).to eql('hello')
     end
 

data/spec/unit/context/test_with_world.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module Startback
+  describe Context, "with_world" do
+
+    let(:who) do
+      Object.new
+    end
+
+    let(:context) do
+      SubContext.new.with_world(hello: who)
+    end
+
+    it 'works as expected' do
+      got = context.world.hello
+      expect(got).to be(who)
+    end
+
+  end
+end

data/spec/unit/context/test_world.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Startback
+  describe Context, "world" do
+
+    let(:context) do
+      SubContext.new
+    end
+
+    it 'works as expected' do
+      got = context.world.partner
+      expect(got).not_to be_nil
+      expect(context.world.partner).to be(got)
+    end
+
+  end
+end

data/spec/unit/support/test_data_object.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+module Startback
+  module Support
+    describe DataObject do
+
+      class FooDataObject
+        include DataObject
+      end
+
+      let(:data) do
+        {
+          :foo => 'bar',
+          'bar' => 'baz'
+        }
+      end
+
+      subject do
+        FooDataObject.new(data)
+      end
+
+      it 'lets create an instance with providing data' do
+        expect(subject).to be_a(FooDataObject)
+      end
+
+      it 'lets get the data back' do
+        expect(subject.to_data).to eql(data)
+        expect(subject.to_data).not_to be(data)
+      end
+
+      it 'lets to_json it' do
+        expect(subject.to_json).to eql(%Q{{"foo":"bar","bar":"baz"}})
+      end
+
+      describe "data helpers" do
+        it 'lets access data through methods' do
+          expect(subject.foo).to eql('bar')
+        end
+
+        it 'is indifferent to symbol vs. string' do
+          expect(subject.bar).to eql('baz')
+        end
+
+        it 'is indifferent to camel casing' do
+          expect(subject.bar).to eql('baz')
+        end
+
+        it 'raises a NoMethodError when not known' do
+          expect {
+            subject.no_such_one
+          }.to raise_error(NoMethodError)
+        end
+
+        it 'implements respond_to? correctly' do
+          expect(subject.respond_to?(:foo)).to eql(true)
+          expect(subject.respond_to?(:bar)).to eql(true)
+          expect(subject.respond_to?(:no_such_one)).to eql(false)
+        end
+      end # data helpers
+
+      describe "? helpers" do
+        let(:data) do
+          {
+            'some' => 'thing',
+            'ready' => false,
+            'unready' => true,
+            'nothing' => nil
+          }
+        end
+
+        it 'works as expected' do
+          expect(subject.some?).to eql(true)
+          expect(subject.ready?).to eql(false)
+          expect(subject.unready?).to eql(true)
+          expect(subject.nothing?).to eql(false)
+        end
+
+        it 'implements respond_to? correctly' do
+          expect(subject.respond_to?(:some?)).to eql(true)
+          expect(subject.respond_to?(:ready?)).to eql(true)
+          expect(subject.respond_to?(:unready?)).to eql(true)
+          expect(subject.respond_to?(:nothing?)).to eql(true)
+        end
+
+        it 'stays conservative' do
+          expect {
+            subject.no_such_one?
+          }.to raise_error(NoMethodError)
+          expect(subject.respond_to?(:no_such_one?)).to eql(false)
+        end
+      end
+
+      describe "case helpers" do
+        let(:data) do
+          {
+            'camelCase' => 'snake_case'
+          }
+        end
+
+        it 'lets use camelCase' do
+          expect(subject.camelCase).to eql('snake_case')
+        end
+
+        it 'lets use camel_case' do
+          expect(subject.camel_case).to eql('snake_case')
+        end
+
+        it 'implements respond_to? correctly' do
+          expect(subject.respond_to?(:camelCase)).to eql(true)
+          expect(subject.respond_to?(:camel_case)).to eql(true)
+        end
+
+        it 'is compatible with ? helpers' do
+          expect(subject.camelCase?).to eql(true)
+          expect(subject.camel_case?).to eql(true)
+        end
+
+        it 'stays conservative' do
+          expect {
+            subject.no_such_one
+          }.to raise_error(NoMethodError)
+          expect(subject.respond_to?(:no_such_one)).to eql(false)
+          expect(subject.respond_to?(:no_such_one?)).to eql(false)
+        end
+      end
+
+      describe '[]' do
+        let(:data) do
+          {
+            :foo => 'bar',
+            'bar' => 'baz',
+            'camelCase' => 'snake_case'
+          }
+        end
+
+        it 'lets access data' do
+          expect(subject[:foo]).to eql('bar')
+          expect(subject['bar']).to eql('baz')
+          expect(subject['camelCase']).to eql('snake_case')
+        end
+
+        it 'uses indifferent access' do
+          expect(subject['foo']).to eql('bar')
+          expect(subject[:bar]).to eql('baz')
+          expect(subject[:camelCase]).to eql('snake_case')
+        end
+
+        it 'has no other magic and returns nil in all other cases' do
+          expect(subject[:foo?]).to be_nil
+          expect(subject[:camel_case]).to be_nil
+          expect(subject[:camel_case?]).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/unit/support/test_world.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module Startback
+  module Support
+    describe World do
+
+      let(:world) do
+        World.new
+      end
+
+      describe 'with' do
+        subject do
+          world.with(foo: :bar, bar: :baz)
+        end
+
+        it 'returns a new world instance' do
+          expect(subject).to be_a(World)
+          expect(subject).not_to be(world)
+        end
+
+        it 'gives access to those variables' do
+          expect(subject.foo).to eql(:bar)
+          expect(subject[:bar]).to eql(:baz)
+        end
+      end
+
+      describe 'dup' do
+        let(:world) do
+          World.new(foo: :bar)
+        end
+
+        subject do
+          world.dup
+        end
+
+        it 'returns another instance' do
+          expect(subject).to be_a(World)
+          expect(subject).not_to be(world)
+        end
+
+        it 'keeps variables' do
+          expect(subject.foo).to eql(:bar)
+        end
+      end
+
+      describe 'class factory' do
+        subject do
+          world.factory(:foo) do
+            hello
+          end
+        end
+
+        def hello
+          OpenStruct.new(bar: 12)
+        end
+
+        it 'returns a world instance' do
+          expect(subject).to be_a(World)
+          expect(subject).not_to be(world)
+        end
+
+        it 'installs the factory' do
+          bound = subject.with_scope(self)
+          got = bound.foo
+          expect(got).to be_a(OpenStruct)
+          expect(got.bar).to eql(12)
+          expect(bound.foo).to be(got)
+        end
+      end
+    end
+  end
+end

data/tasks/test.rake

@@ -1,4 +1,5 @@
 require 'rspec/core/rake_task'
+require 'path'
 
 namespace :test do
 
@@ -8,14 +9,6 @@ namespace :test do
     t.rspec_opts = %{-Ilib -Ispec --color --backtrace --format progress --format RspecJunitFormatter --out spec/rspec-unit.xml}
   end
 
-  desc "Run the tests in the examples folder"
-  task :example do
-    Bundler.with_original_env do
-      system("cd example && bundle exec rake")
-      abort("Example tests failed") unless $?.exitstatus == 0
-    end
-  end
-
-  task :all => [:unit, :example]
+  task :all => [:unit]
 end
 task :test => :'test:all'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: startback
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.14.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-20 00:00:00.000000000 Z
+date: 2022-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -270,20 +270,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.20.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.20.0
+        version: 0.21.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.20.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.20.0
+        version: 0.21.0
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
@@ -389,6 +389,7 @@ files:
 - lib/startback/caching/no_store.rb
 - lib/startback/caching/store.rb
 - lib/startback/context.rb
+- lib/startback/context/h_factory.rb
 - lib/startback/context/middleware.rb
 - lib/startback/errors.rb
 - lib/startback/event.rb
@@ -405,10 +406,13 @@ files:
 - lib/startback/ext.rb
 - lib/startback/ext/date_time.rb
 - lib/startback/ext/time.rb
+- lib/startback/model.rb
 - lib/startback/operation.rb
 - lib/startback/operation/error_operation.rb
 - lib/startback/operation/multi_operation.rb
+- lib/startback/services.rb
 - lib/startback/support.rb
+- lib/startback/support/data_object.rb
 - lib/startback/support/env.rb
 - lib/startback/support/fake_logger.rb
 - lib/startback/support/hooks.rb
@@ -418,6 +422,7 @@ files:
 - lib/startback/support/robustness.rb
 - lib/startback/support/transaction_manager.rb
 - lib/startback/support/transaction_policy.rb
+- lib/startback/support/world.rb
 - lib/startback/version.rb
 - lib/startback/web/api.rb
 - lib/startback/web/auto_caching.rb
@@ -439,15 +444,19 @@ files:
 - spec/unit/context/test_fork.rb
 - spec/unit/context/test_h_factory.rb
 - spec/unit/context/test_middleware.rb
+- spec/unit/context/test_with_world.rb
+- spec/unit/context/test_world.rb
 - spec/unit/event/bus/memory/test_async.rb
 - spec/unit/event/bus/memory/test_sync.rb
 - spec/unit/support/hooks/test_after_hook.rb
 - spec/unit/support/hooks/test_before_hook.rb
 - spec/unit/support/operation_runner/test_around_run.rb
 - spec/unit/support/operation_runner/test_before_after_call.rb
+- spec/unit/support/test_data_object.rb
 - spec/unit/support/test_env.rb
 - spec/unit/support/test_robusteness.rb
 - spec/unit/support/test_transaction_manager.rb
+- spec/unit/support/test_world.rb
 - spec/unit/test_event.rb
 - spec/unit/test_operation.rb
 - spec/unit/test_support.rb
@@ -461,7 +470,7 @@ files:
 - spec/unit/web/test_healthcheck.rb
 - spec/unit/web/test_magic_assets.rb
 - tasks/test.rake
-homepage: http://www.enspirit.be
+homepage: https://www.enspirit.be
 licenses:
 - MIT
 metadata: {}
@@ -480,7 +489,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Got Your Ruby Back