rails 4.2.11.3 → 5.0.7.2

data/guides/rails_guides/helpers.rb

@@ -1,53 +0,0 @@
-require 'yaml'
-
-module RailsGuides
-  module Helpers
-    def guide(name, url, options = {}, &block)
-      link = content_tag(:a, :href => url) { name }
-      result = content_tag(:dt, link)
-
-      if options[:work_in_progress]
-        result << content_tag(:dd, 'Work in progress', :class => 'work-in-progress')
-      end
-
-      result << content_tag(:dd, capture(&block))
-      result
-    end
-
-    def documents_by_section
-      @documents_by_section ||= YAML.load_file(File.expand_path('../../source/documents.yaml', __FILE__))
-    end
-
-    def documents_flat
-      documents_by_section.flat_map {|section| section['documents']}
-    end
-
-    def finished_documents(documents)
-      documents.reject { |document| document['work_in_progress'] }
-    end
-
-    def docs_for_menu(position=nil)
-      if position.nil?
-        documents_by_section
-      elsif position == 'L'
-        documents_by_section.to(3)
-      else
-        documents_by_section.from(4)
-      end
-    end
-
-    def author(name, nick, image = 'credits_pic_blank.gif', &block)
-      image = "images/#{image}"
-
-      result = tag(:img, :src => image, :class => 'left pic', :alt => name, :width => 91, :height => 91)
-      result << content_tag(:h3, name)
-      result << content_tag(:p, capture(&block))
-      content_tag(:div, result, :class => 'clearfix', :id => nick)
-    end
-
-    def code(&block)
-      c = capture(&block)
-      content_tag(:code, c)
-    end
-  end
-end

data/guides/rails_guides/indexer.rb

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

@@ -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.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