rails-http-lab 0.1.0

data/app/views/rails_http_lab/ui/index.html.erb

@@ -0,0 +1,103 @@
+<div class="rhl-app" id="rhl-app">
+  <header class="rhl-topbar">
+    <div class="rhl-topbar__brand">Rails HTTP Lab</div>
+    <div class="rhl-topbar__env">
+      <button class="rhl-btn rhl-btn--ghost" id="rhl-clear-cache" title="Clear locally cached drafts and responses (does not touch saved .bru files)">Clear cache</button>
+      <label for="rhl-env-select">Environment</label>
+      <select id="rhl-env-select">
+        <option value="">(none)</option>
+      </select>
+      <button class="rhl-btn rhl-btn--ghost" id="rhl-env-edit" title="Edit environments">Edit</button>
+    </div>
+  </header>
+
+  <main class="rhl-main">
+    <aside class="rhl-sidebar">
+      <div class="rhl-sidebar__header">
+        <span>Collections</span>
+        <button class="rhl-iconbtn" id="rhl-new-collection" title="New collection">+</button>
+      </div>
+      <div class="rhl-sidebar__tree" id="rhl-tree"><div class="rhl-tree-empty">Loading…</div></div>
+    </aside>
+
+    <section class="rhl-pane">
+      <div class="rhl-pane__empty" id="rhl-empty">
+        <p>Select a request from the sidebar. Use <strong>+</strong> to create a new collection, then add folders and requests via the <strong>⋯</strong> menu on each folder. Rename and delete are available from the <strong>⋯</strong> menu on folders and requests.</p>
+        <p class="rhl-tip">
+          <strong>Tip — environment variables:</strong>
+          write <code>{{var_name}}</code> in any field (URL, headers, query, body, auth) to interpolate from the active environment.
+          For example: <code>{{baseUrl}}/v0/users</code>, <code>Authorization: Bearer {{token}}</code>.
+          Pick an environment in the top-right and manage them with the <strong>Edit</strong> button.
+        </p>
+      </div>
+      <div class="rhl-pane__editor" id="rhl-editor" hidden>
+        <div class="rhl-request-bar">
+          <select class="rhl-verb" id="rhl-verb">
+            <option>GET</option><option>POST</option><option>PUT</option>
+            <option>PATCH</option><option>DELETE</option><option>HEAD</option><option>OPTIONS</option>
+          </select>
+          <input type="text" class="rhl-url" id="rhl-url" placeholder="https://…">
+          <button class="rhl-btn rhl-btn--send" id="rhl-send">Send</button>
+          <button class="rhl-btn" id="rhl-save">Save</button>
+        </div>
+
+        <nav class="rhl-tabs" id="rhl-tabs">
+          <button class="rhl-tab is-active" data-tab="params">Params</button>
+          <button class="rhl-tab" data-tab="headers">Headers</button>
+          <button class="rhl-tab" data-tab="body">Body</button>
+          <button class="rhl-tab" data-tab="auth">Auth</button>
+          <button class="rhl-tab" data-tab="vars">Vars</button>
+          <button class="rhl-tab" data-tab="script">Script</button>
+          <button class="rhl-tab" data-tab="tests">Tests</button>
+          <button class="rhl-tab" data-tab="docs">Docs</button>
+        </nav>
+
+        <div class="rhl-split">
+          <div class="rhl-tab-panel" id="rhl-panel"></div>
+          <div class="rhl-splitter" id="rhl-splitter" title="Drag to resize"></div>
+          <div class="rhl-response" id="rhl-response">
+            <div class="rhl-response__header">
+              <nav class="rhl-response__tabs" id="rhl-response-tabs">
+                <button class="rhl-response-tab is-active" data-rtab="body">Response</button>
+                <button class="rhl-response-tab" data-rtab="pretty">Pretty</button>
+                <button class="rhl-response-tab" data-rtab="headers">Headers<span class="rhl-response-tab__count" id="rhl-response-headers-count" hidden></span></button>
+                <button class="rhl-response-tab" data-rtab="curl">cURL</button>
+              </nav>
+              <div class="rhl-response__meta">
+                <span id="rhl-response-status">Ready</span>
+                <span id="rhl-response-time"></span>
+                <span id="rhl-response-size"></span>
+              </div>
+            </div>
+            <pre class="rhl-response__body" id="rhl-response-body">Click Send to execute the request.</pre>
+            <pre class="rhl-response__body" id="rhl-response-pretty" hidden></pre>
+            <div class="rhl-response__headers" id="rhl-response-headers" hidden></div>
+            <pre class="rhl-response__body" id="rhl-response-curl" hidden></pre>
+          </div>
+        </div>
+      </div>
+    </section>
+  </main>
+
+  <div class="rhl-modal" id="rhl-env-modal" hidden>
+    <div class="rhl-modal__backdrop" data-close="1"></div>
+    <div class="rhl-modal__dialog">
+      <div class="rhl-modal__header">
+        <h2>Environments</h2>
+        <button class="rhl-iconbtn" id="rhl-env-modal-close" title="Close">×</button>
+      </div>
+      <div class="rhl-modal__body">
+        <div class="rhl-envs-list" id="rhl-envs-list"></div>
+        <div class="rhl-envs-editor" id="rhl-envs-editor">
+          <em>Select an environment on the left.</em>
+        </div>
+      </div>
+      <div class="rhl-modal__footer">
+        Reference these variables anywhere in a request with <code>{{name}}</code>.
+        Example: a variable <code>baseUrl = http://localhost:3000</code> used in the URL as
+        <code>{{baseUrl}}/v0/users</code> resolves to <code>http://localhost:3000/v0/users</code>
+        when the environment is active.
+      </div>
+    </div>
+  </div>
+</div>

