stormy 0.0.1

data/lib/stormy/engines/erb.rb

@@ -0,0 +1,8 @@
+class Stormy::Engines::Erb  < Stormy::Engines::Base
+
+  def render(body,bindings)
+    engine = ::ERB.new(body, 0, "<>")
+    engine.result OpenStruct.new(bindings).instance_eval { binding }
+  end
+
+end

data/lib/stormy/engines/haml.rb

@@ -0,0 +1,9 @@
+require "haml"
+
+class Stormy::Engines::Haml < Stormy::Engines::Base
+
+  def render(body,bindings,&block)
+    engine = Haml::Engine.new(body)
+    engine.render(Object.new, bindings,&block)
+  end
+end

data/lib/stormy/engines/html.rb

@@ -0,0 +1,6 @@
+class Stormy::Engines::Html< Stormy::Engines::Base
+
+  def render(body,bindings,&block)
+    body
+  end
+end

data/lib/stormy/engines/markdown.rb

@@ -0,0 +1,8 @@
+require "kramdown"
+
+class Stormy::Engines::Markdown < Stormy::Engines::Base
+
+  def render(body,bindings,&block)
+    Kramdown::Document.new(body).to_html
+  end
+end

data/lib/stormy/engines/sass.rb

@@ -0,0 +1,12 @@
+require "sass"
+
+class Stormy::Engines::Sass < Stormy::Engines::Base
+
+  def render(body,bindings,&block)
+    engine = Sass::Engine.new(body, 
+                              syntax: :scss,
+                              load_paths: [ @app.join("public/assets") ]
+                             )
+    engine.render
+  end
+end

data/lib/stormy/layout.rb

@@ -0,0 +1,21 @@
+class Stormy::Layout < Stormy::Chunk
+
+  def render(child_template)
+    raise "No Matching Template: #{@key}" unless @template
+    output = child_template.render
+    @details.merge!(child_template.details)
+    @template.render do |section=nil|
+      output
+    end
+  end
+
+  def self.fetch(app,key,params)
+    details = app.cache.layout(key) do 
+      app.store.layout(key)
+    end
+
+    self.new(app,details,params)
+  end
+
+  
+end

data/lib/stormy/page.rb

@@ -0,0 +1,32 @@
+class Stormy::Page < Stormy::Chunk
+
+  def initialize(app, details, params)
+
+    super(app,details,params)
+
+    @layout = app.layout(@details["layout"],@details) if @details["layout"]
+    @template.content = resolve_content if details[:content] && @template
+  end
+
+  def self.fetch(app,key,params)
+    details = app.cache.page(key) do 
+      app.store.page(key)
+    end
+
+    self.new(app,details,params)
+  end
+
+  def render(status = nil)
+    output =  @layout && mime_type == "text/html" ? @layout.render(@template) : @template.render
+    if details[:redirect]
+      [status || 301, {'Content-Type' => 'text','Location' => details[:redirect]}, ['301 found'] ]
+    else
+      [status || 200, {'Content-Type' => mime_type }, [ output ] ]
+    end
+  end
+
+  def mime_type
+    @mime_type ||= Rack::Mime.mime_type(File.extname(details["key"]),"text/html")
+  end
+
+end

data/lib/stormy/static.rb

@@ -0,0 +1,20 @@
+class Stormy::Static 
+
+  def initialize(root)
+    @root = root
+    @rack_file = Rack::File.new(root)
+  end
+
+  def can_serve?(path)
+    extension = Stormy::Template.extract_extension(path)
+
+    if !Stormy::Template.rendered_extension?(extension)
+      File.exists?(File.join(@root, path))
+    end
+  end
+
+  def serve(path)
+    @rack_file.call("PATH_INFO" => path, "REQUEST_METHOD"=>"GET")
+  end
+
+end

data/lib/stormy/stores/base.rb

