docs/manual/Rakefile - predictionio - Git at Google

 #
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
 # this work for additional information regarding copyright ownership.
 # The ASF licenses this file to You under the Apache License, Version 2.0
 # (the "License"); you may not use this file except in compliance with
 # the License.  You may obtain a copy of the License at
 #
 #    http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #

 require 'middleman'
 require 'nokogiri'
 require 'rainbow/ext/string'
 require 'uri'
 require 'net/http'
 require 'redcarpet'
 require File.join(File.dirname(__FILE__), 'lib', 'custom_renderer')


 task :test do

 HTML = <<EOT
 <div class="tabs">
   <div data-tab="PHP" data-lang="php">
 ```
 Test 0 <>
 Test 1 >
 Test 3 <
 Test 4 ><
 Test 5 =>
 Test 6 <=
 Test 7 <>
 <p><b>Test 8</b></p>
 ```
   </div>
 </div>
 EOT

 HTML2 = <<EOT
 <div class="tabs">
   <div data-tab="Ruby" data-lang="ruby">
 ```ruby
 Test 0 <>
 Test 1 >
 Test 3 <
 Test 4 ><
 Test 5 =>
 Test 6 <=
 Test 7 <>
 <p><b>Test</b></p>

 # This is a ruby file.
 class MyClass
   def foo
     'bar'
   end
 end
 ```
   </div>
   <div data-tab="Plain">
 This is a test of **markdown** inside a tab!

 ```
 // This tab does not have the data-lang attribute set!
 $ cd path/to/your/file
 ```
   </div>
   <div data-tab="HTML" data-lang="html">
 ```html
 <p>Yes you can still use HTML in code blocks!</p>
 ```
   </div>
 </div>
 EOT

   def block_html(raw_html)
     done = raw_html.gsub(/(```.*?```)/m) do |match|
       markdown = Redcarpet::Markdown.new(CustomRenderer, fenced_code_blocks: true)
       markdown.render(match)
     end

     doc = Nokogiri::HTML::DocumentFragment.parse(done)
     nodes = doc.css('div.tabs > div')

     if nodes.empty?
       raw_html
     else
       ul = Nokogiri::XML::Node.new('ul', doc)
       ul['class'] = 'control'

       nodes.each do |node|
         title = node.attribute('data-tab').to_s
         lang = node.attribute('data-lang').to_s

         uuid = SecureRandom.uuid
         id = "tab-#{uuid}"

         li = Nokogiri::XML::Node.new('li', doc)
         li['data-lang'] = lang
         li.inner_html = %Q(<a href="##{id}">#{title}</a>)

         ul.add_child(li)

         node['id'] = id
       end

       nodes.first.before(ul)

       doc.to_html
     end
   end


   puts 'start block'
   puts block_html(HTML2)
   puts 'end block'
 end


 desc 'Check site for broken links'
 task :check do

   sets = []
   cache = Sanity::Cache.new

   Dir["build/**/*.html"].each do |filename|
     p = Sanity::Page.new(filename, cache)

     sets << p.check_links
   end

   html = Sanity::Report::HTML.new(sets.map{ |s| s.to_html })
   File.open('sanity.html', 'w') { |file| file.write(html) }
 end


 module Sanity
   module Report

     class HTML
       include Padrino::Helpers

       HEADER = <<EOT
 <!DOCTYPE html>
 <html lang="en">
   <head>
     <title>Sanity Report</title>
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <link href="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap.min.css" rel="stylesheet">

   </head>
   <body>
     <div class="jumbotron">
       <div class="container-fluid">
         <h1>Sanity Report</h1>
       </div>
     </div>
     <div class="container-fluid">

 EOT
       FOOTER = <<EOT
     </div>
   </body>
 </html>
 EOT


       def initialize(content)
         if content.respond_to?(:to_html)
           html = content.to_html
         else
           html = content
         end

         @content = content_tag(:div, html, id: 'content')
       end

       def to_html
         "#{HEADER}#{@content}#{FOOTER}"
       end

       def to_s
         to_html
       end
     end
   end

   class ResultSet
     include Padrino::Helpers
     attr_accessor :set
     def initialize(path, set = [])
       @path = path
       @set = set
     end

     def push(item)
       @set.push(item)
     end

     def to_html
       content_tag(:h2, @path) <<
       content_tag(:table, class: 'table table-striped') do
         content_tag(:thead) do
           content_tag(:tr) do
             content_tag(:th, 'Type') <<
             content_tag(:th, 'Status') <<
             content_tag(:th, 'URI') <<
             content_tag(:th, 'Message') <<
             content_tag(:th, 'Path')
           end
         end <<
         content_tag(:tbody) do
           @set.map do |item|
             item.to_html
           end
         end
       end
     end
   end

   class Result
     include Padrino::Helpers
     attr_accessor :type, :status, :path, :uri, :message, :cache, :backtrace

     def initialize
     end

     def exception=(e)
       @status = :exception
       @message = e.message
       @backtrace = e.backtrace
     end

     def to_s
       "#{@type} [#{@status}] #{@uri} #{@message} #{@path}".color(terminal_color)
     end

     def to_html
       content_tag(:tr, class: bootstrap_css_class) do
         content_tag(:td, @type) <<
         content_tag(:td, @status) <<
         content_tag(:td, @uri) <<
         content_tag(:td, @message) <<
         content_tag(:td, @path)
       end
     end


     private

     def bootstrap_css_class
       case @status
       when :success
         'success'
       when :info
         'info'
       when :warning
         'warning'
       when :error
         'danger'
       when :exception
         'danger'
       else
         raise ArgumentError, "Status `#{@status}` is not a valid type"
       end
     end

     def terminal_color
       case @status
       when :success
         :green
       when :info
        :blue
       when :warning
         :yellow
       when :error
         :red
       when :exception
         :red
       else
         raise ArgumentError, "Status `#{@status}` is not a valid type"
       end
     end
   end

   class Cache
     def initialize(store = {})
       @store = store
     end

     def read(uri)
       @store[uri]
     end

     def write(uri, value)
       @store[uri] = value
     end

     def fetch(uri)
       if block_given?
         if exists?(uri)
           read(uri)
         else
           write(uri, yield)
         end
       else
         read(uri)
       end
     end

     def exists?(uri)
       @store.has_key?(uri)
     end
   end

   class Page
     INDEX_FILE = 'index.html'

     def initialize(filename, cache = Sanity::Cache.new)
       @filename = filename
       @cache = cache
       f = File.open(@filename)
       @doc = Nokogiri::HTML(f)

       @build_path = File.join(Middleman::Application.root, 'build')
       f.close
     end

     def check_links
       rs = Sanity::ResultSet.new(@filename)
       @doc.css('a').each do |link|
         uri = link['href']
         r = check_href(uri)
         r.path = @filename
         puts r
         rs.push(r)
       end
       rs
     end

     def check_href(href)
       # TODO: add trailing slash, relative url, and in page anchor links.
       # TODO: Test for missing titles!
       # TODO: Test for unneeded .html extension!
       # TODO: Switch from Nokogir to raw ID checker
       case href
       when /\A\s*\z/, nil
         check_empty_href(href)
       when /\A(https?):\/\/.+\z/
         check_external_href(href)
       when /\A#.+\z/
         check_anchor_href(href)
       when /\A#\z/
         check_empty_anchor_href(href)
       when /\A\/\z/
         check_root_href(href)
       when /\Amailto:.+\z/
         check_mailto_href(href)
       else
         check_internal_href(href)
       end
     end

     def check_external_href(href)
       r = Sanity::Result.new
       r.uri = href
       r.type = :external_uri
       begin
         response = @cache.fetch(href) do
           r.cache = :miss
           uri = URI(href)
           Net::HTTP.get_response(uri)
         end

         case response
         when Net::HTTPSuccess
           r.status = :success
         when Net::HTTPNotFound
           r.status = :error
         when Net::HTTPRedirection
           location = response['location']
           r.status = :info
           r.message = "Redirect: #{location}"
         else
           r.status = :warning
           r.message = "Response: #{response.class}"
         end
       rescue => e
         r.exception = e
       end
       r
     end

     def check_anchor_href(href)
       r = Sanity::Result.new
       r.uri = href
       r.type = :anchor
       begin
         result = @doc.css(href)

         if result.count > 0
           r.status = :success
         else
           r.status = :error
         end

       rescue => e
         r.exception = e
       end
       r
     end

     def check_empty_anchor_href(href)

       r = Sanity::Result.new
       r.uri = href
       r.type = :empty_anchor
       r.status = :info
       r
     end

     def check_root_href(href)
       r = Sanity::Result.new
       r.uri = href
       r.type = :root_path

       filename = File.join(@build_path, INDEX_FILE)
       if File.exist?(filename)
         r.status = :success
       else
         r.status = :error
         r.message "Not found: #{filename}"
       end

       r
     end

     def check_mailto_href(href)
       r = Sanity::Result.new
       r.uri = href
       r.type = :mailto

       uri = URI.parse(href)
       if uri.is_a?(URI::MailTo)
         r.status = :success

       else
         r.status = :error
       end

       r
     end

     def check_empty_href(href)
       r = Sanity::Result.new
       r.uri = href
       r.type = :empty_uri
       r.status = :error
       r
     end

     def check_internal_href(href)

       r = Sanity::Result.new
       r.uri = href
       r.type = :internal_uri

       filename = File.join(@build_path, href.gsub('/', File::SEPARATOR))
       if File.directory?(filename)
         filename = File.join(filename, INDEX_FILE)
       end

       if File.exist?(filename)

         r.status = :success
       else

         r.status = :error
       end

       r
     end
   end
 end
	#
	# Licensed to the Apache Software Foundation (ASF) under one or more
	# contributor license agreements. See the NOTICE file distributed with
	# this work for additional information regarding copyright ownership.
	# The ASF licenses this file to You under the Apache License, Version 2.0
	# (the "License"); you may not use this file except in compliance with
	# the License. You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	#

	require 'middleman'
	require 'nokogiri'
	require 'rainbow/ext/string'
	require 'uri'
	require 'net/http'
	require 'redcarpet'
	require File.join(File.dirname(__FILE__), 'lib', 'custom_renderer')


	task :test do

	HTML = <<EOT
	<div class="tabs">
	<div data-tab="PHP" data-lang="php">
	```
	Test 0 <>
	Test 1 >
	Test 3 <
	Test 4 ><
	Test 5 =>
	Test 6 <=
	Test 7 <>
	<p><b>Test 8</b></p>
	```
	</div>
	</div>
	EOT

	HTML2 = <<EOT
	<div class="tabs">
	<div data-tab="Ruby" data-lang="ruby">
	```ruby
	Test 0 <>
	Test 1 >
	Test 3 <
	Test 4 ><
	Test 5 =>
	Test 6 <=
	Test 7 <>
	<p><b>Test</b></p>

	# This is a ruby file.
	class MyClass
	def foo
	'bar'
	end
	end
	```
	</div>
	<div data-tab="Plain">
	This is a test of markdown inside a tab!

	```
	// This tab does not have the data-lang attribute set!
	$ cd path/to/your/file
	```
	</div>
	<div data-tab="HTML" data-lang="html">
	```html
	<p>Yes you can still use HTML in code blocks!</p>
	```
	</div>
	</div>
	EOT

	def block_html(raw_html)
	done = raw_html.gsub(/(```.*?```)/m) do \|match\|
	markdown = Redcarpet::Markdown.new(CustomRenderer, fenced_code_blocks: true)
	markdown.render(match)
	end

	doc = Nokogiri::HTML::DocumentFragment.parse(done)
	nodes = doc.css('div.tabs > div')

	if nodes.empty?
	raw_html
	else
	ul = Nokogiri::XML::Node.new('ul', doc)
	ul['class'] = 'control'

	nodes.each do \|node\|
	title = node.attribute('data-tab').to_s
	lang = node.attribute('data-lang').to_s

	uuid = SecureRandom.uuid
	id = "tab-#{uuid}"

	li = Nokogiri::XML::Node.new('li', doc)
	li['data-lang'] = lang
	li.inner_html = %Q(<a href="##{id}">#{title}</a>)

	ul.add_child(li)

	node['id'] = id
	end

	nodes.first.before(ul)

	doc.to_html
	end
	end


	puts 'start block'
	puts block_html(HTML2)
	puts 'end block'
	end


	desc 'Check site for broken links'
	task :check do

	sets = []
	cache = Sanity::Cache.new

	Dir["build/*/.html"].each do \|filename\|
	p = Sanity::Page.new(filename, cache)

	sets << p.check_links
	end

	html = Sanity::Report::HTML.new(sets.map{ \|s\| s.to_html })
	File.open('sanity.html', 'w') { \|file\| file.write(html) }
	end


	module Sanity
	module Report

	class HTML
	include Padrino::Helpers

	HEADER = <<EOT
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<title>Sanity Report</title>
	<meta name="viewport" content="width=device-width, initial-scale=1">
	<link href="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap.min.css" rel="stylesheet">

	</head>
	<body>
	<div class="jumbotron">
	<div class="container-fluid">
	<h1>Sanity Report</h1>
	</div>
	</div>
	<div class="container-fluid">

	EOT
	FOOTER = <<EOT
	</div>
	</body>
	</html>
	EOT




	def initialize(content)
	if content.respond_to?(:to_html)
	html = content.to_html
	else
	html = content
	end

	@content = content_tag(:div, html, id: 'content')
	end

	def to_html
	"#{HEADER}#{@content}#{FOOTER}"
	end

	def to_s
	to_html
	end
	end
	end

	class ResultSet
	include Padrino::Helpers
	attr_accessor :set
	def initialize(path, set = [])
	@path = path
	@set = set
	end

	def push(item)
	@set.push(item)
	end

	def to_html
	content_tag(:h2, @path) <<
	content_tag(:table, class: 'table table-striped') do
	content_tag(:thead) do
	content_tag(:tr) do
	content_tag(:th, 'Type') <<
	content_tag(:th, 'Status') <<
	content_tag(:th, 'URI') <<
	content_tag(:th, 'Message') <<
	content_tag(:th, 'Path')
	end
	end <<
	content_tag(:tbody) do
	@set.map do \|item\|
	item.to_html
	end
	end
	end
	end
	end

	class Result
	include Padrino::Helpers
	attr_accessor :type, :status, :path, :uri, :message, :cache, :backtrace

	def initialize
	end

	def exception=(e)
	@status = :exception
	@message = e.message
	@backtrace = e.backtrace
	end

	def to_s
	"#{@type} [#{@status}] #{@uri} #{@message} #{@path}".color(terminal_color)
	end

	def to_html
	content_tag(:tr, class: bootstrap_css_class) do
	content_tag(:td, @type) <<
	content_tag(:td, @status) <<
	content_tag(:td, @uri) <<
	content_tag(:td, @message) <<
	content_tag(:td, @path)
	end
	end



	private

	def bootstrap_css_class
	case @status
	when :success
	'success'
	when :info
	'info'
	when :warning
	'warning'
	when :error
	'danger'
	when :exception
	'danger'
	else
	raise ArgumentError, "Status `#{@status}` is not a valid type"
	end
	end

	def terminal_color
	case @status
	when :success
	:green
	when :info
	:blue
	when :warning
	:yellow
	when :error
	:red
	when :exception
	:red
	else
	raise ArgumentError, "Status `#{@status}` is not a valid type"
	end
	end
	end

	class Cache
	def initialize(store = {})
	@store = store
	end

	def read(uri)
	@store[uri]
	end

	def write(uri, value)
	@store[uri] = value
	end

	def fetch(uri)
	if block_given?
	if exists?(uri)
	read(uri)
	else
	write(uri, yield)
	end
	else
	read(uri)
	end
	end

	def exists?(uri)
	@store.has_key?(uri)
	end
	end

	class Page
	INDEX_FILE = 'index.html'

	def initialize(filename, cache = Sanity::Cache.new)
	@filename = filename
	@cache = cache
	f = File.open(@filename)
	@doc = Nokogiri::HTML(f)

	@build_path = File.join(Middleman::Application.root, 'build')
	f.close
	end

	def check_links
	rs = Sanity::ResultSet.new(@filename)
	@doc.css('a').each do \|link\|
	uri = link['href']
	r = check_href(uri)
	r.path = @filename
	puts r
	rs.push(r)
	end
	rs
	end

	def check_href(href)
	# TODO: add trailing slash, relative url, and in page anchor links.
	# TODO: Test for missing titles!
	# TODO: Test for unneeded .html extension!
	# TODO: Switch from Nokogir to raw ID checker
	case href
	when /\A\s*\z/, nil
	check_empty_href(href)
	when /\A(https?):\/\/.+\z/
	check_external_href(href)
	when /\A#.+\z/
	check_anchor_href(href)
	when /\A#\z/
	check_empty_anchor_href(href)
	when /\A\/\z/
	check_root_href(href)
	when /\Amailto:.+\z/
	check_mailto_href(href)
	else
	check_internal_href(href)
	end
	end

	def check_external_href(href)
	r = Sanity::Result.new
	r.uri = href
	r.type = :external_uri
	begin
	response = @cache.fetch(href) do
	r.cache = :miss
	uri = URI(href)
	Net::HTTP.get_response(uri)
	end

	case response
	when Net::HTTPSuccess
	r.status = :success
	when Net::HTTPNotFound
	r.status = :error
	when Net::HTTPRedirection
	location = response['location']
	r.status = :info
	r.message = "Redirect: #{location}"
	else
	r.status = :warning
	r.message = "Response: #{response.class}"
	end
	rescue => e
	r.exception = e
	end
	r
	end

	def check_anchor_href(href)
	r = Sanity::Result.new
	r.uri = href
	r.type = :anchor
	begin
	result = @doc.css(href)

	if result.count > 0
	r.status = :success
	else
	r.status = :error
	end

	rescue => e
	r.exception = e
	end
	r
	end

	def check_empty_anchor_href(href)

	r = Sanity::Result.new
	r.uri = href
	r.type = :empty_anchor
	r.status = :info
	r
	end

	def check_root_href(href)
	r = Sanity::Result.new
	r.uri = href
	r.type = :root_path

	filename = File.join(@build_path, INDEX_FILE)
	if File.exist?(filename)
	r.status = :success
	else
	r.status = :error
	r.message "Not found: #{filename}"
	end

	r
	end

	def check_mailto_href(href)
	r = Sanity::Result.new
	r.uri = href
	r.type = :mailto

	uri = URI.parse(href)
	if uri.is_a?(URI::MailTo)
	r.status = :success

	else
	r.status = :error
	end

	r
	end

	def check_empty_href(href)
	r = Sanity::Result.new
	r.uri = href
	r.type = :empty_uri
	r.status = :error
	r
	end

	def check_internal_href(href)

	r = Sanity::Result.new
	r.uri = href
	r.type = :internal_uri

	filename = File.join(@build_path, href.gsub('/', File::SEPARATOR))
	if File.directory?(filename)
	filename = File.join(filename, INDEX_FILE)
	end

	if File.exist?(filename)

	r.status = :success
	else

	r.status = :error
	end

	r
	end
	end
	end