yescode 1.0.0

data/lib/yes_record.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+class YesRecord
+  using Refinements
+
+  class QueryNotFound < StandardError; end
+  class RecordNotFound < StandardError; end
+  Column = Struct.new("Column", :name, :type, :primary_key)
+  Query = Struct.new("Query", :name, :sql, :statement)
+
+  class << self
+    attr_writer :table_name
+
+    def table_name
+      @table_name || to_s.snake_case
+    end
+
+    def table(name)
+      @table_name = name
+    end
+
+    def schema
+      @schema ||= Yescode::Database.schema[table_name]
+    end
+
+    def columns
+      @columns ||= schema.map do |r|
+        Column.new(
+          r["columnName"],
+          r["columnType"],
+          r["pk"] == 1
+        )
+      end
+    end
+
+    def column_names
+      @column_names ||= columns.map(&:name)
+    end
+
+    def primary_key_column
+      @primary_key_column ||= columns.find(&:primary_key).first
+    end
+
+    def inspect
+      attr_str = columns.map { |c| "  #{c.name} => #{c.type}" }.join("\n")
+
+      "#{self} {\n#{attr_str}\n}"
+    end
+
+    def connect
+      column_names.each do |column|
+        attr_accessor column.to_sym
+      end
+
+      self
+    end
+
+    def queries(filename)
+      @query_filename = filename
+      filepath = File.join(".", "app", "models", filename)
+      queries = Yescode::Queries.queries(filepath)
+      @queries = {}
+      queries.each do |name, sql|
+        @queries[name] = Query.new(name, sql)
+      end
+
+      @queries
+    end
+
+    def request_cache
+      Yescode::RequestCache.store[table_name] ||= {}
+    end
+
+    def clear_request_cache!
+      Yescode::RequestCache.store[table_name] = nil
+    end
+
+    def execute_query(name, *params)
+      query = @queries[name]
+      key = params
+      request_cache[name] ||= { key => nil }
+
+      raise QueryNotFound, "Can't find a query in #{@query_filename} with name #{name}" unless query
+
+      query.statement ||= Yescode::Database.connection.prepare(query.sql)
+      Yescode::Database.logger&.debug(cached: !request_cache.dig(name, key).nil?, sql: query.sql, params:)
+
+      request_cache[name][key] ||= query.statement.execute(*params).to_a
+    end
+
+    def first(name, *params)
+      row = execute_query(name, *params).first
+
+      new(row) if row
+    end
+
+    def first!(name, *params)
+      row = execute_query(name, *params).first
+
+      raise RecordNotFound unless row
+
+      new(row) if row
+    end
+
+    def select(name, *params)
+      rows = execute_query(name, *params)
+
+      rows.map { |r| new(r) }
+    end
+
+    def all(name = :all, *params)
+      select(name, *params)
+    end
+
+    def value(name, *params)
+      execute_query(name, *params).first&.values&.first
+    end
+
+    def count(name = :count, *params)
+      value(name, *params)
+    end
+
+    def values(keys)
+      if keys.empty?
+        "default values"
+      else
+        "values (#{keys.map(&:inspect).join(', ')})"
+      end
+    end
+
+    def insert_sql(keys)
+      "insert into #{table_name} (#{keys.join(', ')}) #{values(keys)} returning *"
+    end
+
+    def insert(params)
+      params.transform_keys!(&:to_sym)
+      params[:created_at] ||= Time.now.to_i if column_names.include?("created_at")
+      sql = insert_sql(params.keys)
+      inserted = Yescode::Database.get_first_row(sql, params)
+
+      clear_request_cache!
+
+      new(inserted)
+    rescue SQLite3::ConstraintException => e
+      Yescode::Database.logger.error(msg: e.message)
+
+      record = new(params)
+      record.rescue_constraint_error(e)
+
+      record
+    end
+
+    def insert_all
+      # TODO: do it
+    end
+
+    def update_all
+      # TODO: do it
+    end
+
+    def delete_all
+      result = Yescode::Database.execute "delete from #{table_name}"
+      clear_request_cache!
+
+      result
+    end
+  end
+
+  attr_accessor :errors
+
+  def initialize(args = {})
+    self.class.connect
+    load(args)
+  end
+
+  def load(args = {})
+    args.each do |k, v|
+      self.class.attr_accessor(k.to_sym) unless respond_to?(k.to_sym)
+      public_send("#{k}=", v)
+    end
+  end
+
+  def pk_column
+    self.class.primary_key_column.to_sym
+  end
+
+  def pk
+    to_h[pk_column]
+  end
+
+  def pk_param
+    { pk_column => pk }
+  end
+
+  def update_params(params)
+    params.transform_keys!(&:to_sym)
+    params[:updated_at] ||= Time.now.to_i if self.class.column_names.include?("updated_at")
+
+    params
+  end
+
+  def update_sql(keys)
+    set_clause = keys.map { |k| "#{k} = :#{k}" }.join(", ")
+
+    "update #{self.class.table_name} set #{set_clause} where #{pk_column} = :#{pk_column} returning *"
+  end
+
+  def update(params)
+    update_params = update_params(params)
+    sql = update_sql(update_params.keys)
+    update_params.merge!(pk_param)
+    updated = Yescode::Database.get_first_row(sql, update_params)
+    self.class.clear_request_cache!
+    load(updated)
+
+    true
+  rescue SQLite3::ConstraintException => e
+    Yescode::Database.logger.error(msg: e.message)
+    rescue_constraint_error(e)
+
+    false
+  end
+
+  def delete
+    sql = "delete from #{self.class.table_name} where #{pk_column} = ?"
+    Yescode::Database.execute(sql, pk)
+    self.class.clear_request_cache!
+
+    true
+  end
+
+  def check?(constraint_name)
+    return false unless @errors
+
+    @errors[:check]&.include?(constraint_name.to_s)
+  end
+
+  def null?(column_name)
+    return false unless @errors
+
+    @errors[:null]&.include?(column_name.to_s)
+  end
+
+  def duplicate?(column_name)
+    return false unless @errors
+
+    @errors[:unique]&.include?(column_name.to_s)
+  end
+
+  def error?(name)
+    check?(name) || null?(name) || duplicate?(name)
+  end
+
+  def errors?
+    @errors.any?
+  end
+
+  def rescue_constraint_error(error)
+    message = error.message
+    name = message.gsub(/(CHECK|NOT NULL|UNIQUE) constraint failed: (\w+\.)?/, '')
+    @errors ||= { check: [], null: [], unique: [] }
+
+    if message.start_with?("CHECK")
+      @errors[:check] << name
+    elsif message.start_with?("NOT NULL")
+      @errors[:null] << name
+    elsif message.start_with?("UNIQUE")
+      @errors[:unique] << name
+    end
+  end
+
+  def to_h
+    @to_h ||= self.class.column_names.map { |c| [c.to_sym, public_send(c)] }.to_h
+  end
+
+  def saved?
+    !pk.nil?
+  end
+
+  def to_param
+    to_h.slice(self.class.primary_key_column.to_sym)
+  end
+end

