tigger 0.0.1 → 0.0.2

package/bin/example/operation/postCommitTreeSHA.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const { commitUtilities } = require("../../..");  ///
+
+const { commitTreeSHAPostRequest } = commitUtilities;
+
+function postCommitTreeSHAOperation(next, done, context) {
+  const { repository, baseTreeSHA, readmeFileSHA, readmeFilePath, metaJSONFileSHA, metaJSONFilePath, userAgent, gitHubAccessToken } = context,
+        fileShAs = [
+          readmeFileSHA,
+          metaJSONFileSHA
+        ],
+        filePaths = [
+          readmeFilePath,
+          metaJSONFilePath
+        ];
+
+  commitTreeSHAPostRequest(repository, baseTreeSHA, fileShAs, filePaths, userAgent, gitHubAccessToken, (error, json) => {
+    if (error) {
+      done();
+
+      return;
+    }
+
+    const { sha = null } = json;
+
+    if (sha === null) {
+      done();
+
+      return;
+    }
+
+    const commitTreeSHA = sha; ///
+
+    Object.assign(context, {
+      commitTreeSHA
+    });
+
+    next();
+  });
+}
+
+module.exports = postCommitTreeSHAOperation;

package/bin/example/operation/postMetaJSONFileContent.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const { commitUtilities } = require("../../..");  ///
+
+const { contentBlobSHAPostRequest } = commitUtilities;
+
+function postMetaJSONFileContentOperation(next, done, context) {
+  const { repository, userAgent, gitHubAccessToken, metaJSONFileContent } = context,
+        content = metaJSONFileContent;  ///
+
+  contentBlobSHAPostRequest(repository, content, userAgent, gitHubAccessToken, (error, json) => {
+    if (error) {
+      done();
+
+      return;
+    }
+
+    const { sha = null } = json;
+
+    if (sha === null) {
+      done();
+
+      return;
+    }
+
+    const metaJSONFileSHA = sha;
+
+    Object.assign(context, {
+      metaJSONFileSHA
+    });
+
+    next();
+  });
+}
+
+module.exports = postMetaJSONFileContentOperation;

package/bin/example/operation/postReadmeFileContent.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const { commitUtilities } = require("../../..");  ///
+
+const { contentBlobSHAPostRequest } = commitUtilities;
+
+function postReadmeFileContentOperation(next, done, context) {
+  const { repository, userAgent, gitHubAccessToken, readmeFileContent } = context,
+        content = readmeFileContent;  ///
+
+  contentBlobSHAPostRequest(repository, content, userAgent, gitHubAccessToken, (error, json) => {
+    if (error) {
+      done();
+
+      return;
+    }
+
+    const { sha = null } = json;
+
+    if (sha === null) {
+      done();
+
+      return;
+    }
+
+    const readmeFileSHA = sha; ///
+
+    Object.assign(context, {
+      readmeFileSHA
+    });
+
+    next();
+  });
+}
+
+module.exports = postReadmeFileContentOperation;

package/bin/example/operation/postUpdatedHead.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const { commitUtilities } = require("../../..");  ///
+
+const { updatedHeadPostRequest } = commitUtilities;
+
+function postUpdatedHeadOperation(next, done, context) {
+  const { repository, commitSHA, userAgent, gitHubAccessToken } = context;
+
+  updatedHeadPostRequest(repository, commitSHA, userAgent, gitHubAccessToken, (error, json) => {
+    if (error) {
+      done();
+
+      return;
+    }
+
+    const { object = null } = json;
+
+    if (object === null) {
+      done();
+
+      return;
+    }
+
+    next();
+  });
+}
+
+module.exports = postUpdatedHeadOperation;

package/bin/example/operation/removeComment.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const { commentUtilities } = require("../../..");  ///
+
+const { removeCommentDeleteRequest } = commentUtilities;
+
+function removeCommentOperation(next, done, context) {
+  const { repository, commentIdentifier, userAgent, gitHubAccessToken } = context;
+
+  removeCommentDeleteRequest(repository, commentIdentifier, userAgent, gitHubAccessToken, (error, string) => {
+    if (error) {
+      done();
+
+      return;
+    }
+
+    if (string !== "") {
+      done();
+
+      return;
+    }
+
+    next();
+  });
+}
+
+module.exports = removeCommentOperation;

