leg 0.0.1

data/lib/snaptoken/diff_line.rb

@@ -0,0 +1,54 @@
+class Snaptoken::DiffLine
+  TYPES = [:added, :removed, :unchanged, :folded]
+
+  attr_reader :type, :source, :line_numbers
+  attr_writer :source, :line_numbers
+
+  def initialize(type, source, line_numbers)
+    unless TYPES.include? type
+      raise ArgumentError, "type must be one of: #{TYPES.inspect}"
+    end
+    @type = type
+    @source = source.chomp
+    @line_numbers = line_numbers
+  end
+
+  def clone
+    Snaptoken::DiffLine.new(@type, @source.dup, @line_numbers.dup)
+  end
+
+  def type=(type)
+    unless TYPES.include? type
+      raise ArgumentError, "type must be one of: #{TYPES.inspect}"
+    end
+    @type = type
+  end
+
+  def blank?
+    @source.strip.empty?
+  end
+
+  def line_number
+    case @type
+    when :removed, :folded
+      @line_numbers[0]
+    when :added, :unchanged
+      @line_numbers[1]
+    end
+  end
+
+  def to_patch(options = {})
+    options[:unchanged_char] ||= " "
+
+    case @type
+    when :added
+      "+#{@source}\n"
+    when :removed
+      "-#{@source}\n"
+    when :unchanged
+      "#{options[:unchanged_char]}#{@source}\n"
+    when :folded
+      raise "can't convert folded line to patch"
+    end
+  end
+end

data/lib/snaptoken/diff_transformers.rb

@@ -0,0 +1,9 @@
+module Snaptoken::DiffTransformers
+end
+
+require 'snaptoken/diff_transformers/base_transformer'
+
+require 'snaptoken/diff_transformers/fold_sections'
+require 'snaptoken/diff_transformers/omit_adjacent_removals'
+require 'snaptoken/diff_transformers/trim_blank_lines'
+

data/lib/snaptoken/diff_transformers/base_transformer.rb

@@ -0,0 +1,9 @@
+class Snaptoken::DiffTransformers::BaseTransformer
+  def initialize(options = {})
+    @options = options
+  end
+
+  def transform(diff)
+    raise NotImplementedError
+  end
+end

data/lib/snaptoken/diff_transformers/fold_sections.rb

@@ -0,0 +1,85 @@
+class Snaptoken::DiffTransformers::FoldSections < Snaptoken::DiffTransformers::BaseTransformer
+  def transform(diff)
+    sections = @options[:section_types].map { [] }
+
+    cur_sections = @options[:section_types].map { nil }
+    diff.lines.each.with_index do |line, idx|
+      @options[:section_types].each.with_index do |section_type, level|
+        if line.source =~ Regexp.new(section_type[:start])
+          if !section_type[:end] && cur_sections[level]
+            cur_sections[level].end_line = idx - 1
+            if @options[:unfold_before_new_section]
+              cur_sections[level].dirty! if [:added, :removed].include? line.type
+            end
+            sections[level] << cur_sections[level]
+          end
+
+          cur_sections[level] = Section.new(level, idx)
+
+          if [:added, :removed].include? line.type
+            cur_sections[level].dirty!
+          end
+        elsif section_type[:end] && line.source =~ Regexp.new(section_type[:end])
+          if [:added, :removed].include? line.type
+            cur_sections[level].dirty!
+          end
+
+          cur_sections[level].end_line = idx
+          sections[level] << cur_sections[level]
+          cur_sections[level] = nil
+        elsif cur_sections[level]
+          if [:added, :removed].include? line.type
+            cur_sections[level].dirty!
+          end
+        end
+      end
+    end
+    cur_sections.each.with_index do |section, level|
+      unless section.nil?
+        section.end_line = diff.lines.length - 1
+        sections[level] << section
+      end
+    end
+
+    new_diff = diff.clone
+    sections.each.with_index do |level_sections, level|
+      level_sections.each do |section|
+        if !section.dirty? && !new_diff.lines[section.to_range].any?(&:nil?)
+          start_line = new_diff.lines[section.start_line]
+          end_line = new_diff.lines[section.end_line]
+
+          summary_lines = [start_line]
+          summary_lines << end_line if @options[:section_types][level][:end]
+          summary = summary_lines.map(&:source).join(" … ")
+
+          line_numbers = [start_line.line_number, end_line.line_number]
+
+          folded_line = Snaptoken::DiffLine.new(:folded, summary, line_numbers)
+
+          section.to_range.each do |idx|
+            new_diff.lines[idx] = nil
+          end
+
+          new_diff.lines[section.start_line] = folded_line
+        end
+      end
+    end
+    new_diff.lines.compact!
+    new_diff
+  end
+
+  class Section
+    attr_accessor :level, :start_line, :end_line, :dirty
+
+    def initialize(level, start_line, end_line = nil, dirty = false)
+      @level, @start_line, @end_line, @dirty = level, start_line, end_line, dirty
+    end
+
+    def to_range
+      start_line..end_line
+    end
+
+    def dirty?; @dirty; end
+    def dirty!; @dirty = true; end
+  end
+end

