rails 3.2.22.5 → 4.2.11.1

data/guides/rails_guides/indexer.rb

@@ -0,0 +1,68 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+
+module RailsGuides
+  class Indexer
+    attr_reader :body, :result, :warnings, :level_hash
+
+    def initialize(body, warnings)
+      @body     = body
+      @result   = @body.dup
+      @warnings = warnings
+    end
+
+    def index
+      @level_hash = process(body)
+    end
+
+    private
+
+    def process(string, current_level=3, counters=[1])
+      s = StringScanner.new(string)
+
+      level_hash = {}
+
+      while !s.eos?
+        re = %r{^h(\d)(?:\((#.*?)\))?\s*\.\s*(.*)$}
+        s.match?(re)
+        if matched = s.matched
+          matched =~ re
+          level, idx, title = $1.to_i, $2, $3.strip
+
+          if level < current_level
+            # This is needed. Go figure.
+            return level_hash
+          elsif level == current_level
+            index = counters.join(".")
+            idx ||= '#' + title_to_idx(title)
+
+            raise "Parsing Fail" unless @result.sub!(matched, "h#{level}(#{idx}). #{index} #{title}")
+
+            key = {
+              :title => title,
+              :id => idx
+            }
+            # Recurse
+            counters << 1
+            level_hash[key] = process(s.post_match, current_level + 1, counters)
+            counters.pop
+
+            # Increment the current level
+            last = counters.pop
+            counters << last + 1
+          end
+        end
+        s.getch
+      end
+      level_hash
+    end
+
+    def title_to_idx(title)
+      idx = title.strip.parameterize.sub(/^\d+/, '')
+      if warnings && idx.blank?
+        puts "BLANK ID: please put an explicit ID for section #{title}, as in h5(#my-id)"
+      end
+      idx
+    end
+  end
+end

data/guides/rails_guides/kindle.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+
+unless `which kindlerb` 
+  abort "Please gem install kindlerb"
+end
+
+require 'nokogiri'
+require 'fileutils'
+require 'yaml'
+require 'date'
+
+module Kindle
+  extend self
+
+  def generate(output_dir, mobi_outfile, logfile)
+    output_dir = File.absolute_path(output_dir)
+    Dir.chdir output_dir do 
+      puts "=> Using output dir: #{output_dir}"
+      puts "=> Arranging html pages in document order"
+      toc = File.read("toc.ncx")
+      doc = Nokogiri::XML(toc).xpath("//ncx:content", 'ncx' => "http://www.daisy.org/z3986/2005/ncx/")
+      html_pages = doc.select {|c| c[:src]}.map {|c| c[:src]}.uniq
+     
+      generate_front_matter(html_pages)
+
+      generate_sections(html_pages)
+
+      generate_document_metadata(mobi_outfile)
+
+      puts "Creating MOBI document with kindlegen. This make take a while."
+      cmd = "kindlerb . > #{File.absolute_path logfile} 2>&1"
+      puts cmd
+      system(cmd)
+      puts "MOBI document generated at #{File.expand_path(mobi_outfile, output_dir)}"
+    end
+  end
+
+  def generate_front_matter(html_pages)
+    frontmatter = []
+    html_pages.delete_if {|x| 
+      if x =~ /(toc|welcome|credits|copyright).html/
+        frontmatter << x unless x =~ /toc/
+        true
+      end
+    }
+    html = frontmatter.map {|x|
+      Nokogiri::HTML(File.open(x)).at("body").inner_html
+    }.join("\n")
+
+    fdoc = Nokogiri::HTML(html)
+    fdoc.search("h3").each do |h3|
+      h3.name = 'h4'
+    end
+    fdoc.search("h2").each do |h2| 
+      h2.name = 'h3'
+      h2['id'] = h2.inner_text.gsub(/\s/, '-')
+    end
+    add_head_section fdoc, "Front Matter"
+    File.open("frontmatter.html",'w') {|f| f.puts fdoc.to_html}
+    html_pages.unshift "frontmatter.html"
+  end
+
+  def generate_sections(html_pages)
+    FileUtils::rm_rf("sections/")
+    html_pages.each_with_index do |page, section_idx|
+      FileUtils::mkdir_p("sections/%03d" % section_idx)
+      doc = Nokogiri::HTML(File.open(page))
+      title = doc.at("title").inner_text.gsub("Ruby on Rails Guides: ", '')
+      title = page.capitalize.gsub('.html', '') if title.strip == ''
+      File.open("sections/%03d/_section.txt" % section_idx, 'w') {|f| f.puts title}
+      doc.xpath("//h3[@id]").each_with_index do |h3,item_idx|
+        subsection = h3.inner_text
+        content = h3.xpath("./following-sibling::*").take_while {|x| x.name != "h3"}.map {|x| x.to_html}
+        item = Nokogiri::HTML(h3.to_html + content.join("\n"))
+        item_path = "sections/%03d/%03d.html" % [section_idx, item_idx] 
+        add_head_section(item, subsection)
+        item.search("img").each do |img|
+          img['src'] = "#{Dir.pwd}/#{img['src']}"
+        end
+        item.xpath("//li/p").each {|p| p.swap(p.children); p.remove}
+        File.open(item_path, 'w') {|f| f.puts item.to_html}
+      end
+    end
+  end
+
+  def generate_document_metadata(mobi_outfile)
+    puts "=> Generating _document.yml"
+    x = Nokogiri::XML(File.open("rails_guides.opf")).remove_namespaces!
+    cover_jpg = "#{Dir.pwd}/images/rails_guides_kindle_cover.jpg"
+    cover_gif = cover_jpg.sub(/jpg$/, 'gif')
+    puts `convert #{cover_jpg} #{cover_gif}`
+    document = {
+      'doc_uuid' => x.at("package")['unique-identifier'],
+      'title' => x.at("title").inner_text.gsub(/\(.*$/, " v2"),
+      'publisher' => x.at("publisher").inner_text,
+      'author' => x.at("creator").inner_text,
+      'subject' => x.at("subject").inner_text,
+      'date' => x.at("date").inner_text,
+      'cover' => cover_gif,
+      'masthead' => nil,
+      'mobi_outfile' => mobi_outfile
+    }
+    puts document.to_yaml
+    File.open("_document.yml", 'w'){|f| f.puts document.to_yaml}
+  end
+
+  def add_head_section(doc, title)
+    head = Nokogiri::XML::Node.new "head", doc
+    title_node = Nokogiri::XML::Node.new "title", doc
+    title_node.content = title
+    title_node.parent = head
+    css = Nokogiri::XML::Node.new "link", doc
+    css['rel'] = 'stylesheet'
+    css['type'] = 'text/css'
+    css['href'] = "#{Dir.pwd}/stylesheets/kindle.css"
+    css.parent = head
+    doc.at("body").before head
+  end
+end

data/guides/rails_guides/levenshtein.rb

@@ -0,0 +1,37 @@
+module RailsGuides
+  module Levenshtein
+    # This code is based directly on the Text gem implementation
+    # Returns a value representing the "cost" of transforming str1 into str2
+    def self.distance str1, str2
+      s = str1
+      t = str2
+      n = s.length
+      m = t.length
+
+      return m if (0 == n)
+      return n if (0 == m)
+
+      d = (0..m).to_a
+      x = nil
+
+      str1.each_char.each_with_index do |char1,i|
+        e = i+1
+
+        str2.each_char.each_with_index do |char2,j|
+          cost = (char1 == char2) ? 0 : 1
+          x = [
+               d[j+1] + 1, # insertion
+               e + 1,      # deletion
+               d[j] + cost # substitution
+              ].min
+          d[j] = e
+          e = x
+        end
+
+        d[m] = x
+      end
+
+      return x
+    end
+  end
+end

data/guides/rails_guides/markdown.rb

@@ -0,0 +1,167 @@
+# encoding: utf-8
+
+require 'redcarpet'
+require 'nokogiri'
+require 'rails_guides/markdown/renderer'
+
+module RailsGuides
+  class Markdown
+    def initialize(view, layout)
+      @view = view
+      @layout = layout
+      @index_counter = Hash.new(0)
+      @raw_header = ''
+      @node_ids = {}
+    end
+
+    def render(body)
+      @raw_body = body
+      extract_raw_header_and_body
+      generate_header
+      generate_title
+      generate_body
+      generate_structure
+      generate_index
+      render_page
+    end
+
+    private
+
+      def dom_id(nodes)
+        dom_id = dom_id_text(nodes.last.text)
+
+        # Fix duplicate node by prefix with its parent node
+        if @node_ids[dom_id]
+          if @node_ids[dom_id].size > 1
+            duplicate_nodes = @node_ids.delete(dom_id)
+            new_node_id = "#{duplicate_nodes[-2][:id]}-#{duplicate_nodes.last[:id]}"
+            duplicate_nodes.last[:id] = new_node_id
+            @node_ids[new_node_id] = duplicate_nodes
+          end
+
+          dom_id = "#{nodes[-2][:id]}-#{dom_id}"
+        end
+
+        @node_ids[dom_id] = nodes
+        dom_id
+      end
+
+      def dom_id_text(text)
+        escaped_chars = Regexp.escape('\\/`*_{}[]()#+-.!:,;|&<>^~=\'"')
+
+        text.downcase.gsub(/\?/, '-questionmark')
+                     .gsub(/!/, '-bang')
+                     .gsub(/[#{escaped_chars}]+/, ' ').strip
+                     .gsub(/\s+/, '-')
+      end
+
+      def engine
+        @engine ||= Redcarpet::Markdown.new(Renderer, {
+          no_intra_emphasis: true,
+          fenced_code_blocks: true,
+          autolink: true,
+          strikethrough: true,
+          superscript: true,
+          tables: true
+        })
+      end
+
+      def extract_raw_header_and_body
+        if @raw_body =~ /^\-{40,}$/
+          @raw_header, _, @raw_body = @raw_body.partition(/^\-{40,}$/).map(&:strip)
+        end
+      end
+
+      def generate_body
+        @body = engine.render(@raw_body)
+      end
+
+      def generate_header
+        @header = engine.render(@raw_header).html_safe
+      end
+
+      def generate_structure
+        @headings_for_index = []
+        if @body.present?
+          @body = Nokogiri::HTML.fragment(@body).tap do |doc|
+            hierarchy = []
+
+            doc.children.each do |node|
+              if node.name =~ /^h[3-6]$/
+                case node.name
+                when 'h3'
+                  hierarchy = [node]
+                  @headings_for_index << [1, node, node.inner_html]
+                when 'h4'
+                  hierarchy = hierarchy[0, 1] + [node]
+                  @headings_for_index << [2, node, node.inner_html]
+                when 'h5'
+                  hierarchy = hierarchy[0, 2] + [node]
+                when 'h6'
+                  hierarchy = hierarchy[0, 3] + [node]
+                end
+
+                node[:id] = dom_id(hierarchy)
+                node.inner_html = "#{node_index(hierarchy)} #{node.inner_html}"
+              end
+            end
+          end.to_html
+        end
+      end
+
+      def generate_index
+        if @headings_for_index.present?
+          raw_index = ''
+          @headings_for_index.each do |level, node, label|
+            if level == 1
+              raw_index += "1. [#{label}](##{node[:id]})\n"
+            elsif level == 2
+              raw_index += "    * [#{label}](##{node[:id]})\n"
+            end
+          end
+
+          @index = Nokogiri::HTML.fragment(engine.render(raw_index)).tap do |doc|
+            doc.at('ol')[:class] = 'chapters'
+          end.to_html
+
+          @index = <<-INDEX.html_safe
+          <div id="subCol">
+            <h3 class="chapter"><img src="images/chapters_icon.gif" alt="" />Chapters</h3>
+            #{@index}
+          </div>
+          INDEX
+        end
+      end
+
+      def generate_title
+        if heading = Nokogiri::HTML.fragment(@header).at(:h2)
+          @title = "#{heading.text} — Ruby on Rails Guides"
+        else
+          @title = "Ruby on Rails Guides"
+        end
+      end
+
+      def node_index(hierarchy)
+        case hierarchy.size
+        when 1
+          @index_counter[2] = @index_counter[3] = @index_counter[4] = 0
+          "#{@index_counter[1] += 1}"
+        when 2
+          @index_counter[3] = @index_counter[4] = 0
+          "#{@index_counter[1]}.#{@index_counter[2] += 1}"
+        when 3
+          @index_counter[4] = 0
+          "#{@index_counter[1]}.#{@index_counter[2]}.#{@index_counter[3] += 1}"
+        when 4
+          "#{@index_counter[1]}.#{@index_counter[2]}.#{@index_counter[3]}.#{@index_counter[4] += 1}"
+        end
+      end
+
+      def render_page
+        @view.content_for(:header_section) { @header }
+        @view.content_for(:page_title) { @title }
+        @view.content_for(:index_section) { @index }
+        @view.render(:layout => @layout, :text => @body)
+      end
+  end
+end

data/guides/rails_guides/markdown/renderer.rb

@@ -0,0 +1,82 @@
+module RailsGuides
+  class Markdown
+    class Renderer < Redcarpet::Render::HTML
+      def initialize(options={})
+        super
+      end
+
+      def block_code(code, language)
+        <<-HTML
+<div class="code_container">
+<pre class="brush: #{brush_for(language)}; gutter: false; toolbar: false">
+#{ERB::Util.h(code)}
+</pre>
+</div>
+HTML
+      end
+
+      def header(text, header_level)
+        # Always increase the heading level by, so we can use h1, h2 heading in the document
+        header_level += 1
+
+        %(<h#{header_level}>#{text}</h#{header_level}>)
+      end
+
+      def paragraph(text)
+        if text =~ /^(TIP|IMPORTANT|CAUTION|WARNING|NOTE|INFO|TODO)[.:](.*?)/
+          convert_notes(text)
+        elsif text =~ /^\[<sup>(\d+)\]:<\/sup> (.+)$/
+          linkback = %(<a href="#footnote-#{$1}-ref"><sup>#{$1}</sup></a>)
+          %(<p class="footnote" id="footnote-#{$1}">#{linkback} #{$2}</p>)
+        else
+          text = convert_footnotes(text)
+          "<p>#{text}</p>"
+        end
+      end
+
+      private
+
+        def convert_footnotes(text)
+          text.gsub(/\[<sup>(\d+)\]<\/sup>/i) do
+            %(<sup class="footnote" id="footnote-#{$1}-ref">) +
+              %(<a href="#footnote-#{$1}">#{$1}</a></sup>)
+          end
+        end
+
+        def brush_for(code_type)
+          case code_type
+            when 'ruby', 'sql', 'plain'
+              code_type
+            when 'erb'
+              'ruby; html-script: true'
+            when 'html'
+              'xml' # HTML is understood, but there are .xml rules in the CSS
+            else
+              'plain'
+          end
+        end
+
+        def convert_notes(body)
+          # The following regexp detects special labels followed by a
+          # paragraph, perhaps at the end of the document.
+          #
+          # It is important that we do not eat more than one newline
+          # because formatting may be wrong otherwise. For example,
+          # if a bulleted list follows the first item is not rendered
+          # as a list item, but as a paragraph starting with a plain
+          # asterisk.
+          body.gsub(/^(TIP|IMPORTANT|CAUTION|WARNING|NOTE|INFO|TODO)[.:](.*?)(\n(?=\n)|\Z)/m) do
+            css_class = case $1
+                        when 'CAUTION', 'IMPORTANT'
+                          'warning'
+                        when 'TIP'
+                          'info'
+                        else
+                          $1.downcase
+                        end
+            %(<div class="#{css_class}"><p>#{$2.strip}</p></div>)
+          end
+        end
+    end
+  end
+end