guide 0.0.1 → 0.3.1

data/app/assets/stylesheets/guide/application.css

@@ -0,0 +1,141 @@
+/**
+ * prism.js default theme for JavaScript, CSS and HTML
+ * Based on dabblet (http://dabblet.com)
+ * @author Lea Verou
+ */
+
+code[class*="language-"],
+pre[class*="language-"] {
+  color: black;
+  background: none;
+  text-shadow: 0 1px white;
+  font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
+  direction: ltr;
+  text-align: left;
+  white-space: pre;
+  word-spacing: normal;
+  word-break: normal;
+  word-wrap: normal;
+  line-height: 1.5;
+
+  -moz-tab-size: 4;
+  -o-tab-size: 4;
+  tab-size: 4;
+
+  -webkit-hyphens: none;
+  -moz-hyphens: none;
+  -ms-hyphens: none;
+  hyphens: none;
+}
+
+pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
+code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
+  text-shadow: none;
+  background: #b3d4fc;
+}
+
+pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
+code[class*="language-"]::selection, code[class*="language-"] ::selection {
+  text-shadow: none;
+  background: #b3d4fc;
+}
+
+@media print {
+  code[class*="language-"],
+  pre[class*="language-"] {
+    text-shadow: none;
+  }
+}
+
+/* Code blocks */
+
+pre[class*="language-"] {
+  padding: 1em;
+  margin: .5em 0;
+  overflow: auto;
+}
+
+:not(pre) > code[class*="language-"],
+pre[class*="language-"] {
+  background: #f5f2f0;
+}
+
+/* Inline code */
+
+:not(pre) > code[class*="language-"] {
+  padding: .1em;
+  border-radius: .3em;
+  white-space: normal;
+}
+
+.token.comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+  color: slategray;
+}
+
+.token.punctuation {
+  color: #999;
+}
+
+.namespace {
+  opacity: .7;
+}
+
+.token.property,
+.token.tag,
+.token.boolean,
+.token.number,
+.token.constant,
+.token.symbol,
+.token.deleted {
+  color: #905;
+}
+
+.token.selector,
+.token.attr-name,
+.token.string,
+.token.char,
+.token.builtin,
+.token.inserted {
+  color: #690;
+}
+
+.token.operator,
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+  color: #a67f59;
+  background: hsla(0, 0%, 100%, .5);
+}
+
+.token.atrule,
+.token.attr-value,
+.token.keyword {
+  color: #07a;
+}
+
+.token.function {
+  color: #DD4A68;
+}
+
+.token.regex,
+.token.important,
+.token.variable {
+  color: #e90;
+}
+
+.token.important,
+.token.bold {
+  font-weight: bold;
+}
+
+.token.italic {
+  font-style: italic;
+}
+
+.token.entity {
+  cursor: help;
+}

data/app/controllers/guide/base_controller.rb

@@ -0,0 +1,83 @@
+class Guide::BaseController < Guide.configuration.controller_class_to_inherit.constantize
+  helper Rails.application.routes.url_helpers
+  layout 'guide/application'
+
+  private
+
+  around_filter :set_locale
+  def set_locale
+    I18n.with_locale(diplomat.negotiate_locale) { yield }
+  end
+
+  around_filter :handle_known_errors
+  def handle_known_errors
+    begin
+      yield
+    rescue Guide::Errors::Base => error
+      raise error if Rails.env.development?
+
+      case error
+      when Guide::Errors::InvalidNode, Guide::Errors::PermissionDenied
+        render :text => 'Nothing to see here.', :status => '404'
+      else
+        render :text => "Something's gone wrong. Sorry about that.", :status => '500'
+      end
+    end
+  end
+
+  def active_node
+    @node ||= monkey.fetch_node(node_path)
+  end
+
+  def bouncer
+    @bouncer ||= Guide::Bouncer.new(authorisation_system: injected_authorisation_system)
+  end
+
+  def injected_authentication_system
+    if defined?(authentication_system)
+      authentication_system
+    else
+      Guide::DefaultAuthenticationSystem.new
+    end
+  end
+
+  def injected_authorisation_system
+    if defined?(authorisation_system)
+      authorisation_system
+    else
+      Guide::DefaultAuthorisationSystem.new
+    end
+  end
+
+  def injected_html
+    if defined?(html_injection)
+      html_injection
+    else
+      ''
+    end
+  end
+
+  def content
+    @content ||= Guide::Content.new
+  end
+
+  def diplomat
+    @diplomat ||= Guide::Diplomat.new(session, params, I18n.default_locale)
+  end
+
+  def monkey
+    Guide::Monkey.new(content, bouncer)
+  end
+
+  def nobilizer
+    Guide::Nobilizer.new
+  end
+
+  def active_node_visibility
+    Guide::Scout.new(content).visibility_along_path(node_path)
+  end
+
+  def node_path
+    params[:node_path] || ""
+  end
+end