data/config/routes.rb

@@ -0,0 +1,24 @@
+RailsHttpLab::Engine.routes.draw do
+  root to: "ui#index"
+
+  scope "api", defaults: { format: :json } do
+    get    "tree",                       to: "collections#tree"
+    post   "collections",                to: "collections#create"
+
+    post   "folders",                    to: "folders#create"
+    post   "folders/rename",             to: "folders#rename"
+    delete "folders/*path",              to: "folders#destroy", constraints: { path: /.*/ }
+
+    post   "requests/rename",            to: "requests#rename"
+    get    "requests/*path",             to: "requests#show",    constraints: { path: /.*/ }
+    put    "requests/*path",             to: "requests#update",  constraints: { path: /.*/ }
+    delete "requests/*path",             to: "requests#destroy", constraints: { path: /.*/ }
+    post   "requests",                   to: "requests#create"
+
+    get    "environments",               to: "environments#index"
+    get    "environments/:name",         to: "environments#show"
+    put    "environments/:name",         to: "environments#update"
+
+    post   "run",                        to: "runs#create"
+  end
+end

data/lib/generators/rails_http_lab/install/install_generator.rb

@@ -0,0 +1,41 @@
+require "rails/generators"
+require "rails/generators/base"
+
+module RailsHttpLab
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Installs rails-http-lab: initializer, mount in routes, and docs/http-lab/ collection root."
+
+      def copy_initializer
+        template "initializer.rb.tt", "config/initializers/rails_http_lab.rb"
+      end
+
+      def mount_engine
+        route_line = 'mount RailsHttpLab::Engine => RailsHttpLab.config.mount_path'
+        routes_file = "config/routes.rb"
+        if File.exist?(routes_file) && File.read(routes_file).include?(route_line)
+          say_status :exist, "mount already present in #{routes_file}", :blue
+        else
+          route route_line
+        end
+      end
+
+      def create_storage_root
+        # Just the empty root. `bruno.json` and any subfolders
+        # (environments/, collections, ...) are created lazily on first use
+        # via Storage::Filesystem#ensure_root!.
+        empty_directory "docs/http-lab"
+      end
+
+      def post_install_message
+        say ""
+        say "rails-http-lab installed.", :green
+        say "Mounted at /rails/http-lab (configurable in config/initializers/rails_http_lab.rb)"
+        say "Collections live in docs/http-lab/ (Bruno-compatible .bru files)"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/rails_http_lab/install/templates/initializer.rb.tt

@@ -0,0 +1,20 @@
+require "rails_http_lab"
+
+RailsHttpLab.configure do |c|
+  # Where the UI mounts. Default: /rails/http-lab
+  # c.mount_path = "/rails/http-lab"
+
+  # Where collections are stored. Default: Rails.root/docs/http-lab
+  # c.storage_path = Rails.root.join("docs", "http-lab")
+
+  # Rails environments where the engine is reachable. Default: [:development]
+  # Production requires an authenticator (see below) or the engine will refuse to boot.
+  # c.enabled_envs = %i[development]
+
+  # Optional gate. Receives the request object; return truthy to allow.
+  # c.authenticator = ->(request) { request.session[:admin] }
+
+  # Executor limits.
+  # c.executor_timeout  = 30          # seconds
+  # c.executor_max_body = 10 * 1024 * 1024
+end

