fresco 0.0.1

data/lib/fresco/templates/model.rb.erb

@@ -0,0 +1,223 @@
+# Fresco: <%= model_name %> model. Auto-generated by bin/build from
+# db/schema.rb + app/models/<%= file_stem %>.rb. Do not edit.
+#
+# Source of truth lives in lib/templates/model.rb.erb; per-build
+# SQL strings are interpolated for the configured adapter
+# (<%= adapter %>) below.
+#
+# Spinel-shape contract for every generated method:
+#   - Positional + defaulted params everywhere; no required kwargs.
+#   - Attribute readers return one type per column (no nullable
+#     widening — nullable cols return the zero value, matching the
+#     Tep / Fresco convention from M1).
+#   - Finders return Array<<%= model_name %>>. The Array is seeded
+#     with a fresh instance and immediately cleared so Spinel pins
+#     it to the typed Array class on assignment.
+#   - .find always returns a <%= model_name %> instance. Missing rows
+#     come back with `found?` false rather than `nil` — return-type
+#     unions widen the whole dispatch chain to RbVal.
+#   - Prepared-statement cache (M6): every method uses
+#     `Fresco::Db.cached_prepare` and DOES NOT call `finalize`. The
+#     cursor lives for the process lifetime; subsequent calls reset
+#     instead of re-preparing. Ad-hoc handler code outside the model
+#     layer still uses `prepare` + `finalize` as before.
+
+class <%= model_name %>
+<% columns.each do |c| -%>
+  attr_reader :<%= c[:name] %>
+<% end -%>
+  attr_reader :found
+
+  # Positional ctor — kwargs without defaults collapse to mrb_int
+  # under Spinel (see [[spinel_initialize_kwargs]]), so we default
+  # every param to the zero value of its column type. The `found`
+  # flag distinguishes a hydrated row from a default-constructed
+  # placeholder returned by `.find` when the id misses.
+  def initialize(<%= ctor_params %>)
+<% columns.each do |c| -%>
+    @<%= c[:name] %> = <%= c[:name] %>
+<% end -%>
+    @found = found
+  end
+
+  def found?
+    @found
+  end
+
+  # ---- Class-level finders ----------------------------------------
+
+  # Single-row lookup by primary key. Returns a <%= model_name %>
+  # instance; check `.found?` to distinguish hit from miss.
+  def self.find(<%= pk_param %>)
+    cid = Fresco::Db.cached_prepare("<%= select_by_pk_sql %>")
+    if cid < 0
+      return <%= model_name %>.new
+    end
+    Fresco::Db.bind_int(cid, 1, <%= pk_name %>, "<%= pk_name %>")
+    if Fresco::Db.step(cid) == 1
+      return <%= model_name %>.new(<%= row_ctor_args %>, true)
+    end
+    <%= model_name %>.new
+  end
+
+  # Fetch every row in <%= table_name %>. Ordered by primary key for
+  # deterministic output across calls.
+  def self.all
+    out = [<%= model_name %>.new]
+    out.delete_at(0)
+    cid = Fresco::Db.cached_prepare("<%= select_all_sql %>")
+    return out if cid < 0
+    while Fresco::Db.step(cid) == 1
+      out.push(<%= model_name %>.new(<%= row_ctor_args %>, true))
+    end
+    out
+  end
+
+<% finders.each do |f| -%>
+  # `where_<%= f[:name] %>` — generated because `finder :<%= f[:name] %>`
+  # was declared in app/models/<%= file_stem %>.rb. Returns every
+  # matching row as Array<<%= model_name %>>.
+  def self.where_<%= f[:name] %>(<%= f[:name] %> = <%= f[:default] %>)
+    out = [<%= model_name %>.new]
+    out.delete_at(0)
+    cid = Fresco::Db.cached_prepare("<%= f[:sql] %>")
+    return out if cid < 0
+    <%= f[:bind_call] %>
+    while Fresco::Db.step(cid) == 1
+      out.push(<%= model_name %>.new(<%= row_ctor_args %>, true))
+    end
+    out
+  end
+
+  # `count_where_<%= f[:name] %>` — row count for the same predicate
+  # as where_<%= f[:name] %>. Cheaper than materialising the full
+  # Array when you only need the size.
+  def self.count_where_<%= f[:name] %>(<%= f[:name] %> = <%= f[:default] %>)
+    cid = Fresco::Db.cached_prepare("<%= f[:count_sql] %>")
+    return 0 if cid < 0
+    <%= f[:bind_call] %>
+    n = 0
+    if Fresco::Db.step(cid) == 1
+      n = Fresco::Db.col_int(cid, 0)
+    end
+    n
+  end
+
+<% if f[:unique] -%>
+  # `find_by_<%= f[:name] %>` — emitted because the column is declared
+  # `index: :unique` in db/schema.rb. Same single-row contract as
+  # `find`: always returns a <%= model_name %> instance; check
+  # `.found?` to distinguish hit from miss.
+  def self.find_by_<%= f[:name] %>(<%= f[:name] %> = <%= f[:default] %>)
+    cid = Fresco::Db.cached_prepare("<%= f[:sql] %>")
+    if cid < 0
+      return <%= model_name %>.new
+    end
+    <%= f[:bind_call] %>
+    if Fresco::Db.step(cid) == 1
+      return <%= model_name %>.new(<%= row_ctor_args %>, true)
+    end
+    <%= model_name %>.new
+  end
+
+<% end -%>
+<% end -%>
+
+  # Total row count for the table. Returns 0 on a fresh DB or if the
+  # connection isn't usable.
+  def self.count
+    cid = Fresco::Db.cached_prepare("<%= count_sql %>")
+    return 0 if cid < 0
+    n = 0
+    if Fresco::Db.step(cid) == 1
+      n = Fresco::Db.col_int(cid, 0)
+    end
+    n
+  end
+
+
+  # `insert(<%= insert_kwarg_signature %>)` — class method to create a
+  # new row. Returns the new primary-key id (or -1 on failure). The
+  # ergonomic kwargs form converts to positional internally so the
+  # underlying call stays monomorphic.
+  def self.insert(<%= insert_kwargs %>)
+<% validators.each do |v| -%>
+    # validates :<%= v[:column] %>, presence: true
+    return -1 if <%= v[:guard] %>
+<% end -%>
+    cid = Fresco::Db.cached_prepare("<%= insert_sql %>")
+    return -1 if cid < 0
+<% insert_bind_lines.each do |line| -%>
+    <%= line %>
+<% end -%>
+<% if adapter == :postgres -%>
+    new_id = -1
+    if Fresco::Db.step(cid) == 1
+      new_id = Fresco::Db.col_int(cid, 0)
+    end
+    new_id
+<% else -%>
+    Fresco::Db.step(cid)
+    Fresco::Db.last_rowid
+<% end -%>
+  end
+
+  # `Model.query(sql, [bindings])` — escape hatch for one-off
+  # queries the codegen doesn't cover. Bindings is an Array of Str;
+  # bind_int callers should `.to_s` first. Returns Array<<%= model_name %>>.
+  # Each row materialises through the same ctor as the generated
+  # finders, so column count + order must match the SELECT.
+  #
+  # The escape hatch uses `prepare` + `finalize` rather than the
+  # cache — query text is caller-supplied and may be unique per call,
+  # so caching it would just fill the slot table with cold entries.
+  def self.query(sql = "", bindings = [""])
+    out = [<%= model_name %>.new]
+    out.delete_at(0)
+    cid = Fresco::Db.prepare(sql)
+    return out if cid < 0
+    i = 0
+    while i < bindings.length
+      Fresco::Db.bind_str(cid, i + 1, bindings[i])
+      i += 1
+    end
+    while Fresco::Db.step(cid) == 1
+      out.push(<%= model_name %>.new(<%= row_ctor_args %>, true))
+    end
+    Fresco::Db.finalize(cid)
+    out
+  end
+
+  # ---- Instance methods -------------------------------------------
+
+  # `user.update(<%= update_kwarg_signature %>)` — overwrite every
+  # column on the row matching @<%= pk_name %>. Returns true on
+  # success. Caller-supplied values fully replace existing ones;
+  # there is no partial-update form in M3 (each generated finder
+  # needs static SQL — see [[spinel_poly_hash_aset]]).
+  def update(<%= update_kwargs %>)
+<% validators.each do |v| -%>
+    # validates :<%= v[:column] %>, presence: true
+    return false if <%= v[:guard] %>
+<% end -%>
+    cid = Fresco::Db.cached_prepare("<%= update_sql %>")
+    return false if cid < 0
+<% update_bind_lines.each do |line| -%>
+    <%= line %>
+<% end -%>
+    Fresco::Db.bind_int(cid, <%= update_bind_lines.length + 1 %>, @<%= pk_name %>, "<%= pk_name %>")
+    Fresco::Db.step(cid)
+    true
+  end
+
+  # `user.delete` — remove the row matching @<%= pk_name %>. Returns
+  # true on success. No cascade; foreign-key cascades are an M4+
+  # schema concern.
+  def delete
+    cid = Fresco::Db.cached_prepare("<%= delete_sql %>")
+    return false if cid < 0
+    Fresco::Db.bind_int(cid, 1, @<%= pk_name %>, "<%= pk_name %>")
+    Fresco::Db.step(cid)
+    true
+  end
+end

