rails-http-lab 0.1.0

data/lib/rails_http_lab/execution/runner.rb

@@ -0,0 +1,187 @@
+require "net/http"
+require "uri"
+require "json"
+require "rails_http_lab/execution/variable_resolver"
+require "rails_http_lab/execution/response"
+
+module RailsHttpLab
+  module Execution
+    # Executes a Bruno::Document as an HTTP request, returning Response.
+    #
+    # Pipeline:
+    #   1. Resolve {{vars}} in url, headers, query, body, auth fields.
+    #   2. Build query string from params:query (merge with URL query).
+    #   3. Build Net::HTTP::<Verb>.
+    #   4. Apply auth (bearer/basic/apikey).
+    #   5. Set body per body:<type>.
+    #   6. Dispatch with timeout, capture timings + size.
+    class Runner
+      VERBS = {
+        "get"     => Net::HTTP::Get,
+        "post"    => Net::HTTP::Post,
+        "put"     => Net::HTTP::Put,
+        "patch"   => Net::HTTP::Patch,
+        "delete"  => Net::HTTP::Delete,
+        "head"    => Net::HTTP::Head,
+        "options" => Net::HTTP::Options
+      }.freeze
+
+      def initialize(document, resolver: VariableResolver.new, timeout: nil, max_body: nil)
+        @doc      = document
+        @resolver = resolver
+        @timeout  = timeout  || RailsHttpLab.config.executor_timeout
+        @max_body = max_body || RailsHttpLab.config.executor_max_body
+      end
+
+      def run
+        verb_block = @doc.verb_block
+        raise Error, "no HTTP verb block in document" unless verb_block
+
+        sent_request = nil
+
+        url      = @resolver.resolve(verb_block["url"].to_s)
+        body_kind = verb_block["body"].to_s
+        auth_kind = verb_block["auth"].to_s
+
+        uri = URI.parse(url)
+        merge_query!(uri)
+
+        klass = VERBS.fetch(verb_block.name)
+        request = klass.new(uri.request_uri)
+
+        apply_headers!(request)
+        apply_auth!(request, auth_kind)
+        apply_body!(request, body_kind)
+
+        sent_request = summarize_request(request, uri)
+        dispatch(uri, request, sent_request)
+      rescue URI::InvalidURIError => e
+        Response.new(error: "Invalid URL: #{e.message}", request: sent_request)
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        Response.new(error: "Timeout: #{e.message}", request: sent_request)
+      rescue StandardError => e
+        Response.new(error: "#{e.class}: #{e.message}", request: sent_request)
+      end
+
+      private
+
+      def dispatch(uri, request, sent_request)
+        started = monotonic_now
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl     = uri.scheme == "https"
+        http.open_timeout = @timeout
+        http.read_timeout = @timeout
+
+        resp = http.request(request)
+        body = resp.body.to_s
+        body = body[0, @max_body] + "\n[...truncated]" if body.bytesize > @max_body
+
+        Response.new(
+          status:      resp.code.to_i,
+          headers:     resp.each_header.to_h,
+          body:        body,
+          duration_ms: ((monotonic_now - started) * 1000).round,
+          size_bytes:  resp.body.to_s.bytesize,
+          request:     sent_request
+        )
+      end
+
+      # Captures the resolved request after all headers/auth/body have been
+      # applied so the UI can show an equivalent cURL command.
+      def summarize_request(request, uri)
+        headers = {}
+        request.each_header { |k, v| headers[k] = v }
+        {
+          method:  request.method.to_s.upcase,
+          url:     uri.to_s,
+          headers: headers,
+          body:    request.body
+        }
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def merge_query!(uri)
+        params_block = @doc.block("params:query") || @doc.block("query")
+        return unless params_block&.kv?
+
+        existing = uri.query.to_s
+        extra    = params_block.pairs.reject { |k, _| k.start_with?("~") }.map do |k, v|
+          "#{URI.encode_www_form_component(k)}=#{URI.encode_www_form_component(@resolver.resolve(v.to_s))}"
+        end
+        merged = [existing, extra.join("&")].reject(&:empty?).join("&")
+        uri.query = merged unless merged.empty?
+      end
+
+      def apply_headers!(request)
+        block = @doc.block("headers")
+        return unless block&.kv?
+        block.pairs.each do |k, v|
+          next if k.start_with?("~")
+          request[k] = @resolver.resolve(v.to_s)
+        end
+      end
+
+      def apply_auth!(request, kind)
+        case kind
+        when "bearer"
+          token = @resolver.resolve(@doc.block("auth:bearer")&.[]("token").to_s)
+          request["Authorization"] = "Bearer #{token}" unless token.empty?
+        when "basic"
+          user = @resolver.resolve(@doc.block("auth:basic")&.[]("username").to_s)
+          pass = @resolver.resolve(@doc.block("auth:basic")&.[]("password").to_s)
+          request.basic_auth(user, pass)
+        when "apikey"
+          block = @doc.block("auth:apikey")
+          return unless block
+          key = @resolver.resolve(block["key"].to_s)
+          val = @resolver.resolve(block["value"].to_s)
+          placement = block["placement"].to_s
+          if placement == "queryparams"
+            uri = request.uri || URI.parse("")
+            # placement in query is handled at URL level; skip here
+          else
+            request[key] = val unless key.empty?
+          end
+        end
+      end
+
+      def apply_body!(request, kind)
+        case kind
+        when "json"
+          raw = @doc.block("body:json")&.raw.to_s
+          request.body = @resolver.resolve(raw.strip)
+          request["Content-Type"] ||= "application/json"
+        when "text"
+          request.body = @resolver.resolve(@doc.block("body:text")&.raw.to_s)
+          request["Content-Type"] ||= "text/plain"
+        when "xml"
+          request.body = @resolver.resolve(@doc.block("body:xml")&.raw.to_s)
+          request["Content-Type"] ||= "application/xml"
+        when "formUrlEncoded", "form-urlencoded"
+          block = @doc.block("body:form-urlencoded")
+          if block&.kv?
+            pairs = block.pairs.reject { |k, _| k.start_with?("~") }
+            request.set_form_data(pairs.to_h.transform_values { |v| @resolver.resolve(v.to_s) })
+          end
+        when "multipartForm", "multipart-form"
+          # v1: text fields only.
+          block = @doc.block("body:multipart-form")
+          if block&.kv?
+            pairs = block.pairs.reject { |k, _| k.start_with?("~") }
+            request.set_form(pairs.map { |k, v| [k, @resolver.resolve(v.to_s)] }, "multipart/form-data")
+          end
+        when "graphql"
+          query     = @doc.block("body:graphql")&.raw.to_s
+          variables = @doc.block("body:graphql:vars")&.raw.to_s
+          payload   = { "query" => query }
+          payload["variables"] = JSON.parse(variables) rescue payload["variables"] = variables if !variables.empty?
+          request.body = JSON.generate(payload)
+          request["Content-Type"] ||= "application/json"
+        end
+      end
+    end
+  end
+end

