syntropy 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9f54331b249d5f3f5b113380173af8e6179590a60ea5f9f3461b1c87f2c4ce53
+  data.tar.gz: f04553e5a04480e9720319a4b93dacdc38e04990a3e60471cf83fde1eea905eb
+SHA512:
+  metadata.gz: 3c749127a9b98be60618f2d82229bcab09894465caebeef37a04672f5456e1480089cbbb9cb662969d024ed64a1657d6e1cbad96af18a2292c2cc5723628e358
+  data.tar.gz: a0ab0555fff735b401204ee54f294c6c009d18d527c938da0ec467f82d0e30ede3e6a8bc76615ef2d8ba5fc01fcd6cd060f3e5522aaf13e69cf6c31fcfaf704b

data/.github/workflows/test.yml

@@ -0,0 +1,34 @@
+name: Tests
+
+on: [push, pull_request]
+
+concurrency:
+  group: tests-${{ format('{0}-{1}', github.head_ref || github.run_number, github.job) }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        # macos-latest uses arm64, macos-13 uses x86
+        os: [ubuntu-latest]
+        ruby: ['3.4', 'head']
+
+    name: ${{matrix.os}}, ${{matrix.ruby}}
+
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+
+    runs-on: ${{matrix.os}}
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{matrix.ruby}}
+        bundler-cache: true # 'bundle install' and cache
+    - name: Run tests
+      # run: bundle exec ruby test/test_um.rb --name test_read_each_raising_2
+      run: bundle exec rake test

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## 0.1 2025-06-17
+
+- Move context inside Request object
+- Implement routing
+- Implement RPC API controller
+- Implement Context with parameter validation
+- Preliminary version

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sharon Rosner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,105 @@
+<h1 align="center">
+  <br>
+  Syntropy
+</h1>
+
+<h4 align="center">A Web Framework for Ruby</h4>
+
+<p align="center">
+  <a href="http://rubygems.org/gems/syntropy">
+    <img src="https://badge.fury.io/rb/syntropy.svg" alt="Ruby gem">
+  </a>
+  <a href="https://github.com/noteflakes/syntropy/actions">
+    <img src="https://github.com/noteflakes/syntropy/actions/workflows/test.yml/badge.svg" alt="Tests">
+  </a>
+  <a href="https://github.com/noteflakes/syntropy/blob/master/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License">
+  </a>
+</p>
+
+## What is Syntropy?
+
+| Syntropy: A tendency towards complexity, structure, order, organization of
+ever more advantageous and orderly patterns.
+
+Syntropy is a WIP web framework for building multi-page and single-page apps.
+Syntropy uses file tree-based routing, and provides controllers for a number of
+common patterns, such as a SPA with client-side rendering, a standard
+server-rendered MPA, a REST API etc.
+
+## Routing
+
+Routing is performed automatically by following the tree structure of the
+Syntropy app. A simple example:
+
+```
+site/
+├ _layout/
+| └ default.rb
+├ _articles/
+| └ 2025-06-01-hello_world.md
+├ api/
+| └ v1.rb
+├ assets/
+| ├ css/
+| ├ img/
+| └ js/
+├ about.md
+├ archive.rb
+├ index.rb
+└ robots.txt
+```
+
+The routing follows the file hierarchy, and Syntropy knows how to serve static
+asset files (CSS, JS, images...) as well as render markdown files and run custom
+Ruby code.
+
+## What does a Syntropic Ruby module look like?
+
+Consider `archive.rb` in the example above. We want to get a list of articles
+and render it with the given layout:
+
+```ruby
+# archive.rb
+@@layout = import('$layout/default')
+
+def articles
+  Syntropy.stamped_file_entries('/_articles')
+end
+
+@@layout.apply(title: 'archive') {
+  div {
+    ul {
+      articles.each { |article|
+        li { a(article.title, href: article.url) }
+      }
+    }
+  }
+}
+```
+
+But a module can be something completely different:
+
+```ruby
+# api/v1.rb
+class APIV1 < Syntropy::RPCAPI
+  def initialize(db)
+    @db = db
+  end
+
+  # /posts
+  def all(req)
+    @db[:posts].order_by(:stamp.desc).to_a
+  end
+
+  def by_id(req)
+    id = req.validate_param(:id, /^{4,32}$/)
+    @db[:posts].where(id: id).first
+  end
+end
+
+APIV1.new(Syntropy.env.open_db)
+```
+
+Basically, the return value of the module is a template or a resource that
+responds to the request.

