georgi-shinmun 0.3

data/lib/shinmun.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'fileutils'
+
+require 'bluecloth'
+require 'rubypants'
+require 'coderay'
+require 'packr'
+require 'grit'
+
+begin; require 'redcloth'; rescue LoadError; end
+
+require 'kontrol'
+require 'shinmun/bluecloth_coderay'
+require 'shinmun/helpers'
+require 'shinmun/blog'
+require 'shinmun/post'
+require 'shinmun/comment'
+require 'shinmun/post_handler'
+
+require 'shinmun/aggregations/delicious'
+require 'shinmun/aggregations/flickr'

data/lib/shinmun/aggregations/delicious.rb

@@ -0,0 +1,57 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+class Delicious
+  include REXML
+
+  attr_accessor :url, :items, :link, :title, :days
+
+  # This object holds given information of an item
+  class DeliciousItem < Struct.new(:link, :title, :description, :description_link, :date)
+    def to_s; title end
+  end
+
+  # Pass the url to the RSS feed you would like to keep tabs on
+  # by default this will request the rss from the server right away and
+  # fill the items array
+  def initialize(url, refresh = true)
+    self.items  = []
+    self.url    = url
+    self.days   = {}
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the items in the items array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+
+    xml = Document.new(body)
+
+    self.items        = []
+    self.link         = XPath.match(xml, "//channel/link/text()").first.value rescue ""
+    self.title        = XPath.match(xml, "//channel/title/text()").first.value rescue ""
+
+    XPath.each(xml, "//item/") do |elem|
+      item = DeliciousItem.new
+      item.title       = XPath.match(elem, "title/text()").first.value rescue ""
+      item.link        = XPath.match(elem, "link/text()").first.value rescue ""
+      item.description = XPath.match(elem, "description/text()").first.value rescue ""
+      item.date        = Time.mktime(*ParseDate.parsedate(XPath.match(elem, "dc:date/text()").first.value)) rescue Time.now
+
+      item.description_link = item.description
+      item.description.gsub!(/<\/?a\b.*?>/, "") # remove all <a> tags
+      items << item
+    end
+
+    self.items = items.sort_by { |item| item.date }.reverse
+  end
+end

data/lib/shinmun/aggregations/flickr.rb

@@ -0,0 +1,81 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+# Example:
+#
+# flickr = Flickr.new('http://www.flickr.com/services/feeds/photos_public.gne?id=40235412@N00&format=rss_200')
+# flickr.pics.each do |pic|
+#   puts "#{pic.title} @ #{pic.link} updated at #{pic.date}"
+# end
+#
+class FlickrAggregation
+  include REXML
+
+  def choose(num)
+    return pics unless pics.size > num
+    bag = []
+    set = pics.dup
+    num.times {|x| bag << set.delete_at(rand(set.size))}
+    bag
+  end
+
+  attr_accessor :url, :pics, :link, :title, :description
+
+  # This object holds given information of a picture
+  class Picture
+    attr_accessor :link, :title, :date, :description, :thumbnail
+
+    def to_s
+      title
+    end
+
+    def date=(value)
+      @date = Time.parse(value)
+    end
+
+  end
+
+  # Pass the url to the RSS feed you would like to keep tabs on
+  # by default this will request the rss from the server right away and
+  # fill the tasks array
+  def initialize(url, refresh = true)
+    self.pics  = []
+    self.url    = url
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the tasks int the tasks array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+
+    xml = Document.new(body)
+
+    self.pics        = []
+    self.link         = XPath.match(xml, "//channel/link/text()").to_s
+    self.title        = XPath.match(xml, "//channel/title/text()").to_s
+    self.description  = XPath.match(xml, "//channel/description/text()").to_s
+
+    XPath.each(xml, "//item/") do |elem|
+
+      picture = Picture.new
+      picture.title       = XPath.match(elem, "title/text()").to_s
+      picture.date        = XPath.match(elem, "pubDate/text()").to_s
+      picture.link        = XPath.match(elem, "link/text()").to_s
+      picture.description = XPath.match(elem, "description/text()").to_s
+      picture.thumbnail   = XPath.match(elem, "media:thumbnail/@url").to_s
+
+      pics << picture
+    end
+  end
+end
+
+

data/lib/shinmun/blog.rb

