github-to-canvas 0.1.1 → 0.1.7.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a091b1eff741a97c405fa521cdc476c674f0d3dedb915d919045fab6244b5037
-  data.tar.gz: 5c384485dfcbb6da42dcf8db87115173d72b1ef548d3bfe99cfe6fec3af9ce98
+  metadata.gz: 53c9c96308fae1d78f27bc68e80fee55baf2ff23d381866edfd1d114b30601ec
+  data.tar.gz: bf7570a5be4657e102659454295beb72023864ceb20562b51858fa094997b5f7
 SHA512:
-  metadata.gz: 5ae4d1c9c1ade17a0a15d148267f2e9c5949857c3f76ce0a65c1a0f6ac5e7c382ab29c2ae1ef9c37ace078178a7ae8a342e3f543813384d350279093cd483233
-  data.tar.gz: b2165b3675bc12d80149975edeaf77341ccade1687b1558a4463613853df78362c16f3520f1ae5baf394854cb06f4e21e1c90525feefeecccbd2103b684f712d
+  metadata.gz: adbf272b0121b81582d6520bc0c3881980276ede161cb97515d1792563cb29a603c93e7bf35790db1eacc89fb471b68127dccaf24fa43f3205cd758fa53739c2
+  data.tar.gz: 45182fbe2c428468ed967650a5e42ad496af4fa8dca236b61ec52ef9aa0ace3c209ece9a52eadd46849252a7dd6f9fa7c047a5017057bb96ca5143ee3155784a

data/README.md

@@ -6,7 +6,7 @@ The `github-to-canvas` gem is designed to aid in integrating GitHub and the
 Canvas LMS. This gem takes a GitHub repository's `README.md` file, converts it
 to HTML, and pushes it to Canvas using the Canvas API. This gem can also update
 existing Canvas lessons, allowing continuous alignment of content between GitHub
-and Canvas, using the GitHub repository as the single source of truth.
+and Canvas.
 
 This gem is built for use internally at [Flatiron School][], so some features may be
 specific to Flatiron School branding and needs. Access to the
@@ -63,44 +63,21 @@ are present by running `ENV` and finding them in the output list.
 
 ## Common Uses
 
-### Creating and Updating Canvas Lessons
+The GitHub to Canvas gem can be used for the following:
 
