rhet-butler 0.5.0 → 0.9.0

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

@@ -1,10 +1,11 @@
 require 'rhet-butler/yaml-type'
 
 module RhetButler
-  class SlideGroup
-    include YamlType
+  class SlideGroup < YamlType
     include Enumerable
 
+    register "group"
+
     class <<self
       def optional_config
         %w[type slide_type]
@@ -15,16 +16,43 @@ module RhetButler
       end
     end
 
-
     def setup_defaults
-    end
-
-    def initialize
+      @html_id = nil
+      @classes = ["group"]
       @slides = []
       @metadata = {}
     end
+
+    def normalize_config(coder)
+      case coder.type
+      when :map
+        coder.map
+      when :scalar
+        raise "A slide group needs to at least be a list of slides"
+      when :seq
+        { 'slides' => coder.seq}
+      end
+    end
+
+    def configure
+      value_from_config("html_id") do |value|
+        @html_id = value
+      end
+
+      value_from_config("html_classes") do |value|
+        @html_classes += [*value]
+      end
+
+      value_from_config("html_class") do |value|
+        @html_classes << value
+      end
+
+      @slides = @config_hash.delete('slides')
+      @metadata = @config_hash
+    end
+
     attr_accessor :slides
-    attr_reader :metadata
+    attr_reader :metadata, :classes
 
     def each
       if block_given?
@@ -34,23 +62,30 @@ module RhetButler
       end
     end
 
-    def init_with(coder)
-      setup_defaults
-
-      @config_hash =
-        case coder.type
-        when :map
-          coder.map
-        when :scalar
-          raise "A slide group needs to at least be a list of slides"
-        when :seq
-          { 'slides' => coder.seq}
+    def each_slide
+      if block_given?
+        @slides.each do |slide|
+          if slide.is_a? SlideGroup
+            slide.each_slide{|sl| yield sl}
+          else
+            yield slide
+          end
         end
+      else
+        enum_for :each_slide
+      end
+    end
 
-      check_config_hash(@config_hash)
+    def template_name
+      "group.html"
+    end
 
-      @slides = @config_hash.delete('slides')
-      @metadata = @config_hash
+    def id_attr
+      if @html_id.nil?
+        return ""
+      else
+        "id='#@html_id'"
+      end
     end
   end
 end

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

@@ -1,7 +1,10 @@
+require 'rhet-butler/yaml-type'
+
 module RhetButler
-  class Includer
-    include Enumerable
+  class Includer < YamlType
+    register 'include'
 
+    include Enumerable
 
     def initialize
       @slides = []

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

@@ -1,13 +1,16 @@
-require 'rhet-butler/slide-group'
-require 'rhet-butler/slide'
-require 'rhet-butler/slide-includer'
-require 'rhet-butler/arrangement'
+require 'rhet-butler/yaml-schema'
+require 'rhet-butler/file-loading'
+require 'rhet-butler/include-processor'
+require 'rhet-butler/slide-processor'
+require 'rhet-butler/filter-resolver'
 
 module RhetButler
   class SlideLoader
     def initialize(slide_files, configuration)
       @file_set = slide_files
-      @default_slide_type = configuration.default_slide_type
+      @named_filter_lists = configuration.named_filter_lists
+      @default_content_filters = configuration.default_content_filters
+      @default_note_filters = configuration.default_note_filters
       @root_slide = configuration.root_slide
       @root_group = SlideGroup.new
       @blueprint = configuration.arrangement_blueprint
@@ -24,338 +27,19 @@ module RhetButler
       including.root_group = root_group
       including.traverse
 
+      filter_resolver = FilterResolver.new
+      filter_resolver.root_group = root_group
+      filter_resolver.named_filter_lists = @named_filter_lists
+      filter_resolver.default_content_filters = @default_content_filters
+      filter_resolver.default_note_filters = @default_note_filters
+      filter_resolver.traverse
+
       processor = SlideProcessor.new
       processor.root_group = root_group
-      processor.default_slide_type = @default_slide_type
       processor.blueprint = @blueprint
       processor.process
