yobi-http 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8300927c161636f736c477436c29cc441b79847df717a899a465fd0f129cec13
-  data.tar.gz: d6d693cabeea337129547854608fa394a23b870d89f4f60e3d975960a7bcf1cb
+  metadata.gz: 2cd8930bcfe4c6abc945f290f82f4dbca27cbbbe7fb18592e76b0a78f7541325
+  data.tar.gz: dddad8c7efc3aac7d4aaa5a95a67585ee62896f2721bd017fc4f15f8f348761a
 SHA512:
-  metadata.gz: df1eda58dbc36deb0719785872684adc9fbfa43f033e3ded3ff737792e4bf763a3dd98ab0452db1da4f96ce3fdf4450f73d865e13a061b67eef907c4510d2700
-  data.tar.gz: 16d5746464e6619d3dee0725b04b0c0cfd723860f2bd952ba0500f4bc1c238e262aaf521f75d2f92310ef0440bdeadc10ee1f704fc1581f00c06780acd99d054
+  metadata.gz: 32b78e79f26f6e9a1c58165fc0cf50c1d299505a35135cb592c5a4c8e1a1355a16c483cb4486cada273623b1d7f56821a719326d33e536216cd73310abce8057
+  data.tar.gz: eded11c1ac57fc5cd10c029e294465891ec352fbfa332c7de84cef47a1e3a9024742deb60a52ffbcd6f705699c3ea552ad668de40f7ffb1c230d12fcd2d82b65

data/.rspec

@@ -0,0 +1 @@
+--require ./spec/spec_helper

data/exe/yobi

@@ -3,7 +3,6 @@
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
-require "base64"
 require "erb"
 require "json"
 require "net/http"
@@ -77,106 +76,74 @@ end
 parser.parse!(ARGV)
 
 # resolve the HTTP method
-method = Yobi::Http::METHODS.include?(ARGV[0]) ? ARGV.shift : "GET"
+method = Yobi.args.http_method?(ARGV[0]) ? ARGV.shift : "GET"
 
 # resolve the URL