@@ -0,0 +1,165 @@
+module Shinmun
+
+  class Blog < Kontrol::Application
+
+    EXAMPLE_DIR = File.expand_path(File.dirname(__FILE__) + '/../../example')
+
+    include Helpers
+
+    attr_reader :posts, :pages, :aggregations, :categories, :comments
+    
+    config_reader 'blog.yml', :title, :description, :language, :author, :url, :repository, :base_path, :categories
+
+    # Initialize the blog
+    def initialize(&block)
+      super
+
+      @aggregations = {}
+      Thread.start do
+        loop do
+          load_aggregations
+          sleep 300
+        end
+      end
+    end
+
+    def self.init(name)
+      Dir.mkdir name      
+      Dir.chdir name
+      FileUtils.cp_r EXAMPLE_DIR + '/.', '.'
+      `git init`
+      `git add .`
+      `git commit -m 'init'`
+    end
+
+    def posts
+      store['posts'] ||= GitStore::Tree.new
+    end
+
+    def pages
+      store['pages'] ||= GitStore::Tree.new
+    end
+
+    def comments
+      store['comments'] ||= GitStore::Tree.new
+    end
+    
+    def load_aggregations
+      config['aggregations.yml'].to_a.each do |c|
+        aggregations[c['name']] = Object.const_get(c['class']).new(c['url'])
+      end
+    end
+
+    def recent_posts
+      posts.sort_by { |post| post.date }.reverse[0, 20]
+    end
+
+    def posts_by_date      
+      posts.sort_by { |post| post.date }.reverse
+    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 with any of given tags.
+    def posts_with_tags(tags)
+      return [] if tags.nil? or tags.empty?
+      tags = tags.split(',').map { |t| t.strip } if tags.is_a?(String)
+      posts.select do |post|
+        tags.any? do |tag| 
+          post.tag_list.include?(tag)
+        end
+      end
+    end
+
+    # Return all archives as tuples of [year, month].
+    def archives
+      posts.map { |p| [p.year, p.month] }.uniq.sort
+    end
+
+    def tree_for(post)
+      if post.date
+        (posts[post.year] ||= GitStore::Tree.new)[post.month] ||= GitStore::Tree.new
+      else
+        pages
+      end      
+    end
+
+    def symbolize_keys(hash)      
+      hash.inject({}) do |h, (k, v)|
+        h[k.to_sym] = v
+        h
+      end
+    end
+
+    def commit(message)
+      store.commit(message)
+    end
+
+    # Create a new post with given title.
+    def create_post(atts = {})
+      atts = { :type => 'md' }.merge(symbolize_keys(atts))
+      atts[:name] = urlify(atts[:title]) or raise "no title given"
+      post = Post.new(atts)
+      tree_for(post)[post.filename] = post
+      commit "created `#{post.title}`"
+      tree_for(post)[post.filename]
+    end
+
+    def update_post(post, data)
+      tree_for(post).delete(post.filename)
+      post.parse data
+      tree_for(post)[post.filename] = post
+      commit "updated `#{post.title}`"
+      post
+    end
+
+    def delete_post(post)
+      tree_for(post).delete(post.filename)      
+      commit "deleted `#{post.title}`"
+    end
+
+    def comments_for(post)
+      comments["#{post.path}.yml"] ||= []
+    end
+
+    def post_comment(post, params)
+      comments_for(post) << Comment.new(params)
+      commit "new comment for `#{post.title}`"
+    end
+
+    def find_page(name)
+      pages.find { |p| p.name == name }
+    end
+
+    def find_post(year, month, name)
+      tree = posts[year, month] and tree.find { |p| p.name == name }
+    end
+
+    def find_category(permalink)
+      name = categories.find { |name| urlify(name) == permalink } or raise "category not found"
+      posts = self.posts.select { |p| p.category == name }.sort_by { |p| p.date }.reverse
+      { :name => name, :posts => posts, :permalink => permalink }
+    end
+
+    def find_by_path(path)
+      posts.find { |p| p.path == path } or pages.find { |p| p.path == path }
+    end
+
+    def write(file, template, vars={})
+      file = "public/#{base_path}/#{file}"
+      FileUtils.mkdir_p(File.dirname(file))
+      open(file, 'wb') do |io|
+        io << render(template, vars)
+      end
+    end
+
+    def render(name, vars = {})
+      super(name, vars.merge(:blog => self))
+    end
+    
+  end
+  
+end

data/lib/shinmun/bluecloth_coderay.rb

@@ -0,0 +1,21 @@
+class BlueCloth
+
+	def transform_code_blocks( str, rs )
+		@log.debug " Transforming code blocks"
+
+		str.gsub(CodeBlockRegexp) {|block|
+			codeblock = $1
+			remainder = $2
+
+      # Generate the codeblock
+      if codeblock =~ /^(?:[ ]{4}|\t)@@(.*?)\n\n(.*)\n\n/m
+         "\n\n<pre class='highlight'>%s</pre>\n\n%s" %
+          [CodeRay.scan(outdent($2), $1).html(:css => :class, :line_numbers => :list).delete("\n"), remainder]
+      else
+         "\n\n<pre><code>%s\n</code></pre>\n\n%s" %
+          [encode_code(outdent(codeblock), rs).rstrip, remainder]
+      end
+		}
+	end
+
+end

data/lib/shinmun/comment.rb

@@ -0,0 +1,17 @@
+module Shinmun
+
+  class Comment
+
+    attr_accessor :time, :name, :email, :website, :text
+
+    def initialize(attributes)
+      for k, v in attributes
+        send("#{k}=", v) if respond_to?("#{k}=")
+      end
+
+      self.time ||= Time.now
+    end
+
+  end
+
+end

data/lib/shinmun/helpers.rb