data/lib/rails_http_lab/execution/variable_resolver.rb

@@ -0,0 +1,30 @@
+module RailsHttpLab
+  module Execution
+    # Replaces {{var}} with the value from a flat hash of variables.
+    # Unknown vars are left as-is so the user can see what's missing.
+    class VariableResolver
+      VAR_RE = /\{\{\s*([\w.-]+)\s*\}\}/
+
+      def initialize(vars = {})
+        @vars = stringify_keys(vars)
+      end
+
+      def resolve(str)
+        return str unless str.is_a?(String)
+        str.gsub(VAR_RE) { |m| @vars.fetch(Regexp.last_match(1), m) }
+      end
+
+      def self.from_environment_document(doc)
+        return new({}) unless doc
+        pairs = doc.block("vars")&.pairs || []
+        new(pairs.to_h)
+      end
+
+      private
+
+      def stringify_keys(h)
+        h.each_with_object({}) { |(k, v), acc| acc[k.to_s] = v.to_s }
+      end
+    end
+  end
+end

data/lib/rails_http_lab/execution.rb

@@ -0,0 +1,3 @@
+require "rails_http_lab/execution/variable_resolver"
+require "rails_http_lab/execution/response"
+require "rails_http_lab/execution/runner"

data/lib/rails_http_lab/storage/filesystem.rb

