origen 0.0.1 → 0.0.2

data/templates/nanoc/lib/bootstrap_filter.rb

@@ -0,0 +1,49 @@
+require 'nokogiri'
+#require "byebug"
+
+class BootstrapFilter < Nanoc::Filter
+  identifier :bootstrap
+
+  def run(content, params={})
+    doc = Nokogiri::HTML.fragment(content)
+
+    # Add table class to all tables so that they are formatted by bootstrap
+    doc.search('table').tap{ |ns| ns.add_class('table') }.each do |n|
+      n.text
+    end
+
+    # Add an anchor to all headers
+    if item[:header_anchors].nil? || item[:header_anchors]
+      tags = "h1, h2, h3, h4"
+      first_done = false
+      doc.css(tags).each do |header|
+        # Skip the first header in the doc, looks better and no advantage to having an anchor on it
+        if first_done
+          # Don't add an anchor link to headers that already contain a link
+          unless header.at_css("a")
+            tag = header.name
+            cls = header.attr("class")
+            unless cls && cls =~ /(topic-title|topic-subtitle|no-anchor)/
+              header.replace anchor(tag, header.text)
+            end
+          end
+        end
+        first_done = true
+      end
+    end
+
+    doc.to_html
+  end
+
+  def anchor(tag, msg)
+    id = msg.gsub(" ", "_")
+    html = <<-END
+<div>    
+  <a class="anchor" name="#{id}"></a>          
+  <#{tag}><a href="##{id}">#{msg}</a></#{tag}>          
+</div>    
+    END
+    # Need to pass back a node, couldn't work out better syntax to do this
+    Nokogiri::HTML(html).css("div")
+  end
+end

data/templates/nanoc/lib/codeblocks_filter.rb

@@ -0,0 +1,41 @@
+require 'nokogiri'
+require "coderay"
+
+module CodeRay
+  class << self
+    alias :orig_scan :scan
+    # Override the coderay scan method to remove escaped underscores prior
+    # to passing over
+    def scan(*args)
+      args.first.gsub!("\\_", "_")
+      orig_scan(*args)
+    end
+  end
+end
+
+class CodeblocksFilter < Nanoc::Filter
+  identifier :codeblocks
+
+  def run(content, params={})
+    doc = Nokogiri::HTML.fragment(content)
+    # Remove any escaped underscores from code blocks that are not marked
+    # up by coderay
+    doc.search('code').each do |n|
+      n.content = n.content.gsub("\\_", "_")
+    end
+    # Same for coderay markup, not sure if this will apply always,
+    # but seems to deal with highlighted Ruby
+    # Keeping for future reference, but now replaced by remove underscores
+    # prior to passing to coderay above
+    #doc.search('.CodeRay .code').each do |n|
+    #  n.xpath("//text()[. = '\\_']").each do |n|
+    #    n.content = n.content.gsub("\\_", "_")
+    #  end
+    #  n.xpath("//text()[. = '\\']").each do |n|
+    #    n.content = n.content.gsub("\\", "")
+    #  end
+    #end
+    doc.to_html
+  end
+
+end

data/templates/nanoc/lib/default.rb

@@ -0,0 +1,2 @@
+# All files in the 'lib' directory will be loaded
+# before nanoc starts compiling.

data/templates/nanoc/lib/gzip_filter.rb

@@ -0,0 +1,16 @@
+require "zlib"
+
+class GzipFilter < Nanoc::Filter
+  identifier :gzip
+
+  type text: :binary
+
+  def run(content, params = {})
+    Zlib::GzipWriter.open(output_filename, Zlib::BEST_COMPRESSION) do |gz|
+      gz.orig_name = "index.html"
+      gz.mtime = File.mtime(item[:filename]).to_i
+      gz.write content
+    end
+  end
+
+end

data/templates/nanoc/lib/haml_code_filter.rb