-Relevant options:
+- [Create a Canvas Lesson from a Local Repository](#create)
+- [Create a Canvas Lesson from a Remote Repository](#createremote)
+- [Read a Remote Repository as HTML](#read)
+- [Update a Canvas Lesson from a Local Repository](#update)
+- [Update a Canvas Lesson from a Remote Repository](#updateremote)
+- [Retrieve Canvas Course Information as YAML Markdown](#query)
+- [Map GitHub Repositories to a Canvas Course YAML file](#map)
+- [Create New Canvas Course from a YAML file](#buildcourse)
+- [Update Lessons in an Existing Course from a YAML file](#updatecourse)
 
-- `--create-lesson`, `-c`: Requires a Canvas course ID. Creates a new Canvas
-  lesson, converting the local repository's README.md to HTML. Adds `.canvas`
-  file to remote repository
-- `--align`, `-a`: Updates a canvas lesson based on the local repository's
-  README.md. If no other options are used, `--align` will look for a `.canvas`
-  file to know what to lesson to update
-- `--course`: Provide a specific course ID. When used with `--id`, this can
-  override the default behavior for `--align`, allowing you to update any
-  existing lesson and ignore the `.canvas` file if present.
-- `--id`: Provide a specific lesson ID. This can be found in the URL of the
-  specific lesson. For Pages, used the slugified lesson title.
-- `--type`: Sets the type of Canvas lesson to be created (page, assignment or
-  discussion). If no type, type decided based on repository structure.
-- `--name`: Can be used to override default naming behavior. By default, Canvas
-  lesson names are determined by the first top-level (`#`) header in the
-  repository's markdown file.
-- `--fis-links`, `-l`: Adds additional Flatiron School HTML header after
-  markdown conversion, including links back to the GitHub repo and it's issue
-  form.
-- `--forkable`: Adds a **Fork** button to the Flatiron School HTML header. For
-  use with custom Canvas JS to enable Canvas assignment forking workflow for
-  Flatiron School students.
-- `--remove-header-and-footer`, `-r`: Removes top lesson header and any Flatiron
-  School specific footer links before converting to HTML. Removing top lesson
-  header prevent duplicate titles while viewing in Canvas.
-- `--create-from-github`: Requires a GitHub repository URL. Also requires
-  `--course` and `--type`. Creates a Canvas lesson, reading from the remote repo
-  instead of a local repository. Repository must be public.
-- `--align-from-github`: Requires a GitHub repo URL, `--course`, `--id`, and
-  `--type`. Updates a Canvas lesson from a remote repository.
-- `--read-from-github`: Requires a GitHub repo URL. Reads a remote repository
-  and converts its contents to HTML, but does not push to Canvas.
+### Creating and Updating Canvas Lessons
 
-#### Create a Canvas Lesson from a Local Repository
+#### Create a Canvas Lesson from a Local Repository <a name="create"></a>
 
 Navigate into a repository folder cloned down to your local machine and run:
 
@@ -114,16 +91,15 @@ branded footers. It will also add an HTML header for Canvas that includes links
 back to the repository.
 
 If the lesson type is an assignment, a Fork button will also be added to the
-HTML header. Because the command didn't specify, the type of lesson is
-determined based on the structure of the local repo - if it has sub-folders, the
-lesson will become an assignment; if there are no sub-folders, the lesson will
-become a page. If the lesson type is a page, the `--forkable` option will be
-ignored.
+HTML header. Because the command didn't specify, the type of lesson is determined
+based on the local repo structure - if it has sub-folders, the lesson will become
+an assignment; if there are no sub-folders, the lesson will become a page. If the
+lesson type is a page, the `--forkable` option will be ignored.
 
 Creating a lesson this way will also produce a `.canvas` file. This file
 contains info about the Canvas lesson that was created.
 
-#### Create a Canvas Lesson from a Remote Repository
+#### Create a Canvas Lesson from a Remote Repository <a name="createremote"></a>
 
 To create from a remote repo, run the following command:
 
@@ -139,7 +115,7 @@ lesson the same way as before.
 
 The repository must be public in order to read the markdown file.
 
-#### Read a Remote Repository as HTML
+#### Read a Remote Repository as HTML <a name="read"></a>
 
 To read the contents of a remote repo:
 
@@ -150,11 +126,11 @@ github-to-canvas --read-from-github <URL>
 This will produce an HTML conversion of the repository's markdwon. This HTML can
 be directly pasted into Canvas' HTML editor if a manual process is needed.
 
-#### Update a Canvas Lesson from a Local Repository
+#### Update a Canvas Lesson from a Local Repository <a name="update"></a>
 
 If you previously created a Canvas lesson from a local repository, you should
 have a `.canvas` file present in the repo. If that file is present, you can run
-the following command to automatically update that same Canvas lesson:
+the following command to update the listed Canvas lesson automatically:
 
 ```sh
 github-to-canvas -a -lr --forkable
@@ -169,7 +145,7 @@ github-to-canvas -a --course <CANVAS_COURSE_ID> --id <CANVAS_LESSON_ID> -lr --fo
 
 Canvas course and lesson IDs can be found in the URL.
 
-#### Update a Canvas Lesson from a Remote Repository
+#### Update a Canvas Lesson from a Remote Repository <a name="updateremote"></a>
 
 You can update an existing Canvas course using a remote GitHub repository like so:
 
@@ -182,7 +158,7 @@ using the info provided. Type must match the existing lesson type.
 
 ### Course Creation
 
-This gem has the ability to create Canvas courses from scratch. These features
+This gem can create Canvas courses from scratch. These features
 are still in development and may not work for all course designs. Quiz and
 Discussion Topic lesson creation is still under development and will not work.
 
@@ -191,7 +167,7 @@ course, add in modules, and populate those modules with pages and assignments.
 The required YAML file must follow a specific structure. Using the steps below,
 this gem can create the necessary YAML markup from existing Canvas courses.
 
-#### Retrieve Canvas Course Information as YAML
+#### Retrieve Canvas Course Information as YAML Markdown <a name="query"></a>
 
 To create YAML markup of an existing Canvas course, use the following:
 
@@ -243,7 +219,7 @@ The output will look similar to this:
 
 The output YAML will not include associated GitHub repository information.
 
-#### Map GitHub Repositories to a Canvas Course YAML
+#### Map GitHub Repositories to a Canvas Course YAML file <a name="map"></a>
 
 To associate repositories to an existing course YAML, the following command can be used:
 
@@ -264,7 +240,7 @@ github-to-canvas --map query_results.yml > course_structure.yml
 The resulting YAML file will contain course information, the module and lesson
 structure, and each lesson's associated GitHub repository.
 
-#### Create New Canvas Course from YAML
+#### Create New Canvas Course from a YAML file <a name="buildcourse"></a>
 
 To create a Canvas course with this gem, you will need a correctly structured
 YAML file with the course info, modules, lessons and associated lesson
@@ -288,18 +264,18 @@ This command will cause the following to happen:
 - Create the second lesson and add it to the module...
 - Repeate process until all modules and lessons are created
 
-#### Align an Existing Course from YAML
+#### Update Lessons in an Existing Course from a YAML file <a name="updatecourse"></a>
 
-After you've created a course using the previous process, go through the
-previous steps of `--query` and `--map` to get a fully updated YAML for your
-newly created course.
+The GitHub to Canvas gem can be used to update all lessons in a course
+with a single command. To do this, you will need an up-to-date course YAML file with repositories
+mapped to each lesson.
 
 ```sh
 github-to-canvas --query <COURSE_ID> > query_results.yml
 github-to-canvas --map query_results.yml > your_new_course.yml
 ```
 
-With this data file, you can use the following command to update all lessons in
+Use the resulting file (in this example, `your_new_course.yml`) to update all lessons in
 a course based on their GitHub repo:
 
 ```sh
@@ -314,33 +290,49 @@ associated repository.
 ### HTML Code Snippets Do Not Render
 
 The Canvas API renders all HTML it receives. If your repository's markdown
-includes HTML that is not meant to be rendered (i.e. lessons on HTML or
-JavaScript that include HTML code snippets), the content will be rendered as
-part of the page's HTML, resulting in unusual display errors in Canvas.
-
-To fix any rendering issues in Canvas, go to the Canvas WYSIWYG editor for the
-afflicted lesson. Click the HTML editor option (`</>` button in the lower right) to
-switch to HTML.
-
-Read the GitHub repo as HTML:
-
-```sh
-github-to-canvas --read-from-github URL
-```
-
-Copy the output HTML and paste it in to the Canvas editor. This should clear up
-some larger page rendering issues, but may not fix all code snippets issues. To
-fix these, switch back to the regular Canvas WYSIWYG editor, then open a second
-tab to the GitHub repo you're converting from. Copy any HTML code snippets from
-GitHub and paste them into the Canvas editor where they should be displayed.
+includes HTML that is not meant to be rendered, the content will be rendered as
+part of the page's HTML, resulting in unusual display errors in Canvas. Examples of
+this would be lessons on HTML or JavaScript that include HTML code snippets.
+
+To prevent HTML from being rendered, include the `--contains-html` option when
+running the GitHub to Canvas gem. This replaces `<` and `>` characters with HTML
+charset values wrapped in `span` elements. This will stop Canvas from rendering
+the HTML.
+
+If your markdown contains a mix of HTML that should and should not be rendered,
+you will need to either replace HTML that you want to be rendered with markdown
+syntax equivalents. For example, HTML you want to display as code and an `<img>`
+element you want to render as the image itself, replace the `<img>` tag with
+markdown syntax (`![alt text](url)`).
+
+The one exception is the `<iframe>` element. There is no way to easily embed
+videos in GitHub markdown without HTML, so this tag will always be allowed to
+render in Canvas, whether or not you use `--contains-html`.
+
+If you have HTML related rendering issues in Canvas that can't be fixed with
+`--contains-html`:
+
+- Go to the Canvas WYSIWYG editor for the afflicted lesson.
+- Click the HTML editor option (`</>` button in the lower right) to switch to
+  HTML.
+- Read the GitHub repo as HTML:
+
+  ```sh
+  github-to-canvas --read-from-github URL
+  ```
+
+- Copy the output HTML and paste it in to the Canvas editor. This should clear up
+some larger page rendering issues, but may not fix all code snippets issues. 
+- Switch back to the regular Canvas WYSIWYG editor
+- Open a second tab to the GitHub repo you're converting from.
+- Copy any HTML code snippets from GitHub and paste them into the Canvas editor
+  where they should be displayed.
 
 The Canvas editor will treat the pasted HTML content as code and will
 automatically replace some characters, escaping the code from the
 normal rendering process.
 
-Note that realigning after fixing this content with the gem will break the
-rendering for these lessons again. A fix is planned for this issue, but has not
-been implemented.
+Note that realigning after fixing this content may overwrite fixes.
 
 ### Multi-Line Code Snippets Render as a Single Line
 
@@ -352,9 +344,17 @@ issues, please open a new issue with a markdown example to replicate the error.
 
 ### Markdown Formatting Issues Cause Errors in Canvas
 
-Individual markdown headers, paragraphs and code snippets should be separated by
-an empty line in the markdown. Without these empty lines, the contents will be
-interpretted as one continuous paragraph and ignore formatting.
+An empty line should separate individual markdown headers, paragraphs and code snippets
+in the markdown. Without these empty lines, the contents will be interpretted as one
+continuous paragraph and ignore formatting.
+
+### New Repos That Use a `main` Branch
+
+If you are using a new GitHub repository that uses a `main` branch, you may not be able to
+create or update from a remote repository. You can still create and update from a local
+repository by using the `--branch` (`-b`) option and specifying `main` as the branch.
+
+A fix is planned for this issue, but not implemented.
 
 ## Overview of GitHub to Canvas workflows
 
@@ -362,9 +362,8 @@ Using this gem, you can maintain Canvas courses in multiple ways - either by
 creating and updating individual Canvas lessons or through the YAML file process.
 
 At Flatiron School, we use the Canvas blueprint course feature. We use the
-github-to-canvas gem to update the blueprint copy of lessons. These updates will
-appear in future copies of the course, or can be synced down to existing course
-copies.
+github-to-canvas gem to update the blueprint copy of lessons. These updates will appear
+in future copies of the course or when synced down associated courses in Canvas.
 
 ![github-to-canvas workflow chart](./images/github-to-canvas_workflow.png)
 
@@ -375,18 +374,46 @@ If you are using github-to-canvas in this way, changes should always be made on
 the repository, not on Canvas. Any changes made only on Canvas will get
 overwritten if the lesson is updated using the gem.
 
-## Additional Options
-
-### Specify Branch
+## Common Options
 
-When creating or aligning content locally, you can use `--branch` (`-b`) to
-specify which branch you want to use. If you have a newer repository with a
-`main` branch instead of `master`, use this option.
-
-If you are are creating or aligning content locally, the `.canvas` file is not
-automatically committed to the repo. You can automatically commit this file by
-including the `--save-to-github` (`-s`) option. This option will attempt to
-commit and push the `.canvas` file to the remote repository.
+- `--create-lesson`, `-c`: Requires a Canvas course ID. Creates a new Canvas
+  lesson, converting the local repository's README.md to HTML. Adds `.canvas`
+  file to remote repository
+- `--align`, `-a`: Updates a canvas lesson based on the local repository's
+  README.md. If no other options are used, `--align` will look for a `.canvas`
+  file to know what to lesson to update
+- `--course`: Provide a specific course ID. When used with `--id`, this can
+  override the default behavior for `--align`, allowing you to update any
+  existing lesson and ignore the `.canvas` file if present.
+- `--id`: Provide a specific lesson ID. This can be found in the URL of the
+  specific lesson. For Pages, used the slugified lesson title.
+- `--type`: Sets the type of Canvas lesson to be created (page, assignment or
+  discussion). If no type, type decided based on repository structure.
+- `--name`: Can be used to override default naming behavior. By default, Canvas
+  lesson names are determined by the first top-level (`#`) header in the
+  repository's markdown file.
+- `--fis-links`, `-l`: Adds additional Flatiron School HTML header after
+  markdown conversion, including links back to the GitHub repo and it's issue
+  form.
+- `--forkable`: Adds a **Fork** button to the Flatiron School HTML header. For
+  use with custom Canvas JS to enable Canvas assignment forking workflow for
+  Flatiron School students.
+- `--remove-header-and-footer`, `-r`: Removes top lesson header and any Flatiron
+  School specific footer links before converting to HTML. Removing top lesson
+  header prevents duplicate titles while viewing in Canvas.
+- `--create-from-github`: Requires a GitHub repository URL. Also requires
+  `--course` and `--type`. Creates a Canvas lesson, reading from the remote repo
+  instead of a local repository. Repository must be public.
+- `--align-from-github`: Requires a GitHub repo URL, `--course`, `--id`, and
+  `--type`. Updates a Canvas lesson from a remote repository.
+- `--read-from-github`: Requires a GitHub repo URL. Reads a remote repository
+  and converts its contents to HTML, but does not push to Canvas.
+- `--branch`, `-b`: Can be used when creating or aligning with a local repo to
+  specify which branch to use. Use this if you have a new repository that uses a
+  `main` branch instead of `master`.
+- `--save-to-github`, `-s`: If you are are creating or aligning content locally,
+  the `.canvas` file is not automatically committed to the repo. This option will
+  attempt to commit and push the `.canvas` file to the remote repository.
 
 Run `github-to-canvas --help` for additional options not listed in this Readme.
 

data/bin/github-to-canvas

@@ -1,4 +1,7 @@
 #!/usr/bin/env ruby
+
+require 'byebug'
+
 require 'optparse'
 require 'github-to-canvas'
 
@@ -75,12 +78,15 @@ OptionParser.new do |opts|
           end
   opts.on("-tTYPE", "--type TYPE", 
           "Sets the type Canvas lesson to be created (page or assignment). If no type, type decided based on repository structure") do |type| 
-            if type == 'page' || type == 'assignment' || type == 'discussion'
-              options[:type] = type
-            else
-              puts "Invalid type. Defaulting to page"
-              options[:type] = "page"
-            end
+            # byebug
+            options[:type] = type.downcase
+            abort if type == 'quiz' || type == 'discussion'
+            # if type == 'page' || type == 'assignment' || type == 'discussion' || type == 'quiz' || type == 'Page' || type == 'Assignment' || type == 'Discussion' || type == 'Quiz'
+              
+            # else
+            #   puts "Invalid type. Defaulting to page"
+            #   options[:type] = "page"
+            # end
           end
   opts.on("-fFILE", "--file FILE", 
           "Looks for and uses a markdown file in the currentt folder as source for conversion. Default file is README.md. Skips writing .canvas to repository") do |file| 
@@ -102,6 +108,14 @@ OptionParser.new do |opts|
           "Adds additional Flatiron School HTML after markdown conversion") do |f|
             options[:fis] = true
           end
+  opts.on("-g", "--git-links",
+          "Adds additional GitHub after markdown conversion") do |f|
+            options[:git_links] = true
+          end
+  opts.on("--aaq", 
+          "Adds AAQ flag to HTML header appended with --fis-links") do |aaq|
+            options[:aaq] = aaq
+          end
   opts.on("--forkable",
           "Used with --fis-links, adds fork button to HTML header injected into Canvas lesson") do |remote|
             options[:forkable] = true
@@ -130,6 +144,14 @@ OptionParser.new do |opts|
           "REQUIRES -f or --file Associates canvas lessons with repositories. Use query to create required YAML file") do |file|
             options[:map] = file
           end
+  opts.on("--urls-only", 
+          "Use with --map. Outputs repo URLs instead of YAML") do |urls|
+            options[:urls_only] = urls
+          end
+#  opts.on("--csv COURSE", 
+#          "Returns a course's lesson struction as CSV") do |course|
+#            options[:csv] = course
+#          end
   opts.on("--read-from-canvas CANVAS_URL",
           "Retrieves an existing Canvas lesson using the provided URL") do |url|
             options[:read_from_canvas] = url
@@ -162,6 +184,23 @@ OptionParser.new do |opts|
           "Updates all lessons in a course using remote repos in provided YAML file") do |file|
             options[:update_course_lessons] = file
           end
+  opts.on("--clone-from-yaml YAML_FILE", 
+          "Iterates over provided course YAML file and clones repos locally") do |file|
+            options[:clone_from_yaml] = file
+          end
+  opts.on("--contains-html", 
+          "Escapes all HTML included in source markdown by replacing '<' and '>' with HTML charset values") do |html|
+            options[:contains_html] = html
+          end
+  opts.on("--canvas-to-canvas COURSE",
+          "Copies an existing Canvas lesson into another Canvas lesson") do |canvas_to_canvas|
+            options[:canvas_to_canvas] = canvas_to_canvas
+          end
+  opts.on("--build-from-csv CSV",
+          "Build a course usin a CSV of lesson repos, names, modules, and types") do |csv_build|
+            options[:csv_build] = csv_build
+          end
+  
   
 end.parse!
 
@@ -171,12 +210,29 @@ if options[:version]
 end
 
 if options[:read_from_canvas]
-  GithubToCanvas.new(mode: 'canvas_read', filepath: options[:read_from_canvas])
+  GithubToCanvas.new(mode: 'canvas_read', 
+                    filepath: options[:read_from_canvas])
+  abort
+end
+
+if options[:canvas_to_canvas]
+  GithubToCanvas.new(mode: 'canvas_copy',
+                    filepath: options[:canvas_to_canvas],
+                    course_id: options[:course_id], 
+                    type: options[:type],
+                    id: options[:id]
+                    )
   abort
 end
 
 if options[:read_from_github]
-  GithubToCanvas.new(mode: 'github_read', filepath: options[:read_from_github])
+  GithubToCanvas.new(mode: 'github_read', 
+                    filepath: options[:read_from_github],
+                    remove_header_and_footer: !!options[:remove_header_and_footer],
+                    forkable: !!options[:forkable],
+                    fis_links: !!options[:fis],
+                    aaq: !!options[:aaq],
+                    contains_html: options[:contains_html])
   abort
 end
 
@@ -186,9 +242,12 @@ if options[:create_from_github]
                       filepath: options[:create_from_github], 
                       course_id: options[:course_id], 
                       type: options[:type],
+                      name: options[:name],
                       remove_header_and_footer: !!options[:remove_header_and_footer],
                       forkable: !!options[:forkable],
-                      fis_links: !!options[:fis])
+                      fis_links: !!options[:fis],
+                      aaq: !!options[:aaq],
+                      contains_html: options[:contains_html])
   else
     puts 'Canvas course ID and lesson type required. Example: github-to-canvas --create-from-github URL --course ID --type TYPE'
   end
@@ -202,9 +261,12 @@ if options[:align_from_github]
                       course_id: options[:course_id], 
                       type: options[:type], 
                       id: options[:id],
+                      name: options[:name],
                       remove_header_and_footer: !!options[:remove_header_and_footer],
                       forkable: !!options[:forkable],
-                      fis_links: !!options[:fis])
+                      fis_links: !!options[:fis],
+                      aaq: !!options[:aaq],
+                      contains_html: options[:contains_html])
   else
     puts 'Canvas course ID, lesson ID, and type required. Example: github-to-canvas --create-from-github URL --course COURSE_ID --id LESSON_ID --type TYPE'
   end
@@ -217,7 +279,28 @@ if options[:query]
 end
 
 if options[:map]
-  GithubToCanvas.new(mode: 'map', file_to_convert: options[:map])
+  GithubToCanvas.new(mode: 'map', 
+                      file_to_convert: options[:map],
+                      urls_only: !!options[:urls_only])
+  abort
+end
+
+if options[:csv]
+  GithubToCanvas.new(mode: 'csv', file_to_convert: options[:csv])
+  abort
+end
+
+if options[:csv_build]
+  GithubToCanvas.new(mode: 'csv_build', 
+                    file_to_convert: options[:csv_build],
+                    course_id: options[:course_id],
+                    fis_links: !!options[:fis], 
+                    remove_header_and_footer: !!options[:remove_header_and_footer],
+                    aaq: !!options[:aaq],
+                    forkable: !!options[:forkable],
+                    branch: options[:branch],
+                    contains_html: options[:contains_html],
+                    git_links: !!options[:git_links])
   abort
 end
 
@@ -226,7 +309,10 @@ if options[:build_course]
                     file_to_convert: options[:build_course],
                     fis_links: !!options[:fis], 
                     remove_header_and_footer: !!options[:remove_header_and_footer],
-                    forkable: !!options[:forkable])
+                    aaq: !!options[:aaq],
+                    forkable: !!options[:forkable],
+                    contains_html: options[:contains_html],
+                    git_links: !!options[:git_links])
   abort
 end
 
