rhet-butler 0.5.0

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

@@ -0,0 +1,361 @@
+require 'rhet-butler/slide-group'
+require 'rhet-butler/slide'
+require 'rhet-butler/slide-includer'
+require 'rhet-butler/arrangement'
+
+module RhetButler
+  class SlideLoader
+    def initialize(slide_files, configuration)
+      @file_set = slide_files
+      @default_slide_type = configuration.default_slide_type
+      @root_slide = configuration.root_slide
+      @root_group = SlideGroup.new
+      @blueprint = configuration.arrangement_blueprint
+    end
+
+    def load_slides
+      root_group = SlideGroup.new
+      includer = Includer.new
+      includer.path = @root_slide
+      root_group.slides = [includer]
+
+      loading = FileLoading.new(@file_set)
+      including = IncludeProcessor.new(loading)
+      including.root_group = root_group
+      including.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
+    end
+  end
+end

data/lib/rhet-butler/slide.rb

@@ -0,0 +1,164 @@
+require 'rhet-butler/yaml-type'
+
+module RhetButler
+  class Slide
+    include YamlType
+    class << self
+      def optional_config
+        %w[
+          title html_id html_classes html_class
+          pos_x pos_y pos_z rot_x rot_y rot_z scale
+          notes type
+        ]
+      end
+
+      def required_config
+        %w[content]
+      end
+    end
+
+    class Position
+      def initialize
+        @x = 0
+        @y = 0
+        @z = 0
+      end
+
+      attr_accessor :x, :y, :z
+
+      def to_attrs
+        "data-x='#@x' data-y='#@y' data-z='#@z'"
+      end
+    end
+
+    class Rotation
+      def initialize
+        @x = 0
+        @y = 0
+        @z = 0
+      end
+
+      attr_accessor :x, :y, :z
+
+      def to_attrs
+        "data-rotate-x='#@x' data-rotate-y='#@y' data-rotate-z='#@z'"
+      end
+    end
+
+    def setup_defaults
+      @html_classes = ["step"]
+      @html_id = nil
+      @position = Position.new
+      @rotation = Rotation.new
+      @scale = 1.0
+      @notes = ""
+      @type = nil
+    end
+
+    def initialize
+      setup_defaults
+    end
+
+    def initialize_copy(source)
+      super
+      @config_hash = source.config_hash.dup unless source.config_hash.nil?
+      @content = source.content.dup unless source.content.nil?
+      @notes = source.notes.dup unless source.notes.nil?
+      @html_id = source.html_id.dup unless source.html_id.nil?
+      @position = source.position.dup unless source.position.nil?
+      @rotation = source.rotation.dup unless source.rotation.nil?
+      @type = source.type.dup unless source.type.nil?
+      @html_classes = source.html_classes.dup unless source.html_classes.nil?
+    end
+
+    def init_with(coder)
+      setup_defaults
+
+      @config_hash =
+        case coder.type
+        when :map
+          coder.map
+        when :scalar
+          { 'content' => coder.scalar.to_s }
+        when :seq
+          warn "Got a sequence for a slide - not sure how to parse that.  Skipping"
+        end
+
+      check_config_hash(@config_hash)
+
+      value_from_config("title") do |title|
+        @html_id = title.downcase.split(/\s/).join("-")
+      end
+
+      value_from_config("content") do |content|
+        raise "Slide content needs to be a string, was: #{content.inspect}" unless String === content
+        @content = content
+      end
+
+      value_from_config("notes") do |notes|
+        raise "Slide notes needs to be a string, was: #{notes.inspect}" unless String === notes
+        @notes = notes
+      end
+
+      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
+
+      value_from_config("pos_x") do |value|
+        @position.x = value
+      end
+      value_from_config("pos_y") do |value|
+        @position.y = value
+      end
+      value_from_config("pos_z") do |value|
+        @position.z = value
+      end
+
+      value_from_config("rot_x") do |value|
+        @rotation.x = value
+      end
+      value_from_config("rot_y") do |value|
+        @rotation.y = value
+      end
+      value_from_config("rot_z") do |value|
+        @rotation.z = value
+      end
+
+      value_from_config("scale") do |value|
+        @scale = value
+      end
+
+      value_from_config("type") do |value|
+        @type = value
+        @html_classes << value
+      end
+    end
+
+    attr_reader :config_hash
+    attr_accessor :content, :html_classes, :html_id, :notes
+    attr_reader :position, :rotation, :type
+    attr_accessor :scale
+
+    def impress_attrs
+      attrs = []
+      unless @html_id.nil?
+        attrs << "id='#@html_id'"
+      end
+
+      attrs << "class='#{@html_classes.join(" ")}'"
+      attrs << @position.to_attrs
+      attrs << @rotation.to_attrs
+      attrs << "data-scale='#{"%0.2f" % scale}'"
+
+      attrs.join(" ")
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'valise'
+require 'rhet-butler/html-generator'
+require 'rhet-butler/arrangement'
+require 'rhet-butler/file-manager'
+require 'rhet-butler/slide-loader'
+
+module RhetButler
+  class StaticGenerator
+    def initialize(file_manager)
+      @configuration = file_manager.base_config
+      @base_valise = file_manager.slide_files
+      @target_valise = file_manager.target_valise
+      @root_slide = configuration.root_slide
+      @root_slide_template = configuration.root_slide_template
+      @template_handler = file_manager.aspect_templates(:viewer)
+    end
+
+    attr_accessor :target_directory, :root_slides
+    attr_reader :configuration, :template_handler, :target_valise
+
+    def html_document
+      html_generator = HTMLGenerator.new(configuration, template_handler)
+      html_generator.slides = SlideLoader.new(@base_valise, configuration).load_slides
+
+      return html_generator.render(@root_slide_template)
+    end
+
+    def populate_assets
+      @base_valise.sub_set("templates").glob("assets/**").map do |stack|
+        stack.segments[1..-2] +
+          [stack.segments.last.sub(/(.*(?:\..*)?).*/){|| $1}]
+      end.uniq.each do |target_file|
+        target_valise.get(target_file).writable.first.contents =
+          template_handler.render(target_file, nil)
+      end
+    end
+
+    def go!
+      target_valise.get("presentation.html").writable.first.contents = html_document
+
+      populate_assets
+    end
+  end
+end

data/lib/rhet-butler/web/assets-app.rb

@@ -0,0 +1,40 @@
+module RhetButler
+  module Web
+    class AssetsApp
+      def initialize(file_manager)
+        @template_handler = file_manager.base_assets
+      end
+
+      attr_reader :template_handler
+
+      class AssetsContext
+        def render(path, locals = nil)
+          template = @template_handler.find(path).contents
+          if template.respond_to? :render
+            template.render(self, locals)
+          else
+            template
+          end
+        end
+      end
+
+      def assets_context
+        @context ||=
+          begin
+            context = AssetsContext.new
+            context.instance_variable_set("@template_handler", template_handler)
+            context
+          end
+      end
+
+      def call(env)
+        asset_path = env["PATH_INFO"]
+        asset_path.sub!(/^\//,"")
+        extension = asset_path.sub(/.*[.]/, ".")
+
+        mime_type = Rack::Mime.mime_type(extension, "text/plain")
+        [200, {'Content-Type' => mime_type}, [assets_context.render(asset_path)]]
+      end
+    end
+  end
+end