snaptoken 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c560cdd80e151f13503cd318c9aec1dcfa029849
+  data.tar.gz: d950cc9f6aafd966680e21bd949f8d4b5efae81f
+SHA512:
+  metadata.gz: 1de8a8e365f2ba54ca8db92d0042f801b1f9767a2359ee1fae68c849f8949b232aba3ec1e6f88f5d258fe712814279be63b7302218a885439819e91dabf0f2d9
+  data.tar.gz: 8249d015895a23feea437f0b69ffd0f0de8eeb0503b60934cb023f0a9ff66fbab243901da97f7c379f1ecab406a3626652c738fd4ee8c0fa7a798b8b77c0fd4c

data/bin/leg

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
+
+require 'snaptoken'
+
+cli = Snaptoken::CLI.new
+cli.run(ARGV)
+

data/lib/snaptoken/cli.rb

@@ -0,0 +1,46 @@
+class Snaptoken::CLI
+  CONFIG_FILE = "leg.yml"
+
+  def initialize
+    initial_dir = FileUtils.pwd
+
+    last_dir = nil
+    last_dir2 = nil
+    while FileUtils.pwd != last_dir
+      if File.exist?(CONFIG_FILE)
+        @config = YAML.load(File.read(CONFIG_FILE))
+        unless @config.is_a? Hash
+          puts "Error: Invalid config file."
+          exit!
+        end
+        @config[:path] = FileUtils.pwd
+        @config[:step_path] = last_dir2
+        @config[:orig_path] = initial_dir
+        break
+      end
+
+      last_dir2 = last_dir
+      last_dir = FileUtils.pwd
+      FileUtils.cd('..')
+    end
+
+    FileUtils.cd(initial_dir)
+  end
+
+  def run(args)
+    args = ["help"] if args.empty?
+    cmd_name = args.shift.downcase
+
+    if cmd_name =~ /\A\d+\z/
+      args.unshift(cmd_name)
+      cmd_name = "ref"
+    end
+
+    if cmd = Snaptoken::Commands::LIST.find { |cmd| cmd.name == cmd_name }
+      cmd.new(args, @config).run
+    else
+      puts "There is no '#{cmd_name}' command. Run `leg help` for help."
+    end
+  end
+end
+

data/lib/snaptoken/commands/base_command.rb

@@ -0,0 +1,124 @@
+class Snaptoken::Commands::BaseCommand
+  def initialize(args, config)
+    @args = args
+    @config = config
+  end
+
+  def self.name; raise NotImplementedError; end
+  def self.summary; raise NotImplementedError; end
+  def run; raise NotImplementedError; end
+
+  def self.inherited(subclass)
+    Snaptoken::Commands::LIST << subclass
+  end
+
+  ERROR_MSG = {
+    config: {
+      true: "You are not in a leg working directory.",
+      false: "You are already in a leg working directory."
+    },
+    config_title: {
+      true: "You need to set a title in leg.yml."
+    },
+    steps_folder: {
+      true: "There is no steps folder.",
+      false: "There is already a steps folder."
+    },
+    steps: {
+      true: "There are no steps in the steps folder."
+    },
+    repo: {
+      true: "There is no repo folder.",
+      false: "There is already a repo folder."
+    },
+    diff: {
+      true: "There is no steps.diff file."
+    },
+    doc: {
+      true: "There is no doc folder."
+    },
+    doc_out: {
+      true: "There are no doc output files."
+    },
+    ftp: {
+      true: "There is no ftp.yml file."
+    }
+  }
+
+  def needs!(*whats)
+    options = whats.pop if whats.last.is_a? Hash
+    options ||= {}
+
+    yes = Array(whats).flatten.map { |w| [w, true] }
+    no = Array(options[:not]).map { |w| [w, false] }
+
+    (yes + no).each do |what, v|
+      valid = false
+      case what
+      when :config
+        valid = true if @config
+      when :config_title
+        valid = true if @config[:title]
+      when :steps_folder
+        valid = true if File.exist?(File.join(@config[:path], "steps"))
+      when :steps
+        valid = true if steps.length > 0
+      when :repo
+        valid = true if File.exist?(File.join(@config[:path], "repo"))
+      when :diff
+        valid = true if File.exist?(File.join(@config[:path], "steps.diff"))
+      when :doc
+        valid = true if File.exist?(File.join(@config[:path], "doc"))
+      when :doc_out
+        valid = true if File.exist?(File.join(@config[:path], "doc/html_out"))
+      when :ftp
+        valid = true if File.exist?(File.join(@config[:path], "ftp.yml"))
+      else
+        raise NotImplementedError
+      end
+
+      if valid != v
+        puts "Error: " + ERROR_MSG[what][v.to_s.to_sym]
+        exit!
+      end
+    end
+  end
+
+  def steps
+    @steps ||= Dir[File.join(@config[:path], "steps/*")].map do |f|
+      name = File.basename(f)
+      name if File.directory?(f) && name =~ /\A\d+(\.\d+)*(-\w+)*\z/
+    end.compact.sort_by { |s| s.split(".").map(&:to_i) }.reject { |s| s.to_i.zero? }
+  end
+
+  def current_step
+    if @config[:step_path]
+      File.basename(@config[:step_path])
+    end
+  end
+
+  def latest_step
+    steps.last
+  end
+
+  def current_or_latest_step
+    current_step || latest_step
+  end
+
+  def step_name(step)
+    parts = step.split('-')
+    if parts.length > 1
+      parts[1..-1].join('-')
+    end
+  end
+
+  def step_path(step)
+    File.join(@config[:path], "steps", step)
+  end
+
+  def select_step(step, &block)
+    puts "Selecting step: #{step}"
+    FileUtils.cd(step_path(step), &block)
+  end
+end
+

