bookingit 0.0.1 → 0.1.0

data/features/step_definitions/bookinggit_steps.rb

@@ -24,3 +24,21 @@ Given(/^this config file:$/) do |string|
   end
 end
 
+Given(/^a git repo "(.*?)" in "(.*?)" containing the file "(.*?)" and a tag "(.*?)"$/) do |repo_name, repo_basedir, file_name, tag_name|
+  FileUtils.chdir "tmp/aruba" do
+    FileUtils.mkdir repo_basedir
+    @dirs_created << repo_basedir
+    FileUtils.chdir repo_basedir do
+      FileUtils.mkdir repo_name
+      FileUtils.chdir repo_name do
+        File.open(file_name,'w') do |file|
+          file.puts "Some stuff and whatnot"
+        end
+        system "git init"
+        system "git add #{file_name}"
+        system "git commit -m 'initial'"
+        system "git tag #{tag_name}"
+      end
+    end
+  end
+end

data/features/support/env.rb

@@ -8,12 +8,16 @@ Before do
   @puts = true
   @original_rubylib = ENV['RUBYLIB']
   @files_created = []
+  @dirs_created = []
   ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
 end
 
 After do
   ENV['RUBYLIB'] = @original_rubylib
   @files_created.each do |file|
-    FileUtils.rm file
+    FileUtils.rm file if File.exists?(file)
+  end
+  @dirs_created.each do |dir|
+    FileUtils.rm_rf dir if File.exists?(dir)
   end
 end

data/lib/bookingit.rb

@@ -1,3 +1,8 @@
+require 'bookingit/views'
 require 'bookingit/version.rb'
+require 'bookingit/errors.rb'
+require 'bookingit/code_block_interpreter.rb'
+require 'bookingit/shell_command.rb'
 require 'bookingit/renderer.rb'
 require 'bookingit/config.rb'
+require 'bookingit/book.rb'

data/lib/bookingit/book.rb

@@ -0,0 +1,94 @@
+module Bookingit
+  class Book
+    def initialize(config)
+      @config = config
+      @output_dir = 'book'
+    end
+
+    def render_html!
+      mkdir @output_dir unless Dir.exists?(@output_dir)
+
+      rendering_config = @config.rendering_config
+      rendering_config[:cache] = File.expand_path('cache') if @config.cache
+      renderer = Bookingit::Renderer.new(@config)
+      @redcarpet = Redcarpet::Markdown.new(renderer, no_intra_emphasis: true,
+                                                                tables: true,
+                                                    fenced_code_blocks: true,
+                                                              autolink: true,
+                                                         strikethrough: true,
+                                                           superscript: true)
+
+      toc = parse_chapters_to_get_headers(renderer)
+      generate_chapters(renderer)
+      generate_toc(toc,renderer.stylesheets,renderer.theme)
+      copy_assets(renderer)
+    end
+
+  private
+
+    def parse_chapters_to_get_headers(renderer)
+      toc = {}
+      each_chapter do |matter,contents,chapter|
+        toc[matter] ||= []
+        renderer.current_chapter = chapter
+        @redcarpet.render(contents)
+        chapter.title = Array(renderer.headers[1]).first
+        toc[matter] << chapter
+      end
+    toc
+    end
+
+    def each_chapter(&block)
+      %w(front_matter main_matter back_matter).each do |matter|
+        @config.send(matter).chapters.each do |chapter|
+          block.call(matter,File.read(chapter.markdown_path),chapter)
+        end
+      end
+    end
+
+    def generate_chapters(renderer)
+      each_chapter do |_,contents,chapter|
+        output_file = chapter.relative_url
+        renderer.current_chapter = chapter
+        File.open(File.join(@output_dir,output_file),'w') do |file|
+          file.puts @redcarpet.render(contents)
+        end
+      end
+    end
+
+    def generate_toc(toc,stylesheets,theme)
+      if @config.templates["index"] =~ /^\//
+        Views::IndexView.template_path = File.dirname(@config.templates["index"])
+        Views::IndexView.template_name = File.basename(@config.templates["index"])
+      else
+        Views::IndexView.template_name = @config.templates["index"]
+      end
+      view = Views::IndexView.new(stylesheets,
+                                  theme,
+                                  toc['front_matter'],
+                                  toc['main_matter'],
+                                  toc['back_matter'],
+                                  @config)
+      File.open(File.join(@output_dir,'index.html'),'w') do |index|
+        index.puts view.render
+      end
+    end
+
+    def copy_assets(renderer)
+      @config.rendering_config[:stylesheets].each do |stylesheet|
+        cp stylesheet, @output_dir
+      end
+      renderer.images.each do |image|
+        if File.exists?(image)
+          dest_dir = File.join(@output_dir,File.dirname(image))
+          unless File.exists? dest_dir
+            mkdir_p dest_dir
+          end
+          cp image,dest_dir
+        else
+          $stderr.puts "Missing image #{image}"
+        end
+      end
+    end
+  end
+end

