shinmun 0.1 → 0.2

data/lib/shinmun/blog.rb

@@ -0,0 +1,319 @@
+module Shinmun
+
+  class Blog
+
+    # Define reader methods for configuration.
+    def self.config_reader(file, *names)
+      names.each do |name|
+        name = name.to_s        
+        define_method(name) { @config[file][name] }
+      end
+    end
+
+    attr_reader :root, :posts, :pages, :aggregations
+    
+    config_reader 'config/assets.yml', :javascript_files, :stylesheet_files, :base_path, :images_path, :javascripts_path, :stylesheets_path
+    config_reader 'config/blog.yml', :title, :description, :language, :author, :url, :repository
+    config_reader 'config/categories.yml', :categories
+
+    # Initialize the blog, load the config file and write the index files.
+    def initialize
+      @config = Cache.new do |file|
+        YAML.load(File.read(file))
+      end
+
+      @stylesheets = Cache.new
+
+      @templates = Cache.new do |file|
+        ERB.new(File.read(file))
+      end
+
+      @javascripts = Cache.new do |file|
+        script = File.read(file)
+        script = Packr.pack(script) if defined?(Packr)
+        "/* #{file} */\n #{script}\n"
+      end
+
+      @posts_cache = Cache.new do |file|
+        Post.new(:filename => file).load
+      end
+
+      @pages_cache = Cache.new do |file|
+        Post.new(:filename => file).load
+      end
+
+      Dir['pages/**/*'].each do |file|
+        @pages_cache.load(file) if File.file?(file) and file[-1, 1] != '~'
+      end
+
+      Dir['posts/**/*'].each do |file|
+        @posts_cache.load(file) if File.file?(file) and file[-1, 1] != '~'
+      end
+
+      @config.load('config/aggregations.yml')
+      @config.load('config/assets.yml')
+      @config.load('config/blog.yml')
+      @config.load('config/categories.yml')
+
+      @aggregations = {}
+
+      load_aggregations
+
+      Thread.start do
+        sleep 300
+        load_aggregations
+      end
+    end
+
+    def load_aggregations
+      @config['config/aggregations.yml'].to_a.each do |c|
+        @aggregations[c['name']] = Object.const_get(c['class']).new(c['url'])
+      end
+    end
+
+    # Reload config, assets and posts.
+    def reload
+      if @config.dirty? || @templates.dirty?
+        @config.reload!
+        @templates.reload!
+        @posts_cache.reload!
+        @pages_cache.reload!        
+      else
+        @config.reload_dirty!
+        @templates.reload_dirty!
+        @posts_cache.reload_dirty!
+        @pages_cache.reload_dirty!
+      end
+
+      @posts = @posts_cache.values.sort_by { |p| p.date }.reverse
+      @pages = @pages_cache.values
+
+      pack_javascripts if @javascripts.dirty? or @javascripts.empty?
+      pack_stylesheets if @stylesheets.dirty? or @stylesheets.empty? 
+
+      load 'templates/helpers.rb'
+    end
+
+    # Use rsync to synchronize the rendered blog to web server.
+    def push
+      system "rsync -avz public/ #{repository}"
+    end
+
+    def urlify(string)
+      string.downcase.gsub(/[ -]+/, '-').gsub(/[^-a-z0-9_]+/, '')
+    end
+
+    # Compress the javascripts using PackR and write them to one file called 'all.js'.
+    def pack_javascripts
+      @javascripts.reload_dirty!
+      File.open("assets/#{javascripts_path}/all.js", "wb") do |io|
+        for file in javascript_files
+          io << @javascripts["assets/#{javascripts_path}/#{file.strip}.js"] << "\n\n"
+        end
+      end
+    end
+
+    # Pack the stylesheets and write them to one file called 'all.css'.
+    def pack_stylesheets
+      @stylesheets.reload_dirty!
+      File.open("assets/#{stylesheets_path}/all.css", "wb") do |io|
+        for file in stylesheet_files
+          io << @stylesheets["assets/#{stylesheets_path}/#{file.strip}.css"] << "\n\n"
+        end
+      end
+    end
+
+    # Write a file to output directory.
+    def write_file(path, data)
+      FileUtils.mkdir_p("public/#{base_path}/#{File.dirname path}")
+
+      open("public/#{base_path}/#{path}", 'wb') do |file|
+        file << data
+      end    
+    end
+
+    # Return all posts for a given month.
+    def posts_for_month(year, month)
+      posts.select { |p| p.year == year and p.month == month }
+    end
+
+    # Return all posts in given category.
+    def posts_for_category(category)
+      name = category['name']
+      posts.select { |p| p.category == name }
+    end
+
+    # Return all posts with any of given tags.
+    def posts_with_tags(tags)
+      return [] if tags.nil?
+      tags = tags.split(',').map { |t| t.strip } if tags.is_a?(String)
+      posts.select do |post|
+        tags.any? do |tag| 
+          post.tags.to_s.include?(tag) 
+        end
+      end
+    end
+
+    # Return all months as tuples of [year, month].
+    def months
+      posts.map { |p| [p.year, p.month] }.uniq.sort
+    end
+
+    # Create a new post with given title.
+    def create_post(title)
+      date = Date.today
+      name = urlify(title)
+      path = "#{date.year}/#{date.month}/#{name}.md"
+
+      if File.exist?(file)
+        raise "#{file} exists"
+      else
+        Post.new(:path => path,
+                 :title => title,
+                 :date => date).save
+      end
+    end
+
+    def find_page(path)
+      pages.find { |p| p.path == path }
+    end
+
+    def find_post(path)
+      posts.find { |p| p.path == path }
+    end
+
+    def find_category(category)
+      category = urlify(category)
+      categories.find { |c| urlify(c['name']) == category }
+    end
+
+    # Render template with given variables.
+    def render_template(name, vars)
+      template = Template.new(@templates["templates/#{name}"], name)
+      template.set_variables(vars)
+      template.render
+    end
+
+    def render_layout(vars)
+      render_template("layout.rhtml", vars.merge(:blog => self))
+    end
+
+    # Render named template and insert into layout with given variables.
+    def render(name, vars)
+      render_layout(vars.merge(:content => render_template(name, vars.merge(:blog => self))))
+    end
+
+    # Render given post using the post template and the layout template.
+    def render_post(post)
+      render('post.rhtml', post.variables.merge(:header => post.category))
+    end
+
+    # Render given page using only the layout template.
+    def render_page(page)
+      render_layout(page.variables.merge(:content => page.body_html))
+    end
+
+    # Render comments.
+    def render_comments(comments)
+      render_template('comments.rhtml', :comments => comments)
+    end
+
+    # Render index page using the index and the layout template.
+    def render_index_page
+      render('index.rhtml', 
+             :header => 'Home',
+             :posts => posts)
+    end
+
+    # Render the category summary for given category.
+    def render_category(category)
+      posts = posts_for_category(category)
+      render("category.rhtml",  
+             :header => category['name'],
+             :category => category,
+             :posts => posts)
+    end
+
+    # Render the archive summary for given month.
+    def render_month(year, month)
+      path = "#{year}/#{month}"
+      month_name = Date::MONTHNAMES[month]
+      posts = posts_for_month(year, month)
+      render("month.rhtml", 
+             :header => "#{month_name} #{year}",
+             :year => year, 
+             :month => month_name, 
+             :posts => posts)
+    end
+
+    # Render index feed using the feed template.
+    def render_index_feed
+      render_template("index.rxml", 
+                      :blog => self,
+                      :posts => posts)
+    end
+
+    # Render category feed for given category using the feed template .
+    def render_category_feed(category)
+      render_template("category.rxml", 
+                      :blog => self,
+                      :category => category, 
+                      :posts => posts_for_category(category))
+    end
+
+    def write_index_page
+      write_file("index.html", render_index_page)
+    end
+
+    # Write all pages.
+    def write_pages
+      for page in pages
+        write_file("#{page.path}.html", render_page(page))
+      end
+    end
+
+    # Write all posts.
+    def write_posts
+      for post in posts
+        write_file("#{post.path}.html", render_post(post))
+      end
+    end
+
+    # Write archive summaries.
+    def write_archives
+      for year, month in months
+        write_file("#{year}/#{month}/index.html", render_month(year, month))
+      end
+    end
+
+    # Write category summaries.
+    def write_categories
+      for category in categories
+        write_file("categories/#{urlify category['name']}.html", render_category(category))
+      end
+    end
+
+    # Write rss feeds for index page and categories.
+    def write_feeds
+      write_file("index.rss", render_index_feed)      
+      for category in categories
+        write_file("categories/#{urlify category['name']}.rss", render_category_feed(category))
+      end
+    end
+
+    # Render everything to public folder.
+    def write_all
+      load_aggregations
+      reload
+
+      write_index_page
+      write_pages
+      write_posts
+      write_archives
+      write_categories
+      write_feeds      
+    end
+
+  end
+
+end