package/bin/example.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const issueHandler = require("./example/handler/issue"),
+      issuesHandler = require("./example/handler/issues"),
+      commitHandler = require("./example/handler/commit"),
+      editIssueHandler = require("./example/handler/editIssue"),
+      alterIssueHandler = require("./example/handler/alterIssue"),
+      createIssueHandler = require("./example/handler/createIssue"),
+      editCommentHandler = require("./example/handler/editComment"),
+      createCommentHandler = require("./example/handler/createComment"),
+      removeCommentHandler = require("./example/handler/removeComment");
+
+const clientId = "...",
+      userAgent = "...",
+      repository = "...",
+      clientSecret = "...",
+      gitHubAccessToken = "...",
+      context = {
+        clientId,
+        userAgent,
+        repository,
+        clientSecret,
+        gitHubAccessToken
+      };

package/bin/uris.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const SETTINGS_URI = "/settings",
+      LATEST_RELEASES_URI = "/",  ///
+      GITHUB_USER_URI = "/user",
+      GITHUB_REPOS_URI = "/repos",
+      GITHUB_ISSUES_URI = "/issues",
+      GITHUB_COMMENTS_URI = "/comments",
+      GITHUB_GIT_TREES_URI = "/git/trees",
+      GITHUB_GIT_BLOBS_URI = "/git/blobs",
+      GITHUB_GIT_COMMITS_URI = "/git/commits",
+      GITHUB_ISSUES_COMMENTS_URI = "/issues/comments",
+      GITHUB_GIT_REFS_HEADS_MASTER_URI = "/git/refs/heads/master",
+      GITHUB_LOGIN_OAUTH_AUTHORIZE_URI = "/login/oauth/authorize",
+      GITHUB_LOGIN_OAUTH_ACCESS_TOKEN_URI = "/login/oauth/access_token";
+
+module.exports = {
+  SETTINGS_URI,
+  LATEST_RELEASES_URI,
+  GITHUB_USER_URI,
+  GITHUB_REPOS_URI,
+  GITHUB_ISSUES_URI,
+  GITHUB_COMMENTS_URI,
+  GITHUB_GIT_TREES_URI,
+  GITHUB_GIT_BLOBS_URI,
+  GITHUB_GIT_COMMITS_URI,
+  GITHUB_ISSUES_COMMENTS_URI,
+  GITHUB_LOGIN_OAUTH_AUTHORIZE_URI,
+  GITHUB_GIT_REFS_HEADS_MASTER_URI,
+  GITHUB_LOGIN_OAUTH_ACCESS_TOKEN_URI
+};

package/bin/utilities/comment.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const { encodings } = require("necessary");
+
+const { repoFromRepository, ownerFromRepository } = require("../utilities/repository"),
+      { getRequest, postRequest, patchRequest, deleteRequest } = require("../utilities/request"),
+      { GITHUB_REPOS_URI, GITHUB_ISSUES_URI, GITHUB_COMMENTS_URI, GITHUB_ISSUES_COMMENTS_URI } = require("../uris");
+
+const { UTF_8_ENCODING } = encodings;
+
+function commentsGetRequest(repository, issueNumber, userAgent, clientId, clientSecret, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_URI}/${issueNumber}${GITHUB_COMMENTS_URI}`,
+        query = {};
+
+  getRequest(uri, query, userAgent, clientId, clientSecret, callback);
+}
+
+function editCommentPatchRequest(repository, description, commentIdentifier, userAgent, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_COMMENTS_URI}/${commentIdentifier}`,
+        encoding = UTF_8_ENCODING,
+        query = {};
+
+  let body = description; ///
+
+  body = JSON.stringify({ ///
+    body,
+    encoding
+  });
+
+  patchRequest(uri, query, body, userAgent, gitHubAccessToken, callback);
+}
+
+function createCommentPostRequest(repository, description, issueNumber, userAgent, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_URI}/${issueNumber}${GITHUB_COMMENTS_URI}`,
+        encoding = UTF_8_ENCODING,
+        query = {};
+
+  let body = description; ///
+
+  body = JSON.stringify({ ///
+    body,
+    encoding
+  });
+
+  postRequest(uri, query, body, userAgent, gitHubAccessToken, callback);
+}
+
+function removeCommentDeleteRequest(repository, commentIdentifier, userAgent, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_COMMENTS_URI}/${commentIdentifier}`,
+        query = {};
+
+  deleteRequest(uri, query, userAgent, gitHubAccessToken, callback);
+}
+
+module.exports = {
+  commentsGetRequest,
+  editCommentPatchRequest,
+  createCommentPostRequest,
+  removeCommentDeleteRequest
+};

