rails 4.2.11.3 → 5.2.2

data/guides/rails_guides/kindle.rb

@@ -1,119 +0,0 @@
-#!/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

@@ -1,37 +0,0 @@
-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/renderer.rb

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

data/guides/rails_guides/markdown.rb

@@ -1,167 +0,0 @@
-# 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.rb

@@ -1,63 +0,0 @@
-pwd = File.dirname(__FILE__)
-$:.unshift pwd
-
-# This is a predicate useful for the doc:guides task of applications.
-def bundler?
-  # Note that rake sets the cwd to the one that contains the Rakefile
-  # being executed.
-  File.exist?('Gemfile')
-end
-
-begin
-  # Guides generation in the Rails repo.
-  as_lib = File.join(pwd, "../activesupport/lib")
-  ap_lib = File.join(pwd, "../actionpack/lib")
-
-  $:.unshift as_lib if File.directory?(as_lib)
-  $:.unshift ap_lib if File.directory?(ap_lib)
-rescue LoadError
-  # Guides generation from gems.
-  gem "actionpack", '>= 3.0'
-end
-
-begin
-  require 'redcarpet'
-rescue LoadError
-  # This can happen if doc:guides is executed in an application.
-  $stderr.puts('Generating guides requires Redcarpet 3.1.2+.')
-  $stderr.puts(<<ERROR) if bundler?
-Please add
-
-  gem 'redcarpet', '~> 3.1.2'
-
-to the Gemfile, run
-
-  bundle install
-
-and try again.
-ERROR
-  exit 1
-end
-
-begin
-  require 'nokogiri'
-rescue LoadError
-  # This can happen if doc:guides is executed in an application.
-  $stderr.puts('Generating guides requires Nokogiri.')
-  $stderr.puts(<<ERROR) if bundler?
-Please add
-
-  gem 'nokogiri'
-
-to the Gemfile, run
-
-  bundle install
-
-and try again.
-ERROR
-  exit 1
-end
-
-require 'rails_guides/markdown'
-require "rails_guides/generator"
-RailsGuides::Generator.new.generate