sitefs 1.0.0.beta1

data/lib/sitefs/handlers/tag_page.rb

@@ -0,0 +1,11 @@
+class Sitefs::Handlers::TagPage < Sitefs::Handlers::RubyGen
+  attr_accessor :registry
+
+  def dsl
+    @dsl ||= TagPageDslContext.new registry, path_helper
+  end
+
+  def delay_generation
+    true
+  end
+end

data/lib/sitefs/handlers.rb

@@ -0,0 +1,6 @@
+module Sitefs
+  module Handlers
+    Autoloaded.module do |autoloading|
+    end
+  end
+end

data/lib/sitefs/html_pipelines.rb

@@ -0,0 +1,95 @@
+require 'uri'
+
+require 'html/pipeline'
+require 'html/pipeline/rouge_filter'
+
+module Sitefs
+  class TitleDeterminer < HTML::Pipeline::Filter
+    def call
+      if node = doc.css('h1:first-child').first
+        text = node.text.strip
+
+        result[:title] = node.text unless text.empty?
+      end
+
+      if node = doc.css('h1:first-child + h2').first
+        text = node.text.strip
+
+        result[:subtitle] = node.text unless text.empty?
+      end
+
+      if node = doc.css('h2 + p:nth-of-type(1)').first
+        text = node.text.strip
+
+        result[:description] = node.text[0..199] unless text.empty?
+      end
+
+      doc
+    end
+  end
+
+  class RelativePathFilter < HTML::Pipeline::Filter
+    def call
+      base_path = context[:image_base_path] || context[:base_path]
+      context_path = context[:context_path]
+
+      unless base_path || context_path
+        return doc
+      end
+
+      doc.search('img').each do |img|
+        next if img['src'].nil?
+
+        src = img['src'].strip
+
+        if src.start_with?('/') || src.start_with?('http')
+        elsif context_path
+          src = File.join(context_path, src)
+        end
+
+        if base_path && src.start_with?('/')
+          src = URI.join(base_path, src).to_s
+        end
+
+        img['src'] = src
+      end
+      doc
+
+    end
+
+  end
+
+  module HtmlPipelines
+    extend self
+
+    def content
+      HTML::Pipeline.new([
+         TitleDeterminer,
+         HTML::Pipeline::RougeFilter,
+       ])
+    end
+
+    def markdown
+      HTML::Pipeline.new(
+          [
+            HTML::Pipeline::MarkdownFilter,
+            TitleDeterminer,
+            HTML::Pipeline::AutolinkFilter,
+            HTML::Pipeline::RougeFilter,
+          ], {
+          gfm: true,
+        })
+    end
+
+    def finishing str, **opts
+
+      filters = [
+        RelativePathFilter,
+        HTML::Pipeline::AutolinkFilter,
+        HTML::Pipeline::RougeFilter,
+      ]
+
+      HTML::Pipeline.new(filters, **opts).call(str)
+    end
+  end
+end

data/lib/sitefs/layout_type.rb

@@ -0,0 +1,16 @@
+module Sitefs
+  module LayoutType
+    extend self
+    def default
+      standard
+    end
+
+    def standard
+      :standard
+    end
+
+    def root
+      :root
+    end
+  end
+end

data/lib/sitefs/manifest.rb