-      return processor.slides
-    end
-  end
-
-  require 'rhet-butler/yaml-schema'
-  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
-
-  class SlideProcessor
-    attr_accessor :root_group, :blueprint, :default_slide_type
-    attr_reader :slides
-
-    def process
-      rendering = SlideRendering.new
-      rendering.root_group = @root_group
-      rendering.default_type = @default_slide_type
-      rendering.traverse
-
-      finder = ArrangementFinder.new
-      finder.root_group = @root_group
-      finder.blueprint = @blueprint
-      finder.traverse
-
-      arranger = SlideArranger.new
-      arranger.root_arrangement = finder.root_arrangement
-      arranger.traverse
-
-      @slides = arranger.slides
-    end
-  end
-
-  class SlideTraverser
-    def initialize
-      @iter_stack = []
-      @target_stack = []
-    end
-
-    attr_reader :iter_stack, :target_stack
-
-    def on_group(group)
-      descend(group, group)
-    end
-
-    def ascend
-      target_stack.pop
-      iter_stack.pop
-    end
-
-    def descend(source, dest)
-      iter_stack.push source.each
-      target_stack.push dest
-    end
-
-    def traverse
-      setup
-      until iter_stack.empty?
-        begin
-          item = iter_stack.last.next
-          case item
-          when Slide
-            on_slide(item)
-          when Includer
-            on_include(item)
-          else
-            on_group(item)
-          end
-        rescue StopIteration
-          ascend
-        end
-      end
-    end
-  end
-
-  class ClassRegistry
-    def initialize
-      @classes = {}
-    end
-
-    def register(name, klass)
-      @classes[name.to_s] = klass
-    end
-
-    def fetch(name)
-      @classes.fetch(name.to_s)
-    end
-    alias [] fetch
-  end
-
-  class SlideRenderer
-    class << self
-      def registry
-        @registry ||= ClassRegistry.new
-      end
-
-      def register(name)
-        SlideRenderer.registry.register(name, self)
-      end
-
-      def for_type(type)
-        SlideRenderer.registry.fetch(type)
-      end
-
-      def process(type, options, slide)
-        for_type(type).new(options, slide).to_s
-      end
-    end
-
-    def initialize(options, slide)
-      @options = options
-      @slide_content = slide
-    end
-
-    def to_s
-      process(@slide_content)
-    end
-  end
-
-  class CodeRenderer < SlideRenderer
-    register :code
-
-    def process(string)
-      "<pre><code#{@options ? " class='#{@options}'" : ""}>#{string}</code></pre>"
-    end
-  end
-
-  require 'redcloth'
-  class TextileRenderer < SlideRenderer
-    register :textile
-    register :texttile
-
-    def process(string)
-      RedCloth.new(string).to_html
-    end
-  end
-
-  class SlideRendering < SlideTraverser
-    attr_accessor :root_group, :default_type
-
-    def setup
-      descend(@root_group, @root_group)
-    end
-
-    def on_slide(slide)
-      slide_type = slide.type || default_type
-      base_type,options = *(slide_type.split(":"))
-      slide.content = SlideRenderer.process(base_type, options, slide.content)
-      slide.notes = SlideRenderer.process("textile", nil, slide.notes) unless slide.notes.nil?
-    end
-  end
-
-  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
-
-  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
-
-  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
+      return root_group
     end
   end
 end

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