data/lib/snaptoken/commands/deploy.rb

@@ -0,0 +1,33 @@
+class Snaptoken::Commands::Deploy < Snaptoken::Commands::BaseCommand
+  def self.name
+    "deploy"
+  end
+
+  def self.summary
+    "Pushes output files in doc/ to production server"
+  end
+
+  def run
+    needs! :config, :doc, :doc_out, :ftp
+
+    only = @args.empty? ? nil : @args
+
+    FileUtils.cd(File.join(@config[:path], "doc/html_out")) do
+      ftp_config = YAML.load(File.read(File.join(@config[:path], "ftp.yml")))
+      Net::FTP.open(ftp_config[:host], ftp_config[:username], ftp_config[:password]) do |ftp|
+        ftp.chdir(ftp_config[:root])
+        Dir["**/*"].each do |f|
+          if only.nil? || only.any? { |o| f[o] }
+            puts f
+            if File.directory?(f)
+              ftp.mkdir(f) rescue Net::FTPPermError
+            elsif File.file?(f)
+              ftp.putbinaryfile(f)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/snaptoken/commands/diff.rb

@@ -0,0 +1,37 @@
+class Snaptoken::Commands::Diff < Snaptoken::Commands::BaseCommand
+  def self.name
+    "diff"
+  end
+
+  def self.summary
+    "Convert repo into a single file containing diffs for each step"
+  end
+
+  def run
+    needs! :config, :repo
+
+    FileUtils.cd(File.join(@config[:path], "repo")) do
+      patches = `git format-patch --stdout -p --no-signature --histogram --root master`
+      File.open("../steps.diff", "w") do |f|
+        step_num = 1
+        patches.each_line do |line|
+          if line =~ /^(From|Date|index)/
+            # skip
+          elsif line =~ /^Subject: \[[^\]]*\](.*)$/
+            f << "\n" unless step_num == 1
+            step_name = $1.strip
+            if step_name =~ /^\w+(-\w+)*$/
+              f << "~~~ step: #{step_name}\n"
+            else
+              f << "~~~ step\n"
+            end
+            step_num += 1
+          elsif line.chomp.length > 0
+            f << line
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/snaptoken/commands/doc.rb

