Adds issue update command, and the lclose alias

Author: bougyman

exe/lclose

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+exec File.join(__dir__, 'lclose.sh'), *ARGV

exe/lclose.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+if [[ "$*" =~ "--help" ]]
+then
+    printf "This wrapper adds the --close option to the 'issue update' command.\n" >&2
+    printf "It is used to close one or many issues. The issues are specified by their ID/slugs.\n" >&2
+    printf "For closing multiple issues, you really want to pass --reason so you do not get prompted for each issue.\n\n" >&2
+    exec lc issue update --help
+fi
+exec lc issue update --close "$@"

lib/linear/cli/sub_commands.rb

@@ -47,6 +47,20 @@ def team_for(key = nil)
           ask_for_team
         end
 
+        def reason_for(reason = nil, four: nil)
+          return reason if reason
+
+          question = four ? "Reason for #{four}:" : 'Reason:'
+          prompt.ask(question)
+        end
+
+        def completed_state_for(thingy)
+          states = thingy.completed_states
+          return states.first if states.size == 1
+
+          prompt.select('Choose a completed state', states.to_h { |s| [s.name, s.id] })
+        end
+
         def description_for(description = nil)
           return description if description
 

lib/linear/commands/issue.rb

@@ -12,13 +12,40 @@ module Issue
         include CLI::SubCommands
         # Aliases for Issue commands
         ALIASES = {
-          create: %w[c new add],        # aliases for the create command
-          develop: %w[d dev],           # aliases for the create command
-          list: %w[l ls],               # aliases for the list command
-          show: %w[s view v],           # aliases for the show command
-          issue: %w[i issues]           # aliases for the main issue command itself
+          create: %w[c new add], # aliases for the create command
+          develop: %w[d dev],    # aliases for the develop command
+          list: %w[l ls],        # aliases for the list command
+          update: %w[u],         # aliases for the close command
+          issue: %w[i issues]    # aliases for the main issue command itself
         }.freeze
 
+        def issue_comment(issue, comment)
+          issue.add_comment(comment)
+          prompt.ok("Comment added to #{issue.identifier}")
+        end
+
+        def close_issue(issue, **options)
+          reason = reason_for(options[:reason], four: "closing #{issue.identifier} - #{issue.title}")
+          issue_comment(issue, reason)
+          close_state = completed_state_for(issue)
+          issue.close!(state: close_state, trash: options[:trash])
+          prompt.ok("#{issue.identifier} was closed")
+        end
+
+        def issue_pr(issue)
+          issue.create_pr!
+          prompt.ok("Pull request created for #{issue.identifier}")
+        end
+
+        def update_issue(issue, **options)
+          issue_comment(issue, options[:comment]) if options[:comment]
+          return close_issue(issue, **options) if options[:close]
+          return issue_pr(issue) if options[:pr]
+
+          prompt.warn('No action taken, no options specified')
+          prompt.ok('Issue was not updated')
+        end
+
         def make_da_issue!(**options)
           # These *_for methods are defined in Rubyists::Linear::CLI::SubCommands
           title = title_for options[:title]
@@ -28,7 +55,7 @@ def make_da_issue!(**options)
           Rubyists::Linear::Issue.create(title:, description:, team:, labels:)
         end
 
-        def gimme_da_issue!(issue_id, me) # rubocop:disable Naming/MethodParameterName
+        def gimme_da_issue!(issue_id, me: Rubyists::Linear::User.me) # rubocop:disable Naming/MethodParameterName
           logger.trace('Looking up issue', issue_id:, me:)
           issue = Rubyists::Linear::Issue.find(issue_id)
           if issue.assignee && issue.assignee[:id] == me.id