data/lib/fresco/templates/view.rb.erb

@@ -0,0 +1,5 @@
+# Fresco: compiled view <%= rel %>. Auto-generated by bin/build; do not edit.
+
+def render_<%= name %><%= signature %>
+  <%= src %>
+end

data/lib/fresco/version.rb

@@ -0,0 +1,3 @@
+module Fresco
+  VERSION = "0.0.1"
+end

data/lib/fresco.rb

@@ -0,0 +1,61 @@
+# Fresco: build-time entry point. Required by `fresco build` before
+# config/routes.rb is evaluated. The DSL captured here is read back
+# out as data for codegen — nothing in this file runs at runtime,
+# so it can use ordinary Ruby (instance_eval, blocks, etc.) without
+# the Spinel-subset constraints user code has to live within.
+#
+# Apps consume the gem (`require "fresco"`) and never load the internal
+# files directly; everything below is the public DSL surface.
+
+require "fresco/version"
+require "fresco/paths"
+
+module Fresco
+  def self.app
+    @app ||= Application.new
+  end
+
+  # --- Build-time naming helpers ----------------------------------
+  #
+  # File paths under app/actions/ map to Ruby constants by segment:
+  # "users/show" → "Users::Show", "admin/api/sessions/new" →
+  # "Admin::Api::Sessions::New". Each path segment is split on
+  # underscores and CamelCased; "::" joins the segments back.
+  #
+  # `const_set_path` exists because `Object.const_set` only accepts
+  # a bare name — passing "Users::Show" raises. We walk the
+  # namespace, creating Module shells where missing, then set the
+  # leaf constant on the resolved parent.
+
+  def self.path_to_class(file, root)
+    rel = file.sub(%r{\A#{Regexp.escape(root)}/?}, "").sub(/\.rb\z/, "")
+    rel.split("/").map { |seg| seg.split("_").map(&:capitalize).join }.join("::")
+  end
+
+  def self.class_to_path(name)
+    name.split("::").map { |seg| seg.gsub(/([a-z0-9])([A-Z])/, '\1_\2').downcase }.join("/")
+  end
+
+  def self.const_set_path(path, value)
+    parts = path.split("::")
+    parent = parts[0...-1].inject(Object) do |mod, seg|
+      if mod.const_defined?(seg, false)
+        mod.const_get(seg, false)
+      else
+        mod.const_set(seg, Module.new)
+      end
+    end
+    parent.const_set(parts.last, value) unless parent.const_defined?(parts.last, false)
+  end
+
+  def self.const_get_path(path)
+    path.split("::").inject(Object) { |mod, seg| mod.const_get(seg, false) }
+  end
+end
+
+require "fresco/application"
+require "fresco/router"
+require "fresco/database_config"
+require "fresco/schema_builder"
+require "fresco/model_builder"
+require "fresco/migration_builder"

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: fresco
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrea Fomera
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: herb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Build-time DSL (routes, schema, models, migrations), codegen pipeline,
+  CRuby dev loop, and a `fresco new` generator. Targets Spinel for release builds.
+email:
+- afomera@hey.com
+executables:
+- fresco
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/fresco
+- lib/fresco.rb
+- lib/fresco/application.rb
+- lib/fresco/cli.rb
+- lib/fresco/cli/build.rb
+- lib/fresco/cli/dev.rb
+- lib/fresco/cli/dev_loop.rb
+- lib/fresco/cli/new.rb
+- lib/fresco/cli/release.rb
+- lib/fresco/database_config.rb
+- lib/fresco/generators/app/Gemfile.tt
+- lib/fresco/generators/app/README.md.tt
+- lib/fresco/generators/app/app.rb.tt
+- lib/fresco/generators/app/app/action.rb.tt
+- lib/fresco/generators/app/app/actions/root_path.rb.tt
+- lib/fresco/generators/app/app/views/layouts/application.html.erb
+- lib/fresco/generators/app/app/views/root_path.html.erb
+- lib/fresco/generators/app/bin/build
+- lib/fresco/generators/app/bin/dev
+- lib/fresco/generators/app/bin/release
+- lib/fresco/generators/app/config/app.rb.tt
+- lib/fresco/generators/app/config/database.rb
+- lib/fresco/generators/app/config/routes.rb
+- lib/fresco/generators/app/db/schema.rb
+- lib/fresco/generators/app/public/404.html
+- lib/fresco/generators/app/public/500.html
+- lib/fresco/migration_builder.rb
+- lib/fresco/model_builder.rb
+- lib/fresco/paths.rb
+- lib/fresco/router.rb
+- lib/fresco/runtime/boot.rb
+- lib/fresco/runtime/db_postgres.rb
+- lib/fresco/runtime/db_sqlite.rb
+- lib/fresco/runtime/http.c
+- lib/fresco/runtime/postgres.c
+- lib/fresco/runtime/runtime.rb
+- lib/fresco/runtime/sqlite.c
+- lib/fresco/runtime/welcome.rb
+- lib/fresco/schema_builder.rb
+- lib/fresco/templates/dispatch.rb.erb
+- lib/fresco/templates/layout_dispatch.rb.erb
+- lib/fresco/templates/manifest.rb.erb
+- lib/fresco/templates/migrations.rb.erb
+- lib/fresco/templates/model.rb.erb
+- lib/fresco/templates/view.rb.erb
+- lib/fresco/version.rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Fresco — an application framework that compiles to a static binary via Spinel.
+test_files: []