@@ -0,0 +1,128 @@
+class Snaptoken::Commands::Doc < Snaptoken::Commands::BaseCommand
+  def self.name
+    "doc"
+  end
+
+  def self.summary
+    "Renders files in doc folder into an HTML book"
+  end
+
+  def run
+    needs! :config, :config_title, :steps_folder, :steps, :doc
+
+    FileUtils.cd(File.join(@config[:path], "doc")) do
+      FileUtils.rm_rf("html_out")
+      FileUtils.mkdir("html_out")
+
+      copy_static_files
+      write_css
+      write_html_files(prerender_diffs)
+    end
+  end
+
+  class HTMLLineByLine < Rouge::Formatter
+    def initialize(formatter)
+      @formatter = formatter
+    end
+
+    def stream(tokens, &b)
+      token_lines(tokens) do |line|
+        line.each do |tok, val|
+          yield @formatter.span(tok, val)
+        end
+        yield "\n"
+      end
+    end
+  end
+
+  private
+
+  def copy_static_files
+    Dir["html_in/*"].each do |f|
+      name = File.basename(f)
+      unless %w(template.html style.css).include? name
+        FileUtils.cp_r(f, "html_out/#{name}")
+      end
+    end
+  end
+
+  def write_css
+    @config[:rouge_theme] ||= "github"
+    if @config[:rouge_theme].is_a? String
+      theme = Rouge::Theme.find(@config[:rouge_theme])
+    elsif @config[:rouge_theme].is_a? Hash
+      theme = Class.new(Rouge::Themes::Base16)
+      theme.name "base16.custom"
+      theme.palette @config[:rouge_theme]
+    end
+
+    css = File.read("html_in/style.css")
+    css << theme.render(scope: ".highlight")
+
+    File.write("html_out/style.css", css)
+  end
+
+  def prerender_diffs
+    diffs = {}
+    FileUtils.cd("../steps") do
+      FileUtils.mkdir_p("0")
+      last_step = "0"
+      Dir["*"].sort_by(&:to_i).each do |step|
+        names = [step.to_i.to_s]
+        if step =~ /\d+\-([\w-]+)$/
+          names << $1
+        end
+
+        diff = Snaptoken::Diff.new(last_step, step)
+
+        names.each do |name|
+          diffs[name] = diff.html.values.join("\n")
+        end
+
+        last_step = step
+      end
+      FileUtils.rmdir("0")
+    end
+    diffs
+  end
+
+  def write_html_files(diffs)
+    html_template = File.read("html_in/template.html")
+
+    index = ""
+    markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML)
+    Dir["*.md"].sort.each do |md_file|
+      html_file = md_file.sub(/\.md$/, '.html')
+
+      md = File.read(md_file)
+      md =~ /^# (.+)$/
+      title = $1
+
+      index << "<li><a href='#{html_file}'>#{title}</a></li>\n"
+
+      content = markdown.render(md)
+      content.gsub!(/<p>{{([\w-]+)}}<\/p>/) { diffs[$1] }
+
+      html = html_template.dup
+      html.gsub!("{{title}}") { "#{@config[:title]} | #{title}" }
+      html.gsub!("{{content}}") { content }
+
+      File.write(File.join("html_out", html_file), html)
+    end
+
+    content = <<~HTML
+    <h1>#{@config[:title]}</h1>
+    <h2>Table of Contents</h2>
+    <ol>
+      #{index}
+    </ol>
+    HTML
+
+    html = html_template.dup
+    html.gsub!("{{title}}", @config[:title])
+    html.gsub!("{{content}}", content)
+
+    File.write("html_out/index.html", html)
+  end
+end
+

data/lib/snaptoken/commands/fancy.rb

@@ -0,0 +1,26 @@
+class Snaptoken::Commands::Fancy < Snaptoken::Commands::BaseCommand
+  def self.name
+    "fancy"
+  end
+
+  def self.summary
+    "Run steps.diff through colordiff, diff-so-fancy, and less"
+  end
+
+  def run
+    needs! :config, :diff
+
+    FileUtils.cd(@config[:path]) do
+      exec("cat steps.diff | colordiff | diff-so-fancy | less --tabs=4 -RFX")
+    end
+  end
+
+  private
+
+  def apply_diff(dir, diff)
+    stdin = IO.popen("git --git-dir= apply --directory=#{dir} -", "w")
+    stdin.write diff
+    stdin.close
+  end
+end
+

data/lib/snaptoken/commands/help.rb

@@ -0,0 +1,20 @@
+class Snaptoken::Commands::Help < Snaptoken::Commands::BaseCommand
+  def self.name
+    "help"
+  end
+
+  def self.summary
+    "Print out this help"
+  end
+
+  def run
+    puts "Usage: leg <command> [args...]"
+    puts
+    puts "Commands:"
+    Snaptoken::Commands::LIST.each do |cmd|
+      puts "  #{cmd.name}"
+      puts "      #{cmd.summary}"
+    end
+  end
+end
+

data/lib/snaptoken/commands/pieces.rb

@@ -0,0 +1,14 @@
+class Snaptoken::Commands::Pieces < Snaptoken::Commands::BaseCommand
+  def self.name
+    "pieces"
+  end
+
+  def self.summary
+    "Print an inventory of the number of tokens used between two steps"
+  end
+
+  def run
+    puts "Not implemented"
+  end
+end
+