@@ -0,0 +1,64 @@
+module Shinmun
+
+  module Helpers
+
+    # 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
+
+    # Render a link to a post
+    def post_link(post)
+      link_to post.title, "#{base_path}/#{post.year}/#{post.month}/#{post.name}"
+    end
+
+    # Render a link to an archive page.
+    def archive_link(year, month)
+      link_to "#{Date::MONTHNAMES[month]} #{year}", "#{base_path}/#{year}/#{month}"
+    end
+
+    # Render a date or time in a nice human readable format.
+    def human_date(time)
+      "%s %d, %d" % [Date::MONTHNAMES[time.month], time.day, time.year]
+    end
+
+    # Render a date or time in rfc822 format.
+    def rfc822(time)
+      time.strftime("%a, %d %b %Y %H:%M:%S %z")
+    end
+
+    def diff_line_class(line)
+      case line[0, 1]
+      when '+' then 'added'
+      when '-' then 'deleted'
+      end
+    end
+
+  end
+end

data/lib/shinmun/post.rb

@@ -0,0 +1,161 @@
+module Shinmun
+  
+  # This class represents a post or page.
+  # Each post has a header, encoded as YAML and a body.
+  #
+  # Example:
+  #     --- 
+  #     category: Ruby
+  #     date: 2008-09-05
+  #      
+  #     BlueCloth, a Markdown library
+  #     =============================
+  #
+  #     This is the summary, which is by definition the first paragraph of the
+  #     article. The summary shows up in list views and rss feeds.  
+  #
+  class Post
+
+    # Define accessor methods for head variable.
+    def self.head_accessor(*names)
+      names.each do |name|
+        name = name.to_s
+        define_method(name) { @head[name] }
+        define_method("#{name}=") {|v| @head[name] = v }
+      end
+    end
+
+    attr_accessor :name, :type, :title, :src, :head, :body, :summary, :body_html, :tag_list
+    head_accessor :author, :date, :category, :tags, :languages, :header
+
+    # Initialize empty post and set specified attributes.
+    def initialize(attributes={})
+      @head = {}
+      @body = ''
+      
+      for k, v in attributes
+        send "#{k}=", v
+      end
+
+      parse src if src
+    end
+
+    def method_missing(id, *args)
+      key = id.to_s
+      if @head.has_key?(key)
+        @head[key]
+      else
+        raise NoMethodError, "undefined method `#{id}' for #{self}", caller(1)
+      end
+    end
+
+    def date=(d)
+      @head['date'] = String === d ? Date.parse(d) : d
+    end
+
+    # Shortcut for year of date
+    def year
+      date.year
+    end
+
+    # Shortcut for month of date
+    def month
+      date.month
+    end
+
+    def filename
+      "#{name}.#{type}"
+    end
+
+    def filename=(filename)
+      self.name, self.type = filename.split('.')
+    end
+
+    def path
+      if date
+        "#{year}/#{month}/#{name}"
+      else
+        name
+      end
+    end
+
+    # Split up the source into header and body. Load the header as
+    # yaml document. Render body and parse the summary from rendered html.
+    def parse(src)
+      src = src.delete("\r")
+
+      # Parse YAML header if present
+      if src =~ /\A(---.*?)\n\n(.*)/m
+        @head = YAML.load($1)
+        @body = $2
+      else
+        @body = src
+      end
+
+      @title = head['title'] or parse_title
+      @body_html = transform(body)
+      @summary = body_html.split("\n\n")[0]
+      @tag_list = tags.to_s.split(",").map { |s| s.strip }
+
+      self
+    end
+
+    # Parse title from different formats
+    def parse_title
+      lines = body.split("\n")
+
+      return if lines.empty?
+
+      case type
+      when 'md'
+        @title = lines.shift.sub(/(^#+|#+$)/,'').strip
+        lines.shift if lines.first.match(/^(=|-)+$/)
+
+      when 'html'
+        @title = lines.shift.sub(/(<h1>|\<\/h1>)/,'').strip
+
+      when 'tt'
+        @title = lines.shift.sub(/(^h1.)/,'').strip
+      end
+
+      @body = lines.join("\n")
+    end
+
+    # Convert to string representation
+    def dump
+      str = head.empty? ? '' : head.to_yaml + "\n"
+      unless head['title']
+        str << \
+        case type
+        when 'md'   : "#{title}\n#{'=' * title.size}\n"
+        when 'html' : "<h1>#{title}</h1>\n"
+        when 'tt'   : "h1.#{title}\n"
+        else raise
+        end
+      end
+      str + body
+    end
+
+    # Transform the body of this post. Defaults to Markdown.
+    def transform(src)
+      case type
+      when 'html'
+        RubyPants.new(src).to_html
+      when 'tt'
+        RubyPants.new(RedCloth.new(src).to_html).to_html
+      else
+        RubyPants.new(BlueCloth.new(src).to_html).to_html
+      end
+    end
+
+    def eql?(obj)
+      path == obj.path
+    end
+
+    def ==(obj)
+      path == obj.path
+    end
+
+  end
+
+end