data/lib/rails-http-lab.rb

@@ -0,0 +1 @@
+require "rails_http_lab"

data/lib/rails_http_lab/bruno/block.rb

@@ -0,0 +1,44 @@
+module RailsHttpLab
+  module Bruno
+    class Block
+      MODES = %i[kv raw].freeze
+
+      attr_accessor :name, :mode, :pairs, :raw
+
+      def initialize(name:, mode:, pairs: nil, raw: nil)
+        raise ArgumentError, "invalid mode: #{mode}" unless MODES.include?(mode)
+        @name  = name
+        @mode  = mode
+        @pairs = pairs || []
+        @raw   = raw
+      end
+
+      def kv?;  mode == :kv;  end
+      def raw?; mode == :raw; end
+
+      def [](key)
+        return nil unless kv?
+        found = pairs.find { |k, _| k == key }
+        found && found[1]
+      end
+
+      def []=(key, value)
+        return unless kv?
+        existing = pairs.find { |k, _| k == key }
+        if existing
+          existing[1] = value
+        else
+          pairs << [key, value]
+        end
+      end
+
+      def to_h
+        if kv?
+          pairs.to_h
+        else
+          { raw: raw }
+        end
+      end
+    end
+  end
+end

data/lib/rails_http_lab/bruno/document.rb

@@ -0,0 +1,36 @@
+module RailsHttpLab
+  module Bruno
+    class Document
+      attr_accessor :blocks
+      attr_accessor :leading_blank_lines, :trailing_newline
+
+      def initialize(blocks: [], leading_blank_lines: 0, trailing_newline: true)
+        @blocks              = blocks
+        @leading_blank_lines = leading_blank_lines
+        @trailing_newline    = trailing_newline
+      end
+
+      def block(name)
+        blocks.find { |b| b.name == name }
+      end
+
+      def blocks_named(name)
+        blocks.select { |b| b.name == name }
+      end
+
+      VERBS = %w[get post put patch delete head options].freeze
+
+      def verb_block
+        blocks.find { |b| VERBS.include?(b.name) }
+      end
+
+      def http_method
+        verb_block&.name&.upcase
+      end
+
+      def url
+        verb_block&.[]("url")
+      end
+    end
+  end
+end

data/lib/rails_http_lab/bruno/parser.rb