data/lib/shinmun/cache.rb

@@ -0,0 +1,59 @@
+module Shinmun
+
+  # A simple hashtable, which loads only changed files by calling reload.
+  class Cache
+
+    # Call with a block to specify how the data is loaded.
+    # This is the default behaviour: Cache.new {|file| File.read(file) }
+    def initialize(&block)
+      @map = {}
+      @callback = block || proc { |file| File.read(file) }
+    end
+    
+    # Load a file into the cache, transform it according to callback
+    # and remember the modification time.
+    def load(file)
+      data = @callback.call(file)
+      @map[file] = [data, File.mtime(file)]
+      data
+    end
+
+    def remove(file)
+      @map.delete(file)
+    end
+
+    def dirty_files
+      @map.map { |file, (data, mtime)| mtime != File.mtime(file) ? file : nil }.compact
+    end
+
+    def reload!
+      @map.keys.each { |file| load file }
+    end
+    
+    def reload_dirty!
+      dirty_files.each { |file| load file }
+    end    
+
+    # Access the cache by filename.
+    def [](file)
+      data, mtime = @map[file]
+      data or load(file)
+    end
+
+    def values
+      @map.values.map { |data, | data }
+    end
+
+    # Are there any files loaded?
+    def empty?
+      @map.empty?
+    end
+
+    # Is there any file in this cache, which has changed?
+    def dirty?
+      dirty_files.size > 0
+    end
+
+  end
+
+end

