rhet-butler 0.5.0 → 0.9.0

data/lib/rhet-butler/slide.rb

@@ -1,14 +1,15 @@
 require 'rhet-butler/yaml-type'
 
 module RhetButler
-  class Slide
-    include YamlType
+  class Slide < YamlType
+    register "slide"
+
     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
+          notes filters note_filters
         ]
       end
 
@@ -46,7 +47,8 @@ module RhetButler
     end
 
     def setup_defaults
-      @html_classes = ["step"]
+      @template_name = "slide.html"
+      @html_classes = ["slide"]
       @html_id = nil
       @position = Position.new
       @rotation = Rotation.new
@@ -55,10 +57,6 @@ module RhetButler
       @type = nil
     end
 
-    def initialize
-      setup_defaults
-    end
-
     def initialize_copy(source)
       super
       @config_hash = source.config_hash.dup unless source.config_hash.nil?
@@ -67,25 +65,22 @@ module RhetButler
       @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)
+    def normalize_config(coder)
+      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
+    end
 
+    def configure
       value_from_config("title") do |title|
         @html_id = title.downcase.split(/\s/).join("-")
       end
@@ -136,24 +131,39 @@ module RhetButler
         @scale = value
       end
 
-      value_from_config("type") do |value|
-        @type = value
-        @html_classes << value
+      value_from_config("filters") do |value|
+        @content_filters = value
+      end
+
+      value_from_config("note-filters") do |value|
+        @note_filters = value
+        @html_classes += value.map do |filter|
+          "notes-" + filter.html_class unless filter.html_class.nil?
+        end
       end
     end
 
     attr_reader :config_hash
     attr_accessor :content, :html_classes, :html_id, :notes
-    attr_reader :position, :rotation, :type
+    attr_accessor :position, :rotation, :content_filters, :note_filters
     attr_accessor :scale
+    attr_reader :template_name
+
+    def id_attr
+      if @html_id.nil?
+        return ""
+      else
+        "id='#@html_id'"
+      end
+    end
+
+    def classes
+      @html_classes.join(" ")
+    end
 
     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}'"

data/lib/rhet-butler/stasis/css-transform.rb

@@ -0,0 +1,55 @@
+require 'rhet-butler/stasis/document-transform'
+module RhetButler
+  module Stasis
+    require 'crass'
+    class CSSTransform < DocumentTransform
+      register "text/css"
+
+      def parse_document
+        @parsed = Crass::parse(document.body)
+      end
+
+      def url_nodes(node_list)
+        return [] if node_list.nil?
+
+        list = []
+
+        node_list.each do |node|
+          case node[:node]
+          when :url
+            list << node
+          when :at_rule
+            if node[:name] == "import"
+              list += node[:prelude].find_all do |node|
+                node[:node] == :url or node[:node] == :string
+              end
+            else
+              children = node
+              [:block, :value].each do |key|
+                children = children[key]
+                break if children.nil?
+              end
+              list += url_nodes(children)
+            end
+          else
+            list += url_nodes(node[:children])
+          end
+        end
+        return list
+      end
+
+      def translate_links
+        url_nodes(@parsed).uniq.each do |node|
+          node[:value] = get_link_translation(node[:value]).to_s
+          if node[:node] == :url
+            node[:raw] = "url(#{node[:value]})"
+          end
+        end
+      end
+
+      def render_document
+        Crass::Parser.stringify(@parsed)
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis/document-transform.rb

@@ -0,0 +1,32 @@
+require 'rhet-butler/stasis'
+module RhetButler
+  module Stasis
+    class DocumentTransform
+      def self.register(type)
+        TransformQueue.register(type, self)
+      end
+
+      attr_accessor :document, :queue, :target_path
+
+      def document_source
+        @document.source_uri
+      end
+
+      def save_document
+        @queue.write_document(target_path, render_document)
+      end
+
+      def process
+        parse_document
+
+        translate_links
+
+        save_document
+      end
+
+      def get_link_translation(link)
+        queue.target_for(document, document_source).route_to(queue.target_for(document, link))
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis/html-transform.rb