package/bin/utilities/commit.js

@@ -0,0 +1,115 @@
+"use strict";
+
+const { encodings } = require("necessary");
+
+const { BLOB_MODE, BLOB_TYPE } = require("../constants"),
+      { getRequest, postRequest } = require("../utilities/request"),
+      { repoFromRepository, ownerFromRepository } = require("../utilities/repository"),
+      { GITHUB_REPOS_URI, GITHUB_GIT_TREES_URI, GITHUB_GIT_BLOBS_URI, GITHUB_GIT_COMMITS_URI, GITHUB_GIT_REFS_HEADS_MASTER_URI } = require("../uris");
+
+const { UTF_8_ENCODING } = encodings;
+
+function commitSHAPostRequest(repository, commitMessage, commitTreeSHA, latestCommitSHA, userAgent, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_GIT_COMMITS_URI}`,
+        tree = commitTreeSHA, ///
+        parent = latestCommitSHA, ///
+        parents = [
+          parent
+        ],
+        message = commitMessage,  ///
+        query = {},
+        body = JSON.stringify({
+          tree,
+          parents,
+          message
+        });
+
+  postRequest(uri, query, body, userAgent, gitHubAccessToken, callback);
+}
+
+function baseTreeSHAGetRequest(repository, latestCommitSHA, userAgent, clientId, clientSecret, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_GIT_COMMITS_URI}/${latestCommitSHA}`,
+        query = {};
+
+  getRequest(uri, query, userAgent, clientId, clientSecret, callback);
+}
+
+function updatedHeadPostRequest(repository, commitSHA, userAgent, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_GIT_REFS_HEADS_MASTER_URI}`,
+        sha = commitSHA,  ///
+        query = {},
+        body = JSON.stringify({
+          sha
+        });
+
+  postRequest(uri, query, body, userAgent, gitHubAccessToken, callback);
+}
+
+function commitTreeSHAPostRequest(repository, baseTreeSHA, fileSHAs, filePaths, userAgent, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_GIT_TREES_URI}`,
+        base_tree = baseTreeSHA,  ///
+        tree = [],
+        mode = BLOB_MODE, ///
+        type = BLOB_TYPE; ///
+
+  fileSHAs.forEach((fileSHA, index) => {
+    const filePath = filePaths[index],
+          sha = fileSHA, ///
+          path = filePath;  ///
+
+    tree.push({
+      sha,
+      mode,
+      type,
+      path
+    });
+  });
+
+  const query = {},
+        body = JSON.stringify({
+          base_tree,
+          tree
+        });
+
+  postRequest(uri, query, body, userAgent, gitHubAccessToken, callback);
+}
+
+function latestCommitSHAGetRequest(repository, userAgent, clientId, clientSecret, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_GIT_REFS_HEADS_MASTER_URI}`,
+        query = {};
+
+  getRequest(uri, query, userAgent, clientId, clientSecret, callback);
+}
+
+function contentBlobSHAPostRequest(repository, content, userAgent, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_GIT_BLOBS_URI}`,
+        encoding = UTF_8_ENCODING, ///
+        query = {},
+        body = JSON.stringify({
+          content,
+          encoding
+        })
+
+  postRequest(uri, query, body, userAgent, gitHubAccessToken, callback);
+}
+
+module.exports = {
+  commitSHAPostRequest,
+  baseTreeSHAGetRequest,
+  updatedHeadPostRequest,
+  commitTreeSHAPostRequest,
+  contentBlobSHAPostRequest,
+  latestCommitSHAGetRequest
+};

