itsi 0.1.11 → 0.1.12

data/location_dsl.rb

@@ -1,381 +0,0 @@
-class RouterDSL
-  attr_reader :parent, :children, :filters, :endpoint_defs, :controller_class
-
-  def initialize(parent = nil, route_specs = [], &block)
-    @parent           = parent
-    @children         = []
-    @filters          = {}
-    @endpoint_defs    = [] # Each is [subpath, *endpoint_args]
-    @controller_class = nil
-
-    # We'll store our array of route specs (strings or a single Regexp).
-    @route_specs = Array(route_specs).flatten
-
-    validate_path_specs!(@route_specs)
-
-    instance_eval(&block) if block_given?
-  end
-
-  ################################
-  # DSL: location
-  ################################
-
-  # location can accept multiple strings (and at most one Regexp).
-  # E.g.: location '/foo', '/bar/:id(\d+)' do ... end
-  def location(*route_specs, &block)
-    route_specs = route_specs.flatten
-    child = RouterDSL.new(self, route_specs, &block)
-    @children << child
-  end
-
-  # define endpoints
-  def endpoint(subpath, *args)
-    @endpoint_defs << [subpath, *args]
-  end
-
-  def controller(klass)
-    @controller_class = klass
-  end
-
-  # define some filters
-  def basic_auth(**args)
-    @filters[:basic_auth] = args
-  end
-
-  # define some filters
-  def redirect(**args)
-    @filters[:redirect] = args
-  end
-
-  def jwt_auth(**args)
-    @filters[:jwt_auth] = args
-  end
-
-  def api_key_auth(**args)
-    @filters[:api_key_auth] = args
-  end
-
-  def compress(**args)
-    @filters[:compress] = args
-  end
-
-  def rate_limit(name, **args)
-    @filters[:rate_limit] = { name: name }.merge(args)
-  end
-
-  def cors(**args)
-    @filters[:cors] = args
-  end
-
-  def file_server(**args)
-    @filters[:file_server] = args
-  end
-
-  ################################
-  # Flattening logic
-  ################################
-
-  def flatten_routes
-    # We produce an array of route-hashes:
-    #   { route: Regexp, filters: [ {type:, params:}, ... ] }
-    #
-    # The order: children first (most specific), then endpoints, then the location route.
-
-    # 1) Flatten children (most specific first)
-    child_routes = @children.flat_map(&:flatten_routes)
-
-    # 2) Build the expansions for the "parent portion" (this location) → we'll call them "my_base_expansions"
-    #    That is effectively the parent's expansions combined with mine (OR pattern).
-    my_base_expansions = combined_paths_from_parent
-
-    # 3) Endpoint routes: for each endpoint subpath, produce a single OR pattern that covers
-    #    (base expansions) x (endpoint expansion).
-    endpoint_routes = @endpoint_defs.map do |(endpoint_subpath, *endpoint_args)|
-      # Expand subpath
-      ep_expansions = expand_single_subpath(endpoint_subpath)
-
-      # Combine base expansions with endpoint expansions in a cartesian product, then OR them
-      final_regex_str = or_pattern_for(cartesian_combine(my_base_expansions, ep_expansions))
-
-      {
-        route: Regexp.new("^#{final_regex_str}$"),
-        filters: effective_filters_with_endpoint(endpoint_args)
-      }
-    end
-
-    # 4) A route for this location block itself (without subpaths).
-    #    The OR pattern for my_base_expansions (like '^/(?:foo|bar)$' ).
-    #    If I have route specs, we produce that route. If you want a route even with no route_specs, adapt.
-    location_route = unless @route_specs.empty?
-                       pattern_str = or_pattern_for(my_base_expansions) # the expansions themselves
-                       {
-                         route: Regexp.new("^#{pattern_str}$"),
-                         filters: effective_filters
-                       }
-                     end
-
-    # Final array: child routes first, then endpoints, then my location route
-    result = []
-    result.concat(child_routes)
-    result.concat(endpoint_routes)
-    result << location_route if location_route
-    result
-  end
-
-  ################################
-  # Helpers
-  ################################
-
-  def validate_path_specs!(specs)
-    # 1) If there's more than one raw Ruby Regexp, raise an error
-    # 2) If there's 1 raw Ruby Regexp + anything else, also raise an error
-    # 3) We can allow *multiple strings*, but if any is a Regexp => can't nest children
-    #    We'll actually raise an error if the user tries to create children anyway.
-    regexes = specs.select { |s| s.is_a?(Regexp) }
-    return unless regexes.size > 1
-
-    raise ArgumentError, 'Cannot have multiple raw Regex route specs in a single location.'
-  end
-
-  # Called by flatten_routes to get expansions from the parent's expansions combined with mine
-  def combined_paths_from_parent
-    if parent
-      # get parent's expansions
-      pex = parent.combined_paths_from_parent_for_children
-      # combine with my route specs
-      cartesian_combine(pex, expansions_for(@route_specs))
-    else
-      # top-level: no parent expansions
-      expansions_for(@route_specs)
-    end
-  end
-
-  # If the parent is a raw Regexp route, that parent wouldn't allow children anyway.
-  # But let's define a method the child uses:
-  def combined_paths_from_parent_for_children
-    # The parent's "my_base_expansions" is the expansions from the parent's route specs,
-    # ignoring endpoints. Because a parent's endpoints produce *its own* routes, not expansions for children.
-    parent ? parent.combined_paths_from_parent_for_children : [] # recursion upward
-  end
-
-  # We override that in a simpler way so it includes the parent's expansions.
-  # But to keep it straightforward, we'll store our expansions so children can see them.
-
-  def combined_paths_from_parent_for_children
-    # For me, the expansions are expansions_for(@route_specs) combined with parent's expansions
-    # if there is one. (Essentially the same logic as combined_paths_from_parent,
-    # but we do it for the child's perspective.)
-    if parent
-      pex = parent.combined_paths_from_parent_for_children
-      cartesian_combine(pex, expansions_for(@route_specs))
-    else
-      expansions_for(@route_specs)
-    end
-  end
-
-  # Given a single subpath from an endpoint call (a string or a "*"), produce expansions
-  def expand_single_subpath(subpath)
-    expansions_for([subpath]) # just treat it as a mini specs array
-  end
-
-  # Turn an array of specs (strings or at most one Regexp) into an array of expansions (strings).
-  # If there's exactly one raw Regexp, we store a single special marker that indicates "raw regexp".
-  def expansions_for(specs)
-    return [] if specs.empty?
-
-    # If we have a single raw Ruby Regexp, we do not expand it further;
-    # but that also means no nesting is allowed. We just store that "as-is".
-    if specs.any? { |s| s.is_a? Regexp }
-      # Return something that indicates we have a raw Regexp route:
-      # We'll store it as an array with one element `[:raw_regex, that_regexp]`
-      # so cartesian_combine logic can handle it specially.
-      # Let's say we raise if there's more than one
-      raise 'Cannot combine a raw Regexp with other strings in the same location.' if specs.size > 1
-
-      [[:raw_regex, specs.first]]
-    else
-      # We have multiple strings. Convert each to a "fully expanded" sub-regex piece,
-      # but do NOT add ^...$ here. We'll do that later.
-      # We'll simply store them as strings in "regex-ready" form, i.e. leading slash is included if needed.
-      # Actually we only produce the "inner piece" so we can do `^(?: piece1 | piece2 )$`.
-      specs.map do |string_spec|
-        # remove leading slash
-        string_spec = string_spec.sub(%r{^/}, '')
-        # if empty => it means "/", so let's keep it blank
-        string_spec
-      end
-    end
-  end
-
-  # Combine two arrays of expansions in a cartesian way.
-  # If either array has a raw_regexp, we raise if the other is non-empty or also raw.
-  # If both are pure string expansions, we produce new expansions for each combination.
-  def cartesian_combine(parent_exps, child_exps)
-    return child_exps if parent_exps.empty?
-    return parent_exps if child_exps.empty?
-
-    # If parent_exps has raw_regexp
-    if parent_exps.size == 1 && parent_exps.first.is_a?(Array) && parent_exps.first.first == :raw_regex
-      # That means parent's route is a raw Regexp => no children allowed
-      # (the problem statement: "if any route is a raw Ruby Regexp, no nesting allowed")
-      raise 'Cannot nest under a raw Regexp route.'
-    end
-
-    if child_exps.size == 1 && child_exps.first.is_a?(Array) && child_exps.first.first == :raw_regex
-      # child is also a raw regex => not allowed in combination
-      raise 'Cannot nest a raw Regexp route under a parent string route.'
-    end
-
-    # Both are purely strings => cartesian
-    results = []
-    parent_exps.each do |p|
-      child_exps.each do |c|
-        # combine with a slash if needed (unless p or c are empty)
-        joined = [p, c].reject(&:empty?).join('/')
-        results << joined
-      end
-    end
-    results
-  end
-
-  # Turn an array of expansions (which are strings like "users/(?<id>[^/]+)" or blank "")
-  # into a big OR group. e.g. (?: /users/xxx | /whatever )
-  # We'll inject a leading slash if not empty, then create the group.
-  def or_pattern_for(expansions)
-    return '' if expansions.empty?
-
-    # If expansions has an array that starts with [:raw_regex, /someRegex/], that means no strings
-    # but the user is making a direct Regexp. But we already handle that by disallowing nesting.
-    # So we shouldn't see it here unless it's from the top location with no parent.
-    # In that case let's do a direct pass-through:
-    if expansions.size == 1 && expansions.first.is_a?(Array) && expansions.first.first == :raw_regex
-      raw = expansions.first.last
-      return raw.source # Use the raw Regexp's source
-    end
-
-    # For each expansion, we do a slash plus expansion if expansion isn't blank
-    # If expansion is blank => it's basically "/"
-    pattern_pieces = expansions.map do |exp|
-      if exp.empty?
-        '' # => means top-level "/"
-      else
-        # We'll parse param placeholders into named captures.
-        # So let's do the same param expansions as in the earlier snippet:
-        segment_to_regex_with_slash(exp)
-      end
-    end
-
-    # Join them with '|'
-    joined = pattern_pieces.join('|')
-
-    "(?:#{joined})"
-  end
-
-  # Take a string like "users/:id(\d+)" and produce "users/(?<id>\d+)" with the correct param expansions,
-  # then put a leading slash. If blank => just slash. We'll do a quick parse (like the earlier snippet).
-  def segment_to_regex_with_slash(path_str)
-    return '' if path_str == ''
-
-    segments = path_str.split('/')
-
-    converted = segments.map do |seg|
-      # wildcard?
-      next '.*' if seg == '*'
-
-      # :param(...)?
-      if seg =~ /^:([A-Za-z_]\w*)(?:\(([^)]*)\))?$/
-        param_name = Regexp.last_match(1)
-        custom     = Regexp.last_match(2)
-        if custom && !custom.empty?
-          "(?<#{param_name}>#{custom})"
-        else
-          "(?<#{param_name}>[^/]+)"
-        end
-      else
-        Regexp.escape(seg)
-      end
-    end
-
-    converted.join('/')
-  end
-
-  ################################
-  # Filter merging
-  ################################
-
-  def effective_filters
-    # gather from root -> self, overriding duplicates
-    merged = merge_ancestor_filters
-    # turn into array
-    merged.map { |k, v| { type: k, params: v } }
-  end
-
-  def effective_filters_with_endpoint(endpoint_args)
-    arr = effective_filters
-    # endpoint filter last
-    ep_filter_params = endpoint_args.dup
-    ep_filter_params << @controller_class if @controller_class
-    arr << { type: :endpoint, params: ep_filter_params }
-    arr
-  end
-
-  def merge_ancestor_filters
-    chain = []
-    node = self
-    while node
-      chain << node
-      node = node.parent
-    end
-    chain.reverse!
-
-    merged = {}
-    chain.each do |n|
-      n.filters.each do |k, v|
-        merged[k] = v
-      end
-    end
-    merged
-  end
-end
-
-################################
-# Example usage
-################################
-
-if $0 == __FILE__
-  dsl = RouterDSL.new do
-    location 'http://*' do
-      redirect to: 'https://{host}/{path}', status: 301
-    end
-
-    location 'http://www.google.com/', 'https://www.foo.bar.com' do
-      # Authentication
-      basic_auth credential_pairs: [[ENV['BASIC_USER_EMAIL'], ENV['BASIC_USER_PASSWORD']]]
-      jwt_auth secret: ENV['JWT_SECRET'], algorithm: 'HS256', verification: 'RS256', public_key: 'public.pem'
-      api_key_auth allowed_keys: ENV['API_KEYS'] ? ENV['API_KEYS'].split(',') : []
-
-      # Compression
-      compress types: ['text/html', 'text/css', 'application/javascript'],
-               threshold: 1024,
-               algorithms: %w[gzip deflate]
-
-      # Rate Limiting
-      rate_limit :api_rate, limit: '1000 requests/hour', burst: 50
-
-      # CORS
-      cors allow_origins: ['https://example.com'], methods: %i[GET POST], apply_to: [:api]
-
-      # Static assets
-
-      location '/users', '/members' do
-        file_server dir: 'public', index: 'index.html', default: 'index.html'
-        controller 'User'
-        endpoint ':id(\d+)', :get_user
-      end
-    end
-  end
-
-  flattened = dsl.flatten_routes
-  require 'debug'
-  bb
-end

