jekyll-github-pages-gem 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e96acc9371c59ba0163040fc42595a54ec2dc7602b9d128313cb1b05d2c4106
+  data.tar.gz: 5310d22171f0150137e9abdbac7c0d3147f47f27f84f1c3c240c664e0033baef
+SHA512:
+  metadata.gz: 07c6be16e280cd410f7a0f5c25e16ea7fdbd69611a2a7fb61ec19846428b4ca2fe53a48eb0aec9504b8532b17bb6de815bbde38fc0ce82c6a71e83f0e47881c3
+  data.tar.gz: d9cdef19e6748af33fcd01c8dd1a30fb6a032b38839b924d168b26789720e63aeb032002e7cdbc699fb55f2bf58b45ea13fb6ca7a0c395e4c368a245da4743e8

data/Gemfile

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+gem 'kramdown'
+
+gem 'octokit', '~> 4.18'
+
+gem 'rubocop', '~> 0.71'
+
+gem 'carrierwave', '>= 2.0.0.rc', '< 3.0'
+
+# Octokit does not work with the most recent version of faraday so this locks it to a version that works.
+gem 'faraday', '~> 0.17.1'
+
+gem 'rake'
+
+group :test do
+  gem 'minitest'
+  gem 'mocha'
+  gem 'simplecov'
+end

data/Gemfile.lock