data/app/controllers/guide/nodes_controller.rb

@@ -0,0 +1,40 @@
+class Guide::NodesController < Guide::BaseController
+  def show
+    expose_layout
+    expose_navigation
+    expose_node
+  end
+
+  private
+
+  def expose_layout
+    @layout_view = Guide::LayoutView.new(
+      bouncer: bouncer,
+      diplomat: diplomat,
+      content_node: content,
+      active_node: active_node,
+      active_node_heritage: nobilizer.bestow_heritage(node_path),
+      active_node_visibility: active_node_visibility,
+      active_node_title: nobilizer.bestow_title(node_path),
+      authentication_system: injected_authentication_system,
+      injected_html: injected_html,
+    )
+  end
+
+  def expose_navigation
+    @navigation_view = Guide::NavigationView.new(
+      bouncer: bouncer,
+      node: content,
+      active_node: active_node,
+    )
+  end
+
+  def expose_node
+    @node_view = Guide::NodeView.new(
+      node: active_node,
+      bouncer: bouncer,
+      diplomat: diplomat,
+      node_path: node_path,
+    )
+  end
+end

data/app/controllers/guide/scenarios_controller.rb

@@ -0,0 +1,44 @@
+class Guide::ScenariosController < Guide::BaseController
+  layout 'guide/scenario'
+
+  def show
+    expose_layout
+    expose_scenario
+  end
+
+  private
+
+  def expose_layout
+    @layout_view = Guide::ScenarioLayoutView.new(
+      node: active_node,
+      node_title: nobilizer.bestow_title(node_path),
+      scenario: scenario,
+      format: scenario_format,
+      injected_html: injected_html,
+    )
+  end
+
+  def expose_scenario
+    @scenario_view = Guide::ScenarioView.new(
+      node: active_node,
+      scenario: scenario,
+      format: scenario_format,
+    )
+  end
+
+  def scenario
+    @scenario ||= simulator.fetch_scenario(scenario_id)
+  end
+
+  def simulator
+    @simulator ||= Guide::Simulator.new(active_node, bouncer)
+  end
+
+  def scenario_id
+    params[:scenario_id].to_sym
+  end
+
+  def scenario_format
+    params[:scenario_format]
+  end
+end

data/app/helpers/guide/application_helper.rb

@@ -0,0 +1,4 @@
+module Guide::ApplicationHelper
+  module DefaultInclude; end
+  include Guide.configuration.helper_module_to_globally_include.constantize
+end

data/app/helpers/guide/document_helper.rb

@@ -0,0 +1,20 @@
+module Guide::DocumentHelper
+  def code_example(language='markup', show_rendered_element=true, &block)
+    raise ArgumentError, "Missing block" unless block_given?
+
+    code_stream = capture(&block)
+
+    html = Nokogiri::HTML(code_stream.to_str)
+    code_string = html.css("span.example").collect(&:inner_html).join
+    code_string = code_stream.to_str if code_string.blank?
+
+    code_string = code_string.strip_heredoc.strip
+
+    capture do
+      concat content_tag(:div, code_stream, :class => "sg-content__demo") if show_rendered_element
+      concat content_tag(:pre, content_tag(:code, code_string),
+                         :class => "sg-content__code language-#{language} line-numbers",
+                         :"data-language" => language)
+    end
+  end
+end