data/sandbox/itsi_sandbox_rails/.kamal/hooks/docker-setup.sample

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-echo "Docker set up on $KAMAL_HOSTS..."

data/sandbox/itsi_sandbox_rails/.kamal/hooks/post-app-boot.sample

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-echo "Booted app version $KAMAL_VERSION on $KAMAL_HOSTS..."

data/sandbox/itsi_sandbox_rails/.kamal/hooks/post-deploy.sample

@@ -1,14 +0,0 @@
-#!/bin/sh
-
-# A sample post-deploy hook
-#
-# These environment variables are available:
-# KAMAL_RECORDED_AT
-# KAMAL_PERFORMER
-# KAMAL_VERSION
-# KAMAL_HOSTS
-# KAMAL_ROLE (if set)
-# KAMAL_DESTINATION (if set)
-# KAMAL_RUNTIME
-
-echo "$KAMAL_PERFORMER deployed $KAMAL_VERSION to $KAMAL_DESTINATION in $KAMAL_RUNTIME seconds"

data/sandbox/itsi_sandbox_rails/.kamal/hooks/post-proxy-reboot.sample

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-echo "Rebooted kamal-proxy on $KAMAL_HOSTS"

data/sandbox/itsi_sandbox_rails/.kamal/hooks/pre-app-boot.sample

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-echo "Booting app version $KAMAL_VERSION on $KAMAL_HOSTS..."