data/lib/snaptoken/commands/ref.rb

@@ -0,0 +1,37 @@
+class Snaptoken::Commands::Ref < Snaptoken::Commands::BaseCommand
+  def self.name
+    "ref"
+  end
+
+  def self.summary
+    "Convert a step number or name to a git commit reference"
+  end
+
+  def run
+    needs! :config, :repo
+
+    ref = @args.first
+    is_num = (ref =~ /\A\d+\z/)
+
+    FileUtils.cd(@config[:path]) do
+      repo = Rugged::Repository.new("repo")
+
+      walker = Rugged::Walker.new(repo)
+      walker.sorting(Rugged::SORT_TOPO | Rugged::SORT_REVERSE)
+      walker.push(repo.branches.find { |b| b.name == "master" }.target)
+      walker.each.with_index do |commit, idx|
+        step_num = (idx + 1).to_s
+        step_name = commit.message.lines.first.strip
+
+        if (is_num && ref == step_num) || (!is_num && ref == step_name)
+          puts commit.oid
+          exit
+        end
+      end
+
+      puts "Error: reference not found"
+      exit!
+    end
+  end
+end
+

data/lib/snaptoken/commands/repo.rb

@@ -0,0 +1,43 @@
+class Snaptoken::Commands::Repo < Snaptoken::Commands::BaseCommand
+  def self.name
+    "repo"
+  end
+
+  def self.summary
+    "Convert steps folder into a version controlled repository"
+  end
+
+  def run
+    needs! :config, :steps_folder, :steps, not: :repo
+
+    FileUtils.cd(@config[:path])
+
+    FileUtils.mkdir("repo")
+    repo = Rugged::Repository.init_at("repo")
+
+    steps.each do |step|
+      index = repo.index
+      index.read_tree(repo.head.target.tree) unless repo.empty?
+
+      FileUtils.cd(step_path(step)) do
+        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
+      end
+
+      options = {}
+      options[:tree] = index.write_tree(repo)
+      options[:message] = step_name(step) || "-"
+      options[:parents] = repo.empty? ? [] : [repo.head.target]
+      options[:update_ref] = 'HEAD'
+
+      Rugged::Commit.create(repo, options)
+    end
+
+    repo.checkout_head(strategy: :force)
+  end
+end
+

data/lib/snaptoken/commands/undiff.rb

@@ -0,0 +1,58 @@
+class Snaptoken::Commands::Undiff < Snaptoken::Commands::BaseCommand
+  def self.name
+    "undiff"
+  end
+
+  def self.summary
+    "Convert steps.diff to steps folder"
+  end
+
+  def run
+    needs! :config, :diff, not: :steps_folder
+
+    FileUtils.cd(@config[:path]) do
+      FileUtils.mkdir("steps")
+      FileUtils.cd("steps") do
+        File.open("../steps.diff", "r") do |f|
+          step_num = 0
+          step_dir = nil
+          prev_dir = nil
+          cur_diff = nil
+          while line = f.gets
+            if line =~ /^~~~ step(: \w+(-\w+)*)?$/
+              if cur_diff
+                apply_diff(step_dir, cur_diff)
+                cur_diff = nil
+              end
+
+              step_num += 1
+              step_dir = step_num.to_s
+              step_dir += "-#{$1[2..-1]}" if $1
+              if step_num == 1
+                FileUtils.mkdir(step_dir)
+              else
+                FileUtils.cp_r(prev_dir, step_dir)
+              end
+              prev_dir = step_dir
+            elsif line =~ /^diff --git/
+              apply_diff(step_dir, cur_diff) if cur_diff
+              cur_diff = line
+            elsif cur_diff
+              cur_diff << line
+            end
+          end
+          apply_diff(step_dir, cur_diff) if cur_diff
+        end
+      end
+    end
+  end
+
+  private
+
+  def apply_diff(dir, diff)
+    stdin = IO.popen("git --git-dir= apply --directory=#{dir} -", "w")
+    stdin.write diff
+    stdin.close
+  end
+end
+

data/lib/snaptoken/commands/unrepo.rb