package/bin/utilities/headers.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const { headers, encodings } = require("necessary");
+
+const { APPLICATION_VND_GITHUB_VS_JSON } = require("../constants");
+
+const { BASE64_ENCODING } = encodings,
+      { ACCEPT_HEADER, USER_AGENT_HEADER, CONTENT_TYPE_HEADER, AUTHORIZATION_HEADER } = headers;
+
+function headersFromUserAgentAndGitHubAccessToken(userAgent, gitHubAccessToken) {
+  const tokenAuthorization = `Token ${gitHubAccessToken}`,
+        accept = APPLICATION_VND_GITHUB_VS_JSON,  ///
+        contentType = APPLICATION_VND_GITHUB_VS_JSON,  ///
+        authorization = tokenAuthorization,  ///
+        headers = {
+          [ ACCEPT_HEADER ]: accept,
+          [ USER_AGENT_HEADER ]: userAgent,
+          [ CONTENT_TYPE_HEADER ]: contentType,
+          [ AUTHORIZATION_HEADER ]: authorization
+        };
+
+  return headers;
+}
+
+function headersFromUserAgentClientIdAndClientSecret(userAgent, clientId, clientSecret) {
+  const digest = `${clientId}:${clientSecret}`,
+        encodedDigest = Buffer.from(digest).toString(BASE64_ENCODING),
+        basicAuthorization = `Basic ${encodedDigest}`,
+        accept = APPLICATION_VND_GITHUB_VS_JSON,  ///
+        authorization = basicAuthorization,	///
+        headers = {
+          [ ACCEPT_HEADER ]: accept,
+          [ USER_AGENT_HEADER ]: userAgent,
+          [ AUTHORIZATION_HEADER ]: authorization
+        };
+
+  return headers;
+}
+
+module.exports = {
+  headersFromUserAgentAndGitHubAccessToken,
+  headersFromUserAgentClientIdAndClientSecret
+};

package/bin/utilities/issue.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const { encodings } = require("necessary");
+
+const { GITHUB_REPOS_URI, GITHUB_ISSUES_URI } = require("../uris"),
+      { getRequest, postRequest, patchRequest } = require("../utilities/request"),
+      { repoFromRepository, ownerFromRepository } = require("../utilities/repository");
+
+const { UTF_8_ENCODING } = encodings;
+
+function issueGetRequest(repository, issueNumber, userAgent, clientId, clientSecret, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_URI}/${issueNumber}?`,
+        query = {};
+
+  getRequest(uri, query, userAgent, clientId, clientSecret, callback);
+}
+
+function issuesGetRequest(repository, state, userAgent, clientId, clientSecret, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_URI}`,
+        query = {
+          state
+        };
+
+  getRequest(uri, query, userAgent, clientId, clientSecret, callback);
+}
+
+function editIssuePatchRequest(repository, title, description, issueNumber, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_URI}/${issueNumber}`,
+        encoding = UTF_8_ENCODING,
+        query = {};
+
+  let body = description; ///
+
+  body = JSON.stringify({ ///
+    body,
+    title,
+    encoding
+  });
+
+  patchRequest(uri, query, body, gitHubAccessToken, callback);
+}
+
+function alterIssuePatchRequest(repository, state, issueNumber, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_URI}/${issueNumber}`,
+        encoding = UTF_8_ENCODING,
+        query = {},
+        body = JSON.stringify({ ///
+          state,
+          encoding
+        });
+
+  patchRequest(uri, query, body, gitHubAccessToken, callback);
+}
+
+function createIssuePostRequest(repository, title, description, gitHubAccessToken, callback) {
+  const owner = ownerFromRepository(repository),
+        repo = repoFromRepository(repository),
+        uri = `${GITHUB_REPOS_URI}/${owner}/${repo}${GITHUB_ISSUES_URI}`,
+        encoding = UTF_8_ENCODING,
+        query = {};
+
+  let body = description; ///
+
+  body = JSON.stringify({ ///
+    body,
+    title,
+    encoding
+  });
+
+  postRequest(uri, query, body, gitHubAccessToken, callback);
+}
+
+module.exports = {
+  issueGetRequest,
+  issuesGetRequest,
+  editIssuePatchRequest,
+  alterIssuePatchRequest,
+  createIssuePostRequest
+};