-url = case ARGV[0]
-      when %r{\Ahttps?://}
-        ARGV.shift
-      when /\A:\d+/
-        "http://localhost#{ARGV.shift}"
-      else
-        "http://#{ARGV.shift}"
-      end
-
-data =
-  ARGV.select { |arg| arg.include?("=") }.map.to_h { |arg| arg.split("=", 2).map(&:strip) }
-
-headers =
-  { "Content-Type" => "application/json", "User-Agent" => "#{Yobi.name}/#{Yobi::VERSION}" }
-  .merge(ARGV.select { |arg| arg.include?(":") }.map.to_h { |arg| arg.split(":", 2).map(&:strip) })
+url = Yobi.args.url(ARGV.shift)
+
+data = Yobi.args.parse_data(ARGV)
+headers = Yobi.args.parse_headers(ARGV)
 
 # prepare authentication header if auth is provided
-if @options[:auth]
-  auth_type = @options[:auth_type] || "basic"
-  case auth_type.downcase
-  when "basic"
-    headers["Authorization"] = "Basic #{Base64.strict_encode64(@options[:auth])}"
-  when "bearer"
-    headers["Authorization"] = "Bearer #{@options[:auth]}"
-  else
-    warn "Unsupported authentication type: #{auth_type}"
-  end
-end
+Yobi.args.auth_header(headers, @options) if @options[:auth]
 
 pp [method, url, data, headers, @options, ARGV] if ENV["YOBI_DEBUG"]
 
-if @options[:offline]
+# Extend Net::HTTPResponse to add util behaviors
+def offline_mode(request, options)
   Net::HTTP.class_eval do
     def connect; end
   end
+
+  options[:verbose] = true
+
+  response = Net::HTTPResponse.new("1.1", "200", "OK")
+  response["Content-Type"] = "application/json"
+  response["Access-Control-Allow-Credentials"] = true
+  response["Access-Control-Allow-Origin"] = "*"
+  response["Connection"] = "close"
+  response["Date"] = Time.now.httpdate
+  response["Server"] = "yobi-offline/#{Yobi::VERSION}"
+  response["X-Powered-By"] = "Yobi/#{Yobi::VERSION}"
+  response.body = body = JSON.pretty_generate({ message: "Offline mode enabled" })
+
+  view = Yobi.view(:output)
+  puts TTY::Markdown.parse(view.result(binding), color: :always)
+
+  exit 0
 end
 
-Net::HTTP.start(URI(url).host, URI(url).port, use_ssl: URI(url).scheme == "https") do |http|
-  options = @options
-  request_class = Net::HTTP.const_get(method.capitalize)
-  request = request_class.new(URI(url))
-
-  headers.each { |key, value| request[key] = value }
-  request["Content-Type"] ||= "application/json"
-
-  request.body = data.to_json unless data.empty?
-
-  if options[:offline]
-    options[:verbose] = true
-    # In offline mode, we prepare the request but do not send it. Instead, we print the request details for debugging
-    # purposes.
-    response = Net::HTTPResponse.new("1.1", "200", "OK")
-    response["Content-Type"] = "application/json"
-    response["Access-Control-Allow-Credentials"] = true
-    response["Access-Control-Allow-Origin"] = "*"
-    response["Connection"] = "close"
-    response["Date"] = Time.now.httpdate
-    response["Server"] = "yobi-offline/#{Yobi::VERSION}"
-    response["X-Powered-By"] = "Yobi/#{Yobi::VERSION}"
-    response.body = body = JSON.pretty_generate({ message: "Offline mode enabled" })
-
-    view = Yobi.view(:output)
-    puts TTY::Markdown.parse(ERB.new(view).result(binding), color: :always)
-    break
+def raw_mode(_request, response, options)
+  if options[:print].include?("H")
+    puts "HTTP/#{response.http_version} #{response.code} #{response.message}"
+    response.each_header { |key, value| puts "#{key}: #{value}" }
+    puts
   end
 
-  response = http.request(request)
+  body = response.parsed_body
+  puts body if options[:print].include?("B") && body
 
-  body = nil
-  if response["Content-Type"]&.include?("application/json") && response.body
-    begin
-      body ||= JSON.pretty_generate(JSON.parse(response.body))
-    rescue StandardError
-      body ||= response.body
-    end
-  else
-    body ||= response.body
-  end
+  exit 0
+end
 
-  if options[:raw]
-    if options[:print].include?("H")
-      puts "HTTP/#{response.http_version} #{response.code} #{response.message}"
-      response.each_header { |key, value| puts "#{key}: #{value}" }
-      puts
-    end
+Yobi.request(method, url, data: data, headers: headers, options: @options) do |http, request|
+  options = @options
 
-    puts body if options[:print].include?("B") && body
+  offline_mode(request, options) if options[:offline]
 
-    break
-  end
+  response = http.request(request)
+
+  raw_mode(request, response, options) if options[:raw]
+
+  body = JSON.pretty_generate(response.parsed_body)
 
   view = Yobi.view(:output)
+  output_result = view.result(binding)
 
   if options[:output]
     file = File.expand_path(options[:output], Dir.pwd)
-    File.write(file, ERB.new(view).result(binding), mode: "w")
+    File.write(file, output_result, mode: "w")
   else
-    puts TTY::Markdown.parse(ERB.new(view).result(binding), color: :always)
+    puts TTY::Markdown.parse(output_result, color: :always)
   end
 end

data/lib/yobi/cli/arguments.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Yobi
+  module CLI
+    # Command-line argument utilities
+    module Arguments
+      class << self
+        def http_method?(value)
+          Yobi::Http::METHODS.include? value.upcase
+        end
+
+        def url(value)
+          case value
+          when %r{\Ahttps?://}
+            value
+          when /\A:\d+/
+            "http://localhost#{value}"
+          else
+            "http://#{value}"
+          end
+        end
+
+        def parse_data(args)
+          args.select { |arg| arg.include?("=") }.map.to_h { |arg| arg.split("=", 2).map(&:strip) }
+        end
+
+        def parse_headers(args)
+          { "Content-Type" => "application/json", "User-Agent" => "#{Yobi.name}/#{Yobi::VERSION}" }
+            .merge(args.select { |arg| arg.include?(":") }.map.to_h { |arg| arg.split(":", 2).map(&:strip) })
+        end
+
+        def auth_header(headers, options)
+          raise ArgumentError, "Authentication credentials must be provided with --auth" unless options[:auth]
+
+          auth_type = options.fetch(:auth_type, "basic")
+
+          case auth_type.downcase
+          when "basic"
+            headers["Authorization"] = "Basic #{Base64.strict_encode64(options[:auth])}"
+          when "bearer"
+            headers["Authorization"] = "Bearer #{options[:auth]}"
+          else
+            warn "Unsupported authentication type: #{auth_type}"
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yobi/cli.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "cli/arguments"

data/lib/yobi/extensions/net_http/parsing.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Net
+  # Extend the Net::HTTPResponse class to add parsing methods
+  class HTTPResponse
+    # Parses the response body as JSON if the Content-Type is application/json, otherwise returns the raw body.
+    #
+    # @return [Object, String, nil] The parsed JSON object, raw body string, or nil if there is no body.
+    def parsed_body
+      return @parsed_body if instance_variable_defined?(:@parsed_body)
+
+      if body && content_type&.include?("application/json")
+        begin
+          @parsed_body = JSON.parse(body)
+        rescue JSON::ParserError
+          @parsed_body = body
+        end
+      else
+        @parsed_body = body
+      end
+    end
+  end
+end

data/lib/yobi/extensions/net_http.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "net_http/parsing"

data/lib/yobi/extensions.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob(File.expand_path("extensions/*.rb", __dir__)).sort.each do |path|
+  require path
+end

data/lib/yobi/http.rb

@@ -1,8 +1,31 @@
 # frozen_string_literal: true
 
+require "net/http"
+
 module Yobi
   # Yobi Http behaviors and constants
   module Http
     METHODS = %w[GET POST PUT DELETE PATCH HEAD OPTIONS].freeze
+
+    class << self
+      # rubocop:disable Metrics/AbcSize
+      def request(method, url, data: {}, headers: {}, options: {})
+        @uri = URI(url)
+        @options = options
+        @method = method.capitalize
+
+        Net::HTTP.start(@uri.host, @uri.port, use_ssl: @uri.scheme == "https") do |http|
+          request_class = Net::HTTP.const_get(@method)
+          request = request_class.new(@uri)
+
+          headers.each { |key, value| request[key] = value }
+
+          request.body = data.to_json unless data.empty?
+
+          yield(http, request) if block_given?
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
   end
 end

data/lib/yobi/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Yobi
+  # Yobi gem version
+  VERSION = "0.8.0"
+end

data/lib/yobi.rb

@@ -1,26 +1,37 @@
 # frozen_string_literal: true
 
+require "erb"
+
+require "yobi/cli"
+require "yobi/extensions"
 require "yobi/http"
+require "yobi/version"
 
 # Yobi Http CLI client namespace
 module Yobi
   # Standard Yobi error class
   class Error < StandardError; end
 
-  # Yobi gem version
-  VERSION = "0.6.0"
+  class << self
+    def name
+      "yobi"
+    end
 
+    def description
+      "A simple HTTP client for testing APIs from the command line."
+    end
 
-  def self.name
-    "yobi"
-  end
+    # Load project templates
+    def view(name)
+      ERB.new(File.read(File.join(__dir__, "views/#{name}.md.erb")))
+    end
 
-  def self.description
-    "A simple HTTP client for testing APIs from the command line."
-  end
+    def request(...)
+      Yobi::Http.request(...)
+    end
 
-  # Load project templates
-  def self.view(name)
-    File.read(File.join(__dir__, "views/#{name}.md.erb"))
+    def args
+      Yobi::CLI::Arguments
+    end
   end
 end

data/spec/extensions/net_http/parsing_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Net::HTTPResponse do
+  describe "#parsed_body" do
+    subject(:response) do
+      Yobi::Http.request(:get, "http://example.com") do |http, request|
+        http.request(request)
+      end
+    end
+
+    before do
+      stub_request(:get, "http://example.com")
+        .to_return(status: 200, body: '{"name": "John", "age": 30}', headers: { "Content-Type" => "application/json" })
+    end
+
+    it "parses JSON response bodies into Ruby objects" do
+      expect(response.parsed_body).to eq({ "name" => "John", "age" => 30 })
+    end
+
+    context "when the response body is not valid JSON" do
+      before do
+        stub_request(:get, "http://example.com")
+          .to_return(status: 200, body: "Not a JSON string", headers: { "Content-Type" => "application/json" })
+      end
+
+      it "returns the raw body string if JSON parsing fails" do
+        expect(response.parsed_body).to eq("Not a JSON string")
+      end
+    end
+
+    context "when the Content-Type is not application/json" do
+      before do
+        stub_request(:get, "http://example.com")
+          .to_return(status: 200, body: "Just a plain text response", headers: { "Content-Type" => "text/plain" })
+      end
+
+      it "returns the raw body string if Content-Type is not application/json" do
+        expect(response.parsed_body).to eq("Just a plain text response")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+if ENV["COVERAGE"]
+  require "simplecov"
+  require "simplecov-console"
+
+  SimpleCov.root(File.expand_path("..", __dir__))
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+    [SimpleCov::Formatter::HTMLFormatter,
+     SimpleCov::Formatter::Console]
+  )
+  SimpleCov.coverage_dir("coverage")
+
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_group "Lib", "lib"
+
+    track_files "lib/**/*.rb"
+  end
+
+  SimpleCov.minimum_coverage 90
+end
+
+# puts "ROOT: #{SimpleCov.root}"
+# puts "TRACKED: #{SimpleCov.tracked_files.inspect}"
+# puts "LOADED BEFORE START: #{$LOADED_FEATURES.grep(/lib/).size}"
+
+Dir[File.expand_path("../lib/**/*.rb", __dir__)].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus unless ENV["CI"]
+
+  if ENV["META"]
+    config.example_status_persistence_file_path = "spec/examples.txt"
+    config.profile_examples = 10
+  end
+  # config.warnings = true
+
+  # if config.files_to_run.one?
+  #   config.default_formatter = "doc"
+  # end
+
+  # config.order = :random
+  # Kernel.srand config.seed
+
+  config.after(:suite) do
+    SimpleCov.result.format! if ENV["COVERAGE"]
+  end
+end
+
+# load support configuration files
+Dir[File.expand_path("support/**/*.rb", __dir__)].sort.each { |f| require f }

data/spec/support/webmock.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "webmock/rspec"
+
+RSpec.configure do |config|
+  # Enable WebMock
+  config.before(:each) do
+    WebMock.enable!
+  end
+
+  # Disable WebMock after each test to allow real HTTP connections if needed
+  config.after(:each) do
+    WebMock.disable!
+  end
+end

data/spec/yobi/cli/arguments_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Yobi::CLI::Arguments do
+  describe ".http_method?" do
+    context "when given valid HTTP methods" do
+      Yobi::Http::METHODS.each do |method|
+        it "recognizes #{method} as a valid HTTP method" do
+          expect(described_class.http_method?(method)).to be_truthy
+        end
+
+        it "is case-insensitive for #{method}" do
+          expect(described_class.http_method?(method.downcase)).to be_truthy
+        end
+      end
+    end
+
+    context "when given invalid HTTP methods" do
+      it "does not recognize FOO as a valid HTTP method" do
+        expect(described_class.http_method?("Foo")).to be_falsey
+      end
+    end
+  end
+
+  describe ".url" do
+    context "when given a URL that starts with http://" do
+      it "returns the http URL unchanged if it looks completed and valid" do
+        expect(described_class.url("http://example.com")).to eq("http://example.com")
+      end
+
+      it "returns the https URL unchanged if it looks completed and valid" do
+        expect(described_class.url("https://example.com")).to eq("https://example.com")
+      end
+    end
+
+    context "when given a URL that does not start with http://" do
+      it "prepends http:// to URLs" do
+        expect(described_class.url("example.com")).to eq("http://example.com")
+      end
+    end
+
+    context "when given a URL that starts with :port" do
+      it "returns a URL with http://localhost prepended" do
+        expect(described_class.url(":3000")).to eq("http://localhost:3000")
+      end
+    end
+  end
+
+  describe ".parse_data" do
+    it "parses key=value pairs into a hash" do
+      args = ["name=John", "age=30", "city=New York"]
+
+      expect(described_class.parse_data(args)).to eq({ "name" => "John", "age" => "30", "city" => "New York" })
+    end
+
+    it "ignores arguments that do not contain an equals sign" do
+      args = ["name=John", "invalid_arg", "age=30"]
+
+      expect(described_class.parse_data(args)).to eq({ "name" => "John", "age" => "30" })
+    end
+  end
+
+  describe ".parse_headers" do
+    it "parses key:value pairs into a headers hash" do
+      args = ["Content-Type: text/http", "User-Agent: Yobi/1.0"]
+
+      expect(described_class.parse_headers(args))
+        .to eq({ "Content-Type" => "text/http", "User-Agent" => "Yobi/1.0" })
+    end
+
+    it "includes default headers" do
+      args = []
+
+      expect(described_class.parse_headers(args))
+        .to eq({ "Content-Type" => "application/json", "User-Agent" => "#{Yobi.name}/#{Yobi::VERSION}" })
+    end
+  end
+
+  describe ".auth_header" do
+    it "raises an error if auth credentials are missing" do
+      expect { described_class.auth_header({}, {}) }.to raise_error(ArgumentError)
+    end
+
+    it "adds a Basic Authorization header when auth_type is basic" do
+      headers = {}
+      options = { auth: "user:pass", auth_type: "basic" }
+
+      described_class.auth_header(headers, options)
+      expect(headers["Authorization"]).to eq("Basic #{Base64.strict_encode64("user:pass")}")
+    end
+
+    it "adds a Bearer Authorization header when auth_type is bearer" do
+      headers = {}
+      options = { auth: "mytoken", auth_type: "bearer" }
+
+      described_class.auth_header(headers, options)
+      expect(headers["Authorization"]).to eq("Bearer mytoken")
+    end
+
+    it "exits with an error for unsupported auth types" do
+      headers = {}
+      options = { auth: "mytoken", auth_type: "unsupported" }
+
+      expect { described_class.auth_header(headers, options) }.to raise_error(SystemExit)
+    end
+  end
+end

data/spec/yobi/http_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Yobi::Http do
+  describe "METHODS" do
+    it "includes standard HTTP methods" do
+      expect(Yobi::Http::METHODS).to include("GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS")
+    end
+  end
+
+  describe ".request" do
+    subject(:response) { described_class.request(*meta) { |http, request| http.request(request) } }
+
+    let(:meta) { [:get, "http://example.com"] }
+    let(:result) { { status: 201, body: "Created" } }
+    let(:arguments) { { body: {} } }
+
+    before { stub_request(*meta).to_return(**result) }
+
+    it { expect(Yobi::Http).to respond_to(:request) }
+
+    context "when making a GET request" do
+      let(:result) { { status: 200, body: "OK" } }
+      let(:arguments) { { body: nil } }
+
+      it { expect(response.code).to eq("200") }
+      it { expect(response.body).to eq("OK") }
+    end
+
+    context "when making a POST request with data" do
+      let(:meta) { [:post, "http://example.com"] }
+      let(:result) { { status: 201, body: "Created" } }
+      let(:arguments) { { body: { "name" => "John" }.to_json } }
+
+      it { expect(response.code).to eq("201") }
+      it { expect(response.body).to eq("Created") }
+    end
+  end
+end

data/spec/yobi_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Yobi do
+  describe "VERSION" do
+    it { expect(Yobi.constants).to include(:VERSION) }
+
+    it "follows semantic versioning format" do
+      expect(Yobi::VERSION).to match(/^\d+\.\d+\.\d+$/)
+    end
+  end
+
+  describe ".name" do
+    it { expect(Yobi).to respond_to(:name) }
+    it { expect(Yobi.name).to eq("yobi") }
+  end
+
+  describe ".description" do
+    it { expect(Yobi).to respond_to(:description) }
+    it { expect(Yobi.description).to eq("A simple HTTP client for testing APIs from the command line.") }
+  end
+
+  describe ".view" do
+    it { expect(Yobi).to respond_to(:view) }
+
+    it "loads a template by name" do
+      expect(Yobi.view(:output).src).to include("HTTP/1.1")
+    end
+
+    it "raises an error if the template does not exist" do
+      expect { Yobi.view("nonexistent") }.to raise_error(Errno::ENOENT)
+    end
+  end
+
+  describe ".args" do
+    it { expect(Yobi).to respond_to(:args) }
+    it { expect(Yobi.args).to be(Yobi::CLI::Arguments) }
+  end
+end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: yobi-http
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Daniel Vinciguerra
 bindir: exe
 cert_chain: []
-date: 2026-02-16 00:00:00.000000000 Z
+date: 2026-02-20 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: tty-markdown
   requirement: !ruby/object:Gem::Requirement
@@ -32,6 +46,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
 - Agents.md
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -40,7 +55,19 @@ files:
 - exe/yobi
 - lib/views/output.md.erb
 - lib/yobi.rb
+- lib/yobi/cli.rb
+- lib/yobi/cli/arguments.rb
+- lib/yobi/extensions.rb
+- lib/yobi/extensions/net_http.rb
+- lib/yobi/extensions/net_http/parsing.rb
 - lib/yobi/http.rb
+- lib/yobi/version.rb
+- spec/extensions/net_http/parsing_spec.rb
+- spec/spec_helper.rb
+- spec/support/webmock.rb
+- spec/yobi/cli/arguments_spec.rb
+- spec/yobi/http_spec.rb
+- spec/yobi_spec.rb
 homepage: https://github.com/dvinciguerra/yobi-http
 licenses: []
 metadata: