yobi-http 0.16.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3558906f242a7670158833610ad7b062bf25e308e4985804241bdba30a9d6968
-  data.tar.gz: d96e600ccdf03ebcddb0c9ce14a3a2c141fb1a1ba2ffe04ee7cdb0a1a5383c7d
+  metadata.gz: ee3f871068b818f6f194f64edecbfe16bfb51c5d590445da566a8e6229bd3b28
+  data.tar.gz: 17e8538a544d0cdc95317180a7e11418460c26288ee5f77f770c52356c654c90
 SHA512:
-  metadata.gz: 68ec04f8b731ebc0e9f508ed332d6414292963d1dbbd97aaba96a360e930ce3d1421812d11c1031305126633db9ad012fb2f4efa6e170aba4e09e3eeef37cf3e
-  data.tar.gz: 61c69a1bfdc761df2c791396fb84a3ce5183bf24b71ffb4073fbebdbd1e86b3e5e6986fbeeb977a7c2225624d72d083270e585e0afe186030066b3dab05f0e6c
+  metadata.gz: 70b8027ba0bec021821bd8e50bcc216796e29650d3a4791082146b608293e5b7b088ac7352317c0a010f05e8438b92343c3b8e64e1450027888c4d86d9545f63
+  data.tar.gz: 1b5249c74c29c93de6ae4d6138281745b98eedb50d216e52b096248a331ff7ce552b7d53aae0e4da4d045339d7b66b92f12ef4c72ede58d1c0623aa2bb5e8e01

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.20.0]
+
+- Add support to --stream flag
+
 ## [0.6.0]
 
 - Add output to file feature

data/README.md