data/sandbox/itsi_sandbox_rails/.kamal/hooks/pre-build.sample

@@ -1,51 +0,0 @@
-#!/bin/sh
-
-# A sample pre-build hook
-#
-# Checks:
-# 1. We have a clean checkout
-# 2. A remote is configured
-# 3. The branch has been pushed to the remote
-# 4. The version we are deploying matches the remote
-#
-# These environment variables are available:
-# KAMAL_RECORDED_AT
-# KAMAL_PERFORMER
-# KAMAL_VERSION
-# KAMAL_HOSTS
-# KAMAL_ROLE (if set)
-# KAMAL_DESTINATION (if set)
-
-if [ -n "$(git status --porcelain)" ]; then
-  echo "Git checkout is not clean, aborting..." >&2
-  git status --porcelain >&2
-  exit 1
-fi
-
-first_remote=$(git remote)
-
-if [ -z "$first_remote" ]; then
-  echo "No git remote set, aborting..." >&2
-  exit 1
-fi
-
-current_branch=$(git branch --show-current)
-
-if [ -z "$current_branch" ]; then
-  echo "Not on a git branch, aborting..." >&2
-  exit 1
-fi
-
-remote_head=$(git ls-remote $first_remote --tags $current_branch | cut -f1)
-
-if [ -z "$remote_head" ]; then
-  echo "Branch not pushed to remote, aborting..." >&2
-  exit 1
-fi
-
-if [ "$KAMAL_VERSION" != "$remote_head" ]; then
-  echo "Version ($KAMAL_VERSION) does not match remote HEAD ($remote_head), aborting..." >&2
-  exit 1
-fi
-
-exit 0

