leg 0.0.1 → 0.0.2

data/lib/snaptoken/diff_line.rb

@@ -1,54 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

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

data/lib/snaptoken/representations/base_representation.rb

@@ -1,38 +0,0 @@
-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

@@ -1,262 +0,0 @@
-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