syntropy 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f54331b249d5f3f5b113380173af8e6179590a60ea5f9f3461b1c87f2c4ce53
-  data.tar.gz: f04553e5a04480e9720319a4b93dacdc38e04990a3e60471cf83fde1eea905eb
+  metadata.gz: a9a2e580917d4b05e8470695a75ab399326c6b8f7ee3b576526181c36791ee81
+  data.tar.gz: eb95e089e426bdb618981694cf8240911f30821a90d5ae9ef8f4bf4d79670a44
 SHA512:
-  metadata.gz: 3c749127a9b98be60618f2d82229bcab09894465caebeef37a04672f5456e1480089cbbb9cb662969d024ed64a1657d6e1cbad96af18a2292c2cc5723628e358
-  data.tar.gz: a0ab0555fff735b401204ee54f294c6c009d18d527c938da0ec467f82d0e30ede3e6a8bc76615ef2d8ba5fc01fcd6cd060f3e5522aaf13e69cf6c31fcfaf704b
+  metadata.gz: a85e2502bd313a10b5533ec5b8f124cfa72a3c4494f7ddcd912e0939973e2f72df458e6891543c5cbcf106718254561523c7f561ee1fd23bf348cab701696d4a
+  data.tar.gz: 60391470703441eccb1bdba52edfba754225171bcf65a08d146d01742e1ab8f7b8f6215cfc093ed4aee4b6e99c0f967cb9a6bf1f19274f6f4d34f8ae95a6e2c4

data/.rubocop.yml