data/sandbox/itsi_sandbox_rails/.kamal/hooks/pre-connect.sample

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-
-# A sample pre-connect check
-#
-# Warms DNS before connecting to hosts in parallel
-#
-# These environment variables are available:
-# KAMAL_RECORDED_AT
-# KAMAL_PERFORMER
-# KAMAL_VERSION
-# KAMAL_HOSTS
-# KAMAL_ROLE (if set)
-# KAMAL_DESTINATION (if set)
-# KAMAL_RUNTIME
-
-hosts = ENV["KAMAL_HOSTS"].split(",")
-results = nil
-max = 3
-
-elapsed = Benchmark.realtime do
-  results = hosts.map do |host|
-    Thread.new do
-      tries = 1
-
-      begin
-        Socket.getaddrinfo(host, 0, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)
-      rescue SocketError
-        if tries < max
-          puts "Retrying DNS warmup: #{host}"
-          tries += 1
-          sleep rand
-          retry
-        else
-          puts "DNS warmup failed: #{host}"
-          host
-        end
-      end
-
-      tries
-    end
-  end.map(&:value)
-end
-
-retries = results.sum - hosts.size
-nopes = results.count { |r| r == max }
-
-puts "Prewarmed %d DNS lookups in %.2f sec: %d retries, %d failures" % [ hosts.size, elapsed, retries, nopes ]