@@ -0,0 +1,37 @@
+class Snaptoken::Commands::Unrepo < Snaptoken::Commands::BaseCommand
+  def self.name
+    "unrepo"
+  end
+
+  def self.summary
+    "Convert repository into steps folder"
+  end
+
+  def run
+    needs! :config, :repo, not: :steps_folder
+
+    FileUtils.cd(@config[:path]) do
+      FileUtils.mkdir("steps")
+
+      repo = Rugged::Repository.new("repo")
+
+      walker = Rugged::Walker.new(repo)
+      walker.sorting(Rugged::SORT_TOPO | Rugged::SORT_REVERSE)
+      walker.push(repo.branches.find { |b| b.name == "master" }.target)
+      walker.each.with_index do |commit, idx|
+        step_num = (idx + 1).to_s
+        step_name = commit.message.lines.first.strip
+
+        if step_name.empty?
+          step = step_num
+        else
+          step = "#{step_num}-#{step_name}"
+        end
+
+        repo.checkout(commit.oid, strategy: :force,
+                                  target_directory: step_path(step))
+      end
+    end
+  end
+end
+

data/lib/snaptoken/commands.rb

@@ -0,0 +1,17 @@
+module Snaptoken::Commands
+  LIST = []
+end
+
+require 'snaptoken/commands/base_command'
+
+require 'snaptoken/commands/deploy'
+require 'snaptoken/commands/diff'
+require 'snaptoken/commands/doc'
+require 'snaptoken/commands/help'
+require 'snaptoken/commands/pieces'
+require 'snaptoken/commands/fancy'
+require 'snaptoken/commands/ref'
+require 'snaptoken/commands/repo'
+require 'snaptoken/commands/undiff'
+require 'snaptoken/commands/unrepo'
+

data/lib/snaptoken/diff.rb