@@ -0,0 +1,196 @@
+AllCops:
+  TargetRubyVersion: 3.2
+  RubyInterpreters:
+    - ruby
+  Exclude:
+    - "**/*.gemspec"
+    - "test/**/*.rb"
+    - "examples/**/*.rb"
+    - "Gemfile*"
+# Style/LambdaCall:
+#   Enabled: false
+# Style/ModuleFunction:
+#   Enabled: false
+# Style/RegexpLiteral:
+#   Enabled: false
+
+# Naming/MemoizedInstanceVariableName:
+#   Enabled: false
+
+# Style/Alias:
+#   EnforcedStyle: prefer_alias_method
+
+# Style/SpecialGlobalVars:
+#   Enabled: false
+
+# Style/ClassAndModuleChildren:
+#   Enabled: false
+
+# Metrics/AbcSize:
+#   Enabled: false
+
+# Style/MixinUsage:
+#   Enabled: false
+
+# Style/MultilineBlockChain:
+#   Enabled: false
+
+# Lint/RescueException:
+#   Enabled: false
+
+# Lint/InheritException:
+#   Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+# Style/TrivialAccessors:
+#   Enabled: false
+
+# Lint/MissingSuper:
+#   Enabled: false
+
+# Style/GlobalVars:
+#   Exclude:
+#     - lib/polyphony/auto_run.rb
+#     - lib/polyphony/extensions/core.rb
+#     - examples/**/*.rb
+
+Layout/HashAlignment:
+  Enabled: false
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+# Naming/AccessorMethodName:
+#   Exclude:
+#     - lib/polyphony/extensions/fiber.rb
+#     - examples/**/*.rb
+
+# Naming/MethodName:
+#   Exclude:
+#     - test/test_signal.rb
+
+# Lint/SuppressedException:
+#   Exclude:
+#     - examples/**/*.rb
+
+Metrics/MethodLength:
+  Max: 14
+#   Exclude:
+#     - lib/polyphony/extensions/io.rb
+#     - lib/polyphony/extensions/fiber.rb
+#     - lib/polyphony/extensions/thread.rb
+#     - lib/polyphony/adapters/open3.rb
+#     - test/**/*.rb
+#     - examples/**/*.rb
+
+# Metrics/ModuleLength:
+#   Exclude:
+#     - lib/polyphony/core/global_api.rb
+#     - examples/**/*.rb
+
+# Metrics/ClassLength:
+#   Exclude:
+#     - lib/polyphony/extensions/io.rb
+#     - lib/polyphony/extensions/fiber.rb
+#     - lib/polyphony/extensions/object.rb
+#     - lib/polyphony/extensions/thread.rb
+#     - test/**/*.rb
+#     - examples/**/*.rb
+
+# Metrics/CyclomaticComplexity:
+#   Exclude:
+#     - lib/polyphony/extensions/fiber.rb
+
+# Metrics/PerceivedComplexity:
+#   Exclude:
+#     - lib/polyphony/extensions/fiber.rb
+
+# Style/RegexpLiteral:
+#   Enabled: false
+
+Style/RescueModifier:
+  Enabled: false
+# Style/Documentation:
+#   Exclude:
+#     - test/**/*.rb
+#     - examples/**/*.rb
+#     - lib/polyphony/adapters/**/*.rb
+
+# Style/FormatString:
+#   Exclude:
+#     - test/**/*.rb
+#     - examples/**/*.rb
+
+# Style/FormatStringToken:
+#   Exclude:
+#     - test/**/*.rb
+#     - examples/**/*.rb
+
+Naming/MethodParameterName:
+  Enabled: false
+
+# Security/MarshalLoad:
+#   Exclude:
+#     - examples/**/*.rb
+
+# Lint/ShadowedArgument:
+#   Exclude:
+#     - lib/polyphony/extensions/fiber.rb
+
+# Style/HashEachMethods:
+#   Enabled: true
+
+# Style/HashTransformKeys:
+#   Enabled: true
+
+# Style/HashTransformValues:
+#   Enabled: true
+
+# Layout/EmptyLinesAroundAttributeAccessor:
+#   Enabled: true
+
+# Layout/SpaceAroundMethodCallOperator:
+#   Enabled: true
+
+# Lint/DeprecatedOpenSSLConstant:
+#   Enabled: true
+
+# Lint/MixedRegexpCaptureTypes:
+#   Enabled: true
+
+# Lint/RaiseException:
+#   Enabled: true
+
+# Lint/StructNewOverride:
+#   Enabled: true
+
+Style/NegatedIf:
+  Enabled: false
+# Style/NegatedWhile:
+#   Enabled: false
+
+# Style/CombinableLoops:
+#   Enabled: false
+
+# Style/InfiniteLoop:
+#   Enabled: false
+
+# Style/RedundantReturn:
+#   Enabled: false
+
+# Style/ExponentialNotation:
+#   Enabled: true
+
+# Style/RedundantRegexpCharacterClass:
+#   Enabled: true
+
+# Style/RedundantRegexpEscape:
+#   Enabled: true
+
+# Style/SlicingWithRange:
+#   Enabled: true
+
+# Style/RaiseArgs:
+#   Exclude:
+#     - lib/polyphony/extensions/fiber.rb

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.2 2025-06-24
+
+- Add CLI tool
+- Implement basic module loading
+- Implement ConnectionPool
+
 ## 0.1 2025-06-17
 
 - Move context inside Request object

data/TODO.md

@@ -1,11 +1,97 @@
-- More database methods:
+## Server tool
 
-  - `Database#quote`
-  - `Database#cache_flush` https://sqlite.org/c3ref/db_cacheflush.html
-  - `Database#release_memory` https://sqlite.org/c3ref/db_release_memory.html
+```bash
+$ bundle exec syntropy --dev ./site
+$ bundle exec syntropy --workers 4 ./site
+```
 
-- Security
+And also a config file:
 
