activeproject 0.2.0 → 0.5.0

data/lib/active_project/adapters/github_repo/connection.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module GithubRepo
+      module Connection
+        BASE_URL = "https://api.github.com"
+
+        # Initializes the GitHub Repo Adapter.
+        # @param config [Configurations::BaseAdapterConfiguration, Configurations::GithubConfiguration]
+        #        The configuration object for GitHub.
+        # @raise [ArgumentError] if required configuration options (:owner, :repo, :access_token) are missing.
+        def initialize(config:)
+          unless config.is_a?(ActiveProject::Configurations::BaseAdapterConfiguration)
+            raise ArgumentError, "GithubRepoAdapter requires a BaseAdapterConfiguration object"
+          end
+
+          @config = config
+
+          # Extract required configuration parameters
+          owner = @config.options[:owner]
+          repo = @config.options[:repo]
+          access_token = @config.options[:access_token]
+
+          # Validate required configuration parameters
+          unless owner && !owner.empty?
+            raise ArgumentError, "GithubRepoAdapter configuration requires :owner"
+          end
+
+          unless repo && !repo.empty?
+            raise ArgumentError, "GithubRepoAdapter configuration requires :repo"
+          end
+
+          unless access_token && !access_token.empty?
+            raise ArgumentError, "GithubRepoAdapter configuration requires :access_token"
+          end
+
+          # Set repository path for API requests
+          @repo_path = "repos/#{owner}/#{repo}"
+          @connection = initialize_connection
+        end
+
+        private
+
+        # Initializes the Faraday connection object.
+        # @return [Faraday::Connection] Configured Faraday connection for GitHub API
+        def initialize_connection
+          access_token = @config.options[:access_token]
+
+          Faraday.new(url: BASE_URL) do |conn|
+            conn.request :authorization, :bearer, access_token
+            conn.request :retry
+            conn.headers["Accept"] = "application/vnd.github.v3+json"
+            conn.headers["Content-Type"] = "application/json"
+            conn.headers["User-Agent"] = ActiveProject.user_agent
+            conn.response :raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/github_repo/issues.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module GithubRepo
+      module Issues
+        # Lists GitHub issues within a specific repository (project).
+        # @param project_id [String] The repository name or full_name
+        # @param options [Hash] Optional filtering options.
+        #   Supported keys:
+        #   - status: 'open', 'closed', or 'all' (default: 'open')
+        #   - page: Page number for pagination (default: 1)
+        #   - per_page: Issues per page (default: 30, max: 100)
+        #   - sort: 'created', 'updated', or 'comments' (default: 'created')
+        #   - direction: 'asc' or 'desc' (default: 'desc')
+        # @return [Array<ActiveProject::Resources::Issue>]
+        def list_issues(project_id, options = {})
+          # Determine the repository path to use
+          repo_path = determine_repo_path(project_id)
+
+          # Build query parameters
+          query = {}
+          query[:state] = options[:status] || "open"
+          query[:page] = options[:page] if options[:page]
+          query[:per_page] = options[:per_page] if options[:per_page]
+          query[:sort] = options[:sort] if options[:sort]
+          query[:direction] = options[:direction] if options[:direction]
+
+          issues_data = make_request(:get, "#{repo_path}/issues", nil, query)
+          return [] unless issues_data.is_a?(Array)
+
+          issues_data.map { |issue_data| map_issue_data(issue_data) }
+        end
+
+        # Finds a specific issue by its number.
+        # @param id [String, Integer] The issue number within the repository.
+        # @param context [Hash] Optional context.
+        #   Supported keys:
+        #   - repo_owner: Repository owner if different from configured owner
+        #   - repo_name: Repository name if different from configured repo
+        # @return [ActiveProject::Resources::Issue]
+        def find_issue(id, context = {})
+          # Determine the repository path to use
+          repo_path = if context[:repo_owner] && context[:repo_name]
+                       "repos/#{context[:repo_owner]}/#{context[:repo_name]}"
+          else
+                       @repo_path
+          end
+
+          issue_data = make_request(:get, "#{repo_path}/issues/#{id}")
+          map_issue_data(issue_data)
+        end
+
+        # Creates a new issue in a GitHub repository.
+        # @param project_id [String] The repository name or full_name
+        # @param attributes [Hash] Issue attributes.
+        #   Required: :title
+        #   Optional: :description (body), :assignees (array of usernames)
+        # @return [ActiveProject::Resources::Issue]
+        def create_issue(project_id, attributes)
+          # Determine the repository path to use
+          repo_path = determine_repo_path(project_id)
+
+          unless attributes[:title] && !attributes[:title].empty?
+            raise ArgumentError, "Missing required attribute for GitHub issue creation: :title"
+          end
+
+          data = {
+            title: attributes[:title],
+            body: attributes[:description]
+          }
+
+          # Convert assignees if present
+          if attributes[:assignees] && attributes[:assignees].is_a?(Array)
+            if attributes[:assignees].all? { |a| a.is_a?(Hash) && a[:name] }
+              data[:assignees] = attributes[:assignees].map { |a| a[:name] }
+            else
+              data[:assignees] = attributes[:assignees]
+            end
+          end
+
+          # Add labels if present
+          data[:labels] = attributes[:labels] if attributes[:labels]
+
+          issue_data = make_request(:post, "#{repo_path}/issues", data)
+          map_issue_data(issue_data)
+        end
+
+        # Updates an existing issue in GitHub.
+        # @param id [String, Integer] The issue number.
+        # @param attributes [Hash] Issue attributes to update.
+        #   Supported keys: :title, :description (body), :status (state), :assignees
+        # @param context [Hash] Optional context.
+        #   Supported keys:
+        #   - repo_owner: Repository owner if different from configured owner
+        #   - repo_name: Repository name if different from configured repo
+        # @return [ActiveProject::Resources::Issue]
+        def update_issue(id, attributes, context = {})
+          # Determine the repository path to use
+          repo_path = if context[:repo_owner] && context[:repo_name]
+                       "repos/#{context[:repo_owner]}/#{context[:repo_name]}"
+          else
+                       @repo_path
+          end
+
+          data = {}
+          data[:title] = attributes[:title] if attributes.key?(:title)
+          data[:body] = attributes[:description] if attributes.key?(:description)
+
+          # Handle status mapping
+          if attributes.key?(:status)
+            state = case attributes[:status]
+            when :open, :in_progress then "open"
+            when :closed then "closed"
+            else attributes[:status].to_s
+            end
+            data[:state] = state
+          end
+
+          # Convert assignees if present
+          if attributes.key?(:assignees)
+            if attributes[:assignees].nil? || attributes[:assignees].empty?
+              data[:assignees] = []
+            elsif attributes[:assignees].all? { |a| a.is_a?(Hash) && a[:name] }
+              data[:assignees] = attributes[:assignees].map { |a| a[:name] }
+            else
+              data[:assignees] = attributes[:assignees]
+            end
+          end
+
+          issue_data = make_request(:patch, "#{repo_path}/issues/#{id}", data)
+          map_issue_data(issue_data)
+        end
+
+        # Attempts to delete an issue in GitHub, but since GitHub doesn't support
+        # true deletion, it closes the issue instead.
+        # @param id [String, Integer] The issue number.
+        # @param context [Hash] Optional context.
+        # @return [Boolean] Always returns false since GitHub doesn't support true deletion.
+        def delete_issue(id, context = {})
+          # GitHub doesn't support true deletion of issues
+          # The best we can do is close the issue
+          update_issue(id, { status: :closed }, context)
+          false # Return false indicating true deletion is not supported
+        end
+
+        private
+
+        # Determines the repository path to use based on project_id.
+        # @param project_id [String] Repository name or full_name
+        # @return [String] The repository API path
+        def determine_repo_path(project_id)
+          # If project_id matches configured repo or is the same as the full_name, use @repo_path
+          if project_id.to_s == @config.options[:repo] ||
+             project_id.to_s == "#{@config.options[:owner]}/#{@config.options[:repo]}"
+            return @repo_path
+          end
+
+          # If project_id contains a slash, assume it's a full_name
+          if project_id.to_s.include?("/")
+            return "repos/#{project_id}"
+          end
+
+          # Otherwise, assume it's just a repo name and use the configured owner
+          "repos/#{@config.options[:owner]}/#{project_id}"
+        end
+
+        # Maps raw GitHub issue data to an ActiveProject::Resources::Issue
+        # @param issue_data [Hash] Raw issue data from GitHub API
+        # @return [ActiveProject::Resources::Issue]
+        def map_issue_data(issue_data)
+          # Map state to status
+          status = @config.status_mappings[issue_data["state"]] || :unknown
+
+          # Map assignees
+          assignees = []
+          if issue_data["assignees"] && !issue_data["assignees"].empty?
+            assignees = issue_data["assignees"].map do |assignee|
+              Resources::User.new(
+                self,
+                id: assignee["id"].to_s,
+                name: assignee["login"],
+                adapter_source: :github,
+                raw_data: assignee
+              )
+            end
+          end
+
+          # Map reporter (user who created the issue)
+          reporter = nil
+          if issue_data["user"]
+            reporter = Resources::User.new(
+              self,
+              id: issue_data["user"]["id"].to_s,
+              name: issue_data["user"]["login"],
+              adapter_source: :github,
+              raw_data: issue_data["user"]
+            )
+          end
+
+          # Extract project ID (repo name) from the URL
+          project_id = nil
+          if issue_data["repository_url"]
+            # Extract owner/repo from repository_url
+            repo_parts = issue_data["repository_url"].split("/")
+            project_id = repo_parts.last(2).join("/")
+          elsif issue_data["url"]
+            # Try to extract from issue URL
+            url_parts = issue_data["url"].split("/")
+            if url_parts.include?("repos")
+              repos_index = url_parts.index("repos")
+              if repos_index && repos_index + 2 < url_parts.length
+                project_id = "#{url_parts[repos_index + 1]}/#{url_parts[repos_index + 2]}"
+              end
+            end
+          end
+
+          # If still not found, use configured repo
+          project_id ||= "#{@config.options[:owner]}/#{@config.options[:repo]}"
+
+          Resources::Issue.new(
+            self,
+            id: issue_data["id"].to_s,
+            key: issue_data["number"].to_s,
+            title: issue_data["title"],
+            description: issue_data["body"],
+            status: status,
+            assignees: assignees,
+            reporter: reporter,
+            project_id: project_id,
+            created_at: issue_data["created_at"] ? Time.parse(issue_data["created_at"]) : nil,
+            updated_at: issue_data["updated_at"] ? Time.parse(issue_data["updated_at"]) : nil,
+            due_on: nil, # GitHub issues don't have a built-in due date
+            priority: nil, # GitHub issues don't have a built-in priority
+            adapter_source: :github,
+            raw_data: issue_data
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/github_repo/projects.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module GithubRepo
+      module Projects
+        # Lists projects accessible by the configured credentials.
+        # In GitHub's context, this returns the configured repository as a "project".
+        # @return [Array<ActiveProject::Resources::Project>] Array containing the repository as a project
+        def list_projects
+          # Get the configured repository
+          repo_data = make_request(:get, @repo_path)
+          [ map_repository_to_project(repo_data) ]
+        end
+
+        # Finds a specific project by its ID or name.
+        # In GitHub's context, this finds a repository.
+        # @param id [String, Integer] The ID or full_name of the repository
+        # @return [ActiveProject::Resources::Project, nil] The repository as a project
+        def find_project(id)
+          # If id is nil or empty, use the configured repo
+          if id.nil? || id.to_s.empty?
+            id = @config.options[:repo]
+          end
+
+          # If id matches our configured repo, return that
+          if id.to_s == @config.options[:repo] || id.to_s == "#{@config.options[:owner]}/#{@config.options[:repo]}"
+            repo_data = make_request(:get, @repo_path)
+            return map_repository_to_project(repo_data)
+          end
+
+          # Otherwise, try to find by ID or full name
+          begin
+            repo_data = make_request(:get, "repositories/#{id}")
+            map_repository_to_project(repo_data)
+          rescue NotFoundError
+            # Try with full name path format (owner/repo)
+            if id.to_s.include?("/")
+              repo_data = make_request(:get, "repos/#{id}")
+              map_repository_to_project(repo_data)
+            else
+              # Try with owner + repo name
+              begin
+                repo_data = make_request(:get, "repos/#{@config.options[:owner]}/#{id}")
+                map_repository_to_project(repo_data)
+              rescue NotFoundError
+                raise NotFoundError, "GitHub repository with ID or name '#{id}' not found"
+              end
+            end
+          end
+        end
+
+        # Creates a new repository (project).
+        # Note: In most cases users will already have repositories set up.
+        # @param attributes [Hash] Repository attributes (name, description, etc.)
+        # @return [ActiveProject::Resources::Project] The created repository as a project
+        def create_project(attributes)
+          # Create in organization or user account based on config
+          owner = @config.options[:owner]
+
+          # Determine if creating in org or personal account
+          begin
+            make_request(:get, "orgs/#{owner}")
+            path = "orgs/#{owner}/repos"
+          rescue NotFoundError
+            path = "user/repos"
+          end
+
+          data = {
+            name: attributes[:name],
+            description: attributes[:description],
+            private: attributes[:private] || false,
+            has_issues: attributes[:has_issues] || true
+          }
+
+          repo_data = make_request(:post, path, data)
+          map_repository_to_project(repo_data)
+        end
+
+        # Deletes a repository.
+        # Note: This is a destructive operation and generally not recommended.
+        # @param repo_id [String] The ID or full_name of the repository
+        # @return [Boolean] True if successfully deleted
+        def delete_project(repo_id)
+          # Find the repository first to get its full path
+          repo = find_project(repo_id)
+          raise NotFoundError, "Repository not found" unless repo
+
+          # Delete requires the full path in "owner/repo" format
+          full_path = repo.name # We store full_name in the name field
+          make_request(:delete, "repos/#{full_path}")
+          true
+        rescue NotFoundError
+          false
+        end
+
+        private
+
+        # Maps a GitHub repository to an ActiveProject project resource.
+        # @param repo_data [Hash] Raw repository data from GitHub API
+        # @return [ActiveProject::Resources::Project] The mapped project resource
+        def map_repository_to_project(repo_data)
+          Resources::Project.new(
+            self,
+            id: repo_data["id"].to_s,
+            key: repo_data["name"],               # Repository name (without owner)
+            name: repo_data["full_name"],         # Full repository name (owner/repo)
+            description: repo_data["description"],
+            adapter_source: :github,
+            raw_data: repo_data
+          )
+        end
+      end
+    end
+  end
+end