marlens-jira-api 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 782848ce0d3f51aed25b94ade7e4cabda09106be46fd3803307450f42a9d249c
+  data.tar.gz: ce6672958668fcf08a45a3dbdceb66ba7a99daf5b2d95e5085b07efc8741581b
+SHA512:
+  metadata.gz: b31245df26fe026493a556d6e3b1ab1d9e45be5281705672b631d65b86f85ac91c8ce392064068b913c1c5e0c2096332c4f13533aeffdd59f382f6fd76cf4472
+  data.tar.gz: 5591a8de6a89de181ef02d0d5e4d7427bb20a6fc36c7d8c888c164f9966f029d30277516bf69b17dcc2bea8444dbbcc4bdb9e7d011fe79d422a2827f90cf9521

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marlen Brunner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Marlens Jira API
+
+Small Ruby helper for Jira Cloud comments. It provides basic Jira comment CRUD, converts Markdown to Atlassian Document Format, and can upload allowed remote images as Jira issue attachments.
+
+[RubyGems: `marlens-jira-api`](https://rubygems.org/gems/marlens-jira-api)
+
+## Install
+
+```ruby
+gem "marlens-jira-api", "~> 0.5"
+```
+
+## Ruby API
+
+```ruby
+client = Marlens::JiraApi::Client.new(
+  base_url: ENV.fetch("JIRA_BASE_URL"),
+  email: ENV.fetch("JIRA_EMAIL"),
+  api_token: ENV.fetch("JIRA_API_TOKEN")
+)
+
+comments = client.list_comments(issue_key: "WRAPX-123")
+comment = client.get_comment(issue_key: "WRAPX-123", comment_id: "10001")
+
+created = client.create_markdown_comment(
+  issue_key: "WRAPX-123",
+  markdown: "# Release notes\n\n1. Verify `code` and **bold** text."
+)
+
+client.update_markdown_comment(
+  issue_key: "WRAPX-123",
+  comment_id: created.fetch("id"),
+  markdown: "Updated comment body."
+)
+
+client.delete_comment(issue_key: "WRAPX-123", comment_id: created.fetch("id"))
+```
+
+## CLI
+
+Credentials are read from `JIRA_BASE_URL`, `JIRA_EMAIL`, and `JIRA_API_TOKEN`.
+
+```bash
+jira-comment list --issue-key WRAPX-123
+jira-comment get --issue-key WRAPX-123 --comment-id 10001
+jira-comment create --issue-key WRAPX-123 --markdown-file pr-body.md
+jira-comment update --issue-key WRAPX-123 --comment-id 10001 --markdown-file edited.md
+jira-comment delete --issue-key WRAPX-123 --comment-id 10001
+```
+
+Remote Markdown image URLs are advanced opt-in behavior. Pass `allowed_image_hosts:` in Ruby or repeat `--image-host` in the CLI only when you intentionally want the gem to fetch images from trusted hosts, upload them to Jira, and convert them into Jira media attachments.
+
+## Feature and Issue Workflow
+
+Preferred flow for issue and feature work:
+
+1. Create or identify the GitHub issue with the user story and acceptance criteria.
+2. Branch from current `main` using the issue number and a short slug before editing when possible. If scoped work already exists locally, create the issue-named branch before committing.
+3. Make the smallest change that resolves the request, including tests and README updates that must stay in sync.
+4. For releasable changes, bump `Marlens::JiraApi::VERSION` before opening the release PR.
+5. Open a draft PR, link the issue, include the checks run, and mark it ready only after verification.
+6. Merge the PR to `main` so GitHub records the review path.
+7. After merge, build and publish the gem version to RubyGems with `gem build marlens-jira-api.gemspec` and `gem push marlens-jira-api-<version>.gem`.
+8. Verify RubyGems lists the released version with `gem list --remote marlens-jira-api --exact --all`, then run an install or CLI smoke check.

data/bin/jira-comment

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/marlens/jira_api"
+
+exit(Marlens::JiraApi::CLI.run(ARGV))

data/lib/marlens/jira_api/cli.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+
+module Marlens
+  module JiraApi
+    class CLI
+      COMMANDS = {
+        "list" => { required: %i[issue_key], action: :list_comments },
+        "get" => { required: %i[issue_key comment_id], action: :get_comment },
+        "create" => { required: %i[issue_key markdown_file], action: :create_comment },
+        "update" => { required: %i[issue_key comment_id markdown_file], action: :update_comment },
+        "delete" => { required: %i[issue_key comment_id], action: :delete_comment },
+      }.freeze
+
+      def self.run(argv = ARGV, env: ENV, out: $stdout, err: $stderr, client_factory: nil)
+        new(argv, env:, out:, err:, client_factory:).run
+      end
+
+      def initialize(argv, env:, out:, err:, client_factory: nil)
+        @argv = argv.dup
+        @env = env
+        @out = out
+        @err = err
+        @client_factory = client_factory || method(:build_client)
+      end
+
+      def run
+        command = @argv.shift
+        config = COMMANDS[command]
+        return fail_with("Unknown command #{command.inspect}. Expected one of: #{COMMANDS.keys.join(", ")}") unless config
+
+        options = parse_options
+        missing = config.fetch(:required).select { |key| options[key].to_s.empty? }
+        return fail_with("Missing required option(s): #{option_names(missing)}") unless missing.empty?
+
+        @out.puts JSON.pretty_generate(send(config.fetch(:action), options))
+        0
+      rescue OptionParser::ParseError, KeyError => error
+        fail_with(error.message)
+      end
+
+      private
+
+      def parse_options
+        options = { allowed_image_hosts: [] }
+        parser = OptionParser.new do |parser|
+          parser.banner = "Usage: jira-comment [#{COMMANDS.keys.join("|")}] [options]"
+          parser.on("--issue-key ISSUE", "Jira issue key") { |value| options[:issue_key] = value }
+          parser.on("--comment-id ID", "Jira comment ID") { |value| options[:comment_id] = value }
+          parser.on("--markdown-file FILE", "Markdown file for create/update") { |value| options[:markdown_file] = value }
+          parser.on("--image-host HOST", "Allowed remote image host; repeatable") do |value|
+            options[:allowed_image_hosts] << value
+          end
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def list_comments(options)
+        client.list_comments(issue_key: options.fetch(:issue_key))
+      end
+
+      def get_comment(options)
+        client.get_comment(issue_key: options.fetch(:issue_key), comment_id: options.fetch(:comment_id))
+      end
+
+      def create_comment(options)
+        client.create_markdown_comment(
+          issue_key: options.fetch(:issue_key),
+          markdown: File.read(options.fetch(:markdown_file)),
+          allowed_image_hosts: options.fetch(:allowed_image_hosts)
+        )
+      end
+
+      def update_comment(options)
+        client.update_markdown_comment(
+          issue_key: options.fetch(:issue_key),
+          comment_id: options.fetch(:comment_id),
+          markdown: File.read(options.fetch(:markdown_file)),
+          allowed_image_hosts: options.fetch(:allowed_image_hosts)
+        )
+      end
+
+      def delete_comment(options)
+        client.delete_comment(issue_key: options.fetch(:issue_key), comment_id: options.fetch(:comment_id))
+        { deleted: true }
+      end
+
+      def client
+        @client ||= @client_factory.call(env: @env)
+      end
+
+      def build_client(env:)
+        Client.new(
+          base_url: env.fetch("JIRA_BASE_URL"),
+          email: env.fetch("JIRA_EMAIL"),
+          api_token: env.fetch("JIRA_API_TOKEN")
+        )
+      end
+
+      def fail_with(message)
+        @err.puts(message)
+        1
+      end
+
+      def option_names(keys)
+        keys.map { |key| "--#{key.to_s.tr("_", "-")}" }.join(", ")
+      end
+    end
+  end
+end

data/lib/marlens/jira_api/client.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "multipart/post"
+require "net/http"
+require "uri"
+
+module Marlens
+  module JiraApi
+    class Client
+      def initialize(base_url:, email:, api_token:)
+        @base_url = base_url.to_s.delete_suffix("/")
+        @email = email
+        @api_token = api_token
+      end
+
+      def list_comments(issue_key:, start_at: nil, max_results: nil)
+        uri = api_uri("/issue/#{issue_key}/comment")
+        query = {}
+        query["startAt"] = start_at unless start_at.nil?
+        query["maxResults"] = max_results unless max_results.nil?
+        uri.query = URI.encode_www_form(query) unless query.empty?
+
+        json_request(Net::HTTP::Get.new(uri), uri)
+      end
+
+      def get_comment(issue_key:, comment_id:)
+        uri = api_uri("/issue/#{issue_key}/comment/#{comment_id}")
+        json_request(Net::HTTP::Get.new(uri), uri)
+      end
+
+      def create_comment(issue_key:, document:)
+        uri = api_uri("/issue/#{issue_key}/comment")
+        request = Net::HTTP::Post.new(uri)
+        request.body = JSON.dump({ "body" => document })
+
+        json_request(request, uri)
+      end
+
+      def update_comment(issue_key:, comment_id:, document:)
+        uri = api_uri("/issue/#{issue_key}/comment/#{comment_id}")
+        request = Net::HTTP::Put.new(uri)
+        request.body = JSON.dump({ "body" => document })
+
+        json_request(request, uri)
+      end
+
+      def delete_comment(issue_key:, comment_id:)
+        uri = api_uri("/issue/#{issue_key}/comment/#{comment_id}")
+        response = authenticated_request(Net::HTTP::Delete.new(uri), uri)
+        return true if response.code.to_i == 204
+
+        raise "Failed to delete Jira comment #{comment_id} for #{issue_key}: #{response.code} #{response.body}"
+      end
+
+      def create_markdown_comment(issue_key:, markdown:, allowed_image_hosts: [])
+        document = markdown_document(
+          issue_key: issue_key,
+          markdown: markdown,
+          allowed_image_hosts: allowed_image_hosts
+        )
+        create_comment(issue_key: issue_key, document: document)
+      end
+
+      def update_markdown_comment(issue_key:, comment_id:, markdown:, allowed_image_hosts: [])
+        document = markdown_document(
+          issue_key: issue_key,
+          markdown: markdown,
+          allowed_image_hosts: allowed_image_hosts
+        )
+        update_comment(issue_key: issue_key, comment_id: comment_id, document: document)
+      end
+
+      alias post_comment create_comment
+      alias post_markdown_comment create_markdown_comment
+
+      def upload_attachment(issue_key:, io:, filename:, content_type:)
+        uri = api_uri("/issue/#{issue_key}/attachments")
+        request = Net::HTTP::Post::Multipart.new(
+          uri.request_uri,
+          "file" => UploadIO.new(io, content_type, filename)
+        )
+        request.basic_auth(@email, @api_token)
+        request["X-Atlassian-Token"] = "no-check"
+
+        response = http_request(uri, request)
+        unless response.code.to_i.between?(200, 299)
+          raise "Failed to upload Jira attachment for #{issue_key}: #{response.code} #{response.body}"
+        end
+
+        JSON.parse(response.body).first
+      end
+
+      private
+
+      def markdown_document(issue_key:, markdown:, allowed_image_hosts:)
+        image_uploader = RemoteImageAttachmentUploader.new(
+          client: self,
+          issue_key: issue_key,
+          allowed_hosts: allowed_image_hosts
+        )
+        MarkdownToAdf.call(markdown) do |image|
+          image_uploader.media_node_for(image)
+        end
+      end
+
+      def json_request(request, uri)
+        response = authenticated_request(request, uri)
+        return JSON.parse(response.body) if response.code.to_i.between?(200, 299)
+
+        raise "Jira API request failed: #{request.method} #{uri.request_uri}: #{response.code} #{response.body}"
+      end
+
+      def authenticated_request(request, uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Basic #{auth_token}"
+        http_request(uri, request)
+      end
+
+      def api_uri(path)
+        URI("#{@base_url}/rest/api/3#{path}")
+      end
+
+      def http_request(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.request(request)
+      end
+
+      def auth_token
+        Base64.strict_encode64("#{@email}:#{@api_token}")
+      end
+    end
+  end
+end

data/lib/marlens/jira_api/markdown_to_adf.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "commonmarker"
+
+module Marlens
+  module JiraApi
+    class MarkdownToAdf
+      IMAGE_TAG_PATTERN = /<img\b(?<attributes>[^>]+)>/i
+
+      def self.call(markdown, &image_resolver)
+        new(markdown, image_resolver: image_resolver).to_document
+      end
+
+      def self.media_single(id:, alt:, width:, height:)
+        {
+          "type" => "mediaSingle",
+          "attrs" => { "layout" => "center" },
+          "content" => [
+            {
+              "type" => "media",
+              "attrs" => {
+                "id" => id,
+                "type" => "file",
+                "collection" => "jira-issue-attachments",
+                "alt" => alt,
+                "width" => width,
+                "height" => height,
+              },
+            },
+          ],
+        }
+      end
+
+      def self.paragraph(text)
+        new("").send(:paragraph_from_text, text)
+      end
+
+      def initialize(markdown, image_resolver: nil)
+        @markdown = markdown.to_s
+        @image_resolver = image_resolver
+      end
+
+      def to_document
+        {
+          "type" => "doc",
+          "version" => 1,
+          "content" => document_content,
+        }
+      end
+
+      private
+
+      def document_content
+        blocks = render_blocks(markdown_document)
+        blocks.empty? ? [paragraph_from_text("(No PR description provided.)")] : blocks
+      end
+
+      def markdown_document
+        Commonmarker.parse(
+          @markdown,
+          options: {
+            parse: { smart: true },
+            extension: {
+              autolink: true,
+              strikethrough: true,
+              table: true,
+              tagfilter: false,
+            },
+          }
+        )
+      end
+
+      def render_blocks(parent)
+        children(parent).flat_map { |node| render_block(node) }.compact
+      end
+
+      def render_block(node)
+        case node.type
+        when :heading
+          heading(node)
+        when :paragraph
+          paragraph(node)
+        when :code_block
+          code_block(node)
+        when :list
+          list(node)
+        when :item
+          list_item(node)
+        when :block_quote
+          blockquote(node)
+        when :thematic_break
+          { "type" => "rule" }
+        when :html_block
+          html_image_block(node) || paragraph_from_text(node.to_commonmark.strip)
+        else
+          render_blocks(node)
+        end
+      end
+
+      def heading(node)
+        {
+          "type" => "heading",
+          "attrs" => { "level" => node.header_level },
+          "content" => inline_content(node),
+        }
+      end
+
+      def paragraph(node)
+        return image_block_for(children(node).first) if single_image_node?(node)
+
+        {
+          "type" => "paragraph",
+          "content" => inline_content(node),
+        }
+      end
+
+      def paragraph_from_text(text)
+        {
+          "type" => "paragraph",
+          "content" => [text_node(text)],
+        }
+      end
+
+      def code_block(node)
+        block = {
+          "type" => "codeBlock",
+          "content" => [{ "type" => "text", "text" => node.string_content.chomp }],
+        }
+        block["attrs"] = { "language" => node.fence_info } unless node.fence_info.to_s.empty?
+        block
+      end
+
+      def list(node)
+        content = children(node).map { |child| list_item(child) }
+
+        if node.list_type == :ordered
+          {
+            "type" => "orderedList",
+            "attrs" => { "order" => node.list_start },
+            "content" => content,
+          }
+        else
+          {
+            "type" => "bulletList",
+            "content" => content,
+          }
+        end
+      end
+
+      def list_item(node)
+        content = render_blocks(node)
+        content = [paragraph_from_text("")] if content.empty?
+
+        {
+          "type" => "listItem",
+          "content" => content,
+        }
+      end
+
+      def blockquote(node)
+        {
+          "type" => "blockquote",
+          "content" => render_blocks(node),
+        }
+      end
+
+      def inline_content(parent, marks = [])
+        children(parent).flat_map { |node| render_inline(node, marks) }.compact
+      end
+
+      def render_inline(node, marks)
+        case node.type
+        when :text
+          text_node(node.string_content, marks)
+        when :softbreak, :linebreak
+          text_node("\n", marks)
+        when :code
+          text_node(node.string_content, marks + [{ "type" => "code" }])
+        when :strong
+          inline_content(node, marks + [{ "type" => "strong" }])
+        when :emph
+          inline_content(node, marks + [{ "type" => "em" }])
+        when :strikethrough
+          inline_content(node, marks + [{ "type" => "strike" }])
+        when :link
+          inline_content(node, marks + [link_mark(node.url)])
+        when :image
+          text_node(image_alt(node), marks + [link_mark(node.url)])
+        when :html_inline
+          text_node(node.to_commonmark, marks)
+        else
+          inline_content(node, marks)
+        end
+      end
+
+      def image_block_for(node)
+        resolved_image_block(url: node.url, alt: image_alt(node))
+      end
+
+      def html_image_block(node)
+        match = node.to_commonmark.strip.match(IMAGE_TAG_PATTERN)
+        return nil if match.nil?
+
+        attributes = parse_html_attributes(match[:attributes])
+        resolved_image_block(
+          url: attributes["src"],
+          alt: attributes["alt"],
+          width: attributes["width"],
+          height: attributes["height"]
+        )
+      end
+
+      def resolved_image_block(url:, alt: nil, width: nil, height: nil)
+        return nil if url.nil? || url.strip.empty?
+        return fallback_image_paragraph(url, alt) if @image_resolver.nil?
+
+        @image_resolver.call(url: url, alt: alt, width: width, height: height)
+      end
+
+      def fallback_image_paragraph(url, alt)
+        paragraph_from_text("#{alt.to_s.empty? ? "Image" : alt}: #{url}")
+      end
+
+      def single_image_node?(node)
+        meaningful_children = children(node).reject do |child|
+          child.type == :text && child.string_content.strip.empty?
+        end
+
+        meaningful_children.length == 1 && meaningful_children.first.type == :image
+      end
+
+      def image_alt(node)
+        children(node)
+          .filter_map { |child| child.string_content if child.type == :text }
+          .join
+      end
+
+      def text_node(text, marks = [])
+        return nil if text.nil? || text.empty?
+
+        node = { "type" => "text", "text" => text }
+        node["marks"] = marks unless marks.empty?
+        node
+      end
+
+      def link_mark(url)
+        {
+          "type" => "link",
+          "attrs" => { "href" => url },
+        }
+      end
+
+      def parse_html_attributes(attributes)
+        attributes.scan(/([a-zA-Z:-]+)=["']([^"']+)["']/).to_h
+      end
+
+      def children(node)
+        node.each.to_a
+      end
+    end
+  end
+end

data/lib/marlens/jira_api/remote_image_attachment_uploader.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "fastimage"
+require "net/http"
+require "tempfile"
+require "uri"
+
+module Marlens
+  module JiraApi
+    class RemoteImageAttachmentUploader
+      MAX_REDIRECTS = 5
+
+      def initialize(client:, issue_key:, allowed_hosts:)
+        @allowed_hosts = allowed_hosts
+        @client = client
+        @issue_key = issue_key
+      end
+
+      def media_node_for(image)
+        attachment = upload_image_attachment(image.fetch(:url))
+        dimensions = attachment.fetch("dimensions")
+
+        MarkdownToAdf.media_single(
+          id: attachment.fetch("id"),
+          alt: image[:alt].to_s.strip.empty? ? attachment.fetch("filename") : image[:alt],
+          width: image_dimension_value(image[:width], dimensions.fetch("width")),
+          height: image_dimension_value(image[:height], dimensions.fetch("height"))
+        )
+      rescue StandardError => error
+        warn "Failed to upload image #{image[:url]}: #{error.class}: #{error.message}"
+        MarkdownToAdf.paragraph("#{image[:alt] || "Image"}: #{image[:url]}")
+      end
+
+      private
+
+      def upload_image_attachment(url)
+        uri = allowed_image_uri(url)
+
+        Tempfile.create(["jira-comment-image", File.extname(uri.path)]) do |file|
+          response = fetch_image(uri)
+          content_type = response_content_type(response) || content_type_for(file.path)
+          raise "Expected image content type, got #{content_type}" unless content_type.start_with?("image/")
+
+          file.binmode
+          file.write(response.body)
+          file.rewind
+
+          filename = filename_for(uri, content_type)
+          dimensions = image_dimensions(file.path)
+          attachment = @client.upload_attachment(
+            issue_key: @issue_key,
+            io: file,
+            filename: filename,
+            content_type: content_type
+          )
+
+          return {
+            "id" => attachment.fetch("id").to_s,
+            "filename" => attachment.fetch("filename", filename),
+            "dimensions" => dimensions,
+          }
+        end
+      end
+
+      def allowed_image_uri(url)
+        uri = URI(url)
+        return uri if @allowed_hosts.include?(uri.host)
+
+        raise "Refusing to upload image URL from disallowed host #{uri.host.inspect}"
+      end
+
+      def fetch_image(uri, redirects_remaining: MAX_REDIRECTS)
+        response = Net::HTTP.get_response(uri)
+
+        if response.is_a?(Net::HTTPRedirection)
+          raise "Too many image redirects" if redirects_remaining.zero?
+
+          redirected_uri = allowed_image_uri(URI.join(uri, response["location"]).to_s)
+          return fetch_image(redirected_uri, redirects_remaining: redirects_remaining - 1)
+        end
+
+        return response if response.is_a?(Net::HTTPSuccess)
+
+        raise "Failed to fetch image: #{response.code} #{response.message}"
+      end
+
+      def response_content_type(response)
+        content_type = response["content-type"].to_s.split(";").first.to_s.strip
+        return nil if content_type.empty?
+
+        content_type
+      end
+
+      def image_dimension_value(value, fallback)
+        parsed_value = value.to_s.match?(/\A\d+\z/) ? value.to_i : nil
+        return parsed_value if parsed_value&.positive?
+
+        fallback
+      end
+
+      def filename_for(uri, content_type)
+        filename = File.basename(uri.path)
+        filename = "jira-comment-image" if filename.empty?
+
+        extension = File.extname(filename)
+        return filename unless extension.empty?
+
+        "#{filename}#{extension_for(content_type)}"
+      end
+
+      def extension_for(content_type)
+        case content_type
+        when "image/jpeg" then ".jpg"
+        when "image/png" then ".png"
+        when "image/gif" then ".gif"
+        when "image/webp" then ".webp"
+        else ".img"
+        end
+      end
+
+      def content_type_for(path)
+        case File.extname(path).downcase
+        when ".jpg", ".jpeg" then "image/jpeg"
+        when ".png" then "image/png"
+        when ".gif" then "image/gif"
+        when ".webp" then "image/webp"
+        else "application/octet-stream"
+        end
+      end
+
+      def image_dimensions(path)
+        width, height = FastImage.size(path)
+        return { "width" => width, "height" => height } if width && height
+
+        { "width" => 1200, "height" => 800 }
+      end
+    end
+  end
+end

data/lib/marlens/jira_api/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Marlens
+  module JiraApi
+    VERSION = "0.5.0"
+  end
+end

data/lib/marlens/jira_api.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "jira_api/version"
+require_relative "jira_api/client"
+require_relative "jira_api/markdown_to_adf"
+require_relative "jira_api/remote_image_attachment_uploader"
+require_relative "jira_api/cli"
+
+module Marlens
+  module JiraApi
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: marlens-jira-api
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Marlen Brunner
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: commonmarker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: fastimage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: multipart-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: Provides Jira Cloud comment CRUD, converts Markdown to Atlassian Document
+  Format, and optionally uploads allowed remote images as Jira issue attachments.
+email:
+- klondikemarlen@gmail.com
+executables:
+- jira-comment
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/jira-comment
+- lib/marlens/jira_api.rb
+- lib/marlens/jira_api/cli.rb
+- lib/marlens/jira_api/client.rb
+- lib/marlens/jira_api/markdown_to_adf.rb
+- lib/marlens/jira_api/remote_image_attachment_uploader.rb
+- lib/marlens/jira_api/version.rb
+homepage: https://github.com/klondikemarlen/jira-api
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/klondikemarlen/jira-api
+  source_code_uri: https://github.com/klondikemarlen/jira-api
+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.10
+specification_version: 4
+summary: Small Jira Cloud API helper for comment CRUD and rich Markdown comments.
+test_files: []