data/lib/yes_routes.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class YesRoutes
+  using Refinements
+  class RouteDoesNotExistError < StandardError; end
+  class RouteParamsNilError < StandardError; end
+
+  class << self
+    attr_accessor :routes, :paths
+
+    def match(verb, path_string, class_name, method_name)
+      @paths ||= {}
+      @paths[[class_name, method_name]] = path_string
+
+      @routes ||= Hash.new { |hash, key| hash[key] = [] }
+      @routes[verb] << [path_string, class_name, method_name]
+    end
+
+    def path(class_name, method_name, params = {})
+      path_string = paths[[class_name, method_name]]
+
+      raise RouteParamsNilError, "Route params for :#{class_name}, :#{method_name} cannot be nil" if params.nil?
+
+      params = params.to_param if params.is_a?(YesRecord)
+
+      raise RouteDoesNotExistError, "Route for class #{class_name} and method #{method_name} doesn't exist" unless path_string
+
+      sub_params_in_path(path_string, params)
+    end
+
+    def get(path_string, class_name, method_name)
+      match("GET", path_string, class_name, method_name)
+    end
+
+    def post(path_string, class_name, method_name)
+      match("POST", path_string, class_name, method_name)
+    end
+
+    def resource(path_string, class_name)
+      snake_case = class_name.snake_case
+      [
+        [:get, "index", ""],
+        [:get, "new", "/new"],
+        [:post, "create", "/new"],
+        [:get, "show", "/:#{snake_case}"],
+        [:get, "edit", "/:#{snake_case}/edit"],
+        [:post, "update", "/:#{snake_case}/edit"],
+        [:post, "delete", "/:#{snake_case}/edit"]
+      ].each do |method, method_name, suffix|
+        public_send(method, [path_string, suffix].join("/").gsub(%r{/+}, "/"), class_name, method_name)
+      end
+    end
+
+    private
+
+    def sub_params_in_path(path, params = {})
+      params.transform_keys!(&:inspect)
+
+      re = Regexp.union(params.keys)
+
+      path.gsub(re, params)
+    end
+  end
+end