@@ -0,0 +1,123 @@
+require "json"
+require "fileutils"
+require "pathname"
+
+module RailsHttpLab
+  module Storage
+    # Filesystem-backed CRUD for Bruno collections under config.storage_path.
+    #
+    # All paths are relative to the storage root. The class refuses to operate
+    # on absolute paths, paths containing "..", or paths that escape the root
+    # after resolution.
+    class Filesystem
+      def initialize(root: RailsHttpLab.config.resolved_storage_path)
+        @root = Pathname.new(root.to_s)
+      end
+
+      attr_reader :root
+
+      def root_exists?
+        @root.directory?
+      end
+
+      def ensure_root!
+        FileUtils.mkdir_p(@root) unless @root.directory?
+        unless (@root + "bruno.json").file?
+          File.write(@root + "bruno.json", default_bruno_json)
+        end
+      end
+
+      def read_bru(relative_path)
+        abs = safe_path(relative_path)
+        raise NotFoundError, "no such file: #{relative_path}" unless abs.file?
+        Bruno.parse(abs.read)
+      end
+
+      def write_bru(relative_path, document)
+        abs = safe_path(relative_path)
+        FileUtils.mkdir_p(abs.dirname)
+        File.write(abs, Bruno.dump(document))
+        document
+      end
+
+      def delete(relative_path)
+        abs = safe_path(relative_path)
+        return false unless abs.exist?
+        if abs.directory?
+          FileUtils.rm_rf(abs)
+        else
+          abs.delete
+        end
+        true
+      end
+
+      # Moves a file or directory from one relative path to another. Both paths
+      # are validated through safe_path. Refuses if destination already exists.
+      def rename(from, to)
+        abs_from = safe_path(from)
+        raise NotFoundError, "no such path: #{from}" unless abs_from.exist?
+        abs_to = safe_path(to)
+        raise Error, "destination exists: #{to}" if abs_to.exist?
+        FileUtils.mkdir_p(abs_to.dirname)
+        FileUtils.mv(abs_from.to_s, abs_to.to_s)
+        abs_to
+      end
+
+      def create_folder(relative_path, display_name: nil)
+        abs = safe_path(relative_path)
+        FileUtils.mkdir_p(abs)
+        folder_meta = abs + "folder.bru"
+        unless folder_meta.file?
+          name = display_name || abs.basename.to_s
+          doc = Bruno::Document.new(blocks: [
+            Bruno::Block.new(name: "meta", mode: :kv, pairs: [
+              ["name", name],
+              ["seq",  next_seq(abs.dirname).to_s]
+            ])
+          ])
+          File.write(folder_meta, Bruno.dump(doc))
+        end
+        relative_path
+      end
+
+      def read_bruno_json
+        path = @root + "bruno.json"
+        return nil unless path.file?
+        JSON.parse(path.read)
+      end
+
+      private
+
+      def safe_path(relative_path)
+        rel = relative_path.to_s
+        raise OutsideStorageError, "empty path" if rel.empty?
+        raise OutsideStorageError, "absolute path forbidden: #{rel}" if rel.start_with?("/")
+        raise OutsideStorageError, "traversal forbidden: #{rel}" if rel.split("/").include?("..")
+        abs = (@root + rel).cleanpath
+        unless abs.to_s == @root.to_s || abs.to_s.start_with?(@root.to_s + "/")
+          raise OutsideStorageError, "outside storage root: #{rel}"
+        end
+        abs
+      end
+
+      def default_bruno_json
+        JSON.pretty_generate(
+          "version" => "1",
+          "name"    => "My APIs",
+          "type"    => "collection",
+          "ignore"  => ["node_modules", ".git"]
+        ) + "\n"
+      end
+
+      def next_seq(dir)
+        existing = Dir.glob(File.join(dir, "*.bru")).map do |f|
+          doc = Bruno.parse(File.read(f))
+          (doc.block("meta")&.[]("seq") || "0").to_i
+        rescue StandardError
+          0
+        end
+        existing.empty? ? 1 : existing.max + 1
+      end
+    end
+  end
+end