@@ -2,29 +2,198 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![Maintainability](https://qlty.sh/gh/dvinciguerra/projects/yobi-http/maintainability.svg)](https://qlty.sh/gh/dvinciguerra/projects/yobi-http)
 
-# Yobi(呼び) Http Client
+# :zap: Yobi(呼び) Http Client
 
-Yobi is a Ruby gem that provides a simple and efficient way to make HTTP requests. It is designed to be easy to use
-and flexible, allowing you to customize your requests as needed.
-
-Its a lightweight implementation of the HTTPie tool, which is a command-line HTTP client that allows you to make
-HTTP requests and view the responses in a human-friendly format.
+Yobi (呼び) is a modern HTTP client for the command line, written in Ruby, that makes interacting with APIs simple, intuitive, and fun. Inspired by HTTPie, Yobi provides an elegant way to make HTTP requests with formatted and readable output.
 
 ![](./screenshot.png)
 
+#### Main Features
+
+* Simple and intuitive interface - Natural and easy-to-remember syntax
+* Automatic formatting - JSON responses with syntax highlighting
+* Multiple authentication types - Basic, Bearer, Digest, and more
+* File download - Save responses directly to files
+* Redirect tracking - Automatically follow HTTP redirects
+* Customizable output - Control exactly what you want to see (headers, body, or both)
+* Full HTTP support - GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
+* Offline mode - Prepare and review requests without sending them
+* No heavy dependencies - Quick installation via RubyGems
+* Raw mode - Raw output for integration with other tools
+
+
 ## Installation
 
+#### Prerequisites
+
+* Ruby >= 3.0.0
+* RubyGems (usually included with Ruby)
+
+#### Via RubyGems (Recommended)
+
+```bash
+gem install yobi-http
+```
+
+#### From Source Code
+
 ```bash
+# Clone the repository
+git clone https://github.com/dvinciguerra/yobi-http.git
+cd yobi-http
+
+# Install dependencies
+bundle install
+
+# Install the gem locally
+bundle exec rake install```bash
 gem install yobi-http
 ```
 
-## Usage
+#### Check Installation
+
+```bash
+yobi --version
+```
+
+If you receive command not found: yobi:
+
+* Ensure that the RubyGems bin directory is in your PATH.
+* Try using gem which yobi-http to locate the installation.
+
+
+## Quick Guide
+
+#### Basic Syntax
+
+```bash
+yobi [METHOD] <url> [HEADER:VALUE] [key=value] [key::value]
+```
+
+### Instant Examples
+
+```bash
+# Simple GET
+yobi https://api.github.com/users/github
+
+# POST with JSON
+yobi POST https://jsonplaceholder.typicode.com/posts \
+  title="Hello" \
+  body="World" \
+  userId=1
+
+# With authentication
+yobi -A basic -a username:password https://api.example.com/data
+
+# WITH custom header
+yobi GET https://api.example.com/data \
+  Authorization:"Bearer your_token_here"
+
+# Save response to file
+yobi https://api.example.com/data -o response.json
+
+# Use localhost shortcut
+yobi :8080/api/items
+# Expands to: http://localhost:8080/api/items
+```
+
+**JSONPlaceholder API (Testing Service)**
+
+```bash
+# Get all posts
+yobi https://jsonplaceholder.typicode.com/posts
+
+# Get specific post
+yobi https://jsonplaceholder.typicode.com/posts/1
+
+# Create new post
+yobi POST https://jsonplaceholder.typicode.com/posts \
+  title="My new post" \
+  body="This is the content" \
+  userId=1
+
+# Update post
+yobi PUT https://jsonplaceholder.typicode.com/posts/1 \
+  title="Updated title"
+
+# Delete post
+yobi DELETE https://jsonplaceholder.typicode.com/posts/1
+```
+
+**GitHub API**
+
+```bash
+# User information
+yobi https://api.github.com/users/dvinciguerra
+
+# User repositories
+yobi https://api.github.com/users/dvinciguerra/repos
+
+# With authentication (personal token)
+yobi -A bearer -a your_github_token https://api.github.com/user
+```
+
+**HTTPBin (API Testing Tool)**
+
+```bash
+# GET with query params
+yobi https://httpbin.org/get name=John age=30
+
+# POST with JSON
+yobi POST https://httpbin.org/post name=John age:=30 active:=true
+
+# Custom headers
+yobi https://httpbin.org/headers \
+  "X-Custom:value" \
+  "User-Agent:Yobi/1.0"
+
+# Basic authentication test
+yobi https://httpbin.org/basic-auth/username/password \
+  -A basic -a username:password
+
+# Simulate delay
+yobi https://httpbin.org/delay/5
+
+# Test timeout
+yobi --timeout 2 https://httpbin.org/delay/10
+```
+
+**Typical REST API**
+
+```bash
+# List resources
+yobi GET https://api.example.com/v1/users
+
+# Create resource
+yobi POST https://api.example.com/v1/users \
+  name="John Silva" \
+  email="john@example.com" \
+  department="IT"
+
+# Update resource
+yobi PUT https://api.example.com/v1/users/123 \
+  name="John da Silva" \
+  department="Development"
+
+# Partial update
+yobi PATCH https://api.example.com/v1/users/123 \
+  department="Management"
+
+# Delete resource
+yobi DELETE https://api.example.com/v1/users/123
+
+# With pagination
+yobi GET https://api.example.com/v1/users \
+  page:=1 \
+  limit:=10
+
+# With filters
+yobi GET https://api.example.com/v1/users \
+  department="IT" \
+  status="active"
+```
 
-Some examples of how to use yobi:
 
-- `yobi GET https://jsonplaceholder.typicode.com/posts/1` - Makes a GET request to the specified URL and prints the response.
-- `yobi POST https://jsonplaceholder.typicode.com/posts title="foo" body="bar" userId=1` - Makes a POST request to the specified URL with the given data and prints the response.
-- `yobi GET https://jsonplaceholder.typicode.com/posts/1 Authorization:"Bearer <token>"` - Makes a GET request to the specified URL with the given header and prints the response.
 
 ## Development
 

data/exe/yobi

@@ -16,7 +16,7 @@ require "yobi"
 # parsing arguments
 @options = {
   print: "HB", auth: nil, auth_type: "basic", verbose: false, raw: false, offline: false, follow: false, debug: false,
-  timeout: nil, download: false, output: nil, content_type: :json
+  timeout: nil, download: false, output: nil, content_type: :json, stream: false
 }
 
 parser = OptionParser.new do |opts|
@@ -38,6 +38,7 @@ parser = OptionParser.new do |opts|
 
   opts.on("-p", "--print FORMAT", "Specify the output format (e.g., 'H' for headers, 'B' for body)") do |format|
     @options[:print] = format || "HB" # default to printing both headers and body
+    @options[:print_set_explicitly] = true
     warn "[Argument Error] Unsupported format: #{format}" unless format.match?(/\A[HBhb]+\z/)
   end
 
@@ -53,6 +54,21 @@ parser = OptionParser.new do |opts|
     @options[:raw] = true
   end
 
+  opts.on("-h", "--headers", "Print only response headers") do
+    @options[:raw] = true
+    @options[:print] = "H"
+  end
+
+  opts.on("-b", "--body", "Print only response body") do
+    @options[:raw] = true
+    @options[:print] = "B"
+  end
+
+  opts.on("--status", "Print only response status code") do
+    @options[:raw] = true
+    @options[:print] = "status"
+  end
+
   opts.on("--form", "Send data as application/x-www-form-urlencoded instead of JSON") do
     @options[:content_type] = :form
   end
@@ -74,11 +90,6 @@ parser = OptionParser.new do |opts|
     @options[:content_type] = :json
   end
 
-  opts.on("-h", "--help", "Print this help message") do
-    puts opts
-    exit
-  end
-
   opts.on("--offline", "Run in offline mode (prepare request but do not send)") do
     @options[:offline] = true
   end
@@ -95,6 +106,12 @@ parser = OptionParser.new do |opts|
     @options[:timeout] = timeout.to_f
   end
 
+  opts.on("--stream", "Stream response body (chunked transfer encoding), printing each chunk as it arrives") do
+    @options[:stream] = true
+    # Default to body-only when streaming, unless the user already set --print explicitly
+    @options[:print] = "B" unless @options[:print_set_explicitly]
+  end
+
   opts.on("--download", "Download response body to a file specified by --output") do
     @options[:download] = true
   end
@@ -112,6 +129,11 @@ parser = OptionParser.new do |opts|
     puts "#{Yobi.name} v#{Yobi::VERSION}"
     exit
   end
+
+  opts.on("--help", "Print this help message") do
+    puts opts
+    exit
+  end
 end
 
 parser.parse!(ARGV)
@@ -132,12 +154,14 @@ Yobi.args.auth_header(headers, @options) if @options[:auth]
 Yobi::Http.request(method, url, data: data, headers: headers, query: query, options: @options) do |http, request|
   options = @options
 
-  # follow redirects, offline, download or standard request mode
+  # follow redirects, offline, download, stream or standard request mode
   response =
     if options[:follow]
       Yobi::Http.follow_redirects(http.request(request), url, method, data, headers, options)
     elsif options[:offline]
       Yobi::Http.offline_mode(request, options)
+    elsif options[:stream]
+      Yobi::Http.stream(request, http, options)
     elsif options[:download]
       Yobi::Http.download(request, http, options)
     else
@@ -145,7 +169,9 @@ Yobi::Http.request(method, url, data: data, headers: headers, query: query, opti
     end
 
   # render output
-  if options[:raw]
+  if options[:raw] && options[:print].downcase == "status"
+    print response.code
+  elsif options[:raw]
     Yobi::Renders::Raw.render(request, response, options)
   else
     Yobi::Renders::Colored.render(request, response, options)

data/lib/yobi/http.rb

@@ -41,10 +41,16 @@ module Yobi
           request.body = data.to_json unless data.empty?
 
           yield(http, request) if block_given?
-        rescue Net::OpenTimeout, Net::ReadTimeout => e
-          warn "Request timed out: #{e.message}"
-          exit 1
         end
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        warn "Timeout: #{e.message}"
+        exit 1
+      rescue SocketError, Socket::ResolutionError => e
+        warn "Network error: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        warn "Error: #{e.message}"
+        exit 1
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
 
@@ -86,6 +92,24 @@ module Yobi
       end
       # rubocop:enable Metrics/AbcSize
 
+      def stream(request, http, options)
+        http.request(request) do |response|
+          Yobi::Renders::Stream.render_headers(response, options)
+
+          response.read_body do |chunk|
+            Yobi::Renders::Stream.render_chunk(chunk, options)
+          end
+
+          Yobi::Renders::Stream.flush_buffer(options)
+        end
+
+        exit 0
+      rescue Interrupt
+        Yobi::Renders::Stream.flush_buffer(options)
+        $stdout.puts
+        exit 0
+      end
+
       # rubocop:disable Metrics/AbcSize
       def download(request, http, options)
         http.request(request) do |response|

data/lib/yobi/renders/stream.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Yobi
+  module Renders
+    # Render streaming (chunked) response chunks to the terminal as they arrive
+    module Stream
+      class << self
+        # Called once when the response headers are received
+        def render_headers(response, options = {})
+          return unless options[:print]&.include?("H")
+
+          if options[:raw]
+            $stdout.puts "HTTP/#{response.http_version} #{response.code} #{response.message}"
+            response.each_header { |key, value| $stdout.puts "#{key}: #{value}" }
+            $stdout.puts
+          else
+            header_md = "# HTTP/#{response.http_version} #{response.code} #{response.message}\n\n" \
+                        "```yaml\n" \
+                        "#{response.each_capitalized.to_h.sort.map { |k, v| "#{k}: #{v}" }.join("\n")}\n" \
+                        "```\n"
+            $stdout.print TTY::Markdown.parse(header_md, color: :always)
+          end
+
+          $stdout.flush
+        end
+
+        # Called for each chunk received. Buffers partial lines across calls so
+        # that JSON objects split across chunk boundaries are handled correctly.
+        def render_chunk(chunk, options = {})
+          return if chunk.nil? || chunk.empty?
+          return unless options[:print]&.include?("B")
+
+          if options[:raw]
+            $stdout.print chunk
+            $stdout.flush
+            return
+          end
+
+          data = (@line_buffer || "") + chunk
+          @line_buffer = nil
+
+          lines = data.split("\n", -1)
+
+          @line_buffer = lines.pop unless data.end_with?("\n")
+
+          lines.each do |line|
+            next if line.empty?
+
+            parsed = begin
+              JSON.parse(line)
+            rescue JSON::ParserError
+              nil
+            end
+
+            if parsed
+              pretty = JSON.pretty_generate(parsed)
+              md = "```json\n#{pretty}\n```\n"
+              $stdout.print TTY::Markdown.parse(md, color: :always)
+            else
+              $stdout.puts line
+            end
+
+            $stdout.flush
+          end
+        end
+
+        # Flush any remaining buffered line when the connection closes
+        def flush_buffer(options = {})
+          return unless @line_buffer && !@line_buffer.empty?
+          return unless options[:print]&.include?("B")
+
+          line = @line_buffer
+          @line_buffer = nil
+
+          parsed = begin
+            JSON.parse(line)
+          rescue JSON::ParserError
+            nil
+          end
+
+          if parsed && !options[:raw]
+            pretty = JSON.pretty_generate(parsed)
+            md = "```json\n#{pretty}\n```\n"
+            $stdout.print TTY::Markdown.parse(md, color: :always)
+          else
+            $stdout.puts line
+          end
+
+          $stdout.flush
+        end
+      end
+    end
+  end
+end

data/lib/yobi/version.rb

@@ -2,5 +2,5 @@
 
 module Yobi
   # Yobi gem version
-  VERSION = "0.16.0"
+  VERSION = "0.20.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: yobi-http
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Daniel Vinciguerra
 bindir: exe
 cert_chain: []
-date: 2026-03-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -77,6 +77,7 @@ files:
 - lib/yobi/renders.rb
 - lib/yobi/renders/colored.rb
 - lib/yobi/renders/raw.rb
+- lib/yobi/renders/stream.rb
 - lib/yobi/ui.rb
 - lib/yobi/ui/progress.rb
 - lib/yobi/version.rb
@@ -108,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Yobi is a terminal tool to make HTTP requests and display responses in a
   friendly way inspired by HTTPie.