data/lib/shinmun/comment.rb

@@ -0,0 +1,44 @@
+module Shinmun
+
+  class Comment
+
+    attr_accessor :time, :name, :email, :website, :text
+
+    def initialize(attributes)
+      for k, v in attributes
+        send "#{k}=", v
+      end
+    end
+               
+    def self.read(path)
+      file = "comments/#{path}"
+      comments = []
+
+      if File.exist?(file)
+        File.open(file, "r") do |io|
+          io.flock(File::LOCK_SH)
+          YAML.each_document(io) do |comment|
+            comments << comment
+          end
+          io.flock(File::LOCK_UN)
+        end
+      end
+
+      comments
+    end
+
+    def self.write(path, comment)
+      file = "comments/#{path}"
+
+      FileUtils.mkdir_p(File.dirname(file))
+
+      File.open(file, "a") do |io|
+        io.flock(File::LOCK_EX)
+        io.puts(comment.to_yaml)
+        io.flock(File::LOCK_UN)
+      end
+    end
+
+  end
+
+end

data/lib/shinmun/controller.rb

@@ -0,0 +1,135 @@
+require 'rack'
+
+module Shinmun
+
+  class RackAdapter
+
+    def initialize(blog)
+      @blog = blog
+      @routing = []
+
+      map /\.rss$/, FeedController
+      map /^\/\d\d\d\d\/\d+/, PostController
+      map /^\/categories/, CategoryController
+      map /^\/comments/, CommentsController
+      map //, PageController
+    end
+
+    def map(pattern, controller)
+      @routing << [pattern, controller]
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      response = Rack::Response.new
+
+      @blog.reload
+
+      klass = find_controller(request.path_info)
+
+      controller = klass.new(@blog, request, response)
+      controller.handle_request
+
+      response.status ||= 200
+      response.finish
+    end
+
+    def find_controller(path)
+      for pattern, klass in @routing
+        return klass if pattern.match(path)
+      end
+    end
+
+  end
+
+  class Controller
+    attr_reader :blog, :request, :response, :path, :extname
+
+    def initialize(blog, request, response)
+      @blog = blog
+      @request = request
+      @response = response
+      @extname = File.extname(request.path_info)
+      @path = request.path_info[1..-1].chomp(@extname)
+    end
+
+    def params
+      request.params
+    end
+
+    def redirect_to(location)
+      response.headers["Location"] = location
+      response.status = 302
+    end
+
+    def handle_request
+      action = request.request_method.downcase
+      response.body = send(action) if self.class.public_instance_methods.include?(action)
+    end
+  end
+
+  class PageController < Controller
+    def get
+      if path.empty?
+        blog.render_index_page
+      else
+        page = blog.find_page(path) or raise "#{path} not found"
+        blog.render_page(page)
+      end
+    end
+  end
+
+  class PostController < PageController
+    def get
+      if post = blog.find_post(path)
+        blog.render_post(post)
+      else
+        year, month, = path.split('/')
+        blog.render_month(year.to_i, month.to_i)
+      end
+    end
+  end
+
+  class FeedController < Controller
+    def get
+      path_list = path.split('/')
+      case path_list[0]
+      when 'categories'
+        category = blog.find_category(path_list[1].chomp('.rss'))
+        blog.render_category_feed(category)
+      when 'index'
+        blog.render_index_feed
+      end
+    end
+  end
+
+  class CategoryController < Controller
+    def get
+      category = blog.find_category(path.split('/')[1].chomp('.html'))
+      blog.render_category(category)
+    end
+  end
+
+  class CommentsController < Controller
+
+    def post
+      params['path'].include?('..') and raise 'invalid path'
+
+      comment = Comment.new(:time => Time.now,
+                            :name => params['name'],
+                            :email => params['email'],
+                            :website => params['website'],
+                            :text => params['text'])
+
+      if params['preview'] == 'true'
+        blog.render_comments([comment])
+      else
+        Comment.write(params['path'], comment)
+        blog.render_comments(Comment.read(params['path']))
+      end
+    end
+
+  end
+
+end
+