data/sandbox/itsi_sandbox_rails/.kamal/hooks/pre-deploy.sample

@@ -1,109 +0,0 @@
-#!/usr/bin/env ruby
-
-# A sample pre-deploy hook
-#
-# Checks the Github status of the build, waiting for a pending build to complete for up to 720 seconds.
-#
-# Fails unless the combined status is "success"
-#
-# These environment variables are available:
-# KAMAL_RECORDED_AT
-# KAMAL_PERFORMER
-# KAMAL_VERSION
-# KAMAL_HOSTS
-# KAMAL_COMMAND
-# KAMAL_SUBCOMMAND
-# KAMAL_ROLE (if set)
-# KAMAL_DESTINATION (if set)
-
-# Only check the build status for production deployments
-if ENV["KAMAL_COMMAND"] == "rollback" || ENV["KAMAL_DESTINATION"] != "production"
-  exit 0
-end
-
-require "bundler/inline"
-
-# true = install gems so this is fast on repeat invocations
-gemfile(true, quiet: true) do
-  source "https://rubygems.org"
-
-  gem "octokit"
-  gem "faraday-retry"
-end
-
-MAX_ATTEMPTS = 72
-ATTEMPTS_GAP = 10
-
-def exit_with_error(message)
-  $stderr.puts message
-  exit 1
-end
-
-class GithubStatusChecks
-  attr_reader :remote_url, :git_sha, :github_client, :combined_status
-
-  def initialize
-    @remote_url = `git config --get remote.origin.url`.strip.delete_prefix("https://github.com/")
-    @git_sha = `git rev-parse HEAD`.strip
-    @github_client = Octokit::Client.new(access_token: ENV["GITHUB_TOKEN"])
-    refresh!
-  end
-
-  def refresh!
-    @combined_status = github_client.combined_status(remote_url, git_sha)
-  end
-
-  def state
-    combined_status[:state]
-  end
-
-  def first_status_url
-    first_status = combined_status[:statuses].find { |status| status[:state] == state }
-    first_status && first_status[:target_url]
-  end
-
-  def complete_count
-    combined_status[:statuses].count { |status| status[:state] != "pending"}
-  end
-
-  def total_count
-    combined_status[:statuses].count
-  end
-
-  def current_status
-    if total_count > 0
-      "Completed #{complete_count}/#{total_count} checks, see #{first_status_url} ..."
-    else
-      "Build not started..."
-    end
-  end
-end
-
-
-$stdout.sync = true
-
-puts "Checking build status..."
-attempts = 0
-checks = GithubStatusChecks.new
-
-begin
-  loop do
-    case checks.state
-    when "success"
-      puts "Checks passed, see #{checks.first_status_url}"
-      exit 0
-    when "failure"
-      exit_with_error "Checks failed, see #{checks.first_status_url}"
-    when "pending"
-      attempts += 1
-    end
-
-    exit_with_error "Checks are still pending, gave up after #{MAX_ATTEMPTS * ATTEMPTS_GAP} seconds" if attempts == MAX_ATTEMPTS
-
-    puts checks.current_status
-    sleep(ATTEMPTS_GAP)
-    checks.refresh!
-  end
-rescue Octokit::NotFound
-  exit_with_error "Build status could not be found"
-end