@@ -0,0 +1,41 @@
+# Disabled this for now, don't think anyone uses it.
+# Problem is that the HAML gem seems to have changed in the upgrade to
+# Ruby v2.1.0 and the below will need to be updated accordingly.
+#
+#require "haml"
+#
+## This adds a :code filter to allow code snippets to be embedded in HAML
+## docs which are then highlighted by Coderay. Ruby is the default language, select
+## another by including #!language in the code snippet.
+##
+## :code
+##   def say(msg)
+##     puts "#{msg}"
+##   end
+#module Haml::Filters::Code
+#
+#  include Haml::Filters::Base
+#  lazy_require "coderay"
+#
+#  def render(content, options={})
+#    ::CodeRay.scan(*prepare(content)).send(:div, {})
+#  end
+#
+#  # Prepares the text for passing to `::CodeRay.scan`.
+#  #
+#  # @param [String] text
+#  # @return [Array<String, Symbol>] code and language
+#  def prepare(text)
+#    if text =~ /#!(\S+)/
+#      [ text.sub(/\A\s*#!(\S+)\s*\n+/, ""), $1.downcase.to_sym ]
+#    else
+#      [ text, :ruby ]
+#    end
+#  end
+#
+#  def compile(precompiler, text)
+#    text = Haml::Helpers::find_and_preserve(render(text).rstrip, precompiler.options[:preserve])
+#    precompiler.send(:push_text, text)
+#  end
+#
+#end

data/templates/nanoc/lib/helpers.rb

@@ -0,0 +1 @@
+include Nanoc::Helpers::Rendering

data/templates/nanoc/lib/search_filter.rb

@@ -0,0 +1,62 @@
+# Modified from: https://github.com/severinh/nanoc-lunr-js-search/blob/master/lib/nanoc/filters/lunr_js_search.rb
+require 'json'
+require 'nokogiri'
+
+class SearchFilter < Nanoc::Filter
+  identifier :search
+
+  def run(content, params={})
+    doc = Nokogiri::HTML(content)
+    url = assigns[:item_rep].path
+    #first_image = doc.xpath('//img/@src').to_a[0]
+    document = {
+      title: extract_first(doc, '//article//*[self::h1 or self::h2]/text()'),
+      subtitle: extract_first(doc, '//article//*[self::h3]/text()'),
+      body: extract_all(doc, '//article//*/text()'),
+      #img: (first_image.nil?) ? '' : first_image.value(),
+      #alt: extract_values(doc, '//article//img/@alt')
+    }
+
+    if File.exist?(search_file)
+      documents = JSON.parse(File.read(search_file))
+    else
+      documents = {}
+    end
+
+    documents[url] = document
+
+    File.open(search_file, 'w') do |file|
+      file.write(JSON.pretty_generate(documents))
+    end
+
+    content
+  end
+
+  def search_file
+    @search_file ||= File.join(@site.config[:output_dir],
+      @site.config[:search_file] || 'search.json')
+  end
+
+  def extract_first(doc, path)
+    extract_text(doc, path).first
+  end
+
+  def extract_all(doc, path)
+    extract_text(doc, path).join(' ')
+  end
+
+  def extract_text(doc, path)
+    doc.xpath(path).to_a.map { |t|
+      t.content.gsub('\r', ' ').gsub('\n', ' ').squeeze(' ').strip
+    }.reject { |t|
+      t.empty?
+    }
+  end
+
+  def extract_values(doc, path)
+    tokens = doc.xpath(path).to_a.map { |t|
+      t.value().gsub('\r', ' ').gsub('\n', ' ').squeeze(' ').strip
+    }
+    tokens.join(' ')
+  end
+end

data/templates/nanoc_dynamic/content/search.js.erb