@@ -0,0 +1,97 @@
+PATH
+  remote: .
+  specs:
+    jekyll-github-pages-gem (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.0.2.2)
+      activesupport (= 6.0.2.2)
+    activesupport (6.0.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2)
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    ast (2.4.0)
+    carrierwave (2.1.0)
+      activemodel (>= 5.0.0)
+      activesupport (>= 5.0.0)
+      addressable (~> 2.6)
+      image_processing (~> 1.1)
+      mimemagic (>= 0.3.0)
+      mini_mime (>= 0.1.3)
+    concurrent-ruby (1.1.6)
+    docile (1.3.2)
+    faraday (0.17.3)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.12.2)
+    ffi (1.12.2-x64-mingw32)
+    i18n (1.8.2)
+      concurrent-ruby (~> 1.0)
+    image_processing (1.10.3)
+      mini_magick (>= 4.9.5, < 5)
+      ruby-vips (>= 2.0.17, < 3)
+    jaro_winkler (1.5.4)
+    kramdown (2.1.0)
+    mimemagic (0.3.4)
+    mini_magick (4.10.1)
+    mini_mime (1.0.2)
+    minitest (5.14.0)
+    mocha (1.11.2)
+    multipart-post (2.1.1)
+    octokit (4.18.0)
+      faraday (>= 0.9)
+      sawyer (~> 0.8.0, >= 0.5.3)
+    parallel (1.19.1)
+    parser (2.7.1.0)
+      ast (~> 2.4.0)
+    public_suffix (4.0.4)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    rexml (3.2.4)
+    rubocop (0.81.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.7.0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rexml
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    ruby-progressbar (1.10.1)
+    ruby-vips (2.0.17)
+      ffi (~> 1.9)
+    sawyer (0.8.2)
+      addressable (>= 2.3.5)
+      faraday (> 0.8, < 2.0)
+    simplecov (0.18.5)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.7)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.7.0)
+    zeitwerk (2.3.0)
+
+PLATFORMS
+  ruby
+  x64-mingw32
+
+DEPENDENCIES
+  carrierwave (>= 2.0.0.rc, < 3.0)
+  faraday (~> 0.17.1)
+  jekyll-github-pages-gem!
+  kramdown
+  minitest
+  mocha
+  octokit (~> 4.18)
+  rake
+  rubocop (~> 0.71)
+  simplecov
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -0,0 +1,16 @@
+[![Build Status](https://travis-ci.org/msoe-sg/jekyll-github-pages-gem.svg?branch=master)](https://travis-ci.org/msoe-sg/jekyll-github-pages-gem)
+
+## Setup
+1. Follow the instructions from the wiki article [here](https://github.com/msoe-sg/msoe-sg-website/wiki/Environment-Setup) to setup your development environment.
+2. Open up a terminal to the folder where you want to clone the repo and run the command `git@github.com:msoe-sg/jekyll-github-pages-gem.git`
+3. After run the clone change into the project directory by running the command `cd jekyll-github-pages-gem`
+4. Next install the dependencies for the project by running the command `bundle install`
+5. Contribute
+Our git flow process is typical--we have a master branch that gets released to the public, and feature branches for individual tasks. We don't have a development branch yet since this isn't used in production yet.
+If you have questions on how to contribute, please contact admin@msoe-sse.com or msoe.sg.hosting@gmail.com and we will get back to you at our earliest convenience.
+
+## Continuous Integration
+There are checks that will be performed whenever Pull Requests are opened.  To save time on the build server, please run the tests locally to check for errors that will occur in the CI builds.
+
+1. To run [Rubocop](https://github.com/ashmaroli/rubocop-jekyll), run the command `bundle exec rubocop`
+2. To run all unit tests, run the command `rake`

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+
+task default: 'test'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['tests/**/*_test.rb']
+end

data/jekyll_github_pages.gemspec

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name = 'jekyll-github-pages-gem'
+  s.version = '1.0.0'
+  s.summary = 'A gem that uses the github API to make edits with a jekyll blog'
+  s.files = Dir['*', 'lib/**/*']
+  s.require_paths = ['lib']
+  s.licenses = ['MIT']
+  s.authors = ['MSOE SSE Web Team']
+end

data/lib/factories/post_factory.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../models/post'
+
+module Factories
+  ##
+  # This class is a factory for parsing post text and creating a correseponding post model
+  class PostFactory
+    LEAD = '{: .lead}'
+    BREAK = '<!–-break-–>'
+
+    # serves as the default hero for a post if none is provided.
+    DEFAULT_HERO = 'https://source.unsplash.com/collection/145103/'
+
+    ##
+    # This method parses markdown in a post a returns a post model
+    #
+    # Params:
+    # +post_contents+::markdown in a given post
+    # +file_path+::the path on GitHub to the post
+    # +ref+::a sha for a ref indicating the head of a branch a post is pushed to on the GitHub server
+    def create_post(post_contents, file_path, ref)
+      create_post_model(post_contents, file_path, ref) if !post_contents.nil? && post_contents.is_a?(String)
+    end
+
+    private
+
+    def parse_tags(header)
+      result = []
+      header.lines.each do |line|
+        tag_match = line.match(/\s*-\s*(.*)/)
+        result << tag_match.captures.first if tag_match
+      end
+      result.join(', ')
+    end
+
+    def create_post_model(post_contents, file_path, ref)
+      result = Post.new
+
+      result.file_path = file_path
+      result.github_ref = ref
+
+      # What this regular expression does is it matches three groups
+      # The first group represents the header of the post which appears
+      # between the two --- lines. The second group is for helping capture newline characters
+      # correctly and the third group is the actual post contents
+      match_obj = post_contents.match(/---(.*)---(\r\n|\r|\n)(.*)/m)
+      header = match_obj.captures[0]
+
+      parse_post_header(header, result)
+      result.contents = match_obj.captures[2]
+                                 .remove("#{LEAD}\r\n")
+                                 .remove("#{LEAD}\n")
+                                 .remove("#{BREAK}\r\n")
+                                 .remove("#{BREAK}\n")
+      result.tags = parse_tags(header)
+      result
+    end
+
+    def parse_post_header(header, post_model)
+      # The following regular expressions in this method look for specific properities
+      # located in the post header.
+      post_model.title = header.match(/title:\s*(.*)(\r\n|\r|\n)/).captures.first
+      post_model.author = header.match(/author:\s*(.*)(\r\n|\r|\n)/).captures.first
+      post_model.hero = header.match(/hero:\s*(.*)(\r\n|\r|\n)/).captures.first
+      post_model.hero = '' if post_model.hero == DEFAULT_HERO
+      post_model.overlay = header.match(/overlay:\s*(.*)(\r\n|\r|\n)/).captures.first
+    end
+  end
+end

data/lib/jekyll_github_pages.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Third Party Dependencies
+require 'carrierwave'
+
+# Source Files
+require 'factories/post_factory'
+require 'services/post_services/base_post_service'
+require 'services/post_services/post_creation_service'
+require 'services/post_services/post_editing_service'
+require 'services/post_services/post_pull_request_editing_service'
+require 'services/github_service'
+
+require 'services/kramdown_service'
+
+require 'models/post'
+require 'models/post_image_manager'
+
+require 'uploaders/post_image_uploader'

data/lib/models/post.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+##
+# An object representing an image that is on a post
+class PostImage
+  attr_accessor :filename
+  # The binary contents of an image as a Base64 string
+  attr_accessor :contents
+end
+
+##
+# An object representing a post on the Jekyll website
+class Post
+  attr_accessor :title
+  attr_accessor :author
+  attr_accessor :hero
+  attr_accessor :overlay
+  attr_accessor :contents
+  attr_accessor :tags
+  # Path to the markdown post starting at the root of the repository
+  attr_accessor :file_path
+  # The GitHub ref the post's markdown is at. This is used to indicate
+  # whether a post is in PR or not
+  attr_accessor :github_ref
+  attr_accessor :images
+
+  def initialize
+    @images = []
+  end
+end

data/lib/models/post_image_manager.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+##
+# A singleton class for managing all image attachments for a post
+class PostImageManager
+  include Singleton
+
+  attr_reader :uploaders
+  attr_reader :downloaded_images
+  attr_accessor :root_dir
+
+  ##
+  # The constructor for PostImageManager which initializes the array of Carrierware
+  # image uploaders to use when submiting a post and the array of downloaded images
+  def initialize
+    @uploaders = []
+    @downloaded_images = []
+    @root_dir = ''
+  end
+
+  ##
+  # Adds an image to be uploaded in a Jekyll website post
+  #
+  # Params:
+  # +file+:: A ActionDispatch::Http::UploadedFile object containing the file to be used in a post
+  def add_file(file)
+    uploader_to_add = PostImageUploader.new
+    uploader_to_add.cache!(file)
+    @uploaders.delete_if { |x| x.filename == file.original_filename }
+    @uploaders << uploader_to_add
+  end
+
+  ##
+  # Adds an image that was downloaded from the Jekyll website repo
+  #
+  # Params:
+  # +downloaded_image+:: A PostImage object representing the downloaded image
+  def add_downloaded_image(downloaded_image)
+    @downloaded_images << downloaded_image
+  end
+
+  ##
+  # Clears the manager of all currently exisiting image uploaders and delete's their cache directories.
+  # Also clears the manager of all of the downloaded images
+  def clear(_root_dir)
+    @uploaders.each do |uploader|
+      full_preview_path = "#{@root_dir}/public/uploads/tmp/#{uploader.preview.cache_name}"
+      cache_dir = File.expand_path('..', full_preview_path)
+      uploader.remove!
+      Dir.delete(cache_dir)
+    end
+
+    @uploaders.clear
+    @downloaded_images.clear
+  end
+end

data/lib/services/github_service.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require 'octokit'
+require 'base64'
+require 'date'
+require 'cgi'
+require_relative 'kramdown_service'
+require_relative '../factories/post_factory'
+
+module Services
+  ##
+  # This class contains all operations involving interacting with the GitHub API
+  class GithubService
+    def initialize(full_repo_name, access_token)
+      @full_repo_name = full_repo_name
+      @access_token = access_token
+
+      @kramdown_service = Services::KramdownService.new
+      @post_factory = Factories::PostFactory.new
+    end
+
+    ##
+    # This method fetches all the markdown contents of all the posts on a Jekyll website
+    # that have been written and returns a list of models representing a Post.
+    def get_all_posts
+      result = []
+      client = create_octokit_client
+      posts = client.contents(@full_repo_name, path: '_posts')
+      posts.each do |post|
+        post_api_response = client.contents(@full_repo_name, path: post.path)
+
+        post_model = create_post_from_api_response(post_api_response, nil)
+        image_paths = @kramdown_service.get_all_image_paths(post_model.contents)
+
+        images = []
+        image_paths.each do |image_path|
+          image_content = client.contents(@full_repo_name, path: image_path)
+          images << create_post_image(image_path, image_content.content)
+        end
+
+        post_model.images = images
+
+        result << post_model
+      end
+      result
+    end
+
+    ##
+    # This method fetches all of the posts that have been written but have not been merged into master yet.
+    def get_all_posts_in_pr(pr_body)
+      result = []
+      client = create_octokit_client
+      pull_requests_for_user = get_open_jekyll_pull_requests(pr_body)
+
+      pull_requests_for_user.each do |pull_request|
+        pull_request_files = client.pull_request_files(@full_repo_name, pull_request[:number])
+
+        post = nil
+        images = []
+        pull_request_files.each do |pull_request_file|
+          contents_url_params = CGI.parse(pull_request_file[:contents_url])
+
+          # The CGI.parse method returns a hash with the key being the URL and the value being an array of
+          # URI parameters so in order to get the ref we need to grab the first value in the hash and the first
+          # URI parameter in the first hash value
+          ref = contents_url_params.values.first.first
+          file_contents = client.contents(@full_repo_name, path: pull_request_file[:filename], ref: ref)
+
+          if pull_request_file[:filename].end_with?('.md')
+            post = create_post_from_api_response(file_contents, ref)
+            result << post
+          else
+            images << create_post_image(pull_request_file[:filename], file_contents.content)
+          end
+        end
+
+        post.images = images
+      end
+      result
+    end
+
+    ##
+    # This method fetches a single post from a Jekyll website given a post title
+    # and returns a Post model
+    #
+    # Params:
+    # +title+:: A title of a Jekyll website post
+    # +ref+::a sha for a ref indicating the head of a branch a post is pushed to on the GitHub server
+    def get_post_by_title(title, ref)
+      result = nil
+      result = get_all_posts_in_pr.find { |x| x.title == title } if ref
+      result = get_all_posts.find { |x| x.title == title } unless ref
+      result&.images&.each { |x| PostImageManager.instance.add_downloaded_image(x) }
+      result
+    end
+
+    ##
+    # This method gets the sha of the commit at the head of master in a Jekyll website repo
+    def get_master_head_sha
+      client = create_octokit_client
+      client.ref(@full_repo_name, 'heads/master')[:object][:sha]
+    end
+
+    ##
+    # This method gets the sha of the base tree for a given branch in a Jekyll website repo
+    #
+    # Params
+    # +head_sha+::the sha of the head of a certain branch
+    def get_base_tree_for_branch(head_sha)
+      client = create_octokit_client
+      client.commit(@full_repo_name, head_sha)[:commit][:tree][:sha]
+    end
+
+    ##
+    # This method create a new blob in a Jekyll website repo with text content
+    #
+    # Params
+    # +text+::the text content to create a blob for
+    def create_text_blob(text)
+      client = create_octokit_client
+      client.create_blob(@full_repo_name, text)
+    end
+
+    ##
+    # This method creates a new blob in a Jekyll website with base 64 encoded content
+    #
+    # Params
+    # +content+::the base 64 encoded content to create a blob for
+    def create_base64_encoded_blob(content)
+      client = create_octokit_client
+      client.create_blob(@full_repo_name, content, 'base64')
+    end
+
+    ##
+    # This method creates a new tree in a Jekyll website repo and returns the tree's sha.
+    # The method assumes that the paths passed into the method have corresponding blobs
+    # created for the files
+    #
+    # Params:
+    # +file_information+::an array of hashes containing the file path and the blob sha for a file
+    # +sha_base_tree+::the sha of the base tree
+    def create_new_tree_with_blobs(file_information, sha_base_tree)
+      client = create_octokit_client
+      blob_information = []
+      file_information.each do |file|
+        # This mode property on this hash represents the file mode for a GitHub tree.
+        # The mode is 100644 for a file blob. See https://developer.github.com/v3/git/trees/ for more information
+        blob_information << { path: file[:path],
+                              mode: '100644',
+                              type: 'blob',
+                              sha: file[:blob_sha] }
+      end
+      client.create_tree(@full_repo_name, blob_information, base_tree: sha_base_tree)[:sha]
+    end
+
+    ##
+    # This method commits and pushes a tree to a Jekyll website repo
+    #
+    # Params:
+    # +commit_message+::the message for the new commit
+    # +tree_sha+::the sha of the tree to commit
+    # +head_sha+::the sha of the head to commit from
+    def commit_and_push_to_repo(commit_message, tree_sha, head_sha, ref_name)
+      client = create_octokit_client
+      sha_new_commit = client.create_commit(@full_repo_name, commit_message, tree_sha, head_sha)[:sha]
+      client.update_ref(@full_repo_name, ref_name, sha_new_commit)
+    end
+
+    ##
+    # This method creates a pull request for a branch in a Jekyll website repo
+    #
+    # Params:
+    # +source_branch+::the source branch for the PR
+    # +base_branch+::the base branch for the PR
+    # +pr_title+::the title for the PR
+    # +pr_body+::the body for the PR
+    # +reviewers+::an array of pull request reviewers for the PR
+    def create_pull_request(source_branch, base_branch, pr_title, pr_body, reviewers)
+      client = create_octokit_client
+      pull_number = client.create_pull_request(@full_repo_name, base_branch, source_branch, pr_title, pr_body)[:number]
+      client.request_pull_request_review(@full_repo_name, pull_number, reviewers: reviewers)
+    end
+
+    ##
+    # This method will create a branch in a Jekyll website repo
+    # if it already doesn't exist
+    #
+    # Params:
+    # +ref_name+:: the name of the branch to create if necessary
+    # +master_head_sha+:: the sha representing the head of master
+    def create_ref_if_necessary(ref_name, master_head_sha)
+      client = create_octokit_client
+      client.ref(@full_repo_name, ref_name)
+    rescue Octokit::NotFound
+      client.create_ref(@full_repo_name, ref_name, master_head_sha)
+    end
+
+    ##
+    # This method will fetch a GitHub's ref name given it's sha identifier.
+    # It will also strip off the starting refs portion of the name
+    #
+    # Params:
+    # +oauth_token+::a user's oauth access token
+    # +ref_sha+:: the sha of the ref to fetch
+    def get_ref_name_by_sha(ref_sha)
+      client = create_octokit_client
+      ref_response = client.refs(@full_repo_name).find { |x| x[:object][:sha] == ref_sha }
+      ref_response[:ref].match(%r{refs/(.*)}).captures.first
+    end
+
+    private
+
+    def create_post_from_api_response(post, ref)
+      # Base64.decode64 will convert our string into a ASCII string
+      # calling force_encoding('UTF-8') will fix that problem
+      text_contents = Base64.decode64(post.content).dup.force_encoding('UTF-8')
+      @post_factory.create_post(text_contents, post.path, ref)
+    end
+
+    def get_open_jekyll_pull_requests(pull_request_body)
+      client = create_octokit_client
+      open_pull_requests = client.pull_requests(@full_repo_name, state: 'open')
+      open_pull_requests.select { |x| x[:body] == pull_request_body }
+    end
+
+    def create_post_image(filename, contents)
+      result = PostImage.new
+      result.filename = filename
+      result.contents = contents
+      result
+    end
+
+    def create_octokit_client
+      Octokit::Client.new(access_token: @access_token)
+    end
+  end
+end

data/lib/services/kramdown_service.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'kramdown'
+
+##
+# This modules contains extentions of the Kramdown::Convert module for custom kramdown converters
+module Kramdown
+  module Converter
+    ##
+    # A custom kramdown HTML converter for getting the HTML preview for a post
+    class Preview < Html
+      ##
+      # An override of the convert_img tag which converts all image sources to pull
+      # from the CarrierWare cache location if an uploader exists with the image's filename.
+      # Or the Base64 contents of a downloaded image are replaced in the src attribute if the image
+      # was downloaded for the post
+      #
+      # Params:
+      # +el+::the image element to convert to html
+      # +indent+::the indent of the HTML
+      def convert_img(element, indent)
+        formatted_filename = File.basename(element.attr['src']).tr(' ', '_')
+        uploader = PostImageManager.instance.uploaders.find { |x| x.filename == formatted_filename }
+        if uploader
+          element.attr['src'] = "/uploads/tmp/#{uploader.preview.cache_name}"
+        else
+          downloaded_image = PostImageManager.instance.downloaded_images
+                                             .find { |x| File.basename(x.filename) == File.basename(element.attr['src']) }
+          if downloaded_image
+            extension = File.extname(downloaded_image.filename)
+            extension[0] = ''
+            element.attr['src'] = "data:image/#{extension};base64,#{downloaded_image.contents}"
+          end
+        end
+
+        super(element, indent)
+      end
+    end
+  end
+end
+
+module Services
+  ##
+  # This class contains all operations with interacting with the kramdown engine
+  class KramdownService
+    DEFAULT_HERO = 'https://source.unsplash.com/collection/145103/'
+    ##
+    # This method takes given markdown and converts it to HTML for the post preview
+    #
+    # Params:
+    # +text+:: markdown to convert to html
+    def get_preview(text)
+      Kramdown::Document.new(text).to_preview
+    end
+
+    ##
+    # This method returns the image filename given some markdown
+    #
+    # Params:
+    # +image_file_name+:: a filename of a image to look for in markdown
+    # +markdown+:: text of a markdown post
+    def get_image_filename_from_markdown(image_file_name, markdown)
+      document = Kramdown::Document.new(markdown)
+      document_descendants = []
+
+      get_document_descendants(document.root, document_descendants)
+      all_img_tags = document_descendants.select { |x| x.type == :img }
+      matching_image_tag = all_img_tags.find { |x| get_filename_for_image_tag(x).tr(' ', '_') == image_file_name }
+
+      return get_filename_for_image_tag(matching_image_tag) if matching_image_tag
+
+      nil
+    end
+
+    ##
+    # This method returns an array of all image paths given some markdown
+    #
+    # Params:
+    # +markdown+:: text of a markdown post
+    def get_all_image_paths(markdown)
+      document = Kramdown::Document.new(markdown)
+      document_descendants = []
+
+      get_document_descendants(document.root, document_descendants)
+      all_img_tags = document_descendants.select { |x| x.type == :img }
+
+      result = all_img_tags.map do |img_tag|
+        img_tag.attr['src'][1..-1] if img_tag.attr['src'] !~ URI::DEFAULT_PARSER.make_regexp
+      end
+
+      result.compact
+    end
+
+    ##
+    # This method takes parameters for a given post and formats them
+    # as a valid jekyll post for a Jekyll website
+    #
+    # Params:
+    # +text+:: the markdown contents of the post
+    # +author+:: the author of the post
+    # +title+:: the title of the post
+    # +tags+:: tags specific to the post
+    # +overlay+:: the overlay color of the post
+    # +hero+:: a link to an optional background image for a post
+    def create_jekyll_post_text(text, author, title, tags, overlay, hero)
+      header_converted_text = fix_header_syntax(text)
+      header_converted_text = add_line_break_to_markdown_if_necessary(header_converted_text)
+
+      parsed_tags = parse_tags(tags)
+
+      tag_section = %(tags:
+#{parsed_tags})
+
+      lead_break_section = "{: .lead}\r\n<!–-break-–>"
+
+      hero_to_use = hero
+      hero_to_use = DEFAULT_HERO if hero_to_use.empty?
+      result = %(---
+layout: post
+title: #{title}
+author: #{author}\r\n)
+
+      result += "#{tag_section}\r\n" unless parsed_tags.empty?
+      result += %(hero: #{hero_to_use}
+overlay: #{overlay.downcase}
+published: true
+---
+#{lead_break_section}
+#{header_converted_text})
+
+      result
+    end
+
+    private
+
+    def parse_tags(tags)
+      tag_array = tags.split(',')
+      result = ''
+      tag_array.each do |tag|
+        result += "  - #{tag.strip}"
+        result += "\r\n" if tag != tag_array.last
+      end
+      result
+    end
+
+    def fix_header_syntax(text)
+      document = Kramdown::Document.new(text)
+      header_elements = document.root.children.select { |x| x.type == :header }
+      lines = text.split("\n")
+      lines = lines.map do |line|
+        if header_elements.any? { |x| line.include? x.options[:raw_text] }
+          # This regex matches the line into 2 groups with the first group being the repeating #
+          # characters and the beginning of the string and the second group being the rest of the string
+          line_match = line.match(/(#*)(.*)/)
+          line = "#{line_match.captures.first} #{line_match.captures.last.strip}"
+        else
+          line.delete("\r\n")
+        end
+      end
+      lines.join("\r\n")
+    end
+
+    def get_document_descendants(current_element, result)
+      current_element.children.each do |element|
+        result << element
+        get_document_descendants(element, result)
+      end
+    end
+
+    def get_filename_for_image_tag(image_el)
+      File.basename(image_el.attr['src'])
+    end
+
+    def add_line_break_to_markdown_if_necessary(markdown)
+      lines = markdown.split("\n")
+      # The regular expression in the if statement looks for a markdown reference to a link like
+      # [logo]: https://ieeextreme.org/wp-content/uploads/2019/05/Xtreme_colour-e1557478323964.png
+      # If a post starts with that reference in jekyll followed by an image using that reference
+      # the line below will be interperted as a paragraph tag instead of an image tag. To fix that
+      # we add a line break to the start of the markdown.
+      return "\r\n#{markdown}" if lines.first&.match?(/\[(.*)\]: (.*)/)
+
+      markdown
+    end
+  end
+end

data/lib/services/post_services/base_post_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Services
+  ##
+  # The base class for service classes responsible for performing operations on posts
+  class BasePostService
+    def initialize(repo_name, access_token)
+      @github_service = GithubService.new(repo_name, access_token)
+      @kramdown_service = KramdownService.new
+    end
+
+    protected
+
+    def create_new_tree(post_markdown, post_title, post_file_path, sha_base_tree)
+      file_information = [create_blob_for_post(post_markdown, post_title, post_file_path)]
+      create_image_blobs(post_markdown, file_information)
+      @github_service.create_new_tree_with_blobs(file_information, sha_base_tree)
+    end
+
+    private
+
+    def create_blob_for_post(post_markdown, _post_title, post_file_path)
+      blob_sha = @github_service.create_text_blob(post_markdown)
+      { path: post_file_path, blob_sha: blob_sha }
+    end
+
+    def create_image_blobs(post_markdown, current_file_information)
+      PostImageManager.instance.uploaders.each do |uploader|
+        # This check prevents against images that have been removed from the markdown
+        markdown_file_name = @kramdown_service.get_image_filename_from_markdown(uploader.filename, post_markdown)
+        next unless markdown_file_name
+
+        # This line uses .file.file since the first .file returns a carrierware object
+        File.open(uploader.post_image.file.file, 'rb') do |file|
+          base_64_encoded_image = Base64.encode64(file.read)
+          image_blob_sha = @github_service.create_base64_encoded_blob(base_64_encoded_image)
+          current_file_information << { path: "assets/img/#{markdown_file_name}", blob_sha: image_blob_sha }
+        end
+      end
+    end
+  end
+end

data/lib/services/post_services/post_creation_service.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative './base_post_service'
+require_relative '../github_service'
+
+module Services
+  ##
+  # This class is responsible for creating posts on a Jekyll website
+  class PostCreationService < BasePostService
+    def initialize(repo_name, access_token)
+      super(repo_name, access_token)
+    end
+
+    ##
+    # This method submits a new post to GitHub by checking out a new branch for the post,
+    # if the branch already doesn't exist. Commiting and pushing the markdown and any photos
+    # attached to the post to the branch. And then finally opening a pull request into master
+    # for the new post.
+    #
+    # Params
+    # +oauth_token+::a user's oauth access token
+    # +post_markdown+:: the markdown contents of a post
+    # +pull_request_body+::an optional pull request body for the post, it will be blank if nothing is provided
+    # +reviewers+:: an optional list of reviewers for the post PR
+    def create_post(post_markdown, post_title, pull_request_body = '', reviewers = [])
+      # This ref_name variable represents the branch name
+      # for creating a post. At the end we strip out all of the whitespace in
+      # the post_title to create a valid branch name
+      branch_name = "createPost#{post_title.gsub(/\s+/, '')}"
+      ref_name = "heads/#{branch_name}"
+
+      master_head_sha = @github_service.get_master_head_sha
+      sha_base_tree = @github_service.get_base_tree_for_branch(master_head_sha)
+
+      @github_service.create_ref_if_necessary(ref_name, master_head_sha)
+
+      new_post_path = create_new_filepath_for_post(post_title)
+      new_tree_sha = create_new_tree(post_markdown, post_title, new_post_path, sha_base_tree)
+
+      @github_service.commit_and_push_to_repo("Created post #{post_title}",
+                                              new_tree_sha, master_head_sha, ref_name)
+      @github_service.create_pull_request(branch_name, 'master', "Created Post #{post_title}",
+                                          pull_request_body,
+                                          reviewers)
+
+      PostImageManager.instance.clear
+    end
+
+    private
+
+    def create_new_filepath_for_post(post_title)
+      "_posts/#{DateTime.now.strftime('%Y-%m-%d')}-#{post_title.gsub(/\s+/, '')}.md"
+    end
+  end
+end

data/lib/services/post_services/post_editing_service.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative './base_post_service'
+require_relative '../github_service'
+
+module Services
+  ##
+  # This class is responsible for editing posts on a Jekyll website
+  class PostEditingService < BasePostService
+    def initialize(repo_name, access_token)
+      super(repo_name, access_token)
+    end
+
+    ##
+    # This method submits changes to an existing post to GitHub by checking out a new branch for the post,
+    # if the branch already doesn't exist. Commiting and pushing the markdown changes and any added photos
+    # for the existing post to the branch. And the finally opening a pull request into master for the new post.
+    #
+    # Params
+    # +post_markdown+::the modified markdown to submit
+    # +post_title+::the title for the existing post
+    # +existing_post_file_path+::the file path to the existing post on GitHub
+    # +pull_request_body+::an optional pull request body for the post, it will be blank if nothing is provided
+    # +reviewers+:: an optional list of reviewers for the post PR
+    def edit_post(post_markdown, post_title, existing_post_file_path, pull_request_body = '', reviewers = [])
+      # This ref_name variable represents the branch name
+      # for editing a post. At the end we strip out all of the whitespace in
+      # the post_title to create a valid branch name
+      branch_name = "editPost#{post_title.gsub(/\s+/, '')}"
+      ref_name = "heads/#{branch_name}"
+
+      master_head_sha = @github_service.get_master_head_sha
+      sha_base_tree = @github_service.get_base_tree_for_branch(master_head_sha)
+
+      @github_service.create_ref_if_necessary(ref_name, master_head_sha)
+      new_tree_sha = create_new_tree(post_markdown, post_title, existing_post_file_path, sha_base_tree)
+
+      @github_service.commit_and_push_to_repo("Edited post #{post_title}", new_tree_sha, master_head_sha, ref_name)
+      @github_service.create_pull_request(branch_name, 'master', "Edited Post #{post_title}",
+                                          pull_request_body,
+                                          reviewers)
+
+      PostImageManager.instance.clear
+    end
+  end
+end

data/lib/services/post_services/post_pull_request_editing_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative './base_post_service'
+require_relative '../github_service'
+
+module Services
+  ##
+  # This class is responsible for editing posts that are in PR on a Jekyll website
+  class PostPullRequestEditingService < BasePostService
+    def initialize(repo_name, access_token)
+      super(repo_name, access_token)
+    end
+
+    ##
+    # This method submits changes to a post that is already in PR, commiting and pushing the markdown changes
+    # and any added photos to the branch. Since the post is in PR these changes will be a PR updated to the given branch
+    #
+    # Params:
+    # +post_markdown+::the modified markdown to submit
+    # +post_title+::the title for the existing post
+    # +existing_post_file_path+::the file path to the existing post on GitHub
+    # +ref+::the ref to update
+    def edit_post_in_pr(post_markdown, post_title, existing_post_file_path, ref)
+      ref_name = @github_service.get_ref_name_by_sha(ref)
+      sha_base_tree = @github_service.get_base_tree_for_branch(ref)
+
+      new_tree_sha = create_new_tree(post_markdown, post_title, existing_post_file_path, sha_base_tree)
+      @github_service.commit_and_push_to_repo("Edited post #{post_title}", new_tree_sha, ref, ref_name)
+
+      PostImageManager.instance.clear
+    end
+  end
+end

data/lib/uploaders/post_image_uploader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'carrierwave'
+##
+# The file uploader class for uploading images to a Jekyll website post
+class PostImageUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MiniMagick
+  # These constants represent the maximum width and height an uploaded can be for the post preview
+  # and for actually appearing on a Jekyll website. These numbers were initially determined by testing
+  # with a 1920x1080 image. If you find a reason to change these numbers please document the reason
+  # below
+  PREVIEW_LIMIT = [800, 800].freeze
+  POST_LIMIT = [800, 700].freeze
+
+  storage :file
+
+  ##
+  # Limits only images to be uploaded to an SSE website post
+  def extension_whitelist
+    %w[jpg jpeg gif png]
+  end
+
+  def size_range
+    # 5 mb is a very large photo it will probably never be reached. But
+    # this will prevent people from passing off very large files as an image.
+    # If you change this limit please document the reason for changing it below
+    (1..5).step { |x| bytes_to_megabytes x }
+  end
+
+  version :preview do
+    process resize_to_limit: PREVIEW_LIMIT
+  end
+
+  version :post_image do
+    process resize_to_limit: POST_LIMIT
+  end
+
+  private
+
+  def bytes_to_megabytes(bytes)
+    bytes * (1024.0 * 1024.0)
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-github-pages-gem
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- MSOE SSE Web Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-12 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- jekyll_github_pages.gemspec
+- lib/factories/post_factory.rb
+- lib/jekyll_github_pages.rb
+- lib/models/post.rb
+- lib/models/post_image_manager.rb
+- lib/services/github_service.rb
+- lib/services/kramdown_service.rb
+- lib/services/post_services/base_post_service.rb
+- lib/services/post_services/post_creation_service.rb
+- lib/services/post_services/post_editing_service.rb
+- lib/services/post_services/post_pull_request_editing_service.rb
+- lib/uploaders/post_image_uploader.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: A gem that uses the github API to make edits with a jekyll blog
+test_files: []