-  - Enable extension loading by using
-    [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION](https://www.sqlite.org/c3ref/c_dbconfig_defensive.html#sqlitedbconfigenableloadextension)
-    in order to prevent usage of `load_extension()` SQL function.
+```bash
+$ bundle exec syntropy site.rb
+```
+
+And the config file:
+
+```ruby
+# site.rb
+Syntropy.config do
+  root './site'
+  workers 4
+  log { |req| }
+end
+```
+
+## Lightweight model API on top of Extralite
+
+- DB connection pool
+- Lightweight means 90% features with 10% effort:
+
+```ruby
+Posts = Syntropy::Relation.new('posts')
+
+posts = Posts.order_by(:stamp, :desc).all(db)
+
+post = Posts.where(id: 13).first(db)
+
+id = Posts.insert(db, title: 'foo', body: 'bar')
+
+Posts.where(id: id).update(db, body: 'baz')
+
+Posts.where(id: id).delete(db)
+```
+
+The whole `db` argument thing is very limiting. For easier usage we integrate
+the db connection pool as dependency injection the model:
+
+```ruby
+db_pool = E2::ConnectionPool.new(fn)
+Posts = Syntropy::Dataset.new(db_pool, 'posts')
+
+Posts[id: 1] #=> { id: 1, title: 'foo', body: 'bar' }
+Posts.find(id: 1) #=>
+
+Posts.to_a #=> [...]
+Posts.order_by(:stamp, :desc).to_a #=> [...]
+
+id = Posts.insert(title: 'foo', body: 'bar')
+
+post = Posts.where(id: id)
+post.values #=> { id: 1, title: 'foo', body: 'bar' }
+post.update(body: 'baz') #=> 1
+post.delete
+```
+
+So basically it's a bit similar to Sequel datasets, but there's no "object instance as single row". The instance is the entire set of rows in the table, or a subset thereof:
+
+```ruby
+Posts.where(...).order_by(...).select(...).from(rowset)
+```
+
+How about CTEs?
+
+```ruby
+Users = Syntrop::Dataset.new(db_pool, 'users')
+
+GroupIdRowset = Syntropy::Dataset {
+  with(
+    foo: Users,
+    bar: -> {
+      select user_id, group
+      from foo
+    },
+    baz: -> {
+      select id
+      from bar
+      where user_id == bar.select(:user_id)
+    }
+  )
+
+  select_all
+  from baz
+  where id == :group_id
+}
+
+users = GroupIdRowset.bind(group_id: 5).to_a
+
+```

data/bin/syntropy

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'syntropy'
+require 'optparse'
+
+opts = {
+  banner: Syntropy::BANNER,
+  logger: true
+}
+
+parser = OptionParser.new do |o|
+  o.banner = 'Usage: syntropy [options] DIR'
+
+  o.on('-b', '--bind BIND', String,
+       'Bind address (default: http://0.0.0.0:1234). You can specify this flag multiple times to bind to multiple addresses.') do
+    opts[:bind] ||= []
+    opts[:bind] << it
+  end
+
+  o.on('-s', '--silent', 'Silent mode') do
+    opts[:banner] = nil
+    opts[:logger] = nil
+  end
+
+  o.on('-w', '--watch', 'Watch for changed files') do
+    opts[:watch_files] = 0.1
+  end
+
+  o.on('-h', '--help', 'Show this help message') do
+    puts o
+    exit
+  end
+
+  o.on('-v', '--version', 'Show version') do
+    require 'syntropy/version'
+    puts "Syntropy version #{Syntropy::VERSION}"
+    exit
+  end
+end
+
+RubyVM::YJIT.enable rescue nil
+
+begin
+  parser.parse!
+rescue StandardError => e
+  puts e.message
+  puts e.backtrace.join("\n")
+  exit
+end
+
+opts[:location] = ARGV.shift || '.'
+
+if !File.directory?(opts[:location])
+  puts "#{File.expand_path(opts[:location])} Not a directory"
+  exit
+end
+
+opts[:machine] = UM.new
+app = Syntropy::App.new(opts[:machine], opts[:location], '/', watch_files: 0.05)
+TP2.run(opts) { app.(it) }

data/lib/syntropy/app.rb

@@ -1,20 +1,34 @@
 # frozen_string_literal: true
 
 require 'qeweney'
-require 'syntropy/errors'
 require 'json'
 require 'papercraft'
 
+require 'syntropy/errors'
+require 'syntropy/file_watch'
+require 'syntropy/module'
+
 module Syntropy
   class App
     attr_reader :route_cache
 
-    def initialize(src_path, mount_path)
+    def initialize(machine, src_path, mount_path, env = {})
+      @machine = machine
       @src_path = src_path
       @mount_path = mount_path
       @route_cache = {}
+      @env = env
 
       @relative_path_re = calculate_relative_path_re(mount_path)
+      if (wf = env[:watch_files])
+        period = wf.is_a?(Numeric) ? wf : 0.1
+        machine.spin do
+          Syntropy.file_watch(@machine, src_path, period: period) { invalidate_cache(it) }
+        rescue Exception => e
+          p e
+          p e.backtrace
+        end
+      end
     end
 
     def find_route(path, cache: true)
@@ -28,6 +42,15 @@ module Syntropy
       entry
     end
 
+    def invalidate_cache(fn)
+      invalidated_keys = []
+      @route_cache.each do |k, v|
+        invalidated_keys << k if v[:fn] == fn
+      end
+
+      invalidated_keys.each { @route_cache.delete(it) }
+    end
+
     def call(req)
       entry = find_route(req.path)
       render_entry(req, entry)
@@ -67,7 +90,7 @@ module Syntropy
 
       entry = find_file_entry_with_extension(fs_path)
       return entry if entry[:kind] != :not_found
-        
+
       find_up_tree_module(path)
     end
 
@@ -138,13 +161,15 @@ module Syntropy
     rescue StandardError => e
       p e
       p e.backtrace
-      req.respond(nil, ':status' => Qeweney::S*tatus::INTERNAL_SERVER_ERROR)
+      req.respond(nil, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
     end
 
     def load_module(entry)
-      body = IO.read(entry[:fn])
-      klass = Class.new
-      o = klass.instance_eval(body, entry[:fn], 1)
+      loader = Syntropy::ModuleLoader.new(@src_path, @env)
+      ref = entry[:fn].gsub(%r{^#{@src_path}\/}, '').gsub(/\.rb$/, '')
+      o = loader.load(ref)
+      # klass = Class.new
+      # o = klass.instance_eval(body, entry[:fn], 1)
 
       if o.is_a?(Papercraft::HTML)
         return wrap_template(o)

data/lib/syntropy/connection_pool.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'extralite'
+
+module Syntropy
+  class ConnectionPool
+    attr_reader :count
+
+    def initialize(machine, fn, max_conn)
+      @machine = machine
+      @fn = fn
+      @count = 0
+      @max_conn = max_conn
+      @queue = UM::Queue.new
+      @key = :"db_#{fn}"
+    end
+
+    def with_db
+      if (db = Thread.current[@key])
+        @machine.snooze
+        return yield(db)
+      end
+
+      db = checkout
+      begin
+        Thread.current[@key] = db
+        yield(db)
+      ensure
+        Thread.current[@key] = nil
+        checkin(db)
+      end
+    end
+
+    private
+
+    def checkout
+      if @queue.count == 0 && @count < @max_conn
+        return create_db
+      end
+
+      @machine.shift(@queue)
+    end
+
+    def checkin(db)
+      @machine.push(@queue, db)
+    end
+
+    def create_db
+      db = Extralite::Database.new(@fn, wal: true)
+      setup_db(db)
+      @count += 1
+      db
+    end
+
+    def setup_db(db)
+      # setup WAL, sync
+      # setup concurrency stuff
+    end
+  end
+end

data/lib/syntropy/file_watch.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Syntropy
+  def self.file_watch(machine, *roots, period: 0.1, &block)
+    raise 'Missing root paths' if roots.empty?
+
+    require 'listen'
+
+    queue = Thread::Queue.new
+    listener = Listen.to(*roots) do |modified, added, removed|
+      fns = (modified + added + removed).uniq
+      fns.each { queue.push(it) }
+    end
+    listener.start
+
+    loop do
+      machine.sleep(period) while queue.empty?
+      fn = queue.shift
+      block.call(fn)
+    end
+  rescue StandardError => e
+    p e
+    p e.backtrace
+  ensure
+    listener.stop
+  end
+end

data/lib/syntropy/module.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Syntropy
+  class ModuleLoader
+    def initialize(root, env)
+      @root = root
+      @env = env
+      @loaded = {}
+    end
+
+    def load(ref)
+      @loaded[ref] ||= load_module(ref)
+    end
+
+    private
+
+    def load_module(ref)
+      fn = File.join(@root, "#{ref}.rb")
+      raise RuntimeError, "File not found #{fn}" if !File.file?(fn)
+
+      mod_body = IO.read(fn)
+      mod_ctx = Class.new(Syntropy::Module)
+      mod_ctx.loader = self
+      # mod_ctx = .new(self, @env)
+      mod_ctx.module_eval(mod_body, fn, 1)
+
+      export_value = mod_ctx.__export_value__
+
+      case export_value
+      when nil
+        raise RuntimeError, 'No export found'
+      when Symbol
+        # TODO: verify export_value denotes a valid method
+        mod_ctx.new(@env)
+      when Proc
+        export_value
+      else
+        export_value.new(@env)
+      end
+    end
+  end
+
+  class Module
+    def initialize(env)
+      @env = env
+    end
+
+    def self.loader=(loader)
+      @loader = loader
+    end
+
+    def self.import(ref)
+      @loader.load(ref)
+    end
+
+    def self.export(ref)
+      @__export_value__ = ref
+    end
+
+    def self.__export_value__
+      @__export_value__
+    end
+  end
+end

data/lib/syntropy/rpc_api.rb

@@ -6,6 +6,10 @@ require 'json'
 
 module Syntropy
   class RPCAPI
+    def initialize(env)
+      @env = env
+    end
+
     def call(req)
       response, status = invoke(req)
       req.respond(

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/lib/syntropy.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 require 'qeweney'
+require 'uringmachine'
+require 'tp2'
 
 require 'syntropy/errors'
-# require 'syntropy/context'
+require 'syntropy/connection_pool'
+require 'syntropy/module'
 require 'syntropy/rpc_api'
 require 'syntropy/app'
 
@@ -57,4 +60,23 @@ class Qeweney::Request
 end
 
 module Syntropy
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  GREEN = "\e[32m"
+  WHITE = "\e[0m"
+  YELLOW = "\e[33m"
+
+  BANNER = (
+    "\n"\
+    "  #{GREEN}\n"\
+    "  #{GREEN} ooo\n"\
+    "  #{GREEN}ooooo\n"\
+    "  #{GREEN} ooo vvv       #{WHITE}Syntropy - a web framework for Ruby\n"\
+    "  #{GREEN}  o vvvvv     #{WHITE}--------------------------------------\n"\
+    "  #{GREEN}  #{YELLOW}|#{GREEN}  vvv o    #{WHITE}https://github.com/noteflakes/syntropy\n"\
+    "  #{GREEN} :#{YELLOW}|#{GREEN}:::#{YELLOW}|#{GREEN}::#{YELLOW}|#{GREEN}:\n"\
+    "  #{YELLOW}++++++++++++\e[0m\n\n"
+  )
 end

data/syntropy.gemspec

@@ -1,32 +1,37 @@
 require_relative './lib/syntropy/version'
 
 Gem::Specification.new do |s|
-  s.version     = Syntropy::VERSION
-  s.licenses    = ['MIT']
-  s.author      = 'Sharon Rosner'
-  s.email       = 'sharon@noteflakes.com'
-  s.files       = `git ls-files`.split
+  s.name        = 'syntropy'
+  s.summary     = 'Syntropic Web Framework'
+  s.version       = Syntropy::VERSION
+  s.licenses      = ['MIT']
+  s.author        = 'Sharon Rosner'
+  s.email         = 'sharon@noteflakes.com'
+  s.files         = `git ls-files`.split
 
-  s.homepage    = 'https://github.com/noteflakes/syntropy'
-  s.metadata    = {
+  s.homepage      = 'https://github.com/noteflakes/syntropy'
+  s.metadata      = {
     'homepage_uri' => 'https://github.com/noteflakes/syntropy',
     'documentation_uri' => 'https://www.rubydoc.info/gems/syntropy',
     'changelog_uri' => 'https://github.com/noteflakes/syntropy/blob/master/CHANGELOG.md'
   }
-  s.rdoc_options = ['--title', 'Extralite', '--main', 'README.md']
+  s.rdoc_options  = ['--title', 'Extralite', '--main', 'README.md']
   s.extra_rdoc_files = ['README.md']
   s.require_paths = ['lib']
-  s.required_ruby_version = '>= 3.2'
+  s.required_ruby_version = '>= 3.4'
+  s.executables = ['syntropy']
 
-  s.add_dependency              'json',                 '2.12.2'
-  s.add_dependency              'qeweney',              '0.21'
-  s.add_dependency              'papercraft',           '1.4'
-  s.add_dependency              'tp2',                  '0.11.3'
-  s.add_dependency              'uringmachine',         '0.14'
+  s.add_dependency 'extralite',     '2.12'
+  s.add_dependency 'json',          '2.12.2'
+  s.add_dependency 'papercraft',    '1.4'
+  s.add_dependency 'qeweney',       '0.21'
+  s.add_dependency 'tp2',           '0.12.2'
+  s.add_dependency 'uringmachine',  '0.15'
 
-  s.add_development_dependency  'minitest',             '5.25.5'
-  s.add_development_dependency  'rake',                 '13.3.0'
+  s.add_dependency 'listen',        '3.9.0'
+  s.add_dependency 'logger',        '1.7.0'
+
+  s.add_development_dependency 'minitest',  '5.25.5'
+  s.add_development_dependency 'rake',      '13.3.0'
 
-  s.name        = 'syntropy'
-  s.summary     = 'Syntropic Web Framework'
 end

data/test/app/_lib/callable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Klass = import '_lib/klass'
+
+def call(x)
+  Klass.foo.to_s * x
+end
+
+def bar
+  @env[:baz]
+end
+
+export :call

data/test/app/_lib/klass.rb

@@ -0,0 +1,15 @@
+class Klass
+  def initialize(env)
+    @env = env
+  end
+
+  def foo
+    :bar
+  end
+
+  def bar
+    @env[:baz]
+  end
+end
+
+export Klass

data/test/app/_lib/missing-export.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Klass = import '_lib/klass'
+
+def call
+  Klass.foo
+end

data/test/app/about/index.rb

@@ -1,3 +1,3 @@
-->(req) {
+export ->(req) {
   req.respond('About')
 }

data/test/app/api+.rb

@@ -1,5 +1,6 @@
 class API < Syntropy::RPCAPI
-  def initialize
+  def initialize(env)
+    super(env)
     @count = 0
   end
 
@@ -9,11 +10,11 @@ class API < Syntropy::RPCAPI
 
   def incr!(req)
     if req.path != '/test/api'
-        raise Syntropy::Error.new(Qeweney::Status::TEAPOT, 'Teapot') 
+        raise Syntropy::Error.new(Qeweney::Status::TEAPOT, 'Teapot')
     end
 
     @count += 1
   end
 end
 
-API.new
+export API

data/test/app/bar.rb

@@ -1,3 +1,3 @@
-->(req) {
+export ->(req) {
   req.respond('foobar')
 }

data/test/app/tmp.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+def call(req)
+  req.respond('foo')
+end
+export :call

data/test/test_app.rb

@@ -6,7 +6,12 @@ class AppRoutingTest < Minitest::Test
   APP_ROOT = File.join(__dir__, 'app')
 
   def setup
-    @app = Syntropy::App.new(APP_ROOT, '/test')
+    @machine = UM.new
+
+    @tmp_path = '/test/tmp'
+    @tmp_fn = File.join(APP_ROOT, "tmp.rb")
+
+    @app = Syntropy::App.new(@machine, APP_ROOT, '/test', watch_files: 0.05)
   end
 
   def full_path(fn)
@@ -100,7 +105,21 @@ class AppRoutingTest < Minitest::Test
 
     req = make_request(':method' => 'GET', ':path' => '/test/about/foo/bar')
     assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+  end
+
+  def test_app_file_watching
+    @machine.sleep 0.2
+
+    req = make_request(':method' => 'GET', ':path' => @tmp_path)
+    assert_equal 'foo', req.response_body
 
+    orig_body = IO.read(@tmp_fn)
+    IO.write(@tmp_fn, orig_body.gsub('foo', 'bar'))
+    @machine.sleep(0.5)
 
+    req = make_request(':method' => 'GET', ':path' => @tmp_path)
+    assert_equal 'bar', req.response_body
+  ensure
+    IO.write(@tmp_fn, orig_body) if orig_body
   end
 end

data/test/test_connection_pool.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ConnectionPoolTest < Minitest::Test
+  def setup
+    @machine = UM.new
+    @fn = "/tmp/#{rand(100000)}.db"
+    @cp = Syntropy::ConnectionPool.new(@machine, @fn, 4)
+
+    FileUtils.rm(@fn) rescue nil
+    @standalone_db = Extralite::Database.new(@fn)
+    @standalone_db.execute("create table foo (x,y, z)")
+    @standalone_db.execute("insert into foo values (1, 2, 3)")
+  end
+
+  def test_with_db
+    assert_equal 0, @cp.count
+
+    @cp.with_db do |db|
+      assert_kind_of Extralite::Database, db
+
+      records = db.query("select * from foo")
+      assert_equal [{x: 1, y: 2, z: 3}], records
+    end
+
+    assert_equal 1, @cp.count
+    @cp.with_db { |db| assert_kind_of Extralite::Database, db }
+    assert_equal 1, @cp.count
+
+    dbs = []
+    ff = (1..2).map { |i|
+      @machine.spin {
+        @cp.with_db { |db|
+          dbs << db
+          @machine.sleep(0.05)
+          db.execute("insert into foo values (?, ?, ?)", i * 10 + 1, i * 10 + 2, i * 10 + 3)
+        }
+      }
+    }
+    @machine.join(*ff)
+
+    assert_equal 2, dbs.size
+    assert_equal 2, dbs.uniq.size
+    assert_equal 2, @cp.count
+
+    records = @standalone_db.query("select * from foo order by x")
+    assert_equal [
+      {x: 1, y: 2, z: 3},
+      {x: 11, y: 12, z: 13},
+      {x: 21, y: 22, z: 23},
+    ], records
+
+
+    dbs = []
+    ff = (1..10).map { |i|
+      @machine.spin {
+        @cp.with_db { |db|
+          dbs << db
+          @machine.sleep(0.05 + rand * 0.05)
+          db.execute("insert into foo values (?, ?, ?)", i * 10 + 1, i * 10 + 2, i * 10 + 3)
+        }
+      }
+    }
+    @machine.join(*ff)
+
+    assert_equal 10, dbs.size
+    assert_equal 4, dbs.uniq.size
+    assert_equal 4, @cp.count
+  end
+
+  def test_with_db_reentrant
+    dbs = @cp.with_db do |db1|
+      @cp.with_db do |db2|
+        [db1, db2]
+      end
+    end
+
+    assert_equal 1, dbs.uniq.size
+  end
+end

data/test/test_file_watch.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'helper'
+
+class FileWatchTest < Minitest::Test
+  def setup
+    @machine = UM.new
+    @root = "/tmp/syntropy/#{rand(1000000).to_s(16)}"
+    FileUtils.mkdir_p(@root)
+  end
+
+  def test_file_watch
+    queue = UM::Queue.new
+
+    f = @machine.spin do
+      Syntropy.file_watch(@machine, @root, period: 0.01) { @machine.push(queue, it) }
+    end
+    @machine.sleep(0.05)
+    assert_equal 0, queue.count
+
+    fn = File.join(@root, 'foo.bar')
+    IO.write(fn, 'abc')
+    assert_equal fn, @machine.shift(queue)
+
+    fn = File.join(@root, 'foo.bar')
+    IO.write(fn, 'def')
+    assert_equal fn, @machine.shift(queue)
+
+    FileUtils.rm(fn)
+    assert_equal fn, @machine.shift(queue)
+  ensure
+    @machine.schedule(f, UM::Terminate)
+    # @machine.join(f)
+  end
+end

data/test/test_module.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ModuleTest < Minitest::Test
+  def setup
+    @machine = UM.new
+    @root = File.join(__dir__, 'app')
+    @env = { baz: 42 }
+    @loader = Syntropy::ModuleLoader.new(@root, @env)
+  end
+
+  def test_module_loading
+    mod = @loader.load('_lib/klass')
+    assert_equal :bar, mod.foo
+    assert_equal 42, mod.bar
+
+    assert_raises(RuntimeError) { @loader.load('_lib/foo') }
+    assert_raises(RuntimeError) { @loader.load('_lib/missing-export') }
+
+    mod = @loader.load('_lib/callable')
+    assert_kind_of Syntropy::Module, mod
+    assert_equal 'barbarbar', mod.call(3)
+    assert_raises(NoMethodError) { mod.foo(2) }
+    assert_equal 42, mod.bar
+
+    mod = @loader.load('_lib/klass')
+    assert_equal :bar, mod.foo
+    @env[:baz] += 1
+    assert_equal 43, mod.bar
+  end
+end

data/test/test_rpc_api.rb

@@ -15,7 +15,7 @@ class RPCAPITest < Minitest::Test
   end
 
   def setup
-    @app = TestAPI.new
+    @app = TestAPI.new({})
   end
 
   def test_rpc_api

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syntropy
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -9,6 +9,20 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: extralite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '2.12'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -23,6 +37,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.12.2
+- !ruby/object:Gem::Dependency
+  name: papercraft
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: qeweney
   requirement: !ruby/object:Gem::Requirement
@@ -38,47 +66,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.21'
 - !ruby/object:Gem::Dependency
-  name: papercraft
+  name: tp2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 0.12.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 0.12.2
 - !ruby/object:Gem::Dependency
-  name: tp2
+  name: uringmachine
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.11.3
+        version: '0.15'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.11.3
+        version: '0.15'
 - !ruby/object:Gem::Dependency
-  name: uringmachine
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.14'
+        version: 1.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.14'
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -108,36 +150,48 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 13.3.0
 email: sharon@noteflakes.com
-executables: []
+executables:
+- syntropy
 extensions: []
 extra_rdoc_files:
 - README.md
 files:
 - ".github/workflows/test.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - TODO.md
+- bin/syntropy
 - lib/syntropy.rb
 - lib/syntropy/app.rb
-- lib/syntropy/context.rb
+- lib/syntropy/connection_pool.rb
 - lib/syntropy/errors.rb
+- lib/syntropy/file_watch.rb
+- lib/syntropy/module.rb
 - lib/syntropy/rpc_api.rb
 - lib/syntropy/version.rb
 - syntropy.gemspec
 - test/app/_layout/default.rb
+- test/app/_lib/callable.rb
+- test/app/_lib/klass.rb
+- test/app/_lib/missing-export.rb
 - test/app/about/foo.md
 - test/app/about/index.rb
 - test/app/api+.rb
 - test/app/assets/style.css
 - test/app/bar.rb
 - test/app/index.html
+- test/app/tmp.rb
 - test/helper.rb
 - test/run.rb
 - test/test_app.rb
+- test/test_connection_pool.rb
+- test/test_file_watch.rb
+- test/test_module.rb
 - test/test_rpc_api.rb
 - test/test_validation.rb
 homepage: https://github.com/noteflakes/syntropy
@@ -158,7 +212,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/syntropy/context.rb

@@ -1,58 +0,0 @@
-# # frozen_string_literal: true
-
-# require 'syntropy/errors'
-
-# module Syntropy
-#   class Context
-#     attr_reader :request
-
-#     def initialize(request)
-#       @request = request
-#     end
-
-#     def params
-#       @request.query
-#     end
-
-#     def validate_param(name, *clauses)
-#       value = @request.query[name]
-#       clauses.each do |c|
-#         valid = param_is_valid?(value, c)
-#         raise(Syntropy::ValidationError, 'Validation error') if !valid
-#         value = param_convert(value, c)
-#       end
-#       value
-#     end
-
-#     BOOL_REGEXP = /^(t|f|true|false|on|off|1|0|yes|no)$/
-#     BOOL_TRUE_REGEXP = /^(t|true|on|1|yes)$/
-#     INTEGER_REGEXP = /^[\+\-]?[0-9]+$/
-#     FLOAT_REGEXP = /^[\+\-]?[0-9]+(\.[0-9]+)?$/
-
-#     def param_is_valid?(value, cond)
-#       if cond == :bool
-#         return (value && value =~ BOOL_REGEXP)
-#       elsif cond == Integer
-#         return (value && value =~ INTEGER_REGEXP)
-#       elsif cond == Float
-#         return (value && value =~ FLOAT_REGEXP)
-#       elsif cond.is_a?(Array)
-#         return cond.any? { |c| param_is_valid?(value, c) }
-#       end
-
-#       cond === value
-#     end
-
-#     def param_convert(value, klass)
-#       if klass == :bool
-#         value = value =~ BOOL_TRUE_REGEXP ? true : false
-#       elsif klass == Integer
-#         value = value.to_i
-#       elsif klass == Float
-#         value = value.to_f
-#       else
-#         value
-#       end
-#     end
-#   end
-# end