data/lib/bookingit/code_block_interpreter.rb

@@ -0,0 +1,114 @@
+module Bookingit
+  class CodeBlockInterpreter
+    def initialize(code)
+      @code = code.strip
+      @result = nil
+    end
+
+    def when_file(&block)
+      if @code =~ /^\s*file:\/\/(.*)$/
+        path = $1
+        @result = block.call(path)
+      end
+      self
+    end
+
+    def when_file_in_git(&block)
+      when_git_reference do |repo_path,path_in_repo,reference|
+        if reference !~ /^(.+)\.\.(.+)$/ && reference !~ /^(.+)\!(.+)$/ && reference !~ /^\.\.(.+)$/
+          chdir repo_path do
+            @result = block.call(path_in_repo,reference)
+          end
+        end
+      end
+      self
+    end
+
+    def when_git_diff(&block)
+      when_git_reference do |repo_path,path_in_repo,reference|
+        if reference =~ /^(.+)\.\.(.+)$/
+          chdir repo_path do
+            @result = block.call(path_in_repo,reference)
+          end
+        elsif reference =~ /^\.\.(.+)$/
+          tag_or_sha = $1
+          chdir repo_path do
+            @result = block.call(path_in_repo,"#{tag_or_sha}^..#{tag_or_sha}")
+          end
+        end
+      end
+      self
+    end
+
+    def when_shell_command_in_git(&block)
+      when_git_reference do |repo_path,path_in_repo,reference|
+        if reference =~ /^([^!]+)\!(.+)$/
+          reference = $1
+          command,exit_type  = parse_shell_command($2)
+          chdir repo_path do
+            @result = block.call(reference,shell_command(path: path_in_repo,command: command, exit_type: exit_type))
+          end
+        end
+      end
+    end
+
+    def when_shell_command(&block)
+      if @code.strip =~ /^\s*sh:\/\/(.+)#([^#]+)$/
+        path = $1
+        command,exit_type = parse_shell_command($2)
+        @result = block.call(shell_command(path: path,command: command, exit_type: exit_type))
+      end
+      self
+    end
+
+    def otherwise(&block)
+      @result = block.call if @result.nil?
+      self
+    end
+
+    def result
+      raise "You didn't handle every possible case" if @result.nil?
+      @result
+    end
+
+  private
+
+    def shell_command(path: nil, command: nil, exit_type: nil)
+      ShellCommand.new(path: path,command: command) do |exit_status|
+        case exit_type
+        when :zero
+          exit_status == 0
+        when :nonzero
+          exit_status != 0
+        else
+          raise "unknown exit type #{exit_type}"
+        end
+      end 
+    end
+  
+    def parse_shell_command(shell_command)
+      if shell_command =~ /(^.*)!([^!]+)$/
+        [$1,$2.to_sym]
+      else
+        [shell_command,:zero]
+      end
+    end
+
+    def when_git_reference(&block)
+      if @code =~ /^\s*git:\/\/(.*)$/
+        path = $1
+        if path =~ /(^.*).git\/(.*)#([^#]+)$/
+          repo_path = $1
+          path_in_repo = $2
+          path_in_repo = '.' if String(path_in_repo).strip == ''
+          reference = $3
+          block.call(repo_path,path_in_repo,reference)
+        else
+          raise "You must provide a SHA1 or tagname: #{path}"
+        end
+      end
+      self
+    end
+
+  end
+end

