github-to-canvas 0.0.58 → 0.1.4

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

@@ -0,0 +1,9 @@
+class CourseCreationInterface
+
+  def initialize(file)
+    data = YAML.load(File.read("#{Dir.pwd}/#{file}"))
+    CanvasInterface.create_new_course(data["name"])
+  end
+
+  
+end

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

@@ -1,38 +1,14 @@
 class CreateCanvasLesson
 
-  def initialize(course, filepath, file_to_convert, branch, name, type, save_to_github, fis_links, remove_header_and_footer, forkable)
-    # name = name.split(/[- _]/).map(&:capitalize).join(' ')
-    begin
-      markdown = File.read("#{filepath}/#{file_to_convert}")
-    rescue
-      puts "#{file_to_convert} not found in current directory. Exiting..."
-      abort
-    end
-    create_canvas_lesson(markdown, course, filepath, branch, name, type, save_to_github, fis_links, remove_header_and_footer, forkable)
-  end
-
-  def create_canvas_lesson(markdown, course, filepath, branch, name, type, save_to_github, fis_links, remove_header_and_footer, forkable)
-    GithubInterface.get_updated_repo(filepath, branch)
-    new_html = RepositoryConverter.convert(filepath, markdown, branch, remove_header_and_footer)
-    if fis_links
-      new_html = RepositoryConverter.add_fis_links(filepath, new_html, forkable)
-    end
-    response = CanvasInterface.submit_to_canvas(course, type, name, new_html)
+  # def initialize(course, filepath, file_to_convert, branch, name, type, save_to_github, fis_links, remove_header_and_footer, forkable)
+  #   # name = name.split(/[- _]/).map(&:capitalize).join(' ')
     
-    puts 'Creating .canvas file'
-    CanvasDotfile.update_or_create(filepath, response, course, type) 
-
-    puts "Canvas lesson created. Lesson available at #{response['html_url']}."
+  #   create_canvas_lesson(markdown, course, filepath, branch, name, type, save_to_github, fis_links, remove_header_and_footer, forkable)
+  # end
 
-    # If --save option is used, the .canvas file gets committed and pushed to the remote repo
-    if save_to_github
-      puts 'Adding .canvas file'
-      GithubInterface.git_add(filepath, '.canvas')
-      puts 'Commiting .canvas file'
-      GithubInterface.git_commit(filepath, 'AUTO: add .canvas file after migration')
-      puts 'Pushing .canvas file'
-      GithubInterface.git_push(filepath, branch)
-    end
-  end
+  # def create_canvas_lesson(markdown, course, filepath, branch, name, type, save_to_github, fis_links, remove_header_and_footer, forkable)
+  #   response = CanvasInterface.submit_to_canvas(course, type, name, new_html)
+    
+  # end
 
 end

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

@@ -1,3 +1,5 @@
+require 'json'
+require 'rest-client'
 class GithubInterface
 
   def self.cd_into_and(filepath, command)
@@ -44,4 +46,37 @@ class GithubInterface
   def self.git_push(filepath, branch)
     self.cd_into_and(filepath, "git push origin #{branch}")
   end
+
+  def self.read_remote(url)
+    if url.match(/https:\/\/github.com\//)
+      url = url.sub(/https:\/\/github.com\//, 'https://raw.githubusercontent.com/')
+      url = url.sub(/blob\//, '')
+    end
+    if !url.end_with?('.md')
+      url_fallback = url + '/main/README.md'
+      url = url + '/master/README.md'
+    end
+    begin
+      response = RestClient.get(url)
+    rescue
+      begin
+        response = RestClient.get(url_fallback)
+        return response.body
+      rescue
+        puts 'Error reading ' + url
+      end
+    end
+    
+    
+  end
+
+  def self.save_to_github(filepath, branch)
+    puts 'Adding .canvas file'
+    self.git_add(filepath, '.canvas')
+    puts 'Commiting .canvas file'
+    self.git_commit(filepath, 'AUTO: add .canvas file after migration')
+    puts 'Pushing .canvas file'
+    self.git_push(filepath, branch)
+  end
+  
 end

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

@@ -1,36 +1,131 @@
 require 'redcarpet'
+
+class CustomRender < Redcarpet::Render::HTML
+  def block_code(code, lang)
+    "<pre>" \
+      "<code>#{multi_line(code)}</code>" \
+    "</pre>"
+  end
+
+  def multi_line(code)
+    code.gsub(/\n(?=[^.])/, "<br />")
+  end
+end
+
 class RepositoryConverter
+  def self.local_file_conversion(options)
+    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])
+  end
 
-  def self.convert(filepath, readme, branch, remove_header_and_footer)
-    if remove_header_and_footer
-      readme = self.remove_header(readme)
-      readme = self.remove_footer(readme)
+  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]
+      puts "Contains HTML"
+      puts options[:contains_html]
+      markdown = self.escape_existing_html(markdown)
     end