@@ -0,0 +1,52 @@
+require "yaml" 
+
+module Stormy::Stores 
+
+  class Base
+
+    def initialize(app)
+      @app = app
+    end
+
+    # find the page that matches a key
+    def page(key)
+    end
+
+    def layout(key)
+    end
+
+    # find the content that matches a category and a key
+    def content(category,key)
+    end
+
+    # get all the content that matches a category
+    def content_list(category)
+    end
+
+    def extract_content(body)
+    end
+
+    def extract(key,string, path_meta = {})
+      return {} unless string.present?
+
+      details = {}
+      if(string =~ /^(---\w*$\n.*?)^---\w*$\n(.*)/m)
+        begin 
+          details = YAML.load($1).symbolize_keys
+          details[:body] = $2
+        rescue Exception => e
+          raise "Error Parsing YAML #{key}: #{e.to_s}"
+        end
+      else
+        details[:body] = string
+      end
+
+      details.merge!(path_meta)
+      details[:permalink] = Stormy::Template.extract_segment(key)
+      details[:key] = key
+      details
+    end
+
+  end
+
+end

data/lib/stormy/stores/file_store.rb

@@ -0,0 +1,70 @@
+class Stormy::Stores::FileStore < Stormy::Stores::Base
+
+  def lookup_filename(base,path)
+    files = Dir.glob(@app.join(base,"#{path}.*"))
+    if valid_file?(files[0])
+      return files[0], {}
+    elsif File.directory?(@app.join(base,path))
+      files = Dir.glob(@app.join(base,path,"index.*"))
+      return files[0], {}
+    else 
+      # split by separators and see if there we can match the pieces to segments
+      match_segments(base,path)
+    end
+  end
+
+  def layout(key)
+    read_key("layouts",key)
+  end
+
+  def page(key)
+    read_key("public",key)
+  end
+  
+  def content(category,key)
+    read_key("content/#{category}",key)
+  end
+
+  def content_list(category, options)
+    base = @app.join("content",category)
+    files = Dir.glob(File.join(base,"*.*"))
+    if options[:order] 
+      files = files.sort
+      files = files.reverse if options[:desc]
+    end
+    files.map { |file| read_file(file, File.basename(file)) }
+  end
+
+  def read_key(base,path)
+    file, path_meta = lookup_filename(base,path)
+    return {} unless file
+    read_file(file,path,path_meta)
+  end
+
+  def read_file(file, path, path_meta = {})
+    fp = File.open(file,"rt:UTF-8")
+    path_meta[:path] = file
+    extract(path, fp.read, path_meta)
+  end
+
+  def match_segments(base,path)
+    path_pieces = path.split("/").reject(&:blank?)
+    permalink_piece = path_pieces.pop
+    partial_path = path_pieces.join("/")
+    if File.directory?(@app.join(base,partial_path))
+      files = Dir.glob(@app.join(base,partial_path,":*.*"))
+      if valid_file?(files[0])
+        extension = File.extname(files[0])
+        keyname = File.basename(files[0], extension)[1..-1]
+        return files[0], { keyname.to_sym => permalink_piece }
+      end
+    end
+    nil
+  end
+
+
+  def valid_file?(filename)
+    filename.present? && !File.directory?(filename)
+  end
+
+end

data/lib/stormy/template.rb

@@ -0,0 +1,67 @@
+class Stormy::Template
+
+  attr_reader :details
+  attr_accessor :content
+
+  def initialize(app,key,details)
+    @app = app
+    @details = details
+    @key = key
+    @body = details["body"]
+
+    @engine = resolve_engine(self.class.extract_extension(@key))
+  end
+
+  def render(&block)
+    if @engine
+      @engine.render(@body,resolve_bindings,&block)
+    else
+      nil
+    end
+  end
+
+  protected
+
+  @@engines = {
+    "md" => "Markdown",
+    "haml" => "Haml",
+    "txt"  => "Text",
+    "html" => "Html",
+    "erb" => "Erb",
+    "scss" => "Sass"
+  }
+
+  @@supported_extensions = @@engines.keys
+
+  def self.rendered_extension?(extension)
+    @@supported_extensions.include?(extension)
+  end
+  
+  def self.extract_segment(path)
+    extension = extract_extension(path)
+    if rendered_extension?(extension)
+      File.basename(path,"." + extension)
+    else 
+      File.basename(path)
+    end
+  end
+
+  def self.extract_extension(key)
+    return "txt" unless key.include?(".")
+    key.split(".")[-1].to_s.downcase
+  end
+
+  def resolve_engine(extension)
+    engine = @@engines[extension]
+    if !engine.nil?
+      "Stormy::Engines::#{engine}".constantize.new(@app)
+    end
+  end
+
+  def resolve_bindings
+    { 
+      meta: @details
+    }.merge(@content || {})
+  end
+
+end