data/Rakefile

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rake/clean'
+
+task :default => :test
+task :test do
+  exec 'ruby test/run.rb'
+end
+
+task :release do
+  require_relative './lib/syntropy/version'
+  version = Syntropy::VERSION
+  
+  puts 'Building syntropy...'
+  `gem build syntropy.gemspec`
+
+  puts "Pushing syntropy #{version}..."
+  `gem push syntropy-#{version}.gem`
+
+  puts "Cleaning up..."
+  `rm *.gem`
+end

data/TODO.md

@@ -0,0 +1,11 @@
+- More database methods:
+
+  - `Database#quote`
+  - `Database#cache_flush` https://sqlite.org/c3ref/db_cacheflush.html
+  - `Database#release_memory` https://sqlite.org/c3ref/db_release_memory.html
+
+- Security
+
+  - 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.

data/lib/syntropy/app.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'qeweney'
+require 'syntropy/errors'
+require 'json'
+require 'papercraft'
+
+module Syntropy
+  class App
+    attr_reader :route_cache
+
+    def initialize(src_path, mount_path)
+      @src_path = src_path
+      @mount_path = mount_path
+      @route_cache = {}
+
+      @relative_path_re = calculate_relative_path_re(mount_path)
+    end
+
+    def find_route(path, cache: true)
+      cached = @route_cache[path]
+      return cached if cached
+
+      entry = calculate_route(path)
+      if entry[:kind] != :not_found
+        @route_cache[path] = entry if cache
+      end
+      entry
+    end
+
+    def call(req)
+      entry = find_route(req.path)
+      render_entry(req, entry)
+    rescue StandardError => e
+      p e
+      p e.backtrace
+      req.respond(e.message, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
+    end
+
+    private
+
+    def calculate_relative_path_re(mount_path)
+      mount_path = '' if mount_path == '/'
+      /^#{mount_path}(?:\/(.*))?$/
+    end
+
+    FILE_KINDS = {
+      '.rb' => :module,
+      '.md' => :markdown
+    }
+    NOT_FOUND = { kind: :not_found }
+
+    # We don't allow access to path with /.., or entries that start with _
+    FORBIDDEN_RE = /(\/_)|((\/\.\.)\/?)/
+
+    def calculate_route(path)
+      return NOT_FOUND if path =~ FORBIDDEN_RE
+
+      m = path.match(@relative_path_re)
+      return NOT_FOUND if !m
+
+      relative_path = m[1] || ''
+      fs_path = File.join(@src_path, relative_path)
+
+      return file_entry(fs_path) if File.file?(fs_path)
+      return find_index_entry(fs_path) if File.directory?(fs_path)
+
+      entry = find_file_entry_with_extension(fs_path)
+      return entry if entry[:kind] != :not_found
+        
+      find_up_tree_module(path)
+    end
+
+    def file_entry(fn)
+      { fn: fn, kind: FILE_KINDS[File.extname(fn)] || :static }
+    end
+
+    def find_index_entry(dir)
+      find_file_entry_with_extension(File.join(dir, 'index'))
+    end
+
+    def find_file_entry_with_extension(path)
+      fn = "#{path}.html"
+      return file_entry(fn) if File.file?(fn)
+
+      fn = "#{path}.md"
+      return file_entry(fn) if File.file?(fn)
+
+      fn = "#{path}.rb"
+      return file_entry(fn) if File.file?(fn)
+
+      fn = "#{path}+.rb"
+      return file_entry(fn) if File.file?(fn)
+
+      NOT_FOUND
+    end
+
+    def find_up_tree_module(path)
+      parent = parent_path(path)
+      return NOT_FOUND if !parent
+
+      entry = find_route("#{parent}+.rb", cache: false)
+      entry[:kind] == :module ? entry : NOT_FOUND
+    end
+
+    UP_TREE_PATH_RE = /^(.+)?\/[^\/]+$/
+
+    def parent_path(path)
+      m = path.match(UP_TREE_PATH_RE)
+      m && m[1]
+    end
+
+    def render_entry(req, entry)
+      case entry[:kind]
+      when :not_found
+        req.respond('Not found', ':status' => Qeweney::Status::NOT_FOUND)
+      when :static
+        entry[:mime_type] ||= Qeweney::MimeTypes[File.extname(entry[:fn])]
+        req.respond(IO.read(entry[:fn]), 'Content-Type' => entry[:mime_type])
+      when :markdown
+        body = render_markdown(IO.read(entry[:fn]))
+        req.respond(body, 'Content-Type' => 'text/html')
+      when :module
+        call_module(entry, req)
+      else
+        raise "Invalid entry kind"
+      end
+    end
+
+    def call_module(entry, req)
+      entry[:code] ||= load_module(entry)
+      if entry[:code] == :invalid
+        req.respond(nil, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
+        return
+      end
+
+      entry[:code].call(req)
+    rescue StandardError => e
+      p e
+      p e.backtrace
+      req.respond(nil, ':status' => Qeweney::S*tatus::INTERNAL_SERVER_ERROR)
+    end
+
+    def load_module(entry)
+      body = IO.read(entry[:fn])
+      klass = Class.new
+      o = klass.instance_eval(body, entry[:fn], 1)
+
+      if o.is_a?(Papercraft::HTML)
+        return wrap_template(o)
+      else
+        return o
+      end
+    end
+
+    def wrap_template(templ)
+      ->(req) {
+        body = templ.render
+        req.respond(body, 'Content-Type' => 'text/html')
+      }
+    end
+
+    def render_markdown(str)
+      Papercraft.markdown(str)
+    end
+  end
+end

data/lib/syntropy/context.rb

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

data/lib/syntropy/errors.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'qeweney'
+
+module Syntropy
+  class Error < StandardError
+    attr_reader :http_status
+
+    def initialize(status, msg = '')
+      @http_status = status || Qeweney::Status::INTERNAL_SERVER_ERROR
+      super(msg)
+    end
+  end
+
+  class ValidationError < Error
+    def initialize(msg)
+      @http_status = Qeweney::Status::BAD_REQUEST
+    end
+  end
+end

data/lib/syntropy/rpc_api.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'qeweney'
+require 'syntropy/errors'
+require 'json'
+
+module Syntropy
+  class RPCAPI
+    def call(req)
+      response, status = invoke(req)
+      req.respond(
+        response.to_json,
+        ':status'       => status,
+        'Content-Type'  => 'application/json'
+      )
+    end
+
+    def invoke(req)
+      q = req.validate_param(:q, String)
+      response = case req.method
+      when 'get'
+        send(q.to_sym, req)
+      when 'post'
+        send(:"#{q}!", req)
+      else
+        raise Syntropy::Error.new(Qeweney::Status::METHOD_NOT_ALLOWED)
+      end
+      [{ status: 'OK', response: response }, Qeweney::Status::OK]
+    rescue => e
+      if !e.is_a?(Syntropy::Error)
+        p e
+        p e.backtrace
+      end
+      error_response(e)
+    end
+
+    INTERNAL_SERVER_ERROR = Qeweney::Status::INTERNAL_SERVER_ERROR
+
+    def error_response(err)
+      http_status = err.respond_to?(:http_status) ? err.http_status : INTERNAL_SERVER_ERROR
+      error_name = err.class.name
+      [{ status: error_name, message: err.message }, http_status]
+    end
+  end
+end

data/lib/syntropy/version.rb

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

data/lib/syntropy.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'qeweney'
+
+require 'syntropy/errors'
+# require 'syntropy/context'
+require 'syntropy/rpc_api'
+require 'syntropy/app'
+
+class Qeweney::Request
+  def ctx
+    @ctx ||= {}
+  end
+
+  def validate_param(name, *clauses)
+    value = 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
+
+  private
+
+  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
+
+module Syntropy
+end

data/syntropy.gemspec

@@ -0,0 +1,32 @@
+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.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.extra_rdoc_files = ['README.md']
+  s.require_paths = ['lib']
+  s.required_ruby_version = '>= 3.2'
+
+  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_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/_layout/default.rb

@@ -0,0 +1,8 @@
+->(**props) {
+  header {
+    h1 'Foo'
+  }
+  content {
+    emit_yield(**props)
+  }
+}

data/test/app/about/foo.md

@@ -0,0 +1 @@
+Hello from Markdown

data/test/app/about/index.rb

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

data/test/app/api+.rb

@@ -0,0 +1,19 @@
+class API < Syntropy::RPCAPI
+  def initialize
+    @count = 0
+  end
+
+  def get(req)
+    @count
+  end
+
+  def incr!(req)
+    if req.path != '/test/api'
+        raise Syntropy::Error.new(Qeweney::Status::TEAPOT, 'Teapot') 
+    end
+
+    @count += 1
+  end
+end
+
+API.new

data/test/app/assets/style.css

@@ -0,0 +1 @@
+* { color: beige }

data/test/app/bar.rb

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

data/test/app/index.html

@@ -0,0 +1 @@
+<h1>Hello, world!</h1>

data/test/helper.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require_relative './coverage' if ENV['COVERAGE']
+require 'uringmachine'
+require 'syntropy'
+require 'qeweney/mock_adapter'
+require 'minitest/autorun'
+
+STDOUT.sync = true
+STDERR.sync = true
+
+module ::Kernel
+  def mock_req(**args)
+    Qeweney::MockAdapter.mock(**args)
+  end
+
+  def capture_exception
+    yield
+  rescue Exception => e
+    e
+  end
+
+  def debug(**h)
+    k, v = h.first
+    h.delete(k)
+
+    rest = h.inject(+'') { |s, (k, v)| s << "  #{k}: #{v.inspect}\n" }
+    STDOUT.orig_write("#{k}=>#{v} #{caller[0]}\n#{rest}")
+  end
+
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+
+  def monotonic_clock
+    ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+  end
+end
+
+module Minitest::Assertions
+  def assert_in_range exp_range, act
+    msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
+    assert exp_range.include?(act), msg
+  end
+
+  def assert_response exp_body, exp_content_type, req
+    status = req.response_status
+    msg = message(msg) { "Expected HTTP status 200 OK, but instead got #{status}" }
+    assert_equal 200, status, msg
+
+    actual = req.adapter.body
+    assert_equal exp_body.gsub("\n", ''), actual&.gsub("\n", '')
+
+    return unless exp_content_type
+
+    if Symbol === exp_content_type
+      exp_content_type = Qeweney::MimeTypes[exp_content_type]
+    end
+    actual = req.response_content_type
+    assert_equal exp_content_type, actual
+  end
+end
+
+# Extensions to be used in conjunction with `Qeweney::TestAdapter`
+class Qeweney::Request
+  def response_headers
+    adapter.headers
+  end
+
+  def response_status
+    adapter.status
+  end
+
+  def response_body
+    adapter.body
+  end
+
+  def response_json
+    raise if response_content_type != 'application/json'
+    JSON.parse(response_body, symbolize_names: true)
+  end
+
+  def response_content_type
+    response_headers['Content-Type']
+  end
+end
+
+# puts "Polyphony backend: #{Thread.current.backend.kind}"

data/test/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{__dir__}/test_*.rb").each do |path|
+  require(path)
+end

data/test/test_app.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class AppRoutingTest < Minitest::Test
+  APP_ROOT = File.join(__dir__, 'app')
+
+  def setup
+    @app = Syntropy::App.new(APP_ROOT, '/test')
+  end
+
+  def full_path(fn)
+    File.join(APP_ROOT, fn)
+  end
+
+  def test_find_route
+    entry = @app.find_route('/')
+    assert_equal :not_found, entry[:kind]
+
+    entry = @app.find_route('/test')
+    assert_equal :static, entry[:kind]
+    assert_equal full_path('index.html'), entry[:fn]
+
+    entry = @app.find_route('/test/about')
+    assert_equal :module, entry[:kind]
+    assert_equal full_path('about/index.rb'), entry[:fn]
+
+    entry = @app.find_route('/test/../test_app.rb')
+    assert_equal :not_found, entry[:kind]
+
+    entry = @app.find_route('/test/_layout/default')
+    assert_equal :not_found, entry[:kind]
+
+    entry = @app.find_route('/test/api')
+    assert_equal :module, entry[:kind]
+    assert_equal full_path('api+.rb'), entry[:fn]
+
+    entry = @app.find_route('/test/api/foo/bar')
+    assert_equal :module, entry[:kind]
+    assert_equal full_path('api+.rb'), entry[:fn]
+
+    entry = @app.find_route('/test/api/foo/../bar')
+    assert_equal :not_found, entry[:kind]
+
+    entry = @app.find_route('/test/api_1')
+    assert_equal :not_found, entry[:kind]
+
+    entry = @app.find_route('/test/about/foo')
+    assert_equal :markdown, entry[:kind]
+    assert_equal full_path('about/foo.md'), entry[:fn]
+  end
+
+  def make_request(*, **)
+    req = mock_req(*, **)
+    @app.call(req)
+    req
+  end
+
+  def test_app_rendering
+    req = make_request(':method' => 'GET', ':path' => '/')
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = make_request(':method' => 'GET', ':path' => '/test')
+    assert_equal Qeweney::Status::OK, req.response_status
+    assert_equal '<h1>Hello, world!</h1>', req.response_body
+
+    req = make_request(':method' => 'GET', ':path' => '/test/index')
+    assert_equal '<h1>Hello, world!</h1>', req.response_body
+
+    req = make_request(':method' => 'GET', ':path' => '/test/index.html')
+    assert_equal '<h1>Hello, world!</h1>', req.response_body
+
+    req = make_request(':method' => 'GET', ':path' => '/test/assets/style.css')
+    assert_equal '* { color: beige }', req.response_body
+
+    req = make_request(':method' => 'GET', ':path' => '/assets/style.css')
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = make_request(':method' => 'GET', ':path' => '/test/api?q=get')
+    assert_equal({ status: 'OK', response: 0 }, req.response_json)
+
+    req = make_request(':method' => 'GET', ':path' => '/test/api/foo?q=get')
+    assert_equal({ status: 'OK', response: 0 }, req.response_json)
+
+    req = make_request(':method' => 'POST', ':path' => '/test/api?q=incr')
+    assert_equal({ status: 'OK', response: 1 }, req.response_json)
+
+    req = make_request(':method' => 'POST', ':path' => '/test/api/foo?q=incr')
+    assert_equal({ status: 'Syntropy::Error', message: 'Teapot' }, req.response_json)
+    assert_equal Qeweney::Status::TEAPOT, req.response_status
+
+    req = make_request(':method' => 'GET', ':path' => '/test/bar')
+    assert_equal 'foobar', req.response_body
+
+    req = make_request(':method' => 'GET', ':path' => '/test/about')
+    assert_equal 'About', req.response_body.chomp
+
+    req = make_request(':method' => 'GET', ':path' => '/test/about/foo')
+    assert_equal '<p>Hello from Markdown</p>', req.response_body.chomp
+
+    req = make_request(':method' => 'GET', ':path' => '/test/about/foo/bar')
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+
+  end
+end

data/test/test_rpc_api.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class RPCAPITest < Minitest::Test
+  class TestAPI < Syntropy::RPCAPI
+    def get(req)
+      @value
+    end
+
+    def set!(req)
+      @value = req.query[:v]
+      true
+    end
+  end
+
+  def setup
+    @app = TestAPI.new
+  end
+
+  def test_rpc_api
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    @app.call(req)
+    assert_equal Qeweney::Status::BAD_REQUEST, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/?q=get')
+    @app.call(req)
+    assert_equal Qeweney::Status::OK, req.response_status
+    assert_equal({ status: 'OK', response: nil }, req.response_json)
+
+    req = mock_req(':method' => 'POST', ':path' => '/?q=set&v=foo')
+    @app.call(req)
+    assert_equal Qeweney::Status::OK, req.response_status
+    assert_equal({ status: 'OK', response: true }, req.response_json)
+
+    req = mock_req(':method' => 'GET', ':path' => '/?q=get')
+    @app.call(req)
+    assert_equal Qeweney::Status::OK, req.response_status
+    assert_equal({ status: 'OK', response: 'foo' }, req.response_json)
+  end
+end

data/test/test_validation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ValidationTest < Minitest::Test
+  def setup
+    @req = mock_req(':method' => 'GET', ':path' => '/foo?q=foo&x=bar&y=123&z1=t&z2=f')
+  end
+
+  VE = Syntropy::ValidationError
+
+  def test_validate_param
+    assert_nil @req.validate_param(:azerty, nil)
+    assert_equal 'foo', @req.validate_param(:q)
+    assert_equal 'foo', @req.validate_param(:q, String)
+    assert_equal 'foo', @req.validate_param(:q, [String, nil])
+    assert_nil @req.validate_param(:r, [String, nil])
+
+    assert_equal 123, @req.validate_param(:y, Integer)
+    assert_equal 123, @req.validate_param(:y, Integer, 120..125)
+    assert_equal 123.0, @req.validate_param(:y, Float)
+
+    assert_equal true, @req.validate_param(:z1, :bool)
+    assert_equal false, @req.validate_param(:z2, :bool)
+
+    assert_raises(VE) { @req.validate_param(:azerty, String) }
+    assert_raises(VE) { @req.validate_param(:q, Integer) }
+    assert_raises(VE) { @req.validate_param(:q, Float) }
+    assert_raises(VE) { @req.validate_param(:q, nil) }
+    
+    assert_raises(VE) { @req.validate_param(:y, Integer, 1..100) }
+
+    assert_raises(VE) { @req.validate_param(:y, :bool) }
+  end
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: syntropy
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Sharon Rosner
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+- !ruby/object:Gem::Dependency
+  name: qeweney
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !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: tp2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: uringmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.25.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.25.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 13.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 13.3.0
+email: sharon@noteflakes.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".github/workflows/test.yml"
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- TODO.md
+- lib/syntropy.rb
+- lib/syntropy/app.rb
+- lib/syntropy/context.rb
+- lib/syntropy/errors.rb
+- lib/syntropy/rpc_api.rb
+- lib/syntropy/version.rb
+- syntropy.gemspec
+- test/app/_layout/default.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/helper.rb
+- test/run.rb
+- test/test_app.rb
+- test/test_rpc_api.rb
+- test/test_validation.rb
+homepage: https://github.com/noteflakes/syntropy
+licenses:
+- MIT
+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
+rdoc_options:
+- "--title"
+- Extralite
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: Syntropic Web Framework
+test_files: []