fizzy-cli 0.1.0

data/lib/fizzy/client.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Fizzy
+  Response = Data.define(:body, :headers, :status)
+
+  class Client
+    BASE_URL = "https://app.fizzy.do"
+
+    attr_reader :account_slug
+
+    def initialize(token:, account_slug:)
+      @token = token
+      @account_slug = account_slug
+    end
+
+    def get(path, params: {})
+      request(:get, path, params: params)
+    end
+
+    def post(path, body: nil)
+      request(:post, path, body: body)
+    end
+
+    def put(path, body: nil)
+      request(:put, path, body: body)
+    end
+
+    def patch(path, body: nil)
+      request(:patch, path, body: body)
+    end
+
+    def delete(path)
+      request(:delete, path)
+    end
+
+    private
+
+    def connection
+      @connection ||= begin
+        uri = URI(BASE_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.open_timeout = 5
+        http.read_timeout = 30
+        http.start
+        http
+      end
+    end
+
+    def request(method, path, body: nil, params: {})
+      uri = URI("#{BASE_URL}#{path}")
+      uri.query = URI.encode_www_form(params) unless params.empty?
+
+      req = build_request(method, uri)
+      req["Authorization"] = "Bearer #{@token}"
+      req["Accept"] = "application/json"
+
+      if body
+        req["Content-Type"] = "application/json"
+        req.body = body.to_json
+      end
+
+      response = connection.request(req)
+      handle_response(response)
+    rescue Net::OpenTimeout, Net::ReadTimeout, SocketError, Errno::ECONNREFUSED => e
+      raise NetworkError, "Network error: #{e.message}"
+    end
+
+    def build_request(method, uri)
+      case method
+      when :get    then Net::HTTP::Get.new(uri)
+      when :post   then Net::HTTP::Post.new(uri)
+      when :put    then Net::HTTP::Put.new(uri)
+      when :patch  then Net::HTTP::Patch.new(uri)
+      when :delete then Net::HTTP::Delete.new(uri)
+      end
+    end
+
+    def handle_response(response)
+      status = response.code.to_i
+      parsed_body = parse_body(response)
+
+      case status
+      when 200..299
+        # Follow Location header on 201 to fetch the created resource
+        if status == 201 && parsed_body.nil? && response["location"]
+          location = response["location"].sub(/\.json$/, "")
+          return get(location)
+        end
+
+        Response.new(body: parsed_body, headers: response.to_hash, status: status)
+      when 301, 302
+        raise AuthError.new("Redirected to #{response["location"]} — endpoint may require session auth",
+                            status: status, body: parsed_body)
+      when 401
+        raise AuthError.new("Authentication failed (401)", status: 401, body: parsed_body)
+      when 403
+        raise ForbiddenError.new("Forbidden (403)", status: 403, body: parsed_body)
+      when 404
+        raise NotFoundError.new("Not found (404)", status: 404, body: parsed_body)
+      when 422
+        raise ValidationError.new(parse_error(response), status: 422, body: parsed_body)
+      when 429
+        raise RateLimitError.new("Rate limited (429)", status: 429, body: parsed_body)
+      else
+        raise ServerError.new("HTTP #{response.code}: #{response.body}", status: status, body: parsed_body)
+      end
+    end
+
+    def parse_body(response)
+      body = response.body&.strip
+      body.nil? || body.empty? ? nil : JSON.parse(body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def parse_error(response)
+      data = JSON.parse(response.body)
+      data["error"] || data["errors"]&.join(", ") || response.body
+    rescue JSON::ParserError
+      response.body
+    end
+  end
+end

data/lib/fizzy/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Fizzy
+  class Error < StandardError
+    attr_reader :status, :body
+
+    def initialize(message = nil, status: nil, body: nil)
+      super(message)
+      @status = status
+      @body = body
+    end
+  end
+
+  class AuthError < Error; end
+  class NotFoundError < Error; end
+  class ValidationError < Error; end
+  class ForbiddenError < Error; end
+  class ServerError < Error; end
+  class RateLimitError < Error; end
+  class NetworkError < Error; end
+end

data/lib/fizzy/formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Fizzy
+  class Formatter
+    def self.table(rows, headers:, io: $stdout)
+      return if rows.empty?
+
+      all_rows = [headers] + rows
+      widths = headers.each_index.map do |i|
+        all_rows.map { |r| r[i].to_s.length }.max
+      end
+
+      io.puts headers.each_with_index.map { |h, i| h.to_s.ljust(widths[i]) }.join("  ")
+      io.puts widths.map { |w| "-" * w }.join("  ")
+      rows.each do |row|
+        io.puts row.each_with_index.map { |c, i| c.to_s.ljust(widths[i]) }.join("  ")
+      end
+    end
+
+    def self.json(data, io: $stdout)
+      io.puts JSON.pretty_generate(data)
+    end
+
+    def self.detail(pairs, io: $stdout)
+      width = pairs.map { |k, _| k.to_s.length }.max
+      pairs.each do |key, value|
+        io.puts "#{key.to_s.rjust(width)}  #{value}"
+      end
+    end
+
+    def self.truncate(str, max)
+      return "" unless str
+
+      str.length > max ? "#{str[0...(max - 1)]}…" : str
+    end
+  end
+end

data/lib/fizzy/paginator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Fizzy
+  class Paginator
+    def initialize(client)
+      @client = client
+    end
+
+    def all(path, params: {})
+      items = []
+      each_page(path, params: params) { |page| items.concat(Array(page)) }
+      items
+    end
+
+    def each_page(path, params: {})
+      current_path = path
+      current_params = params
+
+      loop do
+        response = @client.get(current_path, params: current_params)
+        yield response.body if block_given?
+
+        next_path = parse_next_link(response.headers)
+        break unless next_path
+
+        current_path = next_path
+        current_params = {}
+      end
+    end
+
+    private
+
+    def parse_next_link(headers)
+      link = headers["link"]&.first
+      return unless link
+
+      match = link.match(/<([^>]+)>;\s*rel="next"/)
+      return unless match
+
+      URI(match[1]).request_uri
+    end
+  end
+end

data/lib/fizzy/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Fizzy
+  VERSION = "0.1.0"
+end

data/lib/fizzy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+require_relative "fizzy/version"
+require_relative "fizzy/errors"
+require_relative "fizzy/auth"
+require_relative "fizzy/client"
+require_relative "fizzy/paginator"
+require_relative "fizzy/formatter"
+require_relative "fizzy/cli"

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: fizzy-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Paluy
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Command-line client for Fizzy project management. Manage boards, cards,
+  columns, steps, comments, and more from the terminal.
+email:
+- dpaluy@gmail.com
+executables:
+- fizzy
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/fizzy
+- lib/fizzy.rb
+- lib/fizzy/auth.rb
+- lib/fizzy/cli.rb
+- lib/fizzy/cli/auth.rb
+- lib/fizzy/cli/base.rb
+- lib/fizzy/cli/boards.rb
+- lib/fizzy/cli/cards.rb
+- lib/fizzy/cli/columns.rb
+- lib/fizzy/cli/comments.rb
+- lib/fizzy/cli/notifications.rb
+- lib/fizzy/cli/pins.rb
+- lib/fizzy/cli/reactions.rb
+- lib/fizzy/cli/steps.rb
+- lib/fizzy/cli/tags.rb
+- lib/fizzy/cli/users.rb
+- lib/fizzy/client.rb
+- lib/fizzy/errors.rb
+- lib/fizzy/formatter.rb
+- lib/fizzy/paginator.rb
+- lib/fizzy/version.rb
+homepage: https://github.com/dpaluy/fizzy-cli
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/dpaluy/fizzy-cli
+  source_code_uri: https://github.com/dpaluy/fizzy-cli
+  changelog_uri: https://github.com/dpaluy/fizzy-cli/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/dpaluy/fizzy-cli/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: CLI for Fizzy project management
+test_files: []