@@ -0,0 +1,51 @@
+require 'rhet-butler/stasis/document-transform'
+module RhetButler
+  module Stasis
+    require 'nokogiri'
+    class HTMLTransform < DocumentTransform
+      register "text/html"
+
+      NAV_AND_EMBED = %w[
+        //a/@href
+        //applet/@codebase
+        //area/@href
+        //base/@href
+        //body/@background
+        //frame/@longdesc
+        //frame/@src
+        //iframe/@longdesc
+        //iframe/@src
+        //img/@longdesc
+        //img/@src
+        //input/@src
+        //link/@href
+        //object/@codebase
+        //object/@data
+        //script/@src
+        //audio/@src
+        //command/@icon
+        //embed/@src
+        //html/@manifest
+        //source/@src
+        //video/@poster
+        //video/@src
+      ]
+
+      def parse_document
+        @parsed = Nokogiri::HTML(document.body)
+      end
+
+      def translate_links
+        NAV_AND_EMBED.each do |xpath|
+          @parsed.xpath(xpath).each do |attr|
+            attr.value = get_link_translation(attr.value)
+          end
+        end
+      end
+
+      def render_document
+        @parsed.to_html
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis/http-loader.rb

@@ -0,0 +1,19 @@
+require 'rhet-butler/stasis'
+module RhetButler
+  module Stasis
+    class HTTPLoader
+      def initialize
+        require 'net/http'
+      end
+
+      def load(source_uri)
+        response = Net::HTTP.get_response(URI(source_uri.to_s))
+        Document.new.tap do |doc|
+          doc.body = response.body
+          doc.source_uri = source_uri
+          doc.type = response["Content-Type"]
+        end
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis/identity-transform.rb

@@ -0,0 +1,18 @@
+require 'rhet-butler/stasis/document-transform'
+module RhetButler
+  module Stasis
+    class IdentityTransform < DocumentTransform
+      register nil
+
+      def parse_document
+      end
+
+      def translate_links
+      end
+
+      def render_document
+        document.body
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis/rack-loader.rb

@@ -0,0 +1,57 @@
+require 'rhet-butler/stasis'
+module RhetButler
+  module Stasis
+    class RackLoader
+      def initialize(url, app)
+        require 'stringio'
+        @url = url
+        @app = app
+      end
+
+      def root_uri
+        @root_uri ||= Addressable::URI.parse(@url).tap do |root_url|
+          root_url.path = ""
+        end
+      end
+
+      def server_name
+        root_uri.host
+      end
+
+      def load(source_uri)
+        doc = Document.new
+        doc.source_uri = source_uri
+
+        source_uri = root_uri.join(source_uri).route_from(root_uri).to_s
+        source_uri = "/" if source_uri == "#"
+
+        env = {
+          "REQUEST_METHOD" => "GET",
+          "SCRIPT_NAME" => "",
+          "PATH_INFO" => source_uri,
+          "QUERY_STRING" => "",
+          "SERVER_NAME" => server_name,
+          "rack.errors" => StringIO.new,
+          "rack.input" => StringIO.new,
+          "rack.url_scheme" => "http",
+          "rack.version" => Rack::VERSION,
+          "rack.multithread" => false,
+          "rack.multiprocess" => false,
+          "rack.runonce" => false,
+          "rack.hijack?" => false,
+        }
+
+        response = @app.call(env)
+
+        code, headers, body = *response
+
+        unless code == 200
+          raise "Bad response from local server: #{response[0..1].inspect} body: #{response[2].to_a.join.length}"
+        end
+        doc.type = headers["Content-Type"]
+        doc.body = body.to_a.join("")
+        return doc
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis/resource-mapping.rb