@@ -0,0 +1,92 @@
+$.getJSON("<%= path 'search.json' %>", function(json) {
+  window.index = lunr(function() {
+    this.field("title", {boost: 10});
+    this.field("subtitle", {boost: 5});
+    this.field("body");
+    this.ref("id");
+  });
+  window.articles = json;
+  $.each(json, function(id, content) {
+    window.index.add({
+      id: id,
+      title: content.title,
+      subtitle: content.subtitle,
+      body: content.body
+    });
+  });
+});
+
+$(function() {
+  $("#search button").click(function() {
+    search(true);
+  });
+  $("#search input").keypress(function(e) {
+    if(e.which == 13) {
+      e.preventDefault();
+      search(false);
+    }
+  });
+})
+
+function search(go) {
+  var term = $("#search input").val();
+  // Wait for search index to populate
+  while (!window.index) {};
+  var results = window.index.search(term);
+
+  if(results && results.length == 1) {
+    window.location.replace("<%= path "" %>" + results[0].ref + "?highlight=" + escape(term));
+  } else if(results && results.length > 1) {
+    if (go) {
+      window.location.replace("<%= path "" %>" + results[0].ref + "?highlight=" + escape(term));
+    } else {
+      displayResults(results, term);
+    }
+  } else {
+    alert("Found nothing");
+  }
+}
+
+function displayResults(results, term) {
+  var resultTemplate = $("search-view-template");
+  var container = $("article");  
+
+  container.empty();
+  container.append("<h2>Results</h2>");
+
+  $.each(results, function(i, result) {
+    var article = window.articles[result.ref];
+    container.append("<p><a href=\"<%= path "" %>" + result.ref + "?highlight=" + escape(term) + "\">" + article.title + " - " + article.subtitle + "</a></p>");
+  });
+}
+
+function getParams() {
+  var query_string = {};
+  var query = window.location.search.substring(1);
+  var vars = query.split("&");
+  for (var i=0;i<vars.length;i++) {
+    var pair = vars[i].split("=");
+    	// If first entry with this name
+    if (typeof query_string[pair[0]] === "undefined") {
+      query_string[pair[0]] = pair[1];
+    	// If second entry with this name
+    } else if (typeof query_string[pair[0]] === "string") {
+      var arr = [ query_string[pair[0]], pair[1] ];
+      query_string[pair[0]] = arr;
+    	// If third or later entry with this name
+    } else {
+      query_string[pair[0]].push(pair[1]);
+    }
+  } 
+  return query_string;
+}
+
+$(document).ready(function() {
+  var params = getParams();
+  $("#search input").focus();
+
+  if (params.highlight) {
+    var term = unescape(params.highlight);
+    $('article').highlight(term);
+  }
+});

data/templates/shared/web/_logo.html

@@ -0,0 +1,10 @@
+<div class="pull-right logo-rgen" style="margin-top: 18px; margin-left: 10px">
+  <a href="http://rgen.freescale.net" style="text-decoration: none; color: #e66a08; font-weight: bold; font-size: 20px;">
+  <span>RGen</span>
+  </a>
+</div>
+<div class="pull-right">
+  <a href="http://rgen.freescale.net">
+    <img src="http://rgen.freescale.net/img/fsl_logo.png" style="height:40px">
+  </a>
+</div>

data/templates/test/_inline_sub.txt.erb

@@ -0,0 +1,2 @@
+From a sub!
+x = <%= options[:x] %>

data/templates/test/environment.txt.erb

@@ -0,0 +1 @@
+Current environment: <%= RGen.environment.name %>

data/templates/test/inline.txt.erb

@@ -0,0 +1,11 @@
+<%= 5 * 5 %>
+Hello
+% if options[:extra]
+and goodbye
+% end
+% if options[:test_scope]
+<%= secret %>
+% end
+% if options[:test_render]
+<%= render "inline_sub", x: 10 %>
+% end

data/templates/test/inspections.txt.erb

@@ -0,0 +1,19 @@
+This template is used to test that the custom inspect methods of the various RGen datatypes work
+
+Should display a list of registers:
+
+<%= $nvm.regs.inspect %>
+
+Should display an actual register:
+
+<%= $nvm.regs(:mclkdiv).inspect %>
+
+This one had problems in real life:
+
+% $nvm.add_proth_reg
+<%= $nvm.regs(:proth).inspect %>
+
+Check the multi bitgroups scattered through the register
+
+% $nvm.add_multi_split_reg
+<%= $nvm.regs(:multi_group).inspect %>