@@ -237,7 +323,10 @@ if options[:add_to_course]
                       file_to_convert: options[:add_to_course],
                       fis_links: !!options[:fis], 
                       remove_header_and_footer: !!options[:remove_header_and_footer],
-                      forkable: !!options[:forkable])
+                      forkable: !!options[:forkable],
+                      aaq: !!options[:aaq],
+                      contains_html: options[:contains_html],
+                      git_links: !!options[:git_links])
   else
     puts '--course required'
   end
@@ -249,10 +338,18 @@ if options[:update_course_lessons]
                     file_to_convert: options[:update_course_lessons],
                     fis_links: !!options[:fis], 
                     remove_header_and_footer: !!options[:remove_header_and_footer],
-                    forkable: !!options[:forkable])
+                    forkable: !!options[:forkable],
+                    aaq: !!options[:aaq],
+                    contains_html: options[:contains_html],
+                    git_links: !!options[:git_links])
   abort
 end
 
+if options[:clone_from_yaml]
+  GithubToCanvas.new(mode: 'clone_course', 
+                    file_to_convert: options[:clone_from_yaml])
+  abort
+end
 
 if !options[:type]
   if Dir.glob("**/*/").empty?
@@ -304,9 +401,12 @@ if options[:create_lesson]
                     type: options[:type], 
                     save_to_github: !!options[:save_to_github], 
                     fis_links: !!options[:fis], 