@@ -0,0 +1,27 @@
+require 'rhet-butler/slide-rendering'
+require 'rhet-butler/arrangement-finder'
+require 'rhet-butler/slide-arranger'
+
+module RhetButler
+  class SlideProcessor
+    attr_accessor :root_group, :blueprint, :default_content_filters, :default_note_filters
+    attr_reader :slides
+
+    def process
+      rendering = SlideRendering.new
+      rendering.root_group = @root_group
+      rendering.traverse
+
+      finder = ArrangementFinder.new
+      finder.root_group = @root_group
+      finder.blueprint = @blueprint
+      finder.traverse
+
+      arranger = SlideArranger.new
+      arranger.root_arrangement = finder.root_arrangement
+      arranger.traverse
+
+      @slides = arranger.slides
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'rhet-butler/yaml-type'
+
+module RhetButler
+  class SlideRenderer < YamlType
+    def self.required_config
+      []
+    end
+
+    def self.optional_config
+      []
+    end
+
+    def setup_defaults
+    end
+
+    def positional_options
+      []
+    end
+
+    def normalize_config(coder)
+      case coder.type
+      when :seq
+        Hash[positional_options.zip(coder.seq)]
+      when :map
+        coder.map
+      else
+        Hash[positional_options.zip([coder.scalar])]
+      end
+    end
+
+    def configure
+    end
+
+    def html_class
+      nil
+    end
+  end
+end
+
+require 'rhet-butler/slide-renderers/code'
+require 'rhet-butler/slide-renderers/textile'
+require 'rhet-butler/slide-renderers/cues'

data/lib/rhet-butler/slide-renderers/code.rb

@@ -0,0 +1,19 @@
+module RhetButler
+  module SlideRenderers
+    class Code < SlideRenderer
+      register :code
+
+      def self.optional_config
+        %w{class}
+      end
+
+      def positional_options
+        %w{class}
+      end
+
+      def process(string)
+        "<pre><code#{@config_hash ? " class='#{@config_hash['class']}'" : ""}>#{string}</code></pre>"
+      end
+    end
+  end
+end

data/lib/rhet-butler/slide-renderers/cues.rb

@@ -0,0 +1,27 @@
+require 'nokogiri'
+
+module RhetButler
+  module SlideRenderers
+    class Cues < SlideRenderer
+      register "cues"
+
+      class XPathExtensions
+        def self.regex(node_set, pattern)
+          re = Regexp.new(pattern)
+          node_set.find_all do |node|
+            node.value =~ re
+          end
+        end
+      end
+
+      def process(string)
+        doc = Nokogiri::HTML::DocumentFragment.parse(string) #may need DocumentFragment::parse
+        doc.xpath('.//*/@class[regex(.,"\b\d+\b")]', XPathExtensions).each do |attr|
+          attr.value = "rhet-butler item " + attr.value
+          attr.value = attr.value.gsub(/\b\d+\b/){|m| "cue-#{m[0]}"}
+        end
+        doc.to_s
+      end
+    end
+  end
+end

data/lib/rhet-butler/slide-renderers/textile.rb

@@ -0,0 +1,14 @@
+require 'redcloth'
+
+module RhetButler
+  module SlideRenderers
+    class Textile < SlideRenderer
+      register "textile"
+      register "texttile"
+
+      def process(string)
+        RedCloth.new(string).to_html
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'rhet-butler/slide-renderer'
+require 'rhet-butler/slide-traverser'
+module RhetButler
+  class SlideRendering < SlideTraverser
+    attr_accessor :root_group
+
+    def setup
+      descend(@root_group, @root_group)
+    end
+
+    def on_slide(slide)
+      slide.content = filter_text(slide.content, slide.content_filters)
+      slide.notes = filter_text(slide.notes, slide.note_filters)
+    end
+
+    def filter_text(text, filters)
+      filters.inject(text) do |text, filter|
+        filter.process(text)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'rhet-butler/yaml-schema'
+
+module RhetButler
+  class SlideTraverser
+    def initialize
+      @iter_stack = []
+      @target_stack = []
+    end
+
+    attr_reader :iter_stack, :target_stack
+
+    def on_group(group)
+      descend(group, group)
+    end
+
+    def ascend
+      target_stack.pop
+      iter_stack.pop
+    end
+
+    def descend(source, dest)
+      iter_stack.push source.each
+      target_stack.push dest
+    end
+
+    def traverse
+      setup
+      until iter_stack.empty?
+        begin
+          item = iter_stack.last.next
+          case item
+          when Slide
+            on_slide(item)
+          when Includer
+            on_include(item)
+          else
+            on_group(item)
+          end
+        rescue StopIteration
+          ascend
+        end
+      end
+    end
+  end
+end