@@ -0,0 +1,207 @@
+require "rails_http_lab/bruno/block"
+require "rails_http_lab/bruno/document"
+
+module RailsHttpLab
+  module Bruno
+    # Parses Bruno .bru files into a Document of ordered Blocks.
+    #
+    # Two content modes:
+    #   - :kv  — every line is "  key: value" (2-space indent), one pair per line.
+    #   - :raw — opaque body, preserved verbatim. Used for body:json, body:text,
+    #            body:xml, body:graphql, body:graphql:vars, body:sparql,
+    #            script:pre-request, script:post-response, tests, docs.
+    #
+    # Round-trip property: Serializer.dump(Parser.parse(s)) == s for files written
+    # by Bruno itself (see spec/bruno/round_trip_spec.rb).
+    class Parser
+      RAW_BLOCK_NAMES = %w[
+        body:json
+        body:text
+        body:xml
+        body:sparql
+        body:graphql
+        body:graphql:vars
+        script:pre-request
+        script:post-response
+        tests
+        docs
+      ].freeze
+
+      # name = letters/digits/_/- with optional colon-delimited variants
+      BLOCK_OPEN_RE = /\A([a-zA-Z][\w-]*(?::[\w-]+)*)\s*\{\s*\z/
+
+      def self.parse(source)
+        new(source).parse
+      end
+
+      def initialize(source)
+        @source = source
+        # Split keeping line content; the last element may be "" if source ends with \n.
+        @lines = source.split("\n", -1)
+        @i     = 0
+      end
+
+      def parse
+        blocks = []
+        leading_blanks = 0
+
+        # Count leading blank lines.
+        while @i < @lines.length && blank?(@lines[@i])
+          leading_blanks += 1
+          @i += 1
+        end
+
+        while @i < @lines.length
+          line = @lines[@i]
+
+          if blank?(line)
+            @i += 1
+            next
+          end
+
+          if (m = line.match(BLOCK_OPEN_RE))
+            name = m[1]
+            @i += 1
+            if RAW_BLOCK_NAMES.include?(name)
+              blocks << parse_raw_block(name)
+            else
+              blocks << parse_kv_block(name)
+            end
+          else
+            # If we got here we hit something we don't understand. To stay forgiving,
+            # skip it; alternatively raise. We raise so callers know their file is off.
+            raise ParseError, "unexpected line outside of any block (line #{@i + 1}): #{line.inspect}"
+          end
+        end
+
+        # Trailing newline preserved iff source ends with \n (then @lines's last entry is "").
+        trailing_newline = @source.end_with?("\n")
+
+        Document.new(
+          blocks: blocks,
+          leading_blank_lines: leading_blanks,
+          trailing_newline: trailing_newline
+        )
+      end
+
+      private
+
+      def blank?(line)
+        line.nil? || line.strip.empty?
+      end
+
+      def parse_kv_block(name)
+        pairs = []
+        while @i < @lines.length
+          line = @lines[@i]
+          if line.strip == "}"
+            @i += 1
+            return Block.new(name: name, mode: :kv, pairs: pairs)
+          end
+
+          if blank?(line)
+            @i += 1
+            next
+          end
+
+          # Parse "  key: value" — first ":" splits. Value may span multiple
+          # lines via unbalanced braces (URLs with embedded JSON) or via
+          # triple-quoted '''...''' strings (Bruno multi-line literal).
+          stripped = line.sub(/\A {0,4}/, "") # tolerate 0-4 leading spaces
+          colon_idx = stripped.index(":")
+          if colon_idx.nil?
+            raise ParseError, "expected 'key: value' in block #{name} at line #{@i + 1}: #{line.inspect}"
+          end
+
+          key   = stripped[0...colon_idx]
+          value = stripped[(colon_idx + 1)..]
+          value = value.sub(/\A /, "") if value
+          @i += 1
+
+          value = consume_multiline_value(value, block_name: name)
+          pairs << [key, value]
+        end
+
+        raise ParseError, "unterminated block #{name.inspect} (missing closing '}')"
+      end
+
+      # Returns the (possibly multi-line) value. Continues reading lines while
+      # the running brace depth of the value is > 0 OR a '''...''' string is open.
+      def consume_multiline_value(value, block_name:)
+        while value_needs_continuation?(value)
+          if @i >= @lines.length
+            raise ParseError, "unterminated multi-line value in block #{block_name.inspect}"
+          end
+          value = "#{value}\n#{@lines[@i]}"
+          @i += 1
+        end
+        value
+      end
+
+      def value_needs_continuation?(value)
+        in_triple = false
+        depth = 0
+        i = 0
+        len = value.length
+        while i < len
+          if value[i, 3] == "'''"
+            in_triple = !in_triple
+            i += 3
+            next
+          end
+          unless in_triple
+            c = value[i]
+            depth += 1 if c == "{"
+            depth -= 1 if c == "}"
+          end
+          i += 1
+        end
+        in_triple || depth > 0
+      end
+
+      # Counts braces to find matching '}'. Body content can include arbitrary braces
+      # (JSON objects, JS blocks, etc.) so we can't rely on indentation alone.
+      def parse_raw_block(name)
+        content_lines = []
+        depth = 1 # we already consumed the opening '{'
+
+        while @i < @lines.length
+          line = @lines[@i]
+
+          # Compute depth change from this line.
+          opens  = line.count("{")
+          closes = line.count("}")
+
+          # If this line would close the block (depth would reach 0 here),
+          # we need to figure out *which* '}' closes it. If the line is exactly "}"
+          # (with optional leading whitespace) AND no '{' on the same line AND
+          # depth would go to 0, that's the closing brace and isn't part of content.
+          if depth + opens - closes <= 0
+            # Edge case: closing brace is not alone on its line (mixed content).
+            # We try to honor the "alone on a line" convention Bruno uses.
+            if line.strip == "}" && opens == 0
+              @i += 1
+              return Block.new(name: name, mode: :raw, raw: content_lines.join("\n"))
+            else
+              # Mixed line: we still treat the final '}' as terminator and keep the
+              # rest as content. This branch is defensive; real Bruno files don't hit it.
+              # Strip the trailing '}' character from the line; everything before it
+              # is content. This is best-effort.
+              last_brace = line.rindex("}")
+              prefix     = line[0...last_brace]
+              content_lines << prefix unless prefix.empty?
+              @i += 1
+              return Block.new(name: name, mode: :raw, raw: content_lines.join("\n"))
+            end
+          end
+
+          content_lines << line
+          depth += opens - closes
+          @i += 1
+        end
+
+        raise ParseError, "unterminated raw block #{name.inspect}"
+      end
+    end
+  end
+end

data/lib/rails_http_lab/bruno/serializer.rb

@@ -0,0 +1,68 @@
+module RailsHttpLab
+  module Bruno
+    # Round-trip-stable serializer for Bruno documents.
+    #
+    # Format per block:
+    #
+    #   <name> {
+    #     key: value
+    #   }
+    #
+    # Raw blocks emit their `raw` content verbatim between '{' and '}'.
+    # Blocks are separated by a single blank line, matching Bruno's output.
+    class Serializer
+      def self.dump(document)
+        new(document).dump
+      end
+
+      def initialize(document)
+        @document = document
+      end
+
+      def dump
+        out = +""
+        out << ("\n" * @document.leading_blank_lines)
+
+        @document.blocks.each_with_index do |block, idx|
+          out << "\n" if idx > 0
+          out << render_block(block)
+        end
+
+        if @document.trailing_newline && !out.end_with?("\n")
+          out << "\n"
+        elsif !@document.trailing_newline && out.end_with?("\n")
+          out.chomp!
+        end
+
+        out
+      end
+
+      private
+
+      def render_block(block)
+        case block.mode
+        when :kv  then render_kv(block)
+        when :raw then render_raw(block)
+        end
+      end
+
+      def render_kv(block)
+        lines = +"#{block.name} {\n"
+        block.pairs.each do |k, v|
+          lines << "  #{k}: #{v}\n"
+        end
+        lines << "}\n"
+        lines
+      end
+
+      def render_raw(block)
+        body = block.raw.to_s
+        out = +"#{block.name} {\n"
+        out << body
+        out << "\n" unless body.empty? || body.end_with?("\n")
+        out << "}\n"
+        out
+      end
+    end
+  end
+end

data/lib/rails_http_lab/bruno.rb

@@ -0,0 +1,12 @@
+require "rails_http_lab/bruno/block"
+require "rails_http_lab/bruno/document"
+require "rails_http_lab/bruno/parser"
+require "rails_http_lab/bruno/serializer"
+
+module RailsHttpLab
+  module Bruno
+    def self.parse(src);   Parser.parse(src);   end
+    def self.dump(doc);    Serializer.dump(doc); end
+    def self.parse_file(path);  parse(File.read(path)); end
+  end
+end

data/lib/rails_http_lab/configuration.rb

@@ -0,0 +1,51 @@
+module RailsHttpLab
+  class Configuration
+    attr_accessor :mount_path,
+                  :storage_path,
+                  :enabled_envs,
+                  :authenticator,
+                  :executor_timeout,
+                  :executor_max_body
+
+    def initialize
+      @mount_path        = "/rails/http-lab"
+      @storage_path      = nil
+      @enabled_envs      = %i[development]
+      @authenticator     = nil
+      @executor_timeout  = 30
+      @executor_max_body = 10 * 1024 * 1024
+    end
+
+    def resolved_storage_path
+      @storage_path || default_storage_path
+    end
+
+    private
+
+    def default_storage_path
+      if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+        Rails.root.join("docs", "http-lab")
+      else
+        File.expand_path("docs/http-lab", Dir.pwd)
+      end
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def config
+      configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/rails_http_lab/engine.rb

@@ -0,0 +1,25 @@
+require "rails/engine"
+
+module RailsHttpLab
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsHttpLab
+
+    initializer "rails_http_lab.assets" do |app|
+      if app.config.respond_to?(:assets) && app.config.assets.respond_to?(:precompile)
+        app.config.assets.precompile += %w[rails_http_lab/application.css rails_http_lab/application.js]
+      end
+    end
+
+    config.after_initialize do
+      cfg = RailsHttpLab.config
+      if cfg.enabled_envs.include?(:production) &&
+         defined?(Rails) && Rails.env.production? &&
+         cfg.authenticator.nil?
+        raise <<~MSG
+          [rails-http-lab] Refusing to boot: production is in enabled_envs but no authenticator is configured.
+          Set RailsHttpLab.config.authenticator to a callable ->(request) { ... } or remove :production from enabled_envs.
+        MSG
+      end
+    end
+  end
+end

data/lib/rails_http_lab/execution/response.rb

@@ -0,0 +1,20 @@
+module RailsHttpLab
+  module Execution
+    Response = Struct.new(
+      :status, :headers, :body, :duration_ms, :size_bytes, :error, :request,
+      keyword_init: true
+    ) do
+      def to_h
+        {
+          status:      status,
+          headers:     headers,
+          body:        body,
+          duration_ms: duration_ms,
+          size_bytes:  size_bytes,
+          error:       error,
+          request:     request
+        }
+      end
+    end
+  end
+end