data/sandbox/itsi_sandbox_rails/.kamal/hooks/pre-proxy-reboot.sample

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-echo "Rebooting kamal-proxy on $KAMAL_HOSTS..."

data/sandbox/itsi_sandbox_rails/.kamal/secrets

@@ -1,17 +0,0 @@
-# Secrets defined here are available for reference under registry/password, env/secret, builder/secrets,
-# and accessories/*/env/secret in config/deploy.yml. All secrets should be pulled from either
-# password manager, ENV, or a file. DO NOT ENTER RAW CREDENTIALS HERE! This file needs to be safe for git.
-
-# Example of extracting secrets from 1password (or another compatible pw manager)
-# SECRETS=$(kamal secrets fetch --adapter 1password --account your-account --from Vault/Item KAMAL_REGISTRY_PASSWORD RAILS_MASTER_KEY)
-# KAMAL_REGISTRY_PASSWORD=$(kamal secrets extract KAMAL_REGISTRY_PASSWORD ${SECRETS})
-# RAILS_MASTER_KEY=$(kamal secrets extract RAILS_MASTER_KEY ${SECRETS})
-
-# Use a GITHUB_TOKEN if private repositories are needed for the image
-# GITHUB_TOKEN=$(gh config get -h github.com oauth_token)
-
-# Grab the registry password from ENV
-KAMAL_REGISTRY_PASSWORD=$KAMAL_REGISTRY_PASSWORD
-
-# Improve security by using a password manager. Never check config/master.key into git!
-RAILS_MASTER_KEY=$(cat config/master.key)

data/sandbox/itsi_sandbox_rails/bin/dev

@@ -1,2 +0,0 @@
-#!/usr/bin/env ruby
-exec "./bin/rails", "server", *ARGV

data/sandbox/itsi_sandbox_rails/bin/jobs

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative "../config/environment"
-require "solid_queue/cli"
-
-SolidQueue::Cli.start(ARGV)

data/sandbox/itsi_sandbox_rails/bin/kamal

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'kamal' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("kamal", "kamal")

data/sandbox/itsi_sandbox_rails/bin/thrust

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("thruster", "thrust")