data/lib/snaptoken/diff_transformers/omit_adjacent_removals.rb

@@ -0,0 +1,28 @@
+class Snaptoken::DiffTransformers::OmitAdjacentRemovals < Snaptoken::DiffTransformers::BaseTransformer
+  def transform(diff)
+    new_diff = diff.clone
+
+    removed_lines = []
+    saw_added_line = false
+    new_diff.lines.each.with_index do |line, idx|
+      case line.type
+      when :unchanged, :folded
+        if saw_added_line
+          removed_lines.each do |removed_idx|
+            new_diff.lines[removed_idx] = nil
+          end
+        end
+
+        removed_lines = []
+        saw_added_line = false
+      when :added
+        saw_added_line = true
+      when :removed
+        removed_lines << idx
+      end
+    end
+
+    new_diff.lines.compact!
+    new_diff
+  end
+end

data/lib/snaptoken/diff_transformers/trim_blank_lines.rb

@@ -0,0 +1,21 @@
+class Snaptoken::DiffTransformers::TrimBlankLines < Snaptoken::DiffTransformers::BaseTransformer
+  def transform(diff)
+    new_diff = diff.clone_empty
+    diff.lines.each.with_index do |line, idx|
+      line = line.clone
+      if line.blank? && [:added, :removed].include?(line.type)
+        prev_line = idx > 0 ? diff.lines[idx - 1] : nil
+        next_line = idx < diff.lines.length - 1 ? diff.lines[idx + 1] : nil
+
+        prev_changed = prev_line && [:added, :removed].include?(prev_line.type)
+        next_changed = next_line && [:added, :removed].include?(next_line.type)
+
+        if !prev_changed || !next_changed
+          line.type = :unchanged
+        end
+      end
+      new_diff.lines << line
+    end
+    new_diff
+  end
+end

data/lib/snaptoken/markdown.rb

@@ -0,0 +1,18 @@
+module Snaptoken::Markdown
+  class HTMLRouge < Redcarpet::Render::HTML
+    include Rouge::Plugins::Redcarpet
+  end
+
+  HTML_RENDERER = HTMLRouge.new(with_toc_data: true)
+  MARKDOWN_RENDERER = Redcarpet::Markdown.new(HTML_RENDERER, fenced_code_blocks: true)
+
+  def self.render(source)
+    html = MARKDOWN_RENDERER.render(source)
+    html = Redcarpet::Render::SmartyPants.render(html)
+    html.gsub!(/<\/code>&lsquo;/) { "</code>&rsquo;" }
+    html.gsub!(/^\s*<h([23456]) id="([^"]+)">(.+)<\/h\d>$/) {
+      "<h#{$1} id=\"#{$2}\"><a href=\"##{$2}\">#{$3}</a></h#{$1}>"
+    }
+    html
+  end
+end