-    self.fix_local_images(filepath, readme, branch)
-    self.convert_to_html(filepath, readme)
+    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})
+    html = redcarpet.render(markdown)
+    self.remove_line_breaks(html)
+  end
+
+  def self.adjust_converted_html(options, html)
+    
+    if options[:remove_header_and_footer]
+      html = self.remove_header_and_footer(html)
+    end
+    
+    if options[:fis_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)
+    html = html.gsub("<code>&amp;lt;", "<code>&lt;")
+    html = html.gsub("&amp;gt;</code>", "&gt;</code>")
+  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)
+    new_html
   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 (.+?)<\/p>/,"")
+    readme.gsub(/<p class='util--hide'(.+?)<\/p>/,"")
   end
 
-  def self.fix_local_images(filepath, readme, branch)
-    raw_remote_url = self.set_raw_image_remote_url(filepath)
-    self.adjust_local_markdown_images(readme, raw_remote_url, branch)
-    self.adjust_local_html_images(readme, raw_remote_url)
+  def self.remove_html_header(html)
+    html.gsub(/<h1>.*<\/h1>/,"")
   end
 
-  def self.set_raw_image_remote_url(filepath)
+  def self.fix_local_html_links(options, html, filepath)
+    # fixes relative hyperlinks by appending the github path to the file
+    filepath_base = filepath.match(/https:\/\/github.com\/.*?\/.*?\//).to_s
+    filepath_base = self.get_github_base_url(filepath)
+    html.gsub!(/a href="(?!(http|#)).*?"/) {|local_link|
+      local_link[8..-2]
+    }
+  end
+
+  def self.fix_local_images(options, markdown, raw_remote_url)
+    # fixes markdown images with relative links by appending the raw githubusercontent path to the file
+    self.adjust_local_markdown_images(markdown, raw_remote_url, options[:branch])
+    self.adjust_local_html_images(markdown, raw_remote_url, options[:branch])
+    markdown
+  end
+
+  def self.get_github_base_url(filepath)
     remote = GithubInterface.git_remote(filepath)
-    remote.gsub!("git@github.com:","https://raw.githubusercontent.com/")
-    remote.gsub!("https://github.com/","https://raw.githubusercontent.com/")
+    remote.gsub!("git@github.com:","https://github.com/")
     remote.gsub!(/.git$/,"")
-    remote.strip!
+    remote.strip! 
+  end
+
+
+  def self.set_raw_image_remote_url(filepath)
+    if filepath.include? 'https://github.com/'
+      remote = filepath
+    else
+      remote = GithubInterface.git_remote(filepath)
+    end
+    raw_remote = remote.gsub("git@github.com:","https://raw.githubusercontent.com/")
+    raw_remote = raw_remote.gsub("https://github.com/","https://raw.githubusercontent.com/")
+    raw_remote = raw_remote.gsub(/\/blob\/master\/.*$/,"")
+    raw_remote = raw_remote.gsub(/\/blob\/main\/.*$/,"")
+    raw_remote = raw_remote.gsub(/.git$/,"")
+    raw_remote.strip
   end
 
   def self.get_repo_url(filepath)
@@ -53,33 +148,45 @@ class RepositoryConverter
     }
   end
 
-  def self.adjust_local_html_images(readme, raw_remote_url)
+  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 + '/master/' + image_source + '"'
+        'src="' + raw_remote_url + '/' + branch + '/' + image_source + '"'
       else
         image_source
       end
     }
   end
 
-  def self.convert_to_html(filepath, readme)
-    redcarpet = Redcarpet::Markdown.new(Redcarpet::Render::HTML, options={tables: true, autolink: true, fenced_code_blocks: true})
-    # File.write("#{filepath}/README.html", redcarpet.render(readme))
-    redcarpet.render(readme)
+  def self.remove_line_breaks(html)
+    html.gsub("\n",' ')
   end
 
-  def self.add_fis_links(filepath, readme, forkable)
-    repo_path = self.get_repo_url(filepath)
-    repo_name = repo_path.split('/')[-1]
-    repo_org = repo_path.split('/')[-2]
+  
 
-    header = self.create_github_link_header(repo_path, forkable)
-    data_element = self.create_data_element(repo_org, repo_name)
-    data_element + header + readme
+  def self.get_repo_info(filepath)
+    if !filepath.match?('https://github.com')
+      repo_path = self.get_repo_url(filepath)
+    else
+      repo_path = filepath
+    end
+
+    {
+      repo_path: repo_path,
+      repo_name: repo_path.split('/')[4],
+      repo_org: repo_path.split('/')[3]
+    }
+  end
+  
+  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], options[:aaq])
+    data_element + header + html
   end
 
   def self.create_github_link_header(repo_path, forkable)