@@ -0,0 +1,201 @@
+class Snaptoken::Diff
+  GIT_DIFF_OPTIONS = "--histogram --unified=100000 --ignore-space-change --no-index"
+
+  attr_reader :files, :html
+
+  def initialize(step_a, step_b)
+    git_diff = `git diff #{GIT_DIFF_OPTIONS} #{step_a} #{step_b}`
+    parse_git_diff(git_diff)
+    @files.values.each(&:omit_adjacent_removals!)
+
+    @html = {}
+    @files.each do |filename, file|
+      @html[filename] = file.to_html
+    end
+  end
+
+  class DiffLine
+    attr_reader :type, :line
+    attr_writer :type
+
+    def initialize(type, line)
+      @type = type
+      @line = line
+    end
+
+    def empty!; @empty = true; end
+    def empty?; @empty; end
+
+    def omit!; @omit = true; end
+    def omit?; @omit; end
+  end
+
+  class DiffSection
+    attr_reader :type, :lines, :contents
+
+    def initialize(type, line=nil)
+      @type = type
+      @lines = Array(line)
+      @contents = []
+    end
+
+    def <<(content)
+      @contents << content
+    end
+
+    def dirty!; @dirty = true; end
+    def dirty?; @dirty; end
+  end
+
+  class DiffFile < DiffSection
+    attr_reader :filename, :file_contents
+
+    def initialize(filename)
+      super(:file)
+      @filename = filename
+      @file_contents = ""
+    end
+
+    def append_line(line)
+      @file_contents << line
+      @file_contents << "\n" unless line.end_with? "\n"
+    end
+
+    def new_file!; @new_file = true; end
+    def new_file?; @new_file; end
+
+    def omit_adjacent_removals!
+      change_chain = []
+      to_render = @contents.dup
+      until to_render.empty?
+        cur = to_render.shift
+        if cur.is_a? DiffSection
+          if cur.dirty?
+            to_render = cur.contents + to_render
+          else
+            [change_chain.first, change_chain.last].compact.each do |line|
+              line.type = :nochange if line.empty?
+            end
+            change_chain = []
+          end
+        else
+          if cur.type == :nochange
+            [change_chain.first, change_chain.last].compact.each do |line|
+              line.type = :nochange if line.empty?
+            end
+            change_chain = []
+          else
+            change_chain << cur
+            if cur.type == :add
+              change_chain.each { |c| c.omit! if c.type == :remove }
+            elsif cur.type == :remove
+              cur.omit! if change_chain.any? { |c| c.type == :add }
+            end
+          end
+        end
+      end
+    end
+
+    def to_html
+      formatter = Rouge::Formatters::HTML.new
+      formatter = HTMLLineByLine.new(formatter)
+
+      lexer = Rouge::Lexer.guess(filename: @filename)
+      code_hl = formatter.format(lexer.lex(@file_contents)).lines.each(&:chomp!)
+
+      html = ""
+      html << "<div class=\"diff\">\n"
+      html << "<div class=\"filename\">#{@filename}</div>\n"
+      html << "<pre class=\"highlight\"><code>"
+
+      to_render = @contents.dup
+      until to_render.empty?
+        cur = to_render.shift
+        if cur.is_a? DiffSection
+          if cur.dirty?
+            to_render = cur.contents + to_render
+          else
+            summary = cur.lines.map { |n| code_hl[n] }.join(" ... ").gsub("\n", "")
+            html << "<div class=\"line folded\">#{summary}</div>"
+          end
+        elsif !cur.omit?
+          tag = {nochange: :div, add: :ins, remove: :del}[cur.type]
+          tag = :div if new_file?
+          html << "<#{tag} class=\"line\">#{code_hl[cur.line]}</#{tag}>"
+        end
+      end
+      html << "</code></pre>\n</div>\n"
+
+      html
+    end
+  end
+
+  class HTMLLineByLine < Rouge::Formatter
+    def initialize(formatter)
+      @formatter = formatter
+    end
+
+    def stream(tokens, &b)
+      token_lines(tokens) do |line|
+        line.each do |tok, val|
+          yield @formatter.span(tok, val)
+        end
+        yield "\n"
+      end
+    end
+  end
+
+  private
+
+  def parse_git_diff(git_diff)
+    diff_file = nil
+    section_stack = nil
+    line_idx = nil
+    in_diff = false
+    @files = {}
+
+    git_diff.lines.each do |line|
+      if !in_diff && line =~ /^diff --git (\S+) (\S+)$/
+        diff_file = DiffFile.new(File.basename($2))
+        @files[diff_file.filename] = diff_file
+        section_stack = [diff_file]
+        line_idx = -1
+      elsif !in_diff && line.start_with?('new file')
+        diff_file.new_file!
+      elsif line.start_with? '@@'
+        in_diff = true
+      elsif in_diff && [' ', '+', '-'].include?(line[0])
+        type = {' ' => :nochange, '+' => :add, '-' => :remove }[line[0]]
+        diff_file.append_line(line[1..-1])
+        line_idx += 1
+
+        section_stack.each(&:dirty!) if type != :nochange
+
+        if line[1..-1] =~ /^\/\*\*\* (.+) \*\*\*\/$/
+          section = DiffSection.new(:comment, line_idx)
+          diff_file << section
+          section_stack = [diff_file, section]
+        elsif line[1] =~ /\S/ && line.chomp[-1] == "{"
+          section = DiffSection.new(:braces, line_idx)
+          section_stack.pop if section_stack.last.type == :braces
+          section_stack.last << section
+          section_stack.push(section)
+        end
+
+        diff_line = DiffLine.new(type, line_idx)
+        diff_line.empty! if line[1..-1].strip.empty?
+        section_stack.last << diff_line
+
+        if line[1..-1] =~ /^}( \w+)?;?$/ && section_stack.last.type == :braces
+          section = section_stack.pop
+          section.lines << line_idx
+        end
+
+        section_stack.each(&:dirty!) if type != :nochange
+      else
+        in_diff = false
+      end
+    end
+  end
+end
+

data/lib/snaptoken.rb

@@ -0,0 +1,14 @@
+require 'fileutils'
+require 'net/ftp'
+require 'yaml'
+require 'rugged'
+require 'redcarpet'
+require 'rouge'
+
+module Snaptoken
+end
+
+require 'snaptoken/cli'
+require 'snaptoken/commands'
+require 'snaptoken/diff'
+

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: snaptoken
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Jeremy Ruten
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.25.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.25.1.1
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.7
+description: 
+email: jeremy.ruten@gmail.com
+executables:
+- leg
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/leg
+- lib/snaptoken.rb
+- lib/snaptoken/cli.rb
+- lib/snaptoken/commands.rb
+- lib/snaptoken/commands/base_command.rb
+- lib/snaptoken/commands/deploy.rb
+- lib/snaptoken/commands/diff.rb
+- lib/snaptoken/commands/doc.rb
+- lib/snaptoken/commands/fancy.rb
+- lib/snaptoken/commands/help.rb
+- lib/snaptoken/commands/pieces.rb
+- lib/snaptoken/commands/ref.rb
+- lib/snaptoken/commands/repo.rb
+- lib/snaptoken/commands/undiff.rb
+- lib/snaptoken/commands/unrepo.rb
+- lib/snaptoken/diff.rb
+homepage: https://github.com/yjerem/leg
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: tools for .leg files
+test_files: []