+                    git_links: !!options[:git_links],
                     remove_header_and_footer: !!options[:remove_header_and_footer],
                     only_update_content: !!options[:only_content],
-                    forkable: !!options[:forkable])
+                    forkable: !!options[:forkable],
+                    aaq: !!options[:aaq],
+                    contains_html: options[:contains_html])
 end
 
 if options[:align]
@@ -319,8 +419,11 @@ if options[:align]
                     name: options[:name],
                     type: options[:type],
                     save_to_github: !!options[:save_to_github], 
-                    fis_links: !!options[:fis], 
+                    fis_links: !!options[:fis],
+                    git_links: !!options[:git_links], 
                     remove_header_and_footer: !!options[:remove_header_and_footer],
                     only_update_content: !!options[:only_content],
-                    forkable: !!options[:forkable])
+                    forkable: !!options[:forkable],
+                    aaq: !!options[:aaq],
+                    contains_html: options[:contains_html])
 end

data/lib/github-to-canvas.rb

@@ -1,3 +1,5 @@
+require 'byebug'
+require 'csv'
 require_relative './github-to-canvas/create_canvas_lesson'
 require_relative './github-to-canvas/update_canvas_lesson'
 require_relative './github-to-canvas/canvas_dotfile'
@@ -20,12 +22,16 @@ class GithubToCanvas
     when 'query'
       CanvasInterface.get_course_info(options[:course_id], options[:id])
     when 'map'