data/lib/bookingit/config.rb

@@ -7,50 +7,84 @@ module Bookingit
 
     attr_reader :front_matter,
                 :main_matter,
-                :back_matter
+                :back_matter,
+                :rendering_config,
+                :cache,
+                :options,
+                :templates
 
     def initialize(config_json,root_dir)
       config_hash = JSON.parse(config_json)
 
-      @front_matter = Matter.new(config_hash['front_matter'],root_dir)
-      @main_matter  = Matter.new(config_hash['main_matter'],root_dir)
-      @back_matter  = Matter.new(config_hash['back_matter'],root_dir)
+      @front_matter     = Matter.new(config_hash.delete('front_matter'),root_dir)
+      @main_matter      = Matter.new(config_hash.delete('main_matter'),root_dir)
+      @back_matter      = Matter.new(config_hash.delete('back_matter'),root_dir)
+      @templates        = config_hash.delete("templates") || {}
+      @templates["index"] ||= "index.html"
+      @rendering_config = create_rendering_config(config_hash.delete('rendering'))
+      @cache            = false
+      @options          = config_hash
+
+      all_chapters = (@front_matter.chapters + @main_matter.chapters + @back_matter.chapters)
+      all_chapters.each_with_index do |chapter,i|
+        if i > 0
+          all_chapters[i-1].next_chapter = chapter
+          chapter.previous_chapter = all_chapters[i-1]
+        end
+        if i < (all_chapters.size-1)
+          all_chapters[i+1].previous_chapter = chapter
+          chapter.next_chapter = all_chapters[i+1]
+        end
+      end
+    end
+
+    def cache=(cache)
+      @cache = cache
+    end
+
+  private
+
+    def create_rendering_config(raw_config)
+      raw_config ||= {}
+      rendering_config = {}
+      rendering_config[:stylesheets] = Array(raw_config['stylesheets'])
+      rendering_config[:basedir] = raw_config['git_repos_basedir']
+      rendering_config[:languages] = Hash[(raw_config['languages'] || {}).map { |match,language|
+        if match =~ /^\/(.+)\/$/
+          [Regexp.new($1),language]
+        else
+          [match,language]
+        end
+      }]
+      rendering_config[:theme] = raw_config['syntax_theme']
+
+      rendering_config
     end
 
     class Matter
       attr_reader :chapters