data/lib/snaptoken/page.rb

@@ -0,0 +1,64 @@
+class Snaptoken::Page
+  attr_accessor :filename, :steps, :footer_text
+
+  def initialize(filename = "tutorial")
+    @filename = filename
+    @steps = []
+    @footer_text = nil
+  end
+
+  def <<(step)
+    @steps << step
+    self
+  end
+
+  def empty?
+    @steps.empty?
+  end
+
+  def title
+    first_line = @steps.first ? @steps.first.text.lines.first : (@footer_text ? @footer_text.lines.first : nil)
+    if first_line && first_line.start_with?("# ")
+      first_line[2..-1].strip
+    end
+  end
+
+  def to_html(tutorial, offline)
+    content = ""
+    @steps.each do |step|
+      if !step.text.strip.empty?
+        html = Snaptoken::Markdown.render(step.text)
+        html.gsub!(/<p>{{step (\d+)}}<\/p>/) do
+          step = tutorial.step($1.to_i)
+          step.syntax_highlight!
+          step.to_html(tutorial, offline)
+        end
+        content << html
+      end
+
+      step.syntax_highlight!
+      content << step.to_html(tutorial, offline)
+    end
+    if @footer_text
+      # TODO: DRY this up. Please.
+      html = Snaptoken::Markdown.render(@footer_text)
+      html.gsub!(/<p>{{step (\d+)}}<\/p>/) do
+        step = tutorial.step($1.to_i)
+        step.syntax_highlight!
+        step.to_html(tutorial, offline)
+      end
+      content << html
+    end
+
+    page_number = tutorial.pages.index(self) + 1
+
+    Snaptoken::Template.new(tutorial.page_template, tutorial,
+      offline: offline,
+      page_title: title,
+      content: content,
+      page_number: page_number,
+      prev_page: page_number > 1 ? tutorial.pages[page_number - 2] : nil,
+      next_page: page_number < tutorial.pages.length ? tutorial.pages[page_number] : nil
+    ).render_template
+  end
+end

data/lib/snaptoken/representations.rb

@@ -0,0 +1,8 @@
+module Snaptoken::Representations
+end
+
+require 'snaptoken/representations/base_representation'
+
+require 'snaptoken/representations/git'
+require 'snaptoken/representations/litdiff'
+

data/lib/snaptoken/representations/base_representation.rb

@@ -0,0 +1,38 @@
+class Snaptoken::Representations::BaseRepresentation
+  def initialize(tutorial)
+    @tutorial = tutorial
+  end
+
+  # Should save @tutorial to disk.
+  def save!(options = {})
+    raise NotImplementedError
+  end
+
+  # Should load @tutorial (in place) from disk, and return it.
+  def load!(options = {})
+    raise NotImplementedError
+  end
+
+  # Returns true if this representation has been modified by the user since the
+  # last sync.
+  def modified?
+    synced_at = @tutorial.last_synced_at
+    repr_modified_at = modified_at
+    return false if synced_at.nil? or repr_modified_at.nil?
+
+    repr_modified_at > synced_at
+  end
+
+  # Returns true if this representation currently exists on disk.
+  def exists?
+    !modified_at.nil?
+  end
+
+  private
+
+  # Should return the Time the representation on disk was last modified, or nil
+  # if the representation doesn't exist.
+  def modified_at
+    raise NotImplementedError
+  end
+end

data/lib/snaptoken/representations/git.rb