data/lib/stormy/version.rb

@@ -0,0 +1,3 @@
+module Stormy
+  VERSION="0.0.1"
+end

data/lib/stormy_app.rb

@@ -0,0 +1,40 @@
+class StormyApp
+
+  attr_reader :root, :cache, :store, :defaults, :options, :page_not_found
+
+  def initialize(options)
+    @options = options
+    @root = options[:root] || raise("Missing :root config")
+    @cache = (options[:cache] || Stormy::Caches::DummyCache).new(self)
+    @store = (options[:store] || Stormy::Stores::FileStore).new(self)
+    @page_not_found = (options[:page_not_found] || "/404")
+    @defaults =  YAML.load_file(File.join(root, options[:defaults] || 'config.yml')) rescue {}
+    @defaults.symbolize_keys!
+  end
+
+  def page(path,params={})
+    Stormy::Page.fetch(self,path,params)
+  end
+
+  def layout(path,params={})
+    Stormy::Layout.fetch(self,path,params)
+  end
+
+  def content(category,key)
+    Stormy::Content.fetch(self,category,key)
+  end
+
+  def content_list(category,options={})
+    Stormy::ContentList.fetch(self,category,options)
+  end
+
+  def template(key,details)
+    Stormy::Template.new(self,key,details)
+  end
+
+  def join(*args)
+    sanitized_args = [ self.root ] + args.map { |arg| arg.gsub("..","") }
+    File.join(*sanitized_args)
+  end
+
+end

data/lib/stormy_server.rb

@@ -0,0 +1,41 @@
+require "rack"
+require "rack/mime"
+
+class StormyServer
+  def initialize(config_options)
+    @app = StormyApp.new(config_options)
+    @file_server = Stormy::Static.new(File.join(@app.root,"public"))
+  end
+
+  def call(env)
+    render(::Rack::Utils.unescape(env['PATH_INFO']))
+  end
+
+
+  def render(path)
+    if @file_server.can_serve?(path)
+      @file_server.serve(path)
+    else
+      output = render_page(path)
+      if output
+        output
+      else
+        [404, {"Content-Type" => "text/html"}, [ "Page Not Found" ] ] 
+      end
+    end
+  end
+
+  def render_page(path)
+    @page = @app.page(path,{ "path" =>  path })
+
+    if @page.valid?
+      @page.render
+    else
+      @error_page = @app.page(@app.page_not_found, { "path" => @app.page_not_found })
+      if @error_page.valid? 
+        @error_page.render(404)
+      end
+    end
+  end
+end
+

data/spec/fixtures/dummy_site/config.yml

@@ -0,0 +1 @@
+layout: main

data/spec/fixtures/dummy_site/content/blog/blog-post-1.md

@@ -0,0 +1,5 @@
+---
+title: Super post
+author: Svend Karlson
+---
+This is the content of the blog post yo!  This is the content of the blog post yo!  This is the content of the blog post yo!

data/spec/fixtures/dummy_site/content/blog/blog-post-2.md

@@ -0,0 +1,5 @@
+---
+title: Super post 2
+author: Bob Johnson
+---
+This is the content of the second blog post.

data/spec/fixtures/dummy_site/layouts/main.haml

@@ -0,0 +1,2 @@
+%h1 Title
+= yield

data/spec/fixtures/dummy_site/public/blog.haml

@@ -0,0 +1,12 @@
+---
+content:
+  type: blog
+  order: true
+---
+%ul.posts
+  - blog.each do |post|
+    %li.post
+      %h2= post[:title]
+      %h3= post[:author]
+      = post[:body]
+