-      CanvasInterface.map_course_info(options[:file_to_convert])
+      CanvasInterface.map_course_info(options)
+    when 'csv'
+      CanvasInterface.csv(options[:file_to_convert])
     when 'canvas_read'
       puts CanvasInterface.read_lesson(options[:filepath])
+    when 'canvas_copy'
+      CanvasInterface.copy_lesson(options)
     when 'github_read'
-      markdown = GithubInterface.read_remote(options[:filepath])
-      puts RepositoryConverter.convert_to_html(markdown)
+      html = RepositoryConverter.remote_file_conversion(options)
+      puts RepositoryConverter.adjust_converted_html(options, html)
     when 'create' # used with a local repo
       html = RepositoryConverter.local_file_conversion(options)
       name = RepositoryInterface.get_name(options[:filepath], html)
@@ -35,21 +41,30 @@ class GithubToCanvas
       puts "Canvas lesson created. Lesson available at #{response['html_url']}"
     when 'align' # used with a local repo
       html = RepositoryConverter.local_file_conversion(options)
-      name = RepositoryInterface.get_name(options[:filepath], html)
+      name = options[:name] ? options[:name] : RepositoryInterface.get_name(options[:filepath], html)
       html = RepositoryConverter.adjust_converted_html(options, html)
       CanvasInterface.update_all_related_lessons(options, name, html)
       
     when 'github_create'
+      if (!options[:branch])
+        options[:branch] = 'master'
+      end
       html = RepositoryConverter.remote_file_conversion(options)
-      name = RepositoryInterface.get_name(options[:filepath], html)
-      html = RepositoryConverter.adjust_converted_html(options, html)
       
+      html = RepositoryConverter.adjust_converted_html(options, html)
+      name = options[:name] ? options[:name] : RepositoryInterface.get_name(options[:filepath], html)
+      byebug
+      puts name
       response = CanvasInterface.create_lesson(options, name, html)
       
       puts "Canvas lesson created. Lesson available at #{response['html_url']}"
     when 'github_align'
+      if (!options[:branch])
+        options[:branch] = 'master'
+      end
       html = RepositoryConverter.remote_file_conversion(options)
-      name = RepositoryInterface.get_name(options[:filepath], html)
+      name = options[:name] ? options[:name] : RepositoryInterface.get_name(options[:filepath], html)
+      
       html = RepositoryConverter.adjust_converted_html(options, html)
       response = CanvasInterface.update_existing_lesson(options, name, html)
       puts "Canvas lesson updated. Lesson available at #{response['html_url']}"
@@ -69,10 +84,8 @@ class GithubToCanvas
           options[:course_id] = created_course_info["id"]
           options[:filepath] = lesson["repository"]
           
-          
           html = RepositoryConverter.remote_file_conversion(options)
           # Add each lesson to it's module
-          
           html = RepositoryConverter.adjust_converted_html(options, html)
           created_lesson_info = CanvasInterface.create_lesson(options, lesson["title"], html)
           lesson = lesson.merge(created_lesson_info)
@@ -133,6 +146,78 @@ class GithubToCanvas
           sleep(1)
         }
       }