package/bin/utilities/repository.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const { arrayUtilities } = require("necessary");
+
+const { second } = arrayUtilities;
+
+const repoRegularExpression = /([^\/]+)$/,
+      ownerRegularExpression = /([^\/]+)\/[^\/]+$/;
+
+function isRepositoryValid(repository) {
+  const repoPresent = repoRegularExpression.test(repository),
+        ownerPresent = ownerRegularExpression.test(repository),
+        repositoryValid = (repoPresent && ownerPresent);
+
+  return repositoryValid;
+}
+
+function repoFromRepository(repository) {
+  const matches = repository.match(repoRegularExpression),
+        secondMatch = second(matches),
+        repo = secondMatch; ///
+
+  return repo;
+}
+
+function ownerFromRepository(repository) {
+  const matches = repository.match(ownerRegularExpression),
+        secondMatch = second(matches),
+        owner = secondMatch; ///
+
+  return owner;
+}
+
+module.exports = {
+  isRepositoryValid,
+  repoFromRepository,
+  ownerFromRepository
+};
+

package/bin/utilities/request.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const { Readable } = require("stream"),
+      { methods, requestUtilities } = require("necessary");
+
+const { END, DATA, EMPTY_STRING, GITHUB_API_HOST } = require("../constants"),
+      { headersFromUserAgentAndGitHubAccessToken, headersFromUserAgentClientIdAndClientSecret } = require("../utilities/headers");
+
+const { createRequest } = requestUtilities,
+      { GET_METHOD, POST_METHOD, DELETE_METHOD, PATCH_METHOD } = methods;
+
+function getRequest(uri, query, userAgent, clientId, clientSecret, callback) {
+  const host = GITHUB_API_HOST,
+        method = GET_METHOD,
+        headers = headersFromUserAgentClientIdAndClientSecret(userAgent, clientId, clientSecret),
+        request = createRequest(host, uri, query, method, headers, (error, response) => {
+          contentFromResponse(response, (content) => {
+            const jsonString = content,  ///
+                  json = JSON.parse(jsonString);
+
+            callback(error, json);
+          });
+        });
+
+  request.end();
+}
+
+function postRequest(uri, query, content, userAgent, gitHubAccessToken, callback) {
+  const host = GITHUB_API_HOST,
+        method = POST_METHOD,
+        headers = headersFromUserAgentAndGitHubAccessToken(userAgent, gitHubAccessToken),
+        postRequest = createRequest(host, uri, query, method, headers, (error, response) => {
+          contentFromResponse(response, (content) => {
+            const jsonString = content,  ///
+                  json = JSON.parse(jsonString);
+
+            callback(error, json);
+          });
+        }),
+        readable = Readable.from(content);
+
+  readable.pipe(postRequest);
+}
+
+function patchRequest(uri, query, content, userAgent, gitHubAccessToken, callback) {
+  const host = GITHUB_API_HOST,
+        method = PATCH_METHOD,
+        headers = headersFromUserAgentAndGitHubAccessToken(userAgent, gitHubAccessToken),
+        postRequest = createRequest(host, uri, query, method, headers, (error, response) => {
+          contentFromResponse(response, (content) => {
+            const jsonString = content,  ///
+                  json = JSON.parse(jsonString);
+
+            callback(error, json);
+          });
+        }),
+        readable = Readable.from(content);
+
+  readable.pipe(postRequest);
+}
+
+function deleteRequest(uri, query, userAgent, gitHubAccessToken, callback) {
+  const host = GITHUB_API_HOST,
+        method = DELETE_METHOD,
+        headers = headersFromUserAgentAndGitHubAccessToken(userAgent, gitHubAccessToken),
+        deleteRequest = createRequest(host, uri, query, method, headers, (error, response) => {
+          contentFromResponse(response, (content) => {
+            const string = content;  ///
+
+            callback(error, string);
+          });
+        });
+
+  deleteRequest.end();
+}
+
+module.exports = {
+  getRequest,
+  postRequest,
+  patchRequest,
+  deleteRequest
+};
+
+function contentFromResponse(response, callback) {
+  let content = EMPTY_STRING;
+
+  response.on(DATA, (data) => {
+    content += data;
+  });
+
+  response.on(END, () => {
+    callback(content);
+  });
+}

package/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const issueUtilities = require("./bin/utilities/issue"),
+      commitUtilities = require("./bin/utilities/commit"),
+      commentUtilities = require("./bin/utilities/comment");
+
+module.exports = {
+  issueUtilities,
+  commitUtilities,
+  commentUtilities
+};