data/lib/yes_static.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class YesStatic
+  def initialize(app, options = {})
+    @app = app
+    @root = options[:root] || Dir.pwd
+  end
+
+  def call(env)
+    ext = File.extname(env[Rack::PATH_INFO])
+
+    return @app.call(env) if ext.empty?
+
+    filepath = File.join(@root, env[Rack::PATH_INFO])
+
+    if File.exist?(filepath)
+      last_modified = ::File.mtime(filepath).httpdate
+      return [304, {}, []] if env["HTTP_IF_MODIFIED_SINCE"] == last_modified
+
+      [200, { "content-type" => Rack::Mime.mime_type(ext), "last-modified" => last_modified }, File.open(filepath)]
+    else
+      [404, {}, []]
+    end
+  end
+end

data/lib/yes_view.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class YesView
+  using Refinements
+  include Emote::Helpers
+
+  class << self
+    attr_writer :template_path, :layout, :template_name
+    attr_accessor :paths, :logger
+
+    def template_path
+      @template_path || File.join(".", "app", "views")
+    end
+
+    def layout
+      @layout || "layout"
+    end
+
+    def template
+      File.join(template_path, template_name)
+    end
+
+    def view(template_name)
+      @template_name = template_name
+    end
+
+    def template_name
+      @template_name || "#{to_s.snake_case}.emote"
+    end
+  end
+
+  attr_accessor :csrf_name, :csrf_value, :assets, :session, :ajax
+
+  def template
+    self.class.template
+  end
+
+  def render(tmpl, params = {})
+    case tmpl
+    when YesView
+      tmpl.csrf_name = csrf_name
+      tmpl.csrf_value = csrf_value
+      tmpl.session = session
+      tmpl.assets = assets
+      tmpl.ajax = ajax
+      emote(tmpl.template, params, tmpl)
+    when String
+      emote(tmpl, params)
+    else
+      raise StandardError, "Unsupported template type passed to render"
+    end
+  end
+
+  def csrf_field
+    "<input type=\"hidden\" name=\"#{csrf_name}\" value=\"#{csrf_value}\" />"
+  end
+
+  def form(params = {})
+    params = { method: "post" }.merge(params)
+    attr_string = params.map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
+
+    <<~HTML
+      <form #{attr_string}>
+        #{csrf_field}
+    HTML
+  end
+
+  def _form
+    "</form>"
+  end
+
+  def form_link(str, controller_name, method_name, params = {})
+    <<~HTML
+      #{form(action: path(controller_name, method_name, params))}
+        <input type="submit" value="#{str}" />
+      #{_form}
+    HTML
+  end
+
+  def css
+    return [] unless assets
+
+    assets["css"].map { |filename| "/css/#{filename}" }
+  end
+
+  def js
+    return [] unless assets
+
+    assets["js"].map { |filename| "/js/#{filename}" }
+  end
+
+  def path(class_name, method_name, params = {})
+    Object.const_get(:App).path(class_name, method_name, params)
+  end
+
+  def fetch(class_name, method_name, params = {})
+    "<div data-href=\"#{path(class_name, method_name, params)}\"></div>"
+  end
+end

data/lib/yescode/asset.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Yescode
+  class Asset
+    attr_reader :path
+
+    def initialize(filename, path:)
+      @filename = filename
+      @path = path
+    end
+
+    def full_path
+      File.join(path, @filename)
+    end
+
+    def content
+      File.read(full_path)
+    end
+
+    def ext
+      File.extname(@filename)
+    end
+  end
+end

data/lib/yescode/asset_compiler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Yescode
+  class AssetCompiler
+    class << self
+      def compile(assets, ext)
+        # read contents of each file into array of strings
+        combined = StringIO.open do |s|
+          assets[ext].each do |filename|
+            source = File.join(".", "app", ext, filename)
+            s.puts File.read(source)
+          end
+
+          s.string
+        end
+
+        # hash the contents of each concatenated asset
+        hash = Digest::SHA1.hexdigest combined
+
+        # use hash to bust the cache
+        name = "#{hash}.#{ext}"
+        filename = File.join(".", "public", ext, name)
+        FileUtils.mkdir_p(File.join(".", "public", ext))
+
+        # output asset path for browser
+        # returns string of written filename
+        File.write(filename, combined)
+
+        name
+      end
+    end
+  end
+end

