rhet-butler 0.5.0 → 0.9.0

data/default-configuration/presenter/templates/stylesheets.html.erb

@@ -1,3 +1,3 @@
 <link href="/stylesheets/google-open-sans.css" rel="stylesheet" />
-<link href="/stylesheets/presenter/presentation.css" rel="stylesheet" />
+<link href="/stylesheets/presenter/rhet.css" rel="stylesheet" />
 <link href="/stylesheets/highlight/solarized_dark.css" rel="stylesheet" />

data/default-configuration/skels/config.yaml

@@ -0,0 +1,15 @@
+---
+named-filters:
+  normal:
+    - !textile
+    - !cues
+  code:
+    - !code
+    - !textile
+    - !cues
+
+default-content-filters:
+  normal
+
+default-note-filters:
+  normal

data/default-configuration/skels/slides.yaml

@@ -0,0 +1,6 @@
+!slide An awesome presentation
+!group
+  !include whoami.yaml
+!group
+  !slide |
+    contents: It'll knock your socks off!

data/default-configuration/viewer/templates/live-javascript.html.erb

@@ -7,7 +7,7 @@
 
   sock.onmessage = function(e) {
     console.log("message", e.data);
-    impress().goto(e.data);
+    presenter.moveTo(e.data);
   };
 
   sock.onclose = function() {

data/lib/rhet-butler/arrangement-finder.rb

@@ -0,0 +1,71 @@
+require 'rhet-butler/arrangement'
+require 'rhet-butler/slide-traverser'
+module RhetButler
+  class ArrangementFinder < SlideTraverser
+    attr_accessor :root_arrangement, :root_group, :blueprint
+
+    def initialize
+      super
+    end
+
+    def setup
+      if @blueprint.empty?
+        raise "Empty blueprint - can't layout slides"
+      end
+
+      @blueprint.combination(2) do |first, second|
+        if first.match == second.match
+          if first.match == {}
+            raise "Two default rules (default or match: {}) - please fix"
+          end
+          warn "Blueprint rules with duplicate rules: will ignore the later one:"
+          warn second.inspect
+        end
+      end
+
+      unless @blueprint.last.match == {}
+        warn "Last blueprint rule not a default - fixing..."
+        defaults, rules = @blueprint.partition{|rule| rule.match == {}}
+        raise "Multiple default blueprint rules" unless defaults.length < 2
+        raise "No default blueprint rule" unless defaults.length > 0
+        @blueprint = rules + defaults
+      end
+
+      default_rule = @blueprint.last
+      @active_match = default_rule
+      @root_arrangement = default_rule.layout
+      descend(@root_group, @root_arrangement)
+    end
+
+    def on_slide(slide)
+      target_stack.last.slides << slide
+    end
+
+    def on_group(group)
+      arrangement = find_arrangement(group)
+      if arrangement != target_stack.last
+        target_stack.last.slides << arrangement
+      end
+      descend(group, arrangement)
+    end
+
+    def match?(filter, value)
+      return filter === value
+    end
+
+    def find_arrangement(group)
+      match = {}
+      template = nil
+      match = blueprint.find do |rule|
+        rule.match?(group)
+      end
+
+      if !match.nil? and match != @active_match
+        @active_match = match
+        return match.layout
+      else
+        return target_stack.last
+      end
+    end
+  end
+end

data/lib/rhet-butler/command-line.rb

@@ -10,18 +10,65 @@ module RhetButler
       method_option :root_slide, :type => :string
     end
 
+    desc "init", "Create example skeleton files to get started with"
+    def init
+      require 'fileutils'
+
+      file_manager = FileManager.new(options)
+
+      FileUtils.mkdir_p "assets"
+      FileUtils.mkdir_p "presenter/assets"
+      FileUtils.mkdir_p "viewer/assets"
+
+      skels = file_manager.all_files.sub_set("skels")
+
+      %w{slides.yaml}.each do |path|
+        unless Dir.glob(path).empty?
+          puts "Refusing to clobber existing: #{path}"
+          next
+        end
+
+        File::open(path, "w") do |file|
+          file.write skels.contents(path)
+        end
+      end
+    end
+
     desc "static", "Builds a static version of the presentation"
     method_option :target, :type => :string
+    method_option :quiet, :type => :boolean, :aliases => "-q", :desc => "Suppress listing of files as their written"
     shared_options
     def static
       require 'rhet-butler/static-generator'
 
       file_manager = FileManager.new(options)
       generator = StaticGenerator.new(file_manager)
+      generator.store_log = $stderr unless options[:quiet]
 
       generator.go!
     end
 
+    desc "import URL TARGET", "Pulls presentation assets from the web and removes remote dependencies"
+    method_option :role, :type => :string, :desc => "The presentation role for to localize to", :enum => %w{presenter viewer common}
+    method_option :quiet, :type => :boolean, :aliases => "-q", :desc => "Suppress listing of files as their written"
+    def import(url, target)
+      require 'rhet-butler/resource-localizer'
+      file_manager = FileManager.new(options)
+      localizer = ResourceLocalizer.new
+
+      case options[:role]
+      when "presenter", "viewer"
+        localizer.files = file_manager.aspect_search_path(options[:role])
+      else
+        localizer.files = file_manager.all_files
+      end
+      localizer.source_uri = url
+      localizer.target_path = target
+      localizer.store_log = $stderr unless options[:quiet]
+
+      localizer.go!
+    end
+
     desc "check", "Load slide set to check syntax"
     shared_options
     def check
@@ -29,12 +76,31 @@ module RhetButler
 
       file_manager = FileManager.new(options)
       app = Web::MainApp.new(file_manager)
+      app.presentation_app_class = Web::MemoizedPresentationApp
+      app.assets_app_class = Web::MemoizedAssetsApp
+      app.check
 
+      slide_count = app.viewer_app.root_step.each_slide.inject(0) do |count, slide|
+        count + 1
+      end
       say "Slides loaded and parsed"
-      say "  #{app.viewer_app.slides.length} slides loaded"
+      say "  #{slide_count} slides loaded"
       say "  Serving slides and assets found in: #{app.slides}"
     end
 
+    desc "author", "Run the presentation in authoring mode"
+    shared_options
+    def author
+      require 'rhet-butler/web/main-app'
+
+      file_manager = FileManager.new(options)
+      app = Web::MainApp.new(file_manager)
+      app.presentation_app_class = Web::PresentationApp
+      app.assets_app_class = Web::AssetsApp
+      app.check
+      app.start
+    end
+
     desc "serve", "Run the presentation server"
     shared_options
     def serve
@@ -42,6 +108,8 @@ module RhetButler
 
       file_manager = FileManager.new(options)
       app = Web::MainApp.new(file_manager)
+      app.presentation_app_class = Web::MemoizedPresentationApp
+      app.assets_app_class = Web::MemoizedAssetsApp
       app.check
       app.start
     end

data/lib/rhet-butler/configuration.rb

@@ -1,3 +1,5 @@
+require 'rhet-butler/yaml-schema'
+
 module RhetButler
   #This class is used to manage application config throughout. Basically it
   #wraps a hash loaded from the base fileset. Since the file search path can be
@@ -10,8 +12,9 @@ module RhetButler
     def initialize(files, overrides=nil)
       @base_hash =
         begin
-          files.find("config.yaml").contents rescue {}
-        rescue Object
+          files.find("config.yaml").contents
+        rescue Valise::Errors::NotFound
+          warn "No config.yaml found in #{files.inspect} - using defaults"
           {}
         end
       @base_hash.merge!(overrides) unless overrides.nil?
@@ -45,6 +48,10 @@ module RhetButler
       @base_hash["sources"] || []
     end
 
+    def template_cache
+      @base_hash["template-cache"] || ".template-cache"
+    end
+
     def static_target
       @base_hash["static_target"] || "static"
     end
@@ -58,7 +65,7 @@ module RhetButler
     end
 
     def arrangement_blueprint
-      @base_hash["blueprint"] || {}
+      @base_hash["blueprint"] || []
     end
 
     def serve_port
@@ -69,8 +76,16 @@ module RhetButler
       @base_hash["root_slide"] || "slides.yaml"
     end
 
-    def default_slide_type
-      @base_hash["default_slide_type"] || "textile"
+    def named_filter_lists
+      @base_hash["named-filters"] || {"textile" => [SlideRenderers::Textile.new]}
+    end
+
+    def default_content_filters
+      @default_content_filters ||= @base_hash["default-content-filters"] || "textile"
+    end
+
+    def default_note_filters
+      @default_note_filters ||= @base_hash["default-note-filters"] || "textile"
     end
   end
 end

data/lib/rhet-butler/file-loading.rb

@@ -0,0 +1,28 @@
+require 'rhet-butler/yaml-schema'
+
+module RhetButler
+  class FileLoading
+    def initialize(file_set)
+      @file_set = file_set
+      @loaded_paths = {}
+    end
+    attr_reader :loaded_paths, :file_set
+
+    def initialize_copy(other)
+      @file_set = other.file_set
+      @loaded_paths = other.loaded_paths.dup
+    end
+
+    def load_file(rel_path)
+      file = @file_set.find(rel_path)
+
+      if @loaded_paths.has_key?(file.full_path)
+        raise "Circular inclusion of slides: >> #{file.full_path} << #{@loaded_paths.keys.inspect}"
+      else
+        @loaded_paths[file.full_path] = true
+      end
+
+      return YAML.load_stream(file.contents).flatten
+    end
+  end
+end

data/lib/rhet-butler/file-manager.rb

@@ -1,5 +1,9 @@
 require 'valise'
 require 'rhet-butler/configuration'
+require 'compass/import-once'
+require 'compass/core'
+require 'rhet-butler/sass-functions'
+require 'fileutils'
 
 module RhetButler
   #All file handling is routed through this class.
@@ -50,18 +54,51 @@ module RhetButler
       all_files.sub_set("slides") + all_files
     end
 
-    def base_assets
-      all_files.templates("assets")
+    def all_files
+      current_directory + configured_search_path + base_config_set
+    end
+
+    def base_config_search_path
+      set = current_directory + base_config_set
+      set + set.sub_set("common")
+    end
+
+    def template_config(type)
+      case type
+      when "sass", "scss"
+        load_paths = all_files.sub_set("assets/stylesheets").map(&:to_s)
+        load_paths << Compass::Core.base_directory("stylesheets")
+        FileUtils::mkdir_p base_config.template_cache
+        {:template_options =>
+          { :load_paths => load_paths, :cache_location => base_config.template_cache }}
+      else
+        nil
+      end
     end
 
     def aspect_config(aspect_name)
-      @cached_configs[aspect_name] ||= load_config(aspect_search_path(aspect_name))
+      load_config(aspect_search_path(aspect_name))
     end
 
-    def aspect_templates(aspect)
-      @cached_templates[aspect] ||= aspect_search_path(aspect).templates
+    def base_assets(template_cache)
+      all_files.templates("assets") do |mapping|
+        (template_config(mapping) || {}).merge(:template_cache => template_cache)
+      end
     end
 
+    def aspect_templates(aspect, template_cache = nil)
+      aspect_search_path(aspect).templates do |mapping|
+        (template_config(mapping) || {}).merge(:template_cache => template_cache)
+      end
+    end
+
+    def aspect_search_path(aspect)
+      aspect = aspect.to_s
+      set = all_files.sub_set(aspect)
+      set += all_files.sub_set("common")
+      set += all_files
+      return set
+    end
 
     def load_config(files)
       Configuration.new(files, @overrides)
@@ -105,22 +142,5 @@ module RhetButler
           end
         end
     end
-
-    def all_files
-      current_directory + configured_search_path + base_config_set
-    end
-
-    def base_config_search_path
-      set = current_directory + base_config_set
-      set + set.sub_set("common")
-    end
-
-    def aspect_search_path(aspect)
-      aspect = aspect.to_s
-      set = all_files.sub_set(aspect)
-      set += all_files.sub_set("common")
-      set += all_files
-      return set
-    end
   end
 end

data/lib/rhet-butler/filter-resolver.rb

@@ -0,0 +1,45 @@
+require 'rhet-butler/slide-renderer'
+require 'rhet-butler/slide-traverser'
+require 'pp'
+
+module RhetButler
+  class FilterResolver < SlideTraverser
+    attr_accessor :root_group, :named_filter_lists, :default_content_filters, :default_note_filters
+
+    def setup
+      named_filter_lists.each_key do |name|
+        named_filter_lists[name] = get_filters(named_filter_lists[name])
+      end
+      self.default_content_filters = get_filters(default_content_filters)
+      self.default_note_filters = get_filters(default_note_filters)
+      descend(@root_group, @root_group)
+    end
+
+    def get_filters(filter, used_names=nil)
+      case filter
+      when String
+        if !used_names.nil? and used_names.include?(filter)
+          raise "Recursive filter list definitions: #{filter} already referenced in #{used_names}"
+        end
+        get_filters(named_filter_lists.fetch(filter), (used_names||[])+[filter]) do
+          raise "No filter named #{filter}"
+        end
+      when Array
+        filter.map{|item| get_filters(item)}.flatten
+      else
+        filter
+      end
+    end
+
+    def on_slide(slide)
+      slide.content_filters = get_filters(slide.content_filters || default_content_filters)
+      slide.html_classes += slide.content_filters.map do |filter|
+        filter.html_class
+      end
+      slide.note_filters    = get_filters(slide.note_filters || default_note_filters)
+      slide.html_classes += slide.content_filters.map do |filter|
+        "note-" + filter.html_class unless filter.html_class.nil?
+      end
+    end
+  end
+end

data/lib/rhet-butler/html-generator.rb

@@ -13,17 +13,37 @@ module RhetButler
       attr_accessor :author_name, :title, :description
     end
 
+    class RenderFacade
+      def initialize(templates, item)
+        @templates = templates
+        @item = item
+      end
+
+      def method_missing(name, *args, &block)
+        @item.__send__(name, *args, &block)
+      end
+
+      def render(path, item=nil, locals=nil)
+        scope = if(item.nil?)
+          self
+        else
+          self.class.new(@templates, item)
+        end
+        @templates.find(path).contents.render(scope || self, locals || {})
+      end
+    end
+
     def initialize(configuration, templates)
       @impress_config = configuration.impress_config
       @templates = templates
-      @slides = []
+      @root_step
       @presentation = Presentation.new(configuration)
     end
 
-    attr_accessor :slides, :presentation, :impress_config
+    attr_accessor :root_step, :presentation, :impress_config
 
-    def render(path, scope=nil, locals=nil)
-      @templates.find(path).contents.render(scope || self, locals || {})
+    def render(template, item=nil)
+      RenderFacade.new(@templates, item || self).render(template)
     end
   end
 end

data/lib/rhet-butler/include-processor.rb

@@ -0,0 +1,55 @@
+require 'rhet-butler/slide-traverser'
+module RhetButler
+  class IncludeProcessor < SlideTraverser
+    Collector = Struct.new(:group, :slides, :loader)
+    attr_accessor :root_group
+
+    def initialize(loader)
+      @loader = loader
+      super()
+    end
+
+    def current_loader
+      if target_stack.empty?
+        return @loader
+      else
+        return target_stack.last.loader
+      end
+    end
+
+    def setup
+      descend(@root_group, @root_group)
+    end
+
+    def descend(source, dest)
+      unless Collector === dest
+        dest = Collector.new(dest, [], current_loader)
+      end
+      super(source, dest)
+    end
+
+    def ascend
+      target = target_stack.pop
+      unless target == target_stack.last
+        target.group.slides = target.slides
+      end
+      iter_stack.pop
+    end
+
+    def on_include(includer)
+      loader = includer.load(current_loader)
+      collector = target_stack.last.dup
+      collector.loader = loader
+      descend(includer, collector)
+    end
+
+    def on_slide(slide)
+      target_stack.last.slides << slide
+    end
+
+    def on_group(group)
+      target_stack.last.slides << group
+      super
+    end
+  end
+end

data/lib/rhet-butler/layout-rule.rb

@@ -1,8 +1,9 @@
 require 'rhet-butler/yaml-type'
 
 module RhetButler
-  class LayoutRule
-    include YamlType
+  class LayoutRule < YamlType
+    register "layout-rule"
+
     def initialize
       @match = {}
       @layout_args = nil
@@ -17,19 +18,22 @@ module RhetButler
       %w[layout]
     end
 
-    def init_with(coder)
-      @config_hash =
-        case coder.type
-        when :seq
-          { 'match' => coder.seq[0], 'layout' => coder.seq[1] }
-        when :map
-          coder.map
-        else
-          raise "Tried to configure a layout rule with non-sequence: #{coder.inspect}"
-        end
+    def setup_defaults
 
-      check_config_hash(@config_hash)
+    end
+
+    def normalize_config(coder)
+      case coder.type
+      when :seq
+        { 'match' => coder.seq[0], 'layout' => coder.seq[1] }
+      when :map
+        coder.map
+      else
+        raise "Tried to configure a layout rule with non-sequence: #{coder.inspect}"
+      end
+    end
 
+    def configure
       value_from_config("match") do |value|
         if value == 'default'
           @match = {}

data/lib/rhet-butler/resource-localizer.rb

@@ -0,0 +1,22 @@
+require 'rhet-butler/web/main-app'
+require 'rhet-butler/stasis'
+
+module RhetButler
+  class ResourceLocalizer
+    attr_accessor :files, :source_uri, :target_path, :store_log
+
+    def go!
+      app_url = "http://example.com/"
+      transform_queue = Stasis::TransformQueue.new
+      transform_queue.loader = Stasis::HTTPLoader.new
+      transform_queue.mapping = Stasis::ResourceMapping.new
+      transform_queue.mapping.default_uri = app_url
+      transform_queue.writer = Stasis::ValiseWriter.new(@files)
+      transform_queue.writer.store_log = store_log
+
+      target_uri = transform_queue.mapping.target_link_for(source_uri)
+      transform_queue.add_mapping(source_uri, target_uri, target_path)
+      transform_queue.go
+    end
+  end
+end

data/lib/rhet-butler/sass-functions.rb

@@ -0,0 +1,40 @@
+require 'sass'
+require 'sass/script/functions'
+
+module Sass::Script
+  module Functions
+    def exp(modulus, exponent)
+      assert_type modulus, :Number
+      assert_type exponent, :Number
+
+      Number.new(modulus.value ** exponent.value, modulus.numerator_units, modulus.denominator_units)
+    end
+    declare :exp, :args => [:modulus, :exponent]
+
+    def tween(initial, final, ratio)
+      assert_type initial, :Number
+      assert_type final, :Number
+      assert_type ratio, :Number
+
+      initial_units = [initial.numerator_units, initial.denominator_units]
+      final_units = [final.numerator_units, final.denominator_units]
+      unless initial_units == final_units
+        raise ArgumentError, "Mismatched units: initial: #{initial_units.inspect} != final: #{final_units.inspect}"
+      end
+
+      ratio_units = ratio.numerator_units - ratio.denominator_units
+      ratio_value = case ratio_units
+                    when %w{%}
+                      ratio.value / 100.0
+                    when []
+                      ratio.value
+                    else
+                      raise ArgumentError, "Bad units for ratio: #{ratio_units.inspect}"
+                    end
+
+      Number.new(initial.value + ((final.value - initial.value) * ratio_value), *initial_units)
+    end
+
+    declare :tween, :args => [:initial, :final, :ratio]
+  end
+end

data/lib/rhet-butler/slide-arranger.rb

@@ -0,0 +1,39 @@
+require 'rhet-butler/slide-traverser'
+module RhetButler
+  class SlideArranger < SlideTraverser
+    attr_reader :slides, :current_slide
+    attr_accessor :root_arrangement
+
+    def setup
+      @slides = []
+      on_group(@root_arrangement)
+    end
+
+    def null_slide
+      @null_slide ||= Slide.new
+    end
+
+    def previous_slide
+      case @previous_slide
+      when Slide
+        @previous_slide
+      when nil
+        null_slide
+      else
+        @previous_slide.previous_slide
+      end
+    end
+
+    def on_slide(slide)
+      @current_slide = slide.dup
+      target_stack.last.arrange(self)
+      @slides.push @current_slide
+      @previous_slide = @current_slide
+    end
+
+    def ascend
+      @previous_slide = target_stack.last
+      super
+    end
+  end
+end