data/lib/rails_http_lab/storage/tree.rb

@@ -0,0 +1,120 @@
+require "pathname"
+
+module RailsHttpLab
+  module Storage
+    # Builds a hierarchical view of the storage root for the sidebar.
+    # Returns:
+    #   {
+    #     name: "My APIs",
+    #     type: "collection",
+    #     children: [
+    #       { type: "folder", name: "...", path: "...", children: [...] },
+    #       { type: "request", name: "...", path: "...", method: "GET", seq: 1 }
+    #     ],
+    #     environments: [{ name: "Local", path: "environments/Local.bru" }]
+    #   }
+    class Tree
+      def initialize(root: RailsHttpLab.config.resolved_storage_path)
+        @root = Pathname.new(root.to_s)
+      end
+
+      def build
+        return empty_tree unless @root.directory?
+
+        collection = read_collection_manifest
+        children   = list_children(@root, relative_prefix: "")
+        envs       = list_environments
+
+        {
+          name:         collection["name"] || @root.basename.to_s,
+          type:         "collection",
+          children:     children,
+          environments: envs
+        }
+      end
+
+      private
+
+      def empty_tree
+        { name: "(missing)", type: "collection", children: [], environments: [] }
+      end
+
+      def read_collection_manifest
+        f = @root + "bruno.json"
+        return {} unless f.file?
+        JSON.parse(f.read)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def list_children(dir, relative_prefix:)
+        return [] unless dir.directory?
+
+        entries = dir.children.sort_by { |c| c.basename.to_s.downcase }
+        out = []
+
+        entries.each do |child|
+          rel = relative_prefix.empty? ? child.basename.to_s : "#{relative_prefix}/#{child.basename}"
+
+          if child.directory?
+            next if child.basename.to_s == "environments" && relative_prefix.empty?
+            folder_meta = read_folder_meta(child)
+            out << {
+              type:     "folder",
+              name:     folder_meta[:name] || child.basename.to_s,
+              path:     rel,
+              seq:      folder_meta[:seq],
+              children: list_children(child, relative_prefix: rel)
+            }
+          elsif child.file? && child.extname == ".bru" && child.basename.to_s != "folder.bru"
+            meta = read_request_meta(child)
+            out << {
+              type:   "request",
+              name:   meta[:name] || child.basename(".bru").to_s,
+              path:   rel,
+              method: meta[:method],
+              seq:    meta[:seq]
+            }
+          end
+        end
+
+        # Top-level entries (collections) are always alphabetical.
+        # Nested entries respect Bruno's seq ordering, falling back to name.
+        if relative_prefix.empty?
+          out.sort_by { |c| c[:name].to_s.downcase }
+        else
+          out.sort_by { |c| [c[:seq] || 9999, c[:name].to_s.downcase] }
+        end
+      end
+
+      def list_environments
+        envs_dir = @root + "environments"
+        return [] unless envs_dir.directory?
+        envs_dir.children.select { |c| c.file? && c.extname == ".bru" }.map do |f|
+          { name: f.basename(".bru").to_s, path: "environments/#{f.basename}" }
+        end.sort_by { |e| e[:name].downcase }
+      end
+
+      def read_folder_meta(dir)
+        f = dir + "folder.bru"
+        return {} unless f.file?
+        doc  = Bruno.parse(f.read)
+        meta = doc.block("meta")
+        return {} unless meta
+        { name: meta["name"], seq: meta["seq"]&.to_i }
+      rescue StandardError
+        {}
+      end
+
+      def read_request_meta(file)
+        doc    = Bruno.parse(file.read)
+        meta   = doc.block("meta")
+        method = doc.http_method
+        return { method: method } unless meta
+        { name: meta["name"], seq: meta["seq"]&.to_i, method: method }
+      rescue StandardError
+        { method: nil }
+      end
+    end
+  end
+end