data/lib/yescode/assets.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Yescode
+  class Assets
+    def initialize
+      @assets_path = File.join(".", "app")
+      @assets = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def css(filenames = [])
+      @assets["css"] = filenames
+    end
+
+    def js(filenames = [])
+      @assets["js"] = filenames
+    end
+
+    def compile_assets
+      css = AssetCompiler.compile(@assets, "css") unless @assets["css"].empty?
+      js = AssetCompiler.compile(@assets, "js") unless @assets["js"].empty?
+
+      @assets["css"] = [css]
+      @assets["js"] = [js]
+    end
+
+    def to_h
+      @assets
+    end
+  end
+end

data/lib/yescode/database.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Yescode
+  class Database
+    class << self
+      attr_writer :connection_string
+      attr_accessor :logger
+
+      def connection_string
+        @connection_string || ENV["DATABASE_URL"]
+      end
+
+      def connection
+        @connection ||= SQLite3::Database.new(connection_string, { results_as_hash: true })
+      end
+
+      def version(filename)
+        File.basename(filename).split("_").first.to_i
+      end
+
+      def migrate(filenames)
+        execute "create table if not exists yescode_migrations ( version integer primary key )"
+        rows = execute("select version from yescode_migrations").map { |r| r["version"] }
+        file_versions = filenames.map { |f| version(f) }
+
+        return if (file_versions - rows).empty?
+
+        transaction do
+          filenames.each do |filename|
+            version = version(filename)
+            next if rows.include?(version)
+
+            queries = Queries.queries(filename)
+            execute(queries.find { |name, _| name == :up }[1])
+            execute "insert into yescode_migrations (version) values (?)", version
+          end
+        end
+      end
+
+      def rollback_schema(filenames, step: 1)
+        execute "create table if not exists yescode_migrations ( version integer primary key )"
+        rows = execute("select version from yescode_migrations order by version desc limit #{step}").map { |r| r["version"] }
+
+        transaction do
+          rows.each do |row|
+            filename = filenames.find { |f| version(f) == row }
+            version = version(filename)
+            next unless rows.include?(version)
+
+            queries = Queries.queries(filename)
+            execute(queries.find { |name, _| name == :down }[1])
+            execute "delete from yescode_migrations where version = ?", version
+          end
+        end
+      end
+
+      def transaction(mode = :deferred)
+        return yield(connection) if connection.transaction_active?
+
+        execute "begin #{mode} transaction"
+        @abort = false
+        yield self
+
+        true
+      rescue StandardError
+        @abort = true
+        raise
+      ensure
+        if @abort
+          execute "rollback transaction"
+        else
+          execute "commit transaction"
+        end
+      end
+
+      def rollback
+        @abort = true
+      end
+
+      def execute(sql, params = nil)
+        logger&.debug(sql:, params:)
+
+        connection.execute sql, params || []
+      end
+
+      def get_first_value(sql, params = nil)
+        logger&.debug(sql:, params:)
+
+        connection.get_first_value sql, params || []
+      end
+
+      def get_first_row(sql, params = nil)
+        logger&.debug(sql:, params:)
+
+        connection.get_first_row sql, params || []
+      end
+
+      def schema
+        return @schema if @schema
+
+        sql = <<-SQL
+          select
+            m.name as tableName,
+            pti.name as columnName,
+            pti.type as columnType,
+            m.sql as sql,
+            pti.pk as pk
+          from
+            sqlite_master m
+          left outer join
+            pragma_table_info(m.name) pti on pti.name <> m.name
+          where
+            m.type == 'table'
+          order by
+            tableName,
+            columnName
+        SQL
+
+        rows = Database.execute sql
+
+        @schema = rows.group_by do |r|
+          r["tableName"]
+        end
+      end
+    end
+
+    if connection_string && connection
+      execute "PRAGMA journal_model = WAL"
+      execute "PRAGMA foreign_keys = ON"
+      execute "PRAGMA busy_timeout = 5000"
+      execute "PRAGMA synchronous = NORMAL"
+      execute "PRAGMA wal_autocheckpoint = 0"
+      schema
+    end
+  end
+end