@@ -0,0 +1,55 @@
+require 'rhet-butler/stasis'
+module RhetButler
+  module Stasis
+    class ResourceMapping
+      def initalize(queue)
+        @queue = queue
+      end
+
+      attr_writer :default_uri
+
+      def default_uri
+        Addressable::URI.parse(@default_uri)
+      end
+
+      def absolute_uri(uri)
+        uri = default_uri.join(uri)
+        if uri == default_uri
+          uri = uri.join("index.html")
+        end
+        return uri
+      end
+
+      def relative_uri(uri)
+        default_uri.route_to(absolute_uri(uri))
+      end
+
+      def localized(uri)
+        return "/index.html" if uri == "/"
+
+        uri = relative_uri(uri)
+
+        if uri.relative?
+          return uri.to_s
+        end
+
+        query_values = uri.query_values(Array)
+        [
+          [uri.host, uri.port, uri.user, uri.scheme == 'http' ? nil : uri.scheme].compact.join("-"),
+          uri.path,
+          (query_values ? query_values.map{|pair| pair.join("=")}.join(",") : nil)
+        ].compact.map do |part|
+          part.sub(%r{\A/},'').sub(%r{/\Z},'')
+        end.join("/")
+      end
+
+      def storage_for(uri)
+        localized(uri).sub(%r{^/},'')
+      end
+
+      def target_link_for(uri)
+        default_uri.join(storage_for(uri))
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis/transform-queue.rb

@@ -0,0 +1,87 @@
+require 'rhet-butler/stasis'
+module RhetButler
+  module Stasis
+    class TranformationOrder
+      attr_accessor :source_link, :target_link, :storage_target
+
+      def initialize(source_link, target_link, storage_target)
+        @source_link, @target_link, @storage_target =
+          source_link, target_link, storage_target
+      end
+    end
+
+    class TransformQueue
+      class << self
+        def transformers
+          @transformers ||= {}
+        end
+
+        def register(type, klass)
+          transformers[type] = klass
+        end
+
+        def lookup(type)
+          transformers.fetch(type) do
+            transformers.fetch(nil)
+          end
+        end
+      end
+
+      def initialize
+        @list = []
+        @hash = {}
+      end
+      attr_accessor :loader, :writer, :mapping
+
+      def add(source)
+        store_to = mapping.storage_for(source)
+        link_target = mapping.target_link_for(source)
+        add_mapping(source, link_target, store_to)
+        return link_target
+      end
+
+      def add_mapping(source_uri, target_uri, target_path)
+        @hash[source_uri] = target_uri
+        @list << TranformationOrder.new(source_uri, target_uri, target_path)
+      end
+
+      def transform_class(type)
+        self.class.lookup(type)
+      end
+
+      def target_for(document, link)
+        link = canonicalize_uri(mapping.absolute_uri(document.source_uri).join(link))
+        @hash.fetch(link) do
+          add(link)
+        end
+      end
+
+      def canonicalize_uri(string)
+        uri = Addressable::URI.parse(string).normalize
+        uri.fragment = nil
+        uri
+      end
+
+      def load_document(source_path)
+        loader.load(canonicalize_uri(source_path))
+      end
+
+      def write_document(target_path, document_body)
+        writer.write(target_path, document_body)
+      end
+
+      def go
+        until @list.empty?
+          order = @list.pop
+
+          doc = load_document(order.source_link)
+          transformer = transform_class(doc.type).new
+          transformer.queue = self
+          transformer.document = doc
+          transformer.target_path = order.storage_target
+          transformer.process
+        end
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis/writer.rb

@@ -0,0 +1,35 @@
+require 'rhet-butler/stasis'
+module RhetButler
+  module Stasis
+    class Writer
+      def initialize(root)
+        @root = root
+      end
+      attr_accessor :store_log
+
+      def write(path, content)
+        store_log.puts "Writing: #{path}" if store_log.respond_to? :puts
+        store(path, content)
+      end
+
+      def store(path, content)
+        File::open(File::join(@root, path), "w") do |file|
+          file.write(content)
+        end
+      end
+    end
+
+    class ValiseWriter < Writer
+      def initialize(valise)
+        @target_valise = valise
+      end
+
+      attr_reader :target_valise
+
+      def store(path, content)
+        target = target_valise.get(path).writable.first
+        target.contents = content
+      end
+    end
+  end
+end