lib/linear/commands/issue/update.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'semantic_logger'
+require 'git'
+require_relative '../issue'
+
+module Rubyists
+  # Namespace for Linear
+  module Linear
+    M :issue, :user, :label
+    # Namespace for CLI
+    module CLI
+      module Issue
+        Update = Class.new Dry::CLI::Command
+        # The Update class is a Dry::CLI::Command to update an issue
+        class Update
+          include SemanticLogger::Loggable
+          include Rubyists::Linear::CLI::CommonOptions
+          include Rubyists::Linear::CLI::Issue # for #gimme_da_issue! and other Issue methods
+          desc 'Update an issue'
+          argument :issue_ids, type: :array, required: true, desc: 'Issue IDs (i.e. ISS-1)'
+          option :comment, type: :string, aliases: ['--message'], desc: 'Comment to add to the issue'
+          option :pr, type: :boolean, aliases: ['--pull-request'], default: false, desc: 'Create a pull request'
+          option :close, type: :boolean, default: false, desc: 'Close the issue'
+          option :reason, type: :string, aliases: ['--close-reason'], desc: 'Reason for closing the issue'
+
+          def call(issue_ids:, **options)
+            logger.debug('Updating issues', issue_ids:, options:)
+            Rubyists::Linear::Issue.find_all(issue_ids).each do |issue|
+              update_issue(issue, **options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/linear/models/base_model.rb

@@ -5,7 +5,9 @@
 require 'sequel/extensions/inflector'
 
 module Rubyists
+  #  Namespace for Linear
   module Linear
+    L :api, :fragments
     # Module which provides a base model for Linear models.
     class BaseModel
       extend GQLi::DSL
@@ -32,6 +34,20 @@ def self.included(base) # rubocop:disable Metrics/MethodLength
 
       # Class methods for Linear models.
       class << self
+        def has_one(relation, klass) # rubocop:disable Naming/PredicateName
+          define_method relation do
+            return instance_variable_get("@#{relation}") if instance_variable_defined?("@#{relation}")
+
+            instance_variable_set("@#{relation}", Rubyists::Linear.const_get(klass).new(data[relation]))
+          end
+
+          define_method "#{relation}=" do |val|
+            hash = val.is_a?(Hash) ? val : val.data
+            updated_data[relation] = hash
+            instance_variable_set("@#{relation}", Rubyists::Linear.const_get(klass).new(hash))
+          end
+        end
+
         def const_added(const)
           return unless const == :Base
 
@@ -108,6 +124,10 @@ def changed?
         data != updated_data
       end
 
+      def completed_states
+        workflow_states.select { |ws| ws.type == 'completed' }
+      end
+
       def to_h
         updated_data
       end

lib/linear/models/issue.rb

@@ -5,75 +5,136 @@
 module Rubyists
   # Namespace for Linear
   module Linear
-    L :api
-    L :fragments
-    M :base_model
-    M :user
+    M :base_model, :user
     Issue = Class.new(BaseModel)
     # The Issue class represents a Linear issue.
-    class Issue
+    class Issue # rubocop:disable Metrics/ClassLength
       include SemanticLogger::Loggable
+      has_one :assignee, :User
+      has_one :team, :Team
 
       BASIC_FILTER = { completedAt: { null: true } }.freeze
 
       Base = fragment('BaseIssue', 'Issue') do
         id
         identifier
         title
-        assignee { ___ User::Base }
         branchName
         description
         createdAt
         updatedAt
       end
 
       class << self
+        def base_fragment
+          @base_fragment ||= fragment('IssueWithTeams', 'Issue') do
+            ___ Base
+            assignee { ___ User.base_fragment }
+            team { ___ Team.base_fragment }
+          end
+        end
+
         def find(slug)
-          q = query { issue(id: slug) { ___ Base } }
+          q = query { issue(id: slug) { ___ Issue.base_fragment } }
           data = Api.query(q)
           raise NotFoundError, "Issue not found: #{slug}" if data.nil?
 
           new(data[:issue])
         end
 
+        def find_all(*slugs)
+          slugs.flatten.map { |slug| find(slug) }
+        end
+
         def create(title:, description:, team:, labels: [])
           team_id = team.id
           label_ids = labels.map(&:id)
           input = { title:, description:, teamId: team_id }
-          input.merge!(labelIds: label_ids) unless label_ids.empty?
-          m = mutation { issueCreate(input:) { issue { ___ Base } } }
-          data = Api.query(m)
-          new(data[:issueCreate][:issue])
+          input[:labelIds] = label_ids unless label_ids.empty?
+          m = mutation { issueCreate(input:) { issue { ___ Issue.base_fragment } } }
+          query_data = Api.query(m)
+          new query_data.dig(:issueCreate, :issue)
         end
       end
 
-      def assign!(user)
+      def comment_fragment
+        @comment_fragment ||= fragment('Comment', 'Comment') do
+          id
+          body
+          url
+        end
+      end
+
+      # Reference for this mutation:
+      # https://studio.apollographql.com/public/Linear-API/variant/current/schema/reference/inputs/CommentCreateInput
+      def add_comment(comment)
+        id_for_this = identifier
+        comment_frag = comment_fragment
+        m = mutation { commentCreate(input: { issueId: id_for_this, body: comment }) { comment { ___ comment_frag } } }
+
+        query_data = Api.query(m)
+        query_data.dig(:commentCreate, :comment)
+        self
+      end
+
+      def close_mutation(close_state, trash: false)
         id_for_this = identifier
-        m = mutation { issueUpdate(id: id_for_this, input: { assigneeId: user.id }) { issue { ___ Base } } }
-        data = Api.query(m)
-        updated = data.dig(:issueUpdate, :issue)
+        input = { stateId: close_state.id }
+        input[:trash] = true if trash
+        mutation { issueUpdate(id: id_for_this, input:) { issue { ___ Issue.base_fragment } } }
+      end
+
+      def close!(state: nil, trash: false)
+        logger.warn "Using first completed state found: #{completed_states.first}" if state.nil?
+        state ||= completed_states.first
+        query_data = Api.query close_mutation(state, trash:)
+        updated = query_data.dig(:issueUpdate, :issue)
+        raise SmellsBad, "Unknown response for issue close: #{data} (should have :issueUpdate key)" if updated.nil?
+
+        @data = @updated_data = updated
+        self
+      end
+
+      def assign!(user)
+        this_id = identifier
+        m = mutation { issueUpdate(id: this_id, input: { assigneeId: user.id }) { issue { ___ Issue.base_fragment } } }
+        query_data = Api.query(m)
+        updated = query_data.dig(:issueUpdate, :issue)
         raise SmellsBad, "Unknown response for issue update: #{data} (should have :issueUpdate key)" if updated.nil?
 
-        Issue.new updated
+        @data = @updated_data = updated
+        self
+      end
+
+      def workflow_states
+        @workflow_states ||= team.workflow_states
       end
 
       def inspection
         format('id: "%<identifier>s" title: "%<title>s"', identifier:, title:)
       end
 
       def to_s
-        basic = format('%<id>-12s %<title>s', id: data[:identifier], title: data[:title])
+        basic = format('%<id>-12s %<title>s', id: identifier, title:)
         return basic unless (name = data.dig(:assignee, :name))
 
         format('%<basic>s (%<name>s)', basic:, name:)
       end
 
+      def parsed_description
+        return TTY::Markdown.parse(description) if description && !description.empty?
+
+        TTY::Markdown.parse(['# No Description For this issue??',
+                             'Issues really need description',
+                             "## What's up with that?"].join("\n"))
+      rescue StandardError => e
+        logger.error 'Error parsing description', e
+        "Description was unparsable: #{description}\n"
+      end
+
       def full
         sep = '-' * to_s.length
-        format("%<to_s>s\n%<sep>s\n%<description>s\n",
-               sep:,
-               to_s:,
-               description: (TTY::Markdown.parse(data[:description]) rescue 'No Description?')) # rubocop:disable Style/RescueModifier
+        format("%<to_s>s\n%<sep>s\n%<description>s\n", sep:, to_s:, description: parsed_description)
       end
 
       def display(options)

lib/linear/models/label.rb

@@ -31,14 +31,14 @@ def self.base_fragment # rubocop:disable Metrics/AbcSize
         fragment('LabelWithTeams', 'IssueLabel') do
           ___ Base
           parent { ___ Base }
-          team { ___ Team::Base }
+          team { ___ Team.base_fragment }
         end
       end
 
       def self.find_all_by_name(names)
         q = query do
           issueLabels(filter: { name: { in: names } }) do
-            edges { node { ___ Base } }
+            edges { node { ___ base_fragment } }
           end
         end
         data = Api.query(q)

lib/linear/models/team.rb

@@ -5,8 +5,7 @@
 module Rubyists
   # Namespace for Linear
   module Linear
-    L :api, :fragments
-    M :base_model, :issue, :user
+    M :base_model, :issue, :user, :workflow_state
     Team = Class.new(BaseModel)
     # The Issue class represents a Linear issue.
     class Team
@@ -96,6 +95,26 @@ def members
       def display(_options)
         printf "%s\n", full
       end
+
+      def workflow_states_query
+        team_id = id
+        query do
+          team(id: team_id) do
+            states do
+              nodes { ___ WorkflowState.base_fragment }
+            end
+          end
+        end
+      end
+
+      def workflow_states
+        return @workflow_states if @workflow_states
+
+        data = Api.query(workflow_states_query)
+        @workflow_states = data.dig(:team, :states, :nodes)&.map do |state|
+          WorkflowState.new state
+        end
+      end
     end
   end
 end