data/lib/rails_http_lab/storage.rb

@@ -0,0 +1,2 @@
+require "rails_http_lab/storage/filesystem"
+require "rails_http_lab/storage/tree"

data/lib/rails_http_lab/version.rb

@@ -0,0 +1,3 @@
+module RailsHttpLab
+  VERSION = "0.1.0"
+end

data/lib/rails_http_lab.rb

@@ -0,0 +1,14 @@
+require "rails_http_lab/version"
+require "rails_http_lab/configuration"
+
+module RailsHttpLab
+  class Error < StandardError; end
+  class ParseError < Error; end
+  class NotFoundError < Error; end
+  class OutsideStorageError < Error; end
+end
+
+require "rails_http_lab/bruno"
+require "rails_http_lab/storage"
+require "rails_http_lab/execution"
+require "rails_http_lab/engine" if defined?(Rails)

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: rails-http-lab
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jackson Pires
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: Mounts a Bruno-like UI inside your Rails app for ad-hoc HTTP requests,
+  persisting collections as .bru files that are interchangeable with Bruno.
+email:
+- jackson@linkana.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- app/assets/javascripts/rails_http_lab/application.js
+- app/assets/stylesheets/rails_http_lab/application.css
+- app/controllers/rails_http_lab/application_controller.rb
+- app/controllers/rails_http_lab/collections_controller.rb
+- app/controllers/rails_http_lab/environments_controller.rb
+- app/controllers/rails_http_lab/folders_controller.rb
+- app/controllers/rails_http_lab/requests_controller.rb
+- app/controllers/rails_http_lab/runs_controller.rb
+- app/controllers/rails_http_lab/ui_controller.rb
+- app/views/layouts/rails_http_lab.html.erb
+- app/views/rails_http_lab/ui/index.html.erb
+- config/routes.rb
+- lib/generators/rails_http_lab/install/install_generator.rb
+- lib/generators/rails_http_lab/install/templates/initializer.rb.tt
+- lib/rails-http-lab.rb
+- lib/rails_http_lab.rb
+- lib/rails_http_lab/bruno.rb
+- lib/rails_http_lab/bruno/block.rb
+- lib/rails_http_lab/bruno/document.rb
+- lib/rails_http_lab/bruno/parser.rb
+- lib/rails_http_lab/bruno/serializer.rb
+- lib/rails_http_lab/configuration.rb
+- lib/rails_http_lab/engine.rb
+- lib/rails_http_lab/execution.rb
+- lib/rails_http_lab/execution/response.rb
+- lib/rails_http_lab/execution/runner.rb
+- lib/rails_http_lab/execution/variable_resolver.rb
+- lib/rails_http_lab/storage.rb
+- lib/rails_http_lab/storage/filesystem.rb
+- lib/rails_http_lab/storage/tree.rb
+- lib/rails_http_lab/version.rb
+homepage: https://github.com/jacksonpires/rails-http-lab
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/jacksonpires/rails-http-lab
+  bug_tracker_uri: https://github.com/jacksonpires/rails-http-lab/issues
+  rubygems_mfa_required: 'true'
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: In-app HTTP request lab for Rails, with Bruno-compatible storage.
+test_files: []