@@ -0,0 +1,262 @@
+class Snaptoken::Representations::Git < Snaptoken::Representations::BaseRepresentation
+  def save!(options = {})
+    FileUtils.rm_rf(repo_path)
+    FileUtils.mkdir_p(repo_path)
+
+    FileUtils.cd(repo_path) do
+      repo = Rugged::Repository.init_at(".")
+
+      step_num = 1
+      @tutorial.pages.each do |page|
+        message = "~~~ #{page.filename}"
+        message << "\n\n#{page.footer_text}" if page.footer_text
+        add_commit(repo, nil, message, step_num)
+        page.steps.each do |step|
+          message = "#{step.summary}\n\n#{step.text}".strip
+          add_commit(repo, step.to_patch, message, step_num)
+
+          yield step_num if block_given?
+          step_num += 1
+        end
+      end
+
+      #if options[:extra_path]
+      #  FileUtils.cp_r(File.join(options[:extra_path], "."), ".")
+      #  add_commit(repo, nil, "-", step_num, counter)
+      #end
+
+      repo.checkout_head(strategy: :force)
+    end
+  end
+
+  # Options:
+  #   full_diffs: If true, diffs contain the entire file in one hunk instead of
+  #     multiple contextual hunks.
+  #   diffs_ignore_whitespace: If true, diffs don't show changes to lines when
+  #     only the amount of whitespace is changed.
+  def load!(options = {})
+    git_diff_options = {}
+    git_diff_options[:context_lines] = 100_000 if options[:full_diffs]
+    git_diff_options[:ignore_whitespace_change] = true if options[:diffs_ignore_whitespace]
+
+    page = nil
+    @tutorial.clear
+    each_step(git_diff_options) do |step_num, commit, summary, text, patches|
+      if patches.empty?
+        if summary =~ /^~~~ (.+)$/
+          @tutorial << page unless page.nil?
+
+          page = Snaptoken::Page.new($1)
+          page.footer_text = text unless text.empty?
+        else
+          puts "Warning: ignoring empty commit."
+        end
+      else
+        patch = patches.map(&:to_s).join("\n")
+        step_diffs = Snaptoken::Diff.parse(patch)
+
+        page ||= Snaptoken::Page.new
+        page << Snaptoken::Step.new(step_num, summary, text, step_diffs)
+
+        yield step_num if block_given?
+      end
+    end
+    @tutorial << page unless page.nil?
+    @tutorial
+  end
+
+  def copy_repo_to_step!
+    FileUtils.mkdir_p(step_path)
+    FileUtils.rm_rf(File.join(step_path, "."), secure: true)
+    FileUtils.cd(repo_path) do
+      files = Dir.glob("*", File::FNM_DOTMATCH) - [".", "..", ".git"]
+      files.each do |f|
+        FileUtils.cp_r(f, File.join(step_path, f))
+      end
+    end
+  end
+
+  def copy_step_to_repo!
+    FileUtils.mv(
+      File.join(repo_path, ".git"),
+      File.join(repo_path, "../.gittemp")
+    )
+    FileUtils.rm_rf(File.join(repo_path, "."), secure: true)
+    FileUtils.mv(
+      File.join(repo_path, "../.gittemp"),
+      File.join(repo_path, ".git")
+    )
+    FileUtils.cd(step_path) do
+      files = Dir.glob("*", File::FNM_DOTMATCH) - [".", ".."]
+      files.each do |f|
+        FileUtils.cp_r(f, File.join(repo_path, f))
+      end
+    end
+  end
+
+  def repo_path
+    File.join(@tutorial.config[:path], ".leg/repo")
+  end
+
+  def repo
+    @repo ||= Rugged::Repository.new(repo_path)
+  end
+
+  def each_commit(options = {})
+    walker = Rugged::Walker.new(repo)
+    walker.sorting(Rugged::SORT_TOPO | Rugged::SORT_REVERSE)
+
+    master_commit = repo.branches["master"].target
+    walker.push(master_commit)
+
+    return [] if master_commit.oid == options[:after]
+    walker.hide(options[:after]) if options[:after]
+
+    return walker.to_a if not block_given?
+
+    walker.each do |commit|
+      yield commit
+    end
+  end
+
+  alias_method :commits, :each_commit
+
+  def each_step(git_diff_options = {})
+    empty_tree = Rugged::Tree.empty(repo)
+    step_num = 1
+    each_commit do |commit|
+      commit_message = commit.message.strip
+      summary = commit_message.lines.first.strip
+      text = (commit_message.lines[2..-1] || []).join.strip
+      next if commit_message == "-"
+      commit_message = "" if commit_message == "~"
+      last_commit = commit.parents.first
+      diff = (last_commit || empty_tree).diff(commit, git_diff_options)
+      patches = diff.each_patch.to_a
+
+      if patches.empty?
+        yield nil, commit, summary, text, patches
+      else
+        yield step_num, commit, summary, text, patches
+        step_num += 1
+      end
+    end
+  end
+
+  def commit!(options = {})
+    copy_step_to_repo!
+    remaining_commits = commits(after: repo.head.target).map(&:oid)
+    FileUtils.cd(repo_path) do
+      `git add -A`
+      `git commit #{'--amend' if options[:amend]} -m"TODO: let user specify commit message"`
+    end
+    rebase!(remaining_commits)
+  end
+
+  def resolve!
+    copy_step_to_repo!
+    FileUtils.cd(repo_path) do
+      `git add -A`
+      `git -c core.editor=true cherry-pick --allow-empty --allow-empty-message --keep-redundant-commits --continue`
+    end
+    rebase!(load_remaining_commits)
+  end
+
+  def rebase!(remaining_commits)
+    FileUtils.cd(repo_path) do
+      remaining_commits.each.with_index do |commit, commit_idx|
+        `git cherry-pick --allow-empty --allow-empty-message --keep-redundant-commits #{commit}`
+
+        if not $?.success?
+          copy_repo_to_step!
+          save_remaining_commits(remaining_commits[(commit_idx+1)..-1])
+          return false
+        end
+      end
+    end
+
+    save_remaining_commits(nil)
+
+    repo.references.update(repo.branches["master"], repo.head.target_id)
+    repo.head = "refs/heads/master"
+
+    true
+  end
+
+  private
+
+  def step_path
+    File.join(@tutorial.config[:path], "step")
+  end
+
+  def remaining_commits_path
+    File.join(@tutorial.config[:path], ".leg/remaining_commits")
+  end
+
+  def modified_at
+    if File.exist? repo_path
+      repo = Rugged::Repository.new(repo_path)
+      if master = repo.branches.find { |b| b.name == "master" }
+        master.target.time
+      end
+    end
+  end
+
+  def load_remaining_commits
+    if File.exist?(remaining_commits_path)
+      File.readlines(remaining_commits_path).map(&:strip).reject(&:empty?)
+    else
+      []
+    end
+  end
+
+  def save_remaining_commits(remaining_commits)
+    if remaining_commits && !remaining_commits.empty?
+      File.write(remaining_commits_path, remaining_commits.join("\n"))
+    else
+      FileUtils.rm_f(remaining_commits_path)
+    end
+  end
+
+  def add_commit(repo, diff, message, step_num)
+    message ||= "~"
+    message.strip!
+    message = "~" if message.empty?
+
+    if diff
+      stdin = IO.popen("git apply -", "w")
+      stdin.write diff
+      stdin.close
+    end
+
+    index = repo.index
+    index.read_tree(repo.head.target.tree) unless repo.empty?
+
+    Dir["**/*"].each do |path|
+      unless File.directory?(path)
+        oid = repo.write(File.read(path), :blob)
+        index.add(path: path, oid: oid, mode: 0100644)
+      end
+    end
+
+    options = {}
+    options[:tree] = index.write_tree(repo)
+    if @tutorial.config[:repo_author_name]
+      options[:author] = {
+        name: @tutorial.config[:repo_author_name],
+        email: @tutorial.config[:repo_author_email],
+        time: Time.now
+      }
+      options[:committer] = options[:author]
+    end
+    options[:message] = message
+    options[:parents] = repo.empty? ? [] : [repo.head.target]
+    options[:update_ref] = "HEAD"
+
+    commit_oid = Rugged::Commit.create(repo, options)
+
+    if diff
+      repo.references.create("refs/tags/step-#{step_num}", commit_oid)
+    end
+  end
+end