+    when 'clone_course'
+      course_yaml = YAML.load(File.read(options[:file_to_convert]))
+      new_dir = "#{course_yaml[:name].downcase.gsub(' ','-')}"
+      cmd = "mkdir #{new_dir}"
+      `#{cmd}`
+      course_yaml[:modules].each { |module_info|
+      puts "Cloning #{module_info[:name]}"
+        module_info[:lessons].each { |lesson|
+        if lesson["repository"] == ""
+          puts "No repository found for #{lesson['title']}"
+          next
+        else
+          cmd = "git clone #{lesson['repository']}"
+          puts cmd
+          GithubInterface.cd_into_and(new_dir, cmd)
+        end
+        }
+      }
+    when 'csv_build'
+      if !options[:course_id]
+        course_info = {
+          name: "CSV Build Test",
+          course_code: "CSV-TEST"
+        }
+        created_course_info = CanvasInterface.create_course(course_info)
+        puts "Course created - #{created_course_info["id"]}"
+        puts "Make sure to add yourself as a teacher to this course before continuing, then press Enter/Return"
+        input = gets
+        options[:course_id] = created_course_info["id"]
+      else
+        puts "Adding to course #{options[:course_id]}"
+      end
+      
+      csv_data = CSV.read(options[:file_to_convert])
+      created_module_info = {
+        "id" => "",
+        "name" => ""
+      }
+      
+      csv_data.each { |lesson|
+        # lesson[0] == repo
+        # lesson[1] == name
+        # lesson[2] == module
+        # lesson[3] == type
+        # lesson[4] == yes/no contains HTML
+        module_info = {
+          name: lesson[2]
+        }
+        if created_module_info["name"] != module_info[:name]
+          created_module_info = CanvasInterface.create_module(options[:course_id], module_info)
+          puts "New module created - #{created_module_info["id"]} - #{created_module_info["name"]}"
+        end
+
+        options[:filepath] = lesson[0]
+        options[:name] = lesson[1]
+        options[:type] = lesson[3]
+        options[:branch] = "master" if !options[:branch]
+        if !options[:contains_html]
+          options[:contains_html] = (lesson[4] == "yes" || lesson[4] == "Yes") ? true : false
+        end
+        
+
+        html = RepositoryConverter.remote_file_conversion(options)
+        html = RepositoryConverter.adjust_converted_html(options, html)
+        created_lesson_info = CanvasInterface.create_lesson(options, lesson[1], html)
+        created_lesson_info["page_url"] = created_lesson_info["url"] if !created_lesson_info["page_url"]
+        created_lesson_info["id"] = created_lesson_info["page_url"] if !created_lesson_info["id"]
+        created_lesson_info["type"] = options[:type]
+        puts "Creating lesson - #{options[:name]}"
+        response = CanvasInterface.add_to_module(options[:course_id], created_module_info, created_lesson_info)
+        
+      }
     else
       puts VERSION
     end

data/lib/github-to-canvas/canvas_interface.rb

@@ -1,3 +1,4 @@
+require 'byebug'
 require 'json'
 require 'rest-client'
 require 'yaml'
@@ -46,41 +47,39 @@ class CanvasInterface
     JSON.parse(response.body)
   end
 
-  def self.create_quiz(options, quiz_data)
-    
-  end
-
   def self.add_to_module(course_id, module_info, lesson_info)
     # POST /api/v1/courses/:course_id/modules/:module_id/items
     url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/modules/#{module_info["id"]}/items"
     
-    if lesson_info["type"] == "Page"
+    if lesson_info["type"] == "Page" || lesson_info["type"] == "page"
       payload = {
-      'module_item[title]' => lesson_info["title"],
-      'module_item[type]' => lesson_info["type"],
-      'module_item[indent]' => 0,
-      'module_item[completion_requirement][type]' => 'must_view'
-    }
+        'module_item[title]' => lesson_info["title"],
+        'module_item[type]' => lesson_info["type"].capitalize,
+        'module_item[indent]' => 0,
+        'module_item[page_url]' => lesson_info["id"],
+        'module_item[completion_requirement][type]' => 'must_view'
+      }
     elsif lesson_info["type"] == "Quiz"
       puts "Quiz needs to be added manually - #{lesson_info['title']} - lesson_info["
     else
       
       payload = {
         'module_item[title]' => lesson_info["title"],
-        'module_item[type]' => lesson_info["type"],
+        'module_item[type]' => lesson_info["type"].capitalize,
         'module_item[indent]' => 1,
+        'module_item[content_id]' =>  lesson_info["id"],
         'module_item[completion_requirement][type]' => 'must_submit'
       }
     end
     begin
       response = RestClient.post(url, payload, self.headers)
     rescue
-      puts "Something went wrong while add lesson #{lesson_info["id"]} to module #{module_info["id"]} in course #{course_id}" if lesson_info["type"] == "Assignment"
-      puts "Something went wrong while add lesson #{lesson_info["page_url"]} to module #{module_info["id"]} in course #{course_id}" if lesson_info["type"] == "Page"
+      byebug
+
+      puts "Something went wrong while adding lesson #{lesson_info["id"]} to module #{module_info["id"]} in course #{course_id}" if lesson_info["type"] == "Assignment"
+      puts "Something went wrong while adding lesson #{lesson_info["page_url"]} to module #{module_info["id"]} in course #{course_id}" if lesson_info["type"] == "Page"
       abort
     end
-
-    
     response
     
   end
@@ -95,7 +94,7 @@ class CanvasInterface
     
     begin
       headers = self.headers
-      if options[:type] == 'page'
+      if options[:type] == 'page' || options[:type] == 'Page'
         response = RestClient.get(url, headers)
         lesson_info = JSON.parse(response)
         url = url.sub(/[^\/]+$/, lesson_info["page_id"].to_s)
@@ -170,6 +169,7 @@ class CanvasInterface
     [info, type]
   end
 
+
   def self.get_course_info(course, id)
     if id
       lesson_data = self.get_lesson_info(course, id)
@@ -195,6 +195,7 @@ class CanvasInterface
         while !!index
           url = "#{ENV['CANVAS_API_PATH']}/courses/#{course}/modules?page=#{index}&per_page=20"
           index += 1
+          
           response = RestClient.get(url, self.headers)
           modules = JSON.parse(response.body)
           
@@ -202,7 +203,7 @@ class CanvasInterface
             course_info[:modules] = course_info[:modules] + modules
           else
             index = nil
-          end 
+          end
         end
         
         course_info[:modules] = course_info[:modules].map do |mod|
@@ -215,11 +216,12 @@ class CanvasInterface
           while !!index
             url = "#{ENV['CANVAS_API_PATH']}/courses/#{course}/modules/#{mod['id']}/items?page=#{index}&per_page=20"
             index += 1
-            response = RestClient.get(url, headers={
-              "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
-            })
+            response = RestClient.get(url, self.headers)
             lessons = JSON.parse(response.body)
             lessons = lessons.map do |lesson|
+              if lesson["type"] == "ExternalUrl"
+                next
+              end
               lesson = lesson.slice("id","title","name","indent","type","html_url","page_url","url","completion_requirement", "published")
               lesson["repository"] = ""
               lesson['id'] = lesson['url'].gsub(/^(.*[\\\/])/,'')
@@ -234,16 +236,65 @@ class CanvasInterface
           end
           new_mod
         end
-
+        
         puts course_info.to_yaml
       
     rescue
+      byebug
       puts "Something went wrong while getting info about course #{course}"
       abort
     end
   end
 