data/lib/rhet-butler/stasis.rb

@@ -0,0 +1,18 @@
+require 'addressable/uri'
+module RhetButler
+  module Stasis
+    class Document
+      attr_accessor :type, :body, :source_uri
+    end
+  end
+end
+
+require 'rhet-butler/stasis/rack-loader'
+require 'rhet-butler/stasis/http-loader'
+require 'rhet-butler/stasis/writer'
+require 'rhet-butler/stasis/resource-mapping'
+require 'rhet-butler/stasis/transform-queue'
+require 'rhet-butler/stasis/document-transform'
+require 'rhet-butler/stasis/identity-transform'
+require 'rhet-butler/stasis/html-transform'
+require 'rhet-butler/stasis/css-transform'

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

@@ -1,44 +1,36 @@
-require 'valise'
-require 'rhet-butler/html-generator'
-require 'rhet-butler/arrangement'
-require 'rhet-butler/file-manager'
-require 'rhet-butler/slide-loader'
+require 'rhet-butler/web/main-app'
+require 'rhet-butler/stasis'
 
 module RhetButler
   class StaticGenerator
     def initialize(file_manager)
-      @configuration = file_manager.base_config
-      @base_valise = file_manager.slide_files
+      @file_manager = file_manager
       @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
+    attr_reader :target_valise
+    attr_accessor :store_log
 
-    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
+    def app
+      web_app = Web::MainApp.new(@file_manager)
+      web_app.presentation_app_class = Web::MemoizedPresentationApp
+      web_app.assets_app_class = Web::MemoizedAssetsApp
+      web_app.capture_exceptions = false
+      web_app.check
+      web_app.builder.to_app
     end
 
     def go!
-      target_valise.get("presentation.html").writable.first.contents = html_document
+      app_url = "http://example.com/"
+      transform_queue = Stasis::TransformQueue.new
+      transform_queue.loader = Stasis::RackLoader.new(app_url, app)
+      transform_queue.mapping = Stasis::ResourceMapping.new
+      transform_queue.mapping.default_uri = app_url
+      transform_queue.writer = Stasis::ValiseWriter.new(@target_valise)
+      transform_queue.writer.store_log = store_log
 
-      populate_assets
+      transform_queue.add("/")
+      transform_queue.go
     end
   end
 end

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

@@ -2,12 +2,16 @@ module RhetButler
   module Web
     class AssetsApp
       def initialize(file_manager)
-        @template_handler = file_manager.base_assets
+        @file_manager = file_manager
       end
 
-      attr_reader :template_handler
+      attr_reader :file_manager
 
       class AssetsContext
+        def initialize(template_handler)
+          @template_handler = template_handler
+        end
+
         def render(path, locals = nil)
           template = @template_handler.find(path).contents
           if template.respond_to? :render
@@ -18,13 +22,12 @@ module RhetButler
         end
       end
 
+      def template_handler
+        file_manager.base_assets(::Tilt::Cache.new)
+      end
+
       def assets_context
-        @context ||=
-          begin
-            context = AssetsContext.new
-            context.instance_variable_set("@template_handler", template_handler)
-            context
-          end
+        AssetsContext.new(template_handler)
       end
 
       def call(env)
@@ -34,6 +37,19 @@ module RhetButler
 
         mime_type = Rack::Mime.mime_type(extension, "text/plain")
         [200, {'Content-Type' => mime_type}, [assets_context.render(asset_path)]]
+      rescue Object => ex
+        puts ex
+        raise
+      end
+    end
+
+    class MemoizedAssetsApp < AssetsApp
+      def template_handler
+        @template_handler ||= super
+      end
+
+      def assets_context
+        @assets_contenxt ||= super
       end
     end
   end