-      def initialize(chapters_config,root_dir)
-        @chapters = Array(chapters_config).map { |chapter_config|
-          Chapter.new(chapter_config,root_dir)
+      def initialize(chapter_filenames,root_dir)
+        @chapters = Array(chapter_filenames).map { |chapter_filename|
+          Chapter.new(markdown_path: File.join(root_dir,chapter_filename))
         }
       end
     end
 
     class Chapter
-      attr_reader :sections
-      attr_reader :path
-
-      def initialize(chapter_config,root_dir)
-        files = Array(chapter_config).flatten(1).map { |file|
-          Dir[File.join(root_dir,file)]
-        }.flatten
-        if files.size == 1
-          @sections = []
-          @path = files[0]
-        else
-          @sections = files.map { |file|
-            Section.new(file)
-          }
-        end
+      attr_reader :markdown_path, :relative_url, :sections
+      attr_accessor :title, :previous_chapter, :next_chapter
+
+      def initialize(markdown_path: nil, relative_url: nil)
+        @markdown_path = markdown_path
+        @relative_url = relative_url || (File.basename(markdown_path, File.extname(markdown_path)) + ".html")
+        @sections = []
       end
-    end
 
-    class Section
-      attr_reader :path
-      def initialize(path)
-        @path = path
+      def add_section(title,anchor)
+        section = Chapter.new(relative_url: self.relative_url + "##{anchor}")
+        section.title = title
+        @sections << section
       end
     end
   end
-
 end

data/lib/bookingit/errors.rb

@@ -0,0 +1,16 @@
+require 'gli'
+module Bookingit
+  class UnexpectedShellCommandExit < StandardError
+    include GLI::StandardException
+    attr_reader :command, :stdout, :stderr
+    def initialize(command,stdout,stderr)
+      @command = command
+      @stdout = stdout
+      @stderr = stderr
+    end
+
+    def exit_code
+      126
+    end
+  end
+end

data/lib/bookingit/renderer.rb

@@ -6,63 +6,197 @@ module Bookingit
   class Renderer < Redcarpet::Render::HTML
     include FileUtils
 
-    attr_accessor :headers
+    def initialize(config)
+      super()
+      options = config.rendering_config
+      additional_languages = Hash[(options[:languages] || {}).map { |ext_or_regexp,language|
+        if ext_or_regexp.kind_of? String
+          [/#{ext_or_regexp}$/,language]
+        else
+          [ext_or_regexp,language]
+        end
+      }]
+      @language_identifiers = EXTENSION_TO_LANGUAGE.merge(additional_languages)
+      @basedir              = String(options[:basedir]).strip
+      @basedir              = '.' if @basedir == ''
+      @stylesheets          = Array(options[:stylesheets])
+      @theme                = options[:theme] || "default"
+      @cachedir             = options[:cache]
+      @config               = config
+      @images               = []
+    end
+
+    attr_accessor :headers, :stylesheets, :theme, :images
+
+    def current_chapter=(chapter)
+      @chapter = chapter
+    end
+
     def header(text,header_level,anchor)
       @headers[header_level] ||= []
       @headers[header_level] << text
-      "<h#{header_level}>#{text}</h#{header_level}>"
+      if header_level == 2
+        @chapter.add_section(text,anchor)
+      end
+      "<a name='#{anchor}'></a><h#{header_level+1}>#{text}</h#{header_level+1}>"
+    end
+
+    def image(link, title, alt_text)
+      title = title.gsub(/'/,'"') if title
+      @images << link
+      "<img src='#{link}' alt='#{alt_text}' title='#{title}'>"
     end
 
     def doc_header
       @headers = {}
-      ""
+      Views::HeaderView.new(@stylesheets,@theme,@config).render
+    end
+
+    def doc_footer
+      Views::FooterView.new(@chapter,@config).render
     end
 
     EXTENSION_TO_LANGUAGE = {
-      '.rb' => 'ruby',
-      '.html' => 'html',
-      '.scala' => 'scala',
+      /\.rb$/    => 'ruby',
+      /\.html$/  => 'html',
+      /\.scala$/ => 'scala',
+      /Gemfile$/ => 'ruby',
     }
+
+    def identify_language(path)
+      @language_identifiers.select { |matcher,language|
+        path =~ matcher
+      }.values.first
+    end
+
+
     def block_code(code, language)
-      if code.strip =~ /file:\/\/(.*)$/
-        path = $1
-        code = File.read(path)
-        language = EXTENSION_TO_LANGUAGE.fetch(File.extname(path))
-      elsif code.strip =~ /git:\/\/(.*)$/
-        path = $1
-        if path =~ /(^.*).git\/(.*)#([^#]+)$/
-          repo_path = $1
-          path_in_repo = $2
-          reference = $3
-          chdir repo_path do
-            if reference =~ /^(.+)\.\.(.+)$/
-              code = `git diff #{reference}`
-              language = 'diff'
-            else
-              `git checkout #{reference} 2>&1`
-              code = File.read(path_in_repo)
-              `git checkout master 2>&1`
-              language = EXTENSION_TO_LANGUAGE.fetch(File.extname(path_in_repo))
+      result = nil
+      filename = nil
+      chdir @basedir do
+        code,language,filename = CodeBlockInterpreter.new(code)
+        .when_file(                &cache(:read_file))
+        .when_git_diff(            &cache(:read_git_diff))
+        .when_shell_command_in_git(&cache(:run_shell_command_in_git))
+        .when_file_in_git(         &cache(:read_file_in_git))
+        .when_shell_command(       &cache(:run_shell_command))
+        .otherwise {
+          [code,language,nil]
+        }.result
+      end
+      Views::CodeView.new(code,filename,language,@config).render.strip
+    end
+
+  private
+
+    def cache(method_name)
+      ->(*args) {
+        if @cachedir && File.exist?(cached_filename(*args))
+          puts "Pulling from cache..."
+          lines = File.read(cached_filename(*args)).split(/\n/)
+          language = lines.shift
+          filename = lines.shift
+          [lines.join("\n") + "\n",language,filename]
+        else
+          code,language,filename = method(method_name).(*args)
+          if @cachedir
+            FileUtils.mkdir_p(@cachedir) unless File.exist?(@cachedir)
+            File.open(cached_filename(*args),'w') do |file|
+              file.puts language
+              file.puts filename
+              file.puts code
             end
+            puts "Cached output"
           end
+          [code,language,filename]
+        end
+      }
+    end
+
+    def cached_filename(*args)
+      args = args.map { |arg|
+        case arg
+        when ShellCommand
+          [arg.command,arg.expected_exit_status].join("_")
         else
-          raise "You must provide a SHA1 or tagname: #{path}"
+          arg
         end
-      elsif code.strip =~ /sh:\/\/(.+)#([^#]+)$/
-        path = $1
-        command = $2
-        chdir path do
-          output = `#{command}`
-          code = "> #{command}\n#{output}"
-          language = 'shell'
+      }
+      File.join(@cachedir,args.join('__').gsub(/[#\/\!\s><]/,'_'))
+    end
+
+    def at_version_in_git(reference,&block)
+      ShellCommand.new(command: "git checkout #{reference} 2>&1").run!
+      block.call
+      ShellCommand.new(command: "git checkout master 2>&1").run!
+    end
+
+    def capture_command_output(path,command,exit_type=:zero)
+      shell_command = ShellCommand.new(command: command,path: path) do |exit_status|
+        case exit_type
+        when :zero
+          exit_status == 0
+        when :nonzero
+          exit_status != 0
+        else
+          raise "unknown exit type #{exit_type}"
         end
       end
-      css_class = if language.nil? || language.strip == ''
-                    ""
-                  else
-                    " class=\"language-#{language}\""
-                  end
-      %{<pre><code#{css_class}>#{CGI.escapeHTML(code)}</code></pre>}
+      shell_command.run!
+      ["> #{command}\n#{shell_command.stdout}",'shell']
+    end
+
+    def read_file(path)
+      filename = path
+      [File.read(path),identify_language(path),filename]
+    end
+
+    def read_git_diff(path_in_repo,reference)
+      puts "Calculating git diff #{reference}"
+      filename = path_in_repo
+      shell_command = ShellCommand.new(command: "git diff #{reference} #{path_in_repo}")
+      shell_command.run!
+      [ shell_command.stdout, 'diff', filename ]
+    end
+
+    def run_shell_command_in_git(reference,shell_command)
+      code = nil
+      at_version_in_git(reference) do
+        shell_command.run!
+        code = "> #{shell_command.command}\n#{shell_command.stdout}"
+      end
+      [code,'shell']
+    end
+
+    def read_file_in_git(path_in_repo,reference)
+      puts "Getting file at #{reference}"
+      code = nil
+      filename = path_in_repo
+      at_version_in_git(reference) do
+        code = File.read(path_in_repo)
+      end
+      [code, identify_language(path_in_repo),filename]
+    end
+
+    def run_shell_command(shell_command)
+      shell_command.run!
+      ["> #{shell_command.command}\n#{shell_command.stdout}",'shell']
+    end
+
+    def css_class(language)
+      if language.nil? || language.strip == ''
+        ""
+      else
+        " class=\"language-#{language}\""
+      end
+    end
+
+    def filename_footer(filename)
+      if filename && filename.strip != ''
+        %{<footer><h1>#{filename}</h1></footer>}
+      else
+        ''
+      end
     end
   end
 end