-  def self.map_course_info(file_to_convert)
+  def self.map_course_info(options)
+    course_info = YAML.load(File.read("#{Dir.pwd}/#{options[:file_to_convert]}"))
+    course_info[:modules] = course_info[:modules].map do |mod|
+      mod[:lessons] = mod[:lessons].map do |lesson|
+
+        url = lesson["url"]
+        response = RestClient.get(url, headers={
+          "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
+        })
+        begin
+          lesson_data = JSON.parse(response)
+          contents = lesson_data["body"] if lesson["type"] == "Page"
+          contents = lesson_data["message"] if lesson["type"] == "Discussion"
+          contents = lesson_data["description"] if lesson["type"] == "Assignment" || lesson["type"] == "Quiz"
+          if contents.nil?
+            repo = ""
+          else
+            if contents[/data-repo=\"(.*?)"/]
+              repo = contents[/data-repo=\"(.*?)"/]
+              repo = repo.slice(11..-2)
+            elsif contents[/class=\"fis-git-link\" href=\"(.*?)"/]
+              repo = contents[/class=\"fis-git-link\" href=\"(.*?)"/]
+              repo = repo.slice(27..-2)
+            else
+              repo = ""
+            end
+          end
+        rescue
+          puts 'Error while mapping course info.'
+          abort
+        end
+        
+        if repo != nil && repo != ""
+          if repo.include?('https://github.com/learn-co-curriculum/')
+            lesson["repository"] = repo
+          else
+            lesson["repository"] = "https://github.com/learn-co-curriculum/" + repo
+            puts lesson["repository"] if options[:urls_only]
+          end
+        end
+        sleep(1)
+        lesson
+      end
+      mod
+    end
+    puts course_info.to_yaml if !options[:urls_only]
+  end
+
+  def self.csv(file_to_convert)
     course_info = YAML.load(File.read("#{Dir.pwd}/#{file_to_convert}"))
     course_info[:modules] = course_info[:modules].map do |mod|
       mod[:lessons] = mod[:lessons].map do |lesson|
@@ -287,15 +338,41 @@ class CanvasInterface
       end
       mod
     end
+    byebug
     puts course_info.to_yaml
   end
 