data/lib/shinmun/helpers.rb

@@ -0,0 +1,116 @@
+module Shinmun
+
+  module Helpers
+
+    # Render a hash as attributes for a HTML tag. 
+    def attributes(attributes)
+      attributes.map { |k, v| %Q{#{k}="#{v}"} }.join(' ')
+    end
+
+    # Render a HTML tag with given name. 
+    # The last argument specifies the attributes of the tag.
+    # The second argument may be the content of the tag.
+    def tag(name, *args)
+      text, attributes = args.first.is_a?(Hash) ? [nil, args.first] : args
+      "<#{name} #{attributes(attributes)}>#{text}</#{name}>"
+    end
+
+    # Render stylesheet link tag
+    def stylesheet_link_tag(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      options[:media] ||= 'screen'
+      names.map { |name|
+        mtime = File.mtime("assets/#{blog.stylesheets_path}/#{name}.css").to_i
+        path = "/#{blog.stylesheets_path}/#{name}.css?#{mtime}"
+        tag :link, :href => path, :rel => 'stylesheet', :media => options[:media]
+      }.join("\n")
+    end
+
+    # Render javascript tag
+    def javascript_tag(*names)
+      names.map { |name|
+        mtime = File.mtime("assets/#{blog.javascripts_path}/#{name}.js").to_i
+        path = "/#{blog.javascripts_path}/#{name}.js?#{mtime}"
+        tag :script, :src => path, :type => 'text/javascript'
+      }.join("\n")
+    end
+
+    # Render an image tag
+    def image_tag(file, options = {})
+      mtime = File.mtime("assets/#{blog.images_path}/#{file}").to_i
+      path = "/#{blog.images_path}/#{file}?#{mtime}"
+      tag :img, options.merge(:src => path)
+    end
+
+    # Render a link
+    def link_to(text, path, options = {})
+      tag :a, text, options.merge(:href => path)
+    end
+
+    # Render a link to a post
+    def post_link(post)
+      link_to post.title, "#{blog.base_path}/#{post.path}.html"
+    end
+
+    # Render a link to an archive page.
+    def archive_link(year, month)
+      link_to "#{Date::MONTHNAMES[month]} #{year}", "#{blog.base_path}/#{year}/#{month}/index.html"
+    end
+
+    # Render a date or time in a nice human readable format.
+    def date(time)
+      "%s %d, %d" % [Date::MONTHNAMES[time.month], time.day, time.year]
+    end
+
+    # Render a date or time in rfc822 format. This will be used for rss rendering.
+    def rfc822(time)
+      time.strftime("%a, %d %b %Y %H:%M:%S %z")
+    end
+
+    def markdown(text, *args)
+      BlueCloth.new(text, *args).to_html
+    rescue => e      
+      "#{text}<br/><br/><strong style='color:red'>#{e.message}</strong>"
+    end
+
+    def strip_tags(str)
+      str.gsub(/<\/?[^>]*>/, "")
+    end
+
+    def urlify(string)
+      string.downcase.gsub(/[ -]+/, '-').gsub(/[^-a-z0-9_]+/, '')
+    end
+
+    # taken form ActionView::Helpers
+    def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false)
+      from_time = from_time.to_time if from_time.respond_to?(:to_time)
+      to_time = to_time.to_time if to_time.respond_to?(:to_time)
+      distance_in_minutes = (((to_time - from_time).abs)/60).round
+      distance_in_seconds = ((to_time - from_time).abs).round
+
+      case distance_in_minutes
+      when 0..1
+        return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+        case distance_in_seconds
+        when 0..4   then 'less than 5 seconds'
+        when 5..9   then 'less than 10 seconds'
+        when 10..19 then 'less than 20 seconds'
+        when 20..39 then 'half a minute'
+        when 40..59 then 'less than a minute'
+        else             '1 minute'
+        end
+
+      when 2..44           then "#{distance_in_minutes} minutes"
+      when 45..89          then 'about 1 hour'
+      when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+      when 1440..2879      then '1 day'
+      when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+      when 43200..86399    then 'about 1 month'
+      when 86400..525599   then "#{(distance_in_minutes / 43200).round} months"
+      when 525600..1051199 then 'about 1 year'
+      else                      "over #{(distance_in_minutes / 525600).round} years"
+      end
+    end
+  end
+  
+end