@@ -0,0 +1,98 @@
+require 'json'
+
+module Sitefs
+  MANIFEST_FILENAME = '.sitefs-manifest.json'
+
+  class Manifest
+    def initialize root_path
+      @root_path = root_path
+
+      if File.exist? manifest_path
+        @manifest = ManifestFile.from_file manifest_path
+      else
+        @manifest = {}
+      end
+    end
+
+    def clean!
+      @manifest = {}
+      save!
+    end
+
+    def manifest_path
+      File.join @root_path, MANIFEST_FILENAME
+    end
+
+    def resolve_path path
+      path.sub(@root_path, '').sub(/^\//, '').to_sym
+    end
+
+    def [] path
+      @manifest[resolve_path(path)]
+    end
+
+    def []= path, value
+      @manifest[resolve_path(path)] = ManifestFile.ensure(value)
+    end
+
+    def to_h
+      @manifest
+    end
+
+    def as_json *opts
+      to_h.inject({}) do |h, (k,v)|
+        h[k] = v unless v.nil?
+        h
+      end
+    end
+
+    def to_json *opts
+      as_json(*opts).to_json(*opts)
+    end
+
+    def save!
+      File.open(manifest_path, 'w') { |f| f.puts JSON.pretty_generate(as_json) }
+    end
+
+    def delete_generated
+      @manifest.each do |path, file|
+        if file[:'generated_at']
+          full_path = File.join(@root_path, path.to_s)
+          if File.exist? full_path
+            File.delete full_path
+          end
+          file[:'generated_at'] = nil
+          puts "Deleting: #{path}"
+        end
+      end
+
+      save!
+    end
+
+    ManifestFile::ALLOWED_KEYS.each do |key|
+      if key[-3..-1] == '_at'
+        verb = key[0...-3]
+        define_method "#{verb}_path" do |path|
+          now = Time.now
+          send "set_path_#{key}", path, now
+        end
+
+        define_method "#{verb}?" do |path|
+          !!send("path_#{key}", path)
+        end
+      end
+
+      define_method "path_#{key}" do |path|
+        @manifest[resolve_path(path)] && @manifest[resolve_path(path)][key]
+      end
+
+      define_method "set_path_#{key}" do |path, value|
+        @manifest[resolve_path(path)] ||= ManifestFile.new
+        @manifest[resolve_path(path)][key] = value
+        save!
+        @manifest[resolve_path(path)]
+      end
+    end
+
+  end
+end

data/lib/sitefs/manifest_file.rb

@@ -0,0 +1,64 @@
+class Sitefs::ManifestFile
+  ALLOWED_KEYS = %i{generated_at uploaded_at uploaded_hash content_type}
+
+  def initialize **attrs
+    @attributes = attrs
+  end
+
+  def to_h
+    ALLOWED_KEYS.inject({}) do |h, key|
+      h[key] = @attributes[key] if @attributes[key]
+      h
+    end
+  end
+
+  def as_json *opts
+    hsh = to_h
+    if hsh.keys == [:content_type]
+      nil
+    else
+      hsh
+    end
+  end
+
+  def to_json *opts
+    as_json(*opts).to_json(*opts)
+  end
+
+  def [] key
+    raise ArgumentError.new('invalid key') unless ALLOWED_KEYS.include?(key)
+    @attributes[key]
+  end
+
+  def []= key, value
+    raise ArgumentError.new('invalid key') unless ALLOWED_KEYS.include?(key)
+
+    if value.nil?
+      @attributes.delete key
+    else
+      @attributes[key] = value
+    end
+  end
+
+  class << self
+    def ensure val
+      if val.is_a?(self)
+        return val
+      elsif val.respond_to? :to_h
+        return new(**val.to_h)
+      else
+        raise ArgumentError.new('can only convert hashes to ' + self.to_s)
+      end
+    end
+
+    def from_file file
+      content = File.read file
+      raw = JSON.parse content, symbolize_names: true
+
+      raw.inject({}) do |h, (k,v)|
+        h[k] = new **v if k && v
+        h
+      end
+    end
+  end
+end

data/lib/sitefs/page.rb

@@ -0,0 +1,44 @@
+class Sitefs::Page
+  class << self
+    def attribute_key *keys
+      keys.each do |key|
+        define_method(key) { attributes[key.to_s] }
+        define_method("#{key}=") { |v| attributes[key.to_s] = v }
+      end
+    end
+  end
+
+  attr_accessor :path, :attributes
+  attribute_key :title, :subtitle, :description, :tags, :published_at
+  attr_accessor :_rendering_template
+
+  def initialize path_helper, attributes = nil
+    @attributes = attributes
+    @path_helper = path_helper
+    @tags = []
+  end
+
+  def public_tags
+    tags.select {|tag| !tag.start_with?('_')}
+  end
+
+  def href
+    @path_helper.min_href_for @path
+  end
+
+  def href= href
+    @path = @path_helper.pathname_for href
+  end
+
+  def expanded_path
+    File.join(@path_helper.root_path, path)
+  end
+
+  def attributes
+    @attributes ||= AttributeSet.new
+  end
+
+  def [] key
+    attributes[key]
+  end
+end

data/lib/sitefs/page_render.rb

@@ -0,0 +1,6 @@
+class Sitefs::PageRender
+  attr_reader :page, :template
+  def initialize page:, template:
+    @page, @template = page, template
+  end
+end

data/lib/sitefs/path_helper.rb

@@ -0,0 +1,31 @@
+class Sitefs::PathHelper
+  attr_reader :root_path, :source_file
+
+  def initialize root_path, source_file
+    @root_path = File.expand_path root_path
+    @source_file = File.expand_path source_file, @root_path
+  end
+
+  def pathname
+    source_file.sub(File.join(root_path, ''), '')
+  end
+
+  def pathname_for href
+    return nil unless href
+
+    dir = File.dirname source_file
+
+    File.expand_path(href, dir).sub(root_path, '')
+  end
+
+  def min_href_for path
+    return nil unless path
+
+    dir = File.join(File.dirname(source_file), '')
+    File.join(root_path, path, ).sub(dir, '').sub(root_path, '')
+  end
+
+  def full_path_for href
+    File.join(root_path, pathname_for(href))
+  end
+end

data/lib/sitefs/render_context.rb

@@ -0,0 +1,31 @@
+class Sitefs::RenderContext
+  attr_reader :current_page
+
+  def initialize(registry, current_page: nil)
+    @registry, @current_page = registry, current_page
+
+    @content_for = {}
+  end
+
+  def _set_content_for key, val
+    @content_for[key] = val
+  end
+
+  def _get_content_for key
+    @content_for[key]
+  end
+
+  def public_tags
+    @registry ? @registry.public_tags : []
+  end
+
+  def pages_tagged tag_str, all: false
+    @registry ? @registry.pages_tagged(tag_str, all: all) : []
+  end
+
+  class << self
+    def nil
+      @nil ||= new(nil)
+    end
+  end
+end

data/lib/sitefs/render_result.rb

@@ -0,0 +1,16 @@
+module Sitefs
+  class RenderResult
+    attr_reader :text
+    def initialize text:, layout_type: LayoutType.default
+      @text, @layout_type = text, layout_type
+    end
+
+    def hit_root?
+      @layout_type == LayoutType.root
+    end
+
+    def to_s
+      text
+    end
+  end
+end

data/lib/sitefs/renderer.rb

@@ -0,0 +1,65 @@
+require 'erb'
+
+module Sitefs
+  class Renderer
+    attr_reader :context
+    attr_accessor :layout_type
+
+    def initialize content
+      @erb = ERB.new(content, nil, nil, '@_out_buf')
+      @layout_type = LayoutType.default
+      @content_for = {}
+    end
+
+    def is_root!
+      @layout_type = LayoutType.root
+
+      if @context.respond_to? :hit_root!
+        @context.hit_root!
+      end
+    end
+
+    def is_root?
+      @layout_type == LayoutType.root
+    end
+
+    def render context = nil
+      @context = context
+      __result = @erb.result(binding)
+      @context = nil
+
+      RenderResult.new(text: __result, layout_type: @layout_type)
+    end
+
+    def content_for key, txt=nil, &block
+      if block
+        @_out_buf, _buf_was = '', @_out_buf
+        block.call
+        result = eval('@_out_buf', block.binding)
+        @_out_buf = _buf_w
+      else
+        result = txt
+      end
+
+      @context._set_content_for key, (result.strip)
+    end
+
+    def to_s
+      render
+    end
+
+    def title
+      current_page && current_page.title
+    end
+
+    def method_missing name, *args, &blk
+      if context.respond_to? name
+        context.send(name, *args, &blk)
+      elsif RenderContext.nil.respond_to? name
+        RenderContext.nil.send(name, *args, &blk)
+      else
+        raise "Rendering context respond to #{name}"
+      end
+    end
+  end
+end

data/lib/sitefs/renderer_pipeline.rb

@@ -0,0 +1,94 @@
+class Sitefs::RendererPipeline
+  attr_reader :renderers
+
+  def initialize *args
+    @renderers = args
+  end
+
+  def << renderer
+    if renderer.respond_to?(:renderers)
+      renderer.renderers.each do |renderer|
+        self << renderer
+      end
+    else
+      @renderers << renderer
+    end
+  end
+
+  def render context=nil
+    renderers.reverse.reduce('') do |prev, renderer|
+      renderer = ensure_renderer renderer
+
+      result = renderer.render(context) do |arg=nil|
+        if arg
+          if context.respond_to?(:_get_content_for)
+            value = context._get_content_for arg
+          else
+            value = "<!-- No context, so couldn't render content for #{arg} -->"
+          end
+        else
+          value = prev
+        end
+
+        value
+      end
+
+      if result.hit_root?
+        break result.to_s
+      else
+        next result.to_s
+      end
+    end
+  end
+
+  def ensure_renderer renderer
+    if !renderer.respond_to?(:render)
+      if renderer.is_a?(String)
+        renderer = Renderer.new(renderer)
+      else
+        throw "#{renderer.inspect} is not a supported renderer"
+      end
+    end
+
+    renderer
+  end
+
+  class << self
+    def possible_files_for root_path:, source_file:, layout_name: '_layout.html.erb'
+      root_path = File.join(root_path,'')
+
+      files = []
+
+      begin
+        dir = File.join(File.dirname(source_file), '')
+
+        look_at = File.join(dir, layout_name)
+
+        if File.exist? look_at
+          files << look_at
+        end
+
+        source_file = dir
+      end until dir === root_path || root_path.length >= dir.length # safety to ensure the equality doesn't miss
+
+      files
+    end
+
+    def for content_text: nil, **args
+      layouts = possible_files_for **args
+
+      layout_text = layouts.reverse.map do |layout_file|
+        File.read(layout_file)
+      end
+
+      pipeline = new *layout_text
+
+      if content_text
+        pipeline << content_text
+      end
+
+      pipeline
+    end
+  end
+
+end

data/lib/sitefs/servlet.rb

@@ -0,0 +1,31 @@
+require "webrick"
+
+class Sitefs::Servlet < WEBrick::HTTPServlet::FileHandler
+  def initialize server, root, callbacks
+    @sitefs_config = server.config[:SitefsConfig]
+    super
+  end
+
+  def search_file(req, res, basename)
+    case @sitefs_config.index_format
+    when 'github', 'standard'
+      # /file.* > /file/index.html > /file.html
+      super || super(req, res, "#{basename}.html")
+    else
+      super
+    end
+  end
+
+  def do_GET(req, res)
+    rtn = super
+
+    content_type = @sitefs_config.manifest.path_content_type res.filename
+    res['content-type'] = content_type if content_type
+
+    # Disable caching to make dev easier
+    res['Cache-Control'] = "private, max-age=0, proxy-revalidate, " \
+            "no-store, no-cache, must-revalidate"
+
+    rtn
+  end
+end

data/lib/sitefs/tag_page_dsl_context.rb

@@ -0,0 +1,13 @@
+require 'forwardable'
+
+class Sitefs::TagPageDslContext < Sitefs::DslContext
+  extend Forwardable
+  def_delegators :@registry, :pages, :public_tags, :pages_tagged
+
+  def initialize registry, path_helper
+    raise "registry required for #{self.class}" unless registry.is_a? FileRegistry
+
+    super path_helper
+    @registry = registry
+  end
+end

data/lib/sitefs/version.rb

@@ -0,0 +1,3 @@
+module Sitefs
+  VERSION = "1.0.0.beta1"
+end