data/app/models/guide/arborist.rb

@@ -0,0 +1,44 @@
+class Guide::Arborist
+  def initialize(bouncer)
+    @bouncer = bouncer
+  end
+
+  def draw_paths_to_visible_leaf_nodes(starting_node:, include_first_node: false)
+    initial_node_path = include_first_node ? starting_node.id.to_s : nil
+
+    recursively_cartograph_leaf_nodes(starting_node, initial_node_path, {})
+  end
+
+  private
+
+  def recursively_cartograph_leaf_nodes(node, node_path, result)
+    node.child_nodes.each do |child_node_id, child_node|
+      child_node_path = iterate_on_node_path(node_path, child_node_id)
+
+      if @bouncer.user_can_access?(child_node)
+        if child_node.leaf_node?
+          result[child_node_path] = nobilizer.bestow_title(child_node_path)
+        else
+          recursively_cartograph_leaf_nodes(child_node,
+                                            child_node_path,
+                                            result)
+        end
+      end
+    end
+    result
+  end
+
+  private
+
+  def iterate_on_node_path(node_path, child_node_id)
+    if node_path
+      "#{node_path}/#{child_node_id}"
+    else
+      child_node_id.to_s
+    end
+  end
+
+  def nobilizer
+    Guide::Nobilizer.new
+  end
+end

data/app/models/guide/bouncer.rb

@@ -0,0 +1,34 @@
+class Guide::Bouncer
+  def initialize(authorisation_system:)
+    @authorisation_system = authorisation_system
+  end
+
+  def user_can_access?(node)
+    visible_to_user?(node.id, node.options[:visibility])
+  end
+
+  def user_is_privileged?
+    @authorisation_system.user_is_privileged?
+  end
+
+  private
+
+  def visible_to_user?(label, visibility)
+    return true if visibility.blank?
+
+    if valid_visibility_options.include?(visibility)
+      @authorisation_system.allow?(:"view_guide_#{visibility}")
+    else
+      raise Guide::Errors::InvalidVisibilityOption, <<-EOS.gsub(' ,', ' nil,').squish
+        You tried to give :#{label} a visibility of :#{visibility},
+        but :#{visibility} is not a valid selection.
+        Valid visibility options include:
+        #{valid_visibility_options.join(', :')}.
+      EOS
+    end
+  end
+
+  def valid_visibility_options
+    @authorisation_system.valid_visibility_options
+  end
+end

data/app/models/guide/cartographer.rb

@@ -0,0 +1,49 @@
+class Guide::Cartographer
+  def initialize(bouncer)
+    @bouncer = bouncer
+  end
+
+  def draw_paths_to_visible_renderable_nodes(starting_node:)
+    recursively_cartograph_visible_renderable_nodes(node: starting_node)
+  end
+
+  private
+
+  def recursively_cartograph_visible_renderable_nodes(node:, node_path: "", result: {})
+    node.child_nodes.each do |child_node_id, child_node|
+      child_node_path = iterate_on_node_path(node_path: node_path,
+                                             node_id: child_node_id)
+
+      if @bouncer.user_can_access?(child_node)
+        include_node_in_result_if_renderable(node: child_node,
+                                             result: result,
+                                             node_path: child_node_path)
+
+        unless child_node.leaf_node?
+          recursively_cartograph_visible_renderable_nodes(node: child_node,
+                                                          node_path: child_node_path,
+                                                          result: result)
+        end
+      end
+    end
+    result
+  end
+
+  def iterate_on_node_path(node_path:, node_id:)
+    if node_path.empty?
+      node_id.to_s
+    else
+      "#{node_path}/#{node_id}"
+    end
+  end
+
+  def include_node_in_result_if_renderable(node:, node_path:, result:)
+    if node.can_be_rendered?
+      result[node_path] = nobilizer.bestow_title(node_path)
+    end
+  end
+
+  def nobilizer
+    @nobilizer ||= Guide::Nobilizer.new
+  end
+end