-  def self.submit_to_canvas(course_id, type, name, readme)
-    
-  end
+  def self.copy_lesson(options)
+    types = ["page", "assignment", "quiz", "discussion"]
+    url = options[:filepath]
+    type = types.find {|type| url.match(type)}
+    options[:type] = type
+    if !url.include?(ENV['CANVAS_API_PATH'])
+      url = url.sub(/^.*\/\/.*?\//,"#{ENV['CANVAS_API_PATH']}/")
+    end
 
-  
+    response = RestClient.get(url, headers={
+      "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
+    })
 
+    lesson_info = JSON.parse(response)
+    lesson_info = lesson_info.slice("title",
+                                    "name",
+                                    "description",
+                                    "body",
+                                    "message",
+                                    "shuffle_answers",
+                                    "allowed_attempts",
+                                    "question_count"
+                                    )
+    if options[:type] == "page"
+      self.update_existing_lesson(options, lesson_info["title"], lesson_info["body"])
+    else
+      self.update_existing_lesson(options, lesson_info["name"], lesson_info["description"])
+    end
+    
+    
+  end
 
   def self.build_payload(options, name, html)
     if options[:only_update_content]

data/lib/github-to-canvas/github_interface.rb

@@ -61,11 +61,11 @@ class GithubInterface
     rescue
       begin
         response = RestClient.get(url_fallback)
+        return response.body
       rescue
         puts 'Error reading ' + url
       end
     end
-    
     response.body
   end
 

data/lib/github-to-canvas/repository_converter.rb

@@ -17,7 +17,7 @@ class RepositoryConverter
     GithubInterface.get_updated_repo(options[:filepath], options[:branch])
     markdown = RepositoryInterface.read_local_file(options[:filepath], options[:file_to_convert])
     raw_remote_url = self.set_raw_image_remote_url(options[:filepath])
-    
+    markdown = self.escape_existing_html(markdown) if options[:contains_html]
     markdown = self.fix_local_images(options, markdown, raw_remote_url)
     html = self.convert_to_html(markdown)
     # self.fix_local_html_links(options, html, options[:filepath])
@@ -26,15 +26,27 @@ class RepositoryConverter
   def self.remote_file_conversion(options)
     markdown = GithubInterface.read_remote(options[:filepath])
     raw_remote_url = self.set_raw_image_remote_url(options[:filepath])
+    if options[:contains_html]
+      begin
+        markdown = self.escape_existing_html(markdown)
+      rescue
+        puts "Error reading remote markdown"
+        abort
+      end
+    end
+    if (!options[:branch])
+      options[:branch] = 'master'
+    end
     markdown = self.fix_local_images(options, markdown, raw_remote_url)
     html = self.convert_to_html(markdown)
     # self.fix_local_html_links(options, html, options[:filepath])
   end
 
   def self.convert_to_html(markdown)
-    redcarpet = Redcarpet::Markdown.new(CustomRender, options={tables: true, autolink: true, fenced_code_blocks: true})
+    renderer = CustomRender.new(escape_html: true, prettify: true, hard_wrap: true)
+    redcarpet = Redcarpet::Markdown.new(CustomRender, options={tables: true, autolink: true, fenced_code_blocks: true, disable_indented_code_blocks: true})
     html = redcarpet.render(markdown)
-    self.remove_line_breaks(html)
+    # self.remove_line_breaks(html)
   end
 
   def self.adjust_converted_html(options, html)
@@ -43,12 +55,52 @@ class RepositoryConverter
       html = self.remove_header_and_footer(html)
     end
     
-    if options[:fis_links]
+    if options[:fis_links] || options[:git_links]
       html = self.add_fis_links(options, html)
     end
+
+    if options[:contains_html]
+      html = self.fix_escaped_inline_html_code(html)
+    end
+
     html
   end
 
+  def self.fix_escaped_inline_html_code(html)
+    
+    # stops HTML/JSX code blocks from rendering as HTML in Canvas
+    html = html.gsub("&amp;gt;</code>", "&gt;</code>")
+    html = html.gsub("&amp;gt;</code>", "&gt;</code>")
+
+    # fixes < and > code snippets
+    html = html.gsub("&amp;lt;", "&lt;")
+    html = html.gsub("&amp;gt;", "&gt;")
+
+    # # fixes blockquotes
+    # html = html.gsub(/\n<p>&gt\;(.*)\n&gt\;/) { |bq|
+    #   bq.delete_prefix!("\n<p>&gt;")
+    #   "\n<blockquote>" + bq
+    # }
+    # html = html.gsub(/\n&gt\;(.*)\n&gt\;/) { |bq|
+    #   bq.delete_prefix!("\n&gt;")
+    #   " " + bq
+    # }
+    # html = html.gsub(/\n&gt\;(.*)<\/p>/) { |bq|
+    #   bq.delete_prefix!("\n&gt\;")
+    #   bq.delete_suffix!("</p>")
+    #   " " + bq + "</blockquote>"
+    # }
+
+    html
+  end
+
+
+  def self.escape_existing_html(markdown)
+    markdown = markdown.gsub(/<\/(?!iframe)/, "&lt;/")
+    markdown = markdown.gsub(/<(?!iframe)/, "&lt;")
+    markdown = markdown.gsub(/(?<!iframe)>/, "&gt;")
+  end
+
   def self.remove_header_and_footer(html)
     new_html = self.remove_html_header(html)
     new_html = self.remove_footer(new_html)
@@ -56,12 +108,15 @@ class RepositoryConverter
   end
 
   def self.remove_header(readme)
-    readme.gsub!(/^# .+?\n\n/,"")
+    readme = readme.gsub(/^# .+?\n\n/,"")
     readme.gsub(/^# .+?\n/,"")
   end
 
   def self.remove_footer(readme)
     readme.gsub(/<p class='util--hide'(.+?)<\/p>/,"")
+    readme.gsub(/<p data-visibility='hidden'(.+?)<\/p>/,"")
+    readme.gsub(/<p>&lt\;p data-visibility=&#39\;hidden&#39(.+?)<\/p>/,"")
+    readme.gsub(/<p>&lt\;p class=&#39;util--hide&#39\;(.+?)<\/p>/,"")
   end
 
   def self.remove_html_header(html)
@@ -114,7 +169,7 @@ class RepositoryConverter
   end
 
   def self.adjust_local_markdown_images(readme, raw_remote_url, branch)
-    readme.gsub!(/\!\[.+\]\(.+\)/) {|image_markdown|
+    readme.gsub(/\!\[.+\]\(.+\)/) {|image_markdown|
       if !image_markdown.match?('amazonaws.com') && !image_markdown.match?('https://') && !image_markdown.match?('http://') && !image_markdown.match?('youtube')
         image_markdown.gsub!(/\(.+\)/) { |path|
           path.delete_prefix!("(")
@@ -127,12 +182,18 @@ class RepositoryConverter
   end
 
   def self.adjust_local_html_images(readme, raw_remote_url, branch)
-    readme.gsub!(/src=(\'|\")[\s\S]*?(\'|\")/) { |image_source|
-      if !image_source.match?('amazonaws.com') && !image_source.match?('https://') && !image_source.match?('http://') && !image_source.match?('youtube')
-        image_source.gsub!(/(\'|\")/, "")
-        image_source.gsub!(/src=/, '')
-        image_source.strip!
-        'src="' + raw_remote_url + '/' + branch + '/' + image_source + '"'
+    readme.gsub(/src=(\'|\")[\s\S]*?(\'|\")/) { |image_source|
+      
+      if !image_source.match?('amazonaws.com') && !image_source.match?('https://') && !image_source.match?('http://') && !image_source.match?('youtube') && !image_source.match(/src=(\'|\")(?=<%)/)
+        image_source = image_source.gsub(/(\'|\")/, "")
+        image_source = image_source.gsub(/src=/, '')
+        image_source = image_source.strip
+
+        begin
+          'src="' + raw_remote_url + '/' + branch + '/' + image_source + '"'
+        rescue
+          byebug
+        end
       else
         image_source
       end
@@ -162,12 +223,12 @@ class RepositoryConverter
   def self.add_fis_links(options, html)
     repo_info = self.get_repo_info(options[:filepath])
     html = html.sub(/<div id="git-data-element.*<header class="fis-header.*<\/header>/,'') # remove existing fis header
-    header = self.create_github_link_header(repo_info[:repo_path], options[:forkable])
-    data_element = self.create_data_element(repo_info[:repo_org], repo_info[:repo_name])
+    header = self.create_github_link_header(repo_info[:repo_path], options)
+    data_element = self.create_data_element(repo_info[:repo_org], repo_info[:repo_name], options[:aaq])
     data_element + header + html
   end
 
-  def self.create_github_link_header(repo_path, forkable)
+  def self.create_github_link_header(repo_path, options)
     # add link to associated repository
     github_repo_link = "<a class='fis-git-link' href='#{repo_path}' target='_blank' rel='noopener'><img id='repo-img' title='Open GitHub Repo' alt='GitHub Repo' /></a>"
     
@@ -175,16 +236,23 @@ class RepositoryConverter
     github_issue_link = "<a class='fis-git-link' href='#{repo_path}/issues/new' target='_blank' rel='noopener'><img id='issue-img' title='Create New Issue' alt='Create New Issue' /></a>"
     
     # add link to fork (forking handled by separate Flatiron server, generation of link handled via custom Canvas JS theme file)
-    if (forkable)
-      github_fork_link = "<a class='fis-fork-link' id='fork-link' href='#' target='_blank' rel='noopener'><img id='fork-img' title='Fork This Assignment' alt='Fork This Assignment' /></a>"
+
+    if (options[:forkable])
+      github_fork_link = "<a class='fis-fork-link' id='fork-link' href='#{repo_path}/fork' target='_blank' rel='noopener'><img id='fork-img' title='Fork This Assignment' alt='Fork This Assignment' /></a>"
       "<header class='fis-header' style='visibility: hidden;'>#{github_fork_link}#{github_repo_link}#{github_issue_link}</header>"
+    elsif options[:git_links]
+      "<header class='fis-header'>#{github_repo_link}#{github_issue_link}</header>"
     else
       "<header class='fis-header' style='visibility: hidden;'>#{github_repo_link}#{github_issue_link}</header>"
     end
   end
 
-  def self.create_data_element(repo_org, repo_name)
-    "<div id='git-data-element' data-org='#{repo_org}' data-repo='#{repo_name}'></div>"
+  def self.create_data_element(repo_org, repo_name, aaq)
+    if (aaq)
+      "<div id='git-data-element' data-aaq='enabled' data-org='#{repo_org}' data-repo='#{repo_name}'></div>"
+    else
+      "<div id='git-data-element' data-org='#{repo_org}' data-repo='#{repo_name}'></div>"
+    end
   end
 
   

data/lib/github-to-canvas/version.rb

@@ -1,3 +1,3 @@
 class GithubToCanvas
-  VERSION = "0.1.1"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: github-to-canvas
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.7.pre
 platform: ruby
 authors:
 - maxwellbenton
@@ -104,11 +104,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: github-to-canvas is a tool for migrating and aligning GitHub content with