@@ -92,14 +199,19 @@ class RepositoryConverter
     # 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>"
-      "<header class='fis-header' style='visibility: hidden;'>#{github_fork_link}#{github_issue_link}</header>"
+      "<header class='fis-header' style='visibility: hidden;'>#{github_fork_link}#{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
 
+  
 end

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

@@ -0,0 +1,33 @@
+class RepositoryInterface
+
+  def self.local_repo_post_submission(options, response)
+    # Updates or creates a local .canvas file
+    CanvasDotfile.update_or_create(options, response) 
+
+    # If --save option is used, the .canvas file gets committed and pushed to the remote repo
+    if options[:save_to_github]
+      self.save_to_github(options[:filepath], options[:branch])
+    end
+  end
+
+  def self.get_name(filepath, html)
+    repo_info = RepositoryConverter.get_repo_info(filepath)
+    name = html[/<h1>.*<\/h1>/]
+    if name
+      name = name.sub('<h1>','').sub('</h1>','') 
+    else
+      name = repo_info[:repo_name].split(/[- _]/).map(&:capitalize).join(' ')
+    end
+    name
+  end
+
+  def self.read_local_file(filepath, file_to_convert)
+    begin
+      markdown = File.read("#{filepath}/#{file_to_convert}")
+    rescue
+      puts "#{file_to_convert} not found in current directory. Exiting..."
+      abort
+    end
+    markdown
+  end
+end

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

@@ -1,29 +1,10 @@
 class UpdateCanvasLesson
 
   def initialize(course, filepath, file_to_convert, branch, name, type, save_to_github, fis_links, remove_header_and_footer, only_update_content, id, forkable)
-    # name = name.split(/[- _]/).map(&:capitalize).join(' ')
-    begin
-      markdown = File.read("#{filepath}/#{file_to_convert}")
-    rescue
-      puts "#{file_to_convert} not found in current directory. Exiting..."
-      abort
-    end
     update_canvas_lesson(course, markdown, filepath, branch, name, type, save_to_github, fis_links, remove_header_and_footer, only_update_content, id, forkable)
   end
 
   def update_canvas_lesson(course, markdown, filepath, branch, name, type, save_to_github, fis_links, remove_header_and_footer, only_update_content, id, forkable)
-    # Pulls any updates that exist on GitHub
-    GithubInterface.get_updated_repo(filepath, branch)
-    
-    # Converts markdown to HTML
-    # Default is README.md. --file <FILENAME> can be used to override default.
-    new_html = RepositoryConverter.convert(filepath, markdown, branch, remove_header_and_footer)
-    
-    # adds Flatiron School specific header and footer
-    if fis_links
-      new_html = RepositoryConverter.add_fis_links(filepath, new_html, forkable) 
-    end
-
     # Read the local .canvas file if --id <ID> is not used. Otherwise, use provided ID (--course <COURSE> also required)
     if !id
       canvas_data = CanvasDotfile.read_canvas_data
@@ -37,20 +18,7 @@ class UpdateCanvasLesson
 
       # Implements update on Canvas
       response = JSON.parse(CanvasInterface.update_existing_lesson(course, id, info[1], name, new_html, only_update_content))
-      
-      # Updates or creates a local .canvas file
-      CanvasDotfile.update_or_create(filepath, response, course, info[1])
-    end
-    # If --save option is used, the .canvas file gets committed and pushed to the remote repo
-    if save_to_github
-      puts 'Adding .canvas file'
-      GithubInterface.git_add(filepath, '.canvas')
-      puts 'Commiting .canvas file'
-      GithubInterface.git_commit(filepath, 'AUTO: add .canvas file after migration')
-      puts 'Pushing .canvas file'
-      GithubInterface.git_push(filepath, branch)
     end
-    
   end
   
 

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

@@ -1,3 +1,3 @@
 class GithubToCanvas
-  VERSION = "0.0.58"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: github-to-canvas
 version: !ruby/object:Gem::Version
-  version: 0.0.58
+  version: 0.1.4
 platform: ruby
 authors:
 - maxwellbenton
@@ -82,9 +82,11 @@ files:
 - lib/github-to-canvas.rb
 - lib/github-to-canvas/canvas_dotfile.rb
 - lib/github-to-canvas/canvas_interface.rb
+- lib/github-to-canvas/course_creation_interface.rb
 - lib/github-to-canvas/create_canvas_lesson.rb
 - lib/github-to-canvas/github_interface.rb
 - lib/github-to-canvas/repository_converter.rb
+- lib/github-to-canvas/repository_interface.rb
 - lib/github-to-canvas/update_canvas_lesson.rb
 - lib/github-to-canvas/version.rb
 homepage: https://github.com/learn-co-curriculum/github-to-canvas
@@ -106,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.8
 signing_key:
 specification_version: 4
 summary: github-to-canvas is a tool for migrating and aligning GitHub content with