data/templates/test/set1/_sub1.txt.erb

@@ -0,0 +1,12 @@
+sub1: This is content from sub1
+sub1: 
+sub1: This data value should be 0 to prove that it has not
+sub1: been influenced by the calling context:
+sub1: 
+sub1: Data: 0x<%= $nvm.reg(:data).val.to_s(16).upcase %>
+sub1: 
+% if options[:data]
+sub1: Data values passed in: 0x<%= options[:data].to_s(16).upcase %>
+% else
+sub1: No data value passed in!
+% end

data/templates/test/set1/_sub4.txt.erb

@@ -0,0 +1 @@
+sub4: This is a single line from sub4!

data/templates/test/set1/_sub5.txt.erb

@@ -0,0 +1 @@
+sub5: The value of $nvm.attribute_x is: <%= $nvm.attribute_x %>

data/templates/test/set1/main.txt.erb

@@ -0,0 +1,53 @@
+main: This is a basic template example to test the RGen template compiler.
+main: 
+main: Verify that the target objects can be accessed:
+main: 
+% $nvm.reg(:data).write(0x5555)
+main: Data: 0x<%= $nvm.reg(:data).val.to_s(16).upcase %>
+main: 
+main: Verify that sub templates can be rendered and executed within their own context:
+main: 
+<%= render "sub1" %>
+main: Verify that import is an alias for render
+main: 
+<%= import "sub1" %>
+main: 
+main: Rendering the template should not disrupt the current context, verify that the
+main: data is still 0x5555:
+main: 
+main: Data: 0x<%= $nvm.reg(:data).val.to_s(16).upcase %>
+main: 
+main: Verify that option data can be passed to rendered templates, the data
+main: printed here should be 0x1234:
+main: 
+<%= render "sub1", data: 0x1234 %>
+main: 
+main: Again verify that the current context is still intact:
+main: Data: 0x<%= $nvm.reg(:data).val.to_s(16).upcase %>
+main: 
+main: Verify that templates from sub directories can be rendered:
+main: 
+<%= render "sub_dir/sub2" %>
+main: 
+main: Again verify that the current context is still intact:
+main: Data: 0x<%= $nvm.reg(:data).val.to_s(16).upcase %>
+main: 
+main: Verify that no extra linebreaks are added:
+<%= render "sub4.txt.erb" %>
+main: This should butt up against the sub 4 line
+main: 
+main: And that leading spaces are stripped, there should be
+main: no leading whitespace before the sub 4 line:
+      <%= render "sub4.txt.erb" %>
+main: This is a test that helpers can compile templates inline
+<%= test_compile_inline_from_helper %>
+main: This is a test that indent works
+<%= render "sub1", indent: 10 %>
+main: Verify by default that render will reload the target,
+main: the value here should be blank
+% $nvm.attribute_x = "X"
+<%= render "sub5" %>
+main: Verify that target reload can optionally be inhibited,
+main: the value here should be X
+% $nvm.attribute_x = "X"
+<%= render "sub5", preserve_target: true %>

data/templates/test/set1/sub_dir/_sub2.txt.erb

@@ -0,0 +1,20 @@
+sub2: This is content from sub2
+sub2: 
+sub2: This data value should be 0 to prove that it has not
+sub2: been influenced by the calling context:
+sub2: 
+sub2: Data: 0x<%= $nvm.reg(:data).val.to_s(16).upcase %>
+sub2: 
+% if options[:data]
+sub2: Data values passed in: 0x<%= options[:data].to_s(16).upcase %>
+% else
+sub2: No data value passed in!
+% end
+sub2: 
+sub2: Verify that templates can render additional sub-templates:
+sub2: 
+% if options[:data]
+  <%= render "sub3", data: options[:data] * 2 %>
+% else
+  <%= render "sub3" %>
+% end

data/templates/test/set1/sub_dir/_sub3.txt.erb

@@ -0,0 +1,12 @@
+sub3: This is content from sub3
+sub3: 
+sub3: This data value should be 0 to prove that it has not
+sub3: been influenced by the calling context:
+sub3: 
+sub3: Data: 0x<%= $nvm.reg(:data).val.to_s(16).upcase %>
+sub3: 
+% if options[:data]
+sub3: Data values passed in: 0x<%= options[:data].to_s(16).upcase %>
+% else
+sub3: No data value passed in!
+% end

data/templates/test/set1/sub_dir/main2.txt.erb

@@ -0,0 +1,4 @@
+main2: Another simple template to prove that things work from a 
+main2: sub-directory
+main2: 
+<%= render "sub2", data: 0x1111 %>

data/templates/test/set2/template_with_no_erb_1.txt

@@ -0,0 +1,9 @@
+This is a template without a
+.erb extension.
+
+It should only compile if
+RGen.config.compile_only_dot_erb_files == false
+
+% 10.times do
+RGen.config.compile_only_dot_erb_files is <%= RGen.config.compile_only_dot_erb_files %>
+% end

data/templates/test/set2/template_with_no_erb_2.txt

@@ -0,0 +1,9 @@
+This is a template without a
+.erb extension.
+
+It should only compile if
+RGen.config.compile_only_dot_erb_files == false
+
+% 10.times do
+RGen.config.compile_only_dot_erb_files is <%= RGen.config.compile_only_dot_erb_files %>
+% end

data/templates/test/set3/_layout.html.erb

@@ -0,0 +1,4 @@
+<div class="container">
+<%= yield %>
+  <%= options[:repeat] %>
+</div>

data/templates/test/set3/content.html.erb

@@ -0,0 +1,6 @@
+<p>I'm before the layout</p>
+% render "layout", repeat: 2 do
+  <p>I'm inside the layout</p>
+  <p>The value of repeat is...</p>
+% end
+<p>I'm after the layout</p>

data/templates/time/filter.rb.erb

@@ -0,0 +1,15 @@
+class TestTimeFilter
+
+  # All tests to be imported will be passed to this method, if it returns
+  # true then the test will be imported, if it returns false then it will not
+  def import?(test)
+    # For example to only import tests beginning with "nvm":
+    # if test =~ /^nvm/
+    #   true
+    # else
+    #   false
+    # end
+    true
+  end
+
+end

data/templates/time/rules.rb.erb

@@ -0,0 +1,45 @@
+class TestTimeRules
+
+  # All tests to be imported will be passed to this method after they have been filtered.
+  #
+  # Whatever this method returns will be assigned as the rule to be used to work out how
+  # that test scales from one target to another.
+  def assign(name, attrs, options={})
+    :constant
+  end
+
+  # This method will be called to evaluate the result of the rule for the reference target - 
+  # that is the target used when importing an execution time profile.
+  #
+  # The rule name can be obtained from attrs["rule"]
+  def evaluate(name, attrs, options={})
+    rule = attrs["rule"]
+
+    case rule
+    when :constant
+      1
+    else
+      raise "Rule not implemented - #{rule}"
+    end
+  end
+
+  # This method will be called for each test to forecast what the time will be for the current
+  # target, it must return a numeric value in all cases.
+  #
+  # The rule name can obtained from attrs["rule"] and the results from the reference target can
+  # be obtained from attrs["reference"].
+  #
+  # The most basic way to forecast (and which could get you pretty far) is simply to ratio the rule
+  # result for the reference target with the result from the current target, and then multiply
+  # that by the reference time - an example of this is shown below.
+  def forecast(name, attrs, options={})
+    ref = attrs["reference"]
+
+    val_for_current_target = evaluate(name, attrs, options)
+    val_for_reference_target = ref["rule_result"]
+
+    ref["time"] * (val_for_current_target / val_for_reference_target.to_f) # Force to a float so the
+                                                                           # result is not an integer
+  end
+
+end