shinmun 0.1 → 0.2

data/.gitignore

@@ -1 +1,3 @@
 *~
+doc/*
+pkg/*

data/README.md

@@ -1,37 +1,44 @@
 Shinmun, a small and beautiful blog engine
 ==========================================
 
-### Intro
-
 Shinmun is a **minimalist blog engine**. You just write posts as text files,
 render them to static files and push your blog to your server.
 
 This allows you to write posts in your favorite editor like Emacs or
 VI and use a VCS like git.
 
-Your layout can be customized by set of *ERB templates*. These
+Your layout can be customized by a set of *ERB templates*. These
 templates have access to `Post` objects and *helper methods* so that
 anybody who knows *Rails* should feel comfortable with it.
 
-Shinmun has some common features of blog engines like:
 
-* Index summary page
-* Category summary page
-* Archive pages for each month
+### Shinmun Features
+
+* Index listing
+* Category listing
+* Archive listings for each month
 * RSS feeds for index and category pages
+* Builtin webserver for realtime rendering
+* Compression of javascript files with PackR
+* Included syntax highlighting through `highlight.js`
 * AJAX comment system with PHP JSON file storage
-* Integration of the WMD-Markdown Editor for comments
+* Integration of WMD-Markdown Editor for commenting
+
 
 ### Quickstart
 
-Install the gem by typing:
+Install the gem:
+
     gem install shinmun
 
-Issue the following commands and the output will go to the public
-folder:
+Download and extract the example blog from my [github repository][3].
+
+Issue the following commands and you will see the blog on
+`http://localhost:3000`:
+
+    cd shinmun-example
+    shinmun server
 
-    cd example
-    ../bin/shinmun
 
 ### Writing Posts
 
@@ -44,22 +51,38 @@ in `posts/2008/9/the-title-of-the-post.md`. After creating you will
 probably open the file, set the category and start writing your new
 article.
 
-After finishing your post, you may just run `shinmun` without arguments
-and the output will be rendered to the *public* folder.
+Now you want to look at your rendered post. Just run:
+
+    shinmun server
+
+Go to `http://localhost:3000` and you will see your blog served in
+realtime. Just change and save any of your posts and you will see the
+new output in your browser.
+
+After finishing your post, you may run `shinmun render` and the output
+will be rendered to the *public* folder.
+
+By issuing the `shinmun push` command your blog will be pushed to your
+server using rsync. This works only, if you define the blog_repository
+variable inside blog.yml. It should contain something like
+`user@myhost.com:/var/www/my-site/`.
 
 
 ### Post Format
 
 Each blog post is just a text file with an optional header section and
-a markup body, which are separated by a newline. 
+a markup body, which are separated by a newline. Normally you don't
+have to worry about the post format, if you create posts with the
+`shinmun new` command.
 
 The **first line** of the header should start with 3 dashes as usual
 for a YAML document.
 
-The **first and the second line** of the body becomes the title of the
-post.
+The title of your post will be parsed from your first heading
+according to the document type. Shinmun will try to figure out the
+title for Markdown, Textile and HTML files.
 
-The header may have following attributes:
+The yaml header may have following attributes:
 
 * `date`: post will show up in blog page and archive pages
 * `category`: post will show up in the defined category page
@@ -90,32 +113,50 @@ posts for comments.
 
 ### Directory layout
 
-* All your **posts** reside in the `posts` folder sorted by year/month.
+* Your **assets** are in the `assets` folder, which gets copied to the
+  public folder in the render step.
 
-* All the **output** will be rendered to the `public` folder.
+* The **settings of your blog** are defined in `config/blog.yml`
 
-* **Template** files are in the `templates` folder.
+* Your **posts** reside in the `posts` folder sorted by year/month.
 
-* The **properties of your blog** defined in `posts/blog.yml`
+* Your **pages** are located in the `pages` folder.
 
-* **Static files** should be put into the directories `public/images`,
-  `public/stylesheets`, `public/javascripts`.
+* **Template** files are in the `templates` folder.
+
+* The **index page** of your blog is defined in `pages/index.rhtml` and
+  may be customized.
 
-* Archive pages will be rendered to files like `public/2008/9/index.html`.
+* **Archive pages** will be rendered to files like `public/2008/9/index.html`.
 
-* Category pages will be rendered to files like `public/categories/ruby.html`.
+* **Category pages** will be rendered to files like `public/categories/ruby.html`.
 
-* The *home page* of your blog will go to `public/index.html`.
 
 An example tree:
 
-    + posts
+    + assets
+      + images
+      + stylesheets
+      + javascripts      
+    + config
       + blog.yml
+    + pages
       + about.md
+      + index.rhtml
+    + posts
       + 2007
       + 2008
         + 9
           + my-article.md
+    + templates
+      + feed.rxml
+      + layout.rhtml
+      + page.rhtml  
+      + post.rhtml  
+      + posts.rhtml
+
+
+The output will look like this:
 
     + public
       + index.html
@@ -131,13 +172,37 @@ An example tree:
       + stylesheets
       + javascripts
 
-    + templates
-      + feed.rxml
-      + layout.rhtml
-      + page.rhtml  
-      + post.rhtml  
-      + posts.rhtml
- 
+
+### Config file
+
+The configuration of the blog system consists of some variables
+encoded as yaml file:
+
+* blog_title: the title of your blog, used for rss
+
+* blog_description: used for rss
+
+* blog_language: used for rss
+
+* blog_author: used for rss, acts also as fallback for the blog.author variable
+
+* blog_url: used for rss
+
+* blog_repository: path for rsync, used for `shinmun push` command
+
+* base_path: if your blog should not be rendered to your site
+  root, you can define a sub path here (like `blog`)
+
+* images_path: used for templates helper, defaults to `images`
+
+* javascripts_path: used for templates helper, defaults to `javascripts`
+
+* stylesheets_path: used for templates helper, defaults to `stylesheets`
+
+* pack_javascripts: a list of scripts to be compressed
+
+* pack_stylesheets: a list of stylesheets to be concatenated
+
 
 ### Layout
 
@@ -174,6 +239,10 @@ helpers. The helper methods will include a timestamp of the
 modification time as `querystring`, so that the browser will fetch the
 new resource if it has been changed.
 
+If you want to define your own helpers, just define a file named
+`templates/helpers.rb` with a module named `Shinmun::Helpers`. This
+module will be included into the `Shinmun::Template` class.
+
 
 ### Post Template
 
@@ -195,34 +264,29 @@ The attributes of a post are accessible as instance variables in a template:
     </div>
 
 
-
 ### RSS Feeds
 
-Feeds will be rendered by one *ERB template*. Some of the variables
-have been read from the `blog.yml`, like `@blog_title`, other variables
-have been determined by the engine like `@posts` and `@category`.
-
-    <?xml version="1.0" encoding="utf-8"?>
-    <rss version="2.0"> 
-      <channel>
-        <title><%= @category ? @blog_title + ' - ' + @category : @blog_title %></title>
-        <link><%= @blog_url %></link>
-        <description><%= @category ? 'Category ' + @category : @blog_description %></description>
-        <language><%= @blog_language %></language>
-        <copyright><%= @blog_author %></copyright>
-        <pubDate><%= rfc822 Time.now %></pubDate>
-        <% for post in @posts %>
-          <item>
-            <title><%= post.title %></title>
-            <description><%= post.text_summary %></description>
-            <link><%= post.link %></link>
-            <author><%= @blog_author %></author>
-            <guid><%= post.guid %></guid>
-            <pubDate><%= rfc822 post.date %></pubDate>
-          </item>
-        <% end %>
-      </channel> 
-    </rss>
+Feeds will be rendered by the *ERB template*
+`templates/feed.rxml`. Some of the variables have been read from the
+`blog.yml`, like `@blog_title`, other variables have been determined
+by the engine like `@posts` or `@category`.
+
+
+### Packr Support
+
+If you set the variables `pack_javascripts` or `pack_stylesheets`,
+Shinmun will create the files `all.js` or `all.css` automatically
+on rendering (even on each request of the webserver).
+
+The Javascript will be compressed with Packr and for performance
+reasons, minified versions for each of your javascripts will be
+created automatically in `assets/javascripts`.
+
+The stylesheets will be just concatenated to one file named `all.css`.
+
+Note that you define a yaml array of filenames without file
+extensions, so it should like `[jquery, jquery-form]`.
+
 
 ### Commenting System
 
@@ -247,3 +311,4 @@ Download or fork the package at my [github repository][1]
 
 [1]: http://github.com/georgi/shinmun/tree/master
 [2]: commenting-system-with-lightweight-json-store.html
+[3]: http://github.com/georgi/shinmun-example/tree/master

data/Rakefile

@@ -9,24 +9,23 @@ require 'fileutils'
 
 spec = Gem::Specification.new do |s|
   s.name = "shinmun"
-  s.version = `git describe`.strip.sub(/-.*/, '')
+  s.version = `git describe`
   s.platform = Gem::Platform::RUBY
   s.summary = "a small blog engine"
   
   s.description = <<-EOF
 Shinmun is a blog engine, which renders text files using a markup
-language like Markdown and a set of templates into static web
-pages. It supports Categories, Archives and RSS Feeds. Commenting can
-be done with some Javascript, PHP and a flat file JSON store.
+language like Markdown and a set of templates into either static web
+pages or serving them over a rack adapter. Shinmun supports
+categories, archives, rss feeds and commenting.
 EOF
   
-  s.files = `git ls-files`.split("\n")
+  s.files = `git ls-files`.split("\n").reject { |f| f.match /^pkg/ }
   s.bindir = 'bin'
   s.executables << 'shinmun'
   s.require_path = 'lib'
-  s.add_dependency 'uuid', '>=2.0.0'
-  s.add_dependency 'BlueCloth', '>=1.0.0'
-  s.add_dependency 'rubypants', '>=0.2.0'
+  s.add_dependency 'BlueCloth'
+  s.add_dependency 'rubypants'
   s.has_rdoc = true
   s.extra_rdoc_files = ['README.md']
   
@@ -51,10 +50,23 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
     '--charset' << 'utf-8'
   rdoc.rdoc_dir = "doc"
   rdoc.rdoc_files.include 'README.md'
-  rdoc.rdoc_files.include('lib/shinmun.rb')
+  Dir['lib/**/*.rb'].each do |file|
+    rdoc.rdoc_files.include file
+  end
 end
 
 
-task :push => [:rdoc] do
-  sh "rsync -avz doc/ mgeorgi@rack.rubyforge.org:/var/www/gforge-projects/shinmun"
+task :pdoc => [:rdoc] do
+  sh "rsync -avz doc/ mgeorgi@rubyforge.org:/var/www/gforge-projects/shinmun"
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :gem ] do
+  require 'rubyforge'
+  require 'rake/contrib/rubyforgepublisher'
+ 
+  rubyforge = RubyForge.new
+  rubyforge.configure
+  rubyforge.login
+  rubyforge.add_release('shinmun', 'shinmun', spec.version, "pkg/shinmun-#{spec.version}.gem")
 end

data/bin/shinmun

@@ -7,6 +7,11 @@ blog = Shinmun::Blog.new
 case ARGV[0]
 when 'new'
   blog.create_post(ARGV[1])
-else
+
+when 'render'
   blog.write_all
+
+when 'push'
+  blog.push
+
 end

data/lib/shinmun/admin_controller.rb

@@ -0,0 +1,161 @@
+require 'rack'
+require 'json'
+
+module Shinmun
+
+  class AdminController
+
+    def initialize(blog)
+      @blog = blog
+    end
+
+    def tree(request)
+      file_node(request.path_info[1..-1], 1).to_json
+    end
+
+    def get_page(request, path)
+      page = @blog.find_page(path)
+
+      { :title => page.title,
+        :date => page.date,
+        :category => page.category,
+        :tags => page.tags ? page.tags.join(',') : nil,
+        :body => page.body }.to_json
+    end
+
+    def put_page(request, path)
+      params = request.params
+      page = @blog.find_page(path)
+
+      page.title     = params['title']
+      page.author    = params['author']
+      page.date      = Date.parse(params['date']) rescue nil
+      page.category  = params['category']
+      page.tags      = params['tags']
+      page.languages = params['languages']
+      page.body      = params['body']
+      page.save
+
+      git_add(page.filename, 'changed')
+
+      return ''
+    end
+
+    def get_file(request, path)
+      File.read(path)
+    end
+
+    def put_file(request, path)
+      File.open(path, 'w') do |io|
+        io << request.params['body']
+      end
+      git_add(path, 'changed')
+      return ''
+    end
+
+    def data(request)
+      path = request.path_info[1..-1]
+      match = path.match(/^posts\/(.*)\.(.*)$/)
+      method = request.request_method.downcase
+
+      if match
+        send("#{method}_page", request, match[1])
+      else
+        send("#{method}_file", request, path)
+      end
+    end
+
+    def new_folder(request)
+      path = request.path_info[1..-1] + '/' + request.params['name']
+
+      unless File.exist?(path)
+        Dir.mkdir(path) 
+      end
+
+      return ''
+    end
+
+    def new_file(request)
+      path = request.path_info[1..-1] + '/' + request.params['name']
+
+      unless File.exist?(path)
+        File.open(path, "w").close
+        git_add(path, 'created')
+      end
+
+      return ''
+    end
+
+    def rename(request)
+      path = request.path_info[1..-1]
+      dest = File.basename(path) + '/' + request.params['name']
+
+      if File.exist?(path) and !File.exist?(dest)
+        `git mv #{path} #{dest}`
+        `git commit -m 'moved #{path} to #{dest}'`
+      end
+
+      return ''
+    end
+
+    def delete(request)
+      path = request.path_info[1..-1]
+
+      if File.file?(path)
+        `git rm #{path}`
+        `git commit -m 'deleted #{path}'`
+      end
+
+      return ''
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      response = Rack::Response.new
+      action = request.params['action']
+
+      response.body = send(action, request) if self.class.public_instance_methods.include?(action)
+
+      response.status = 200
+      response.finish
+    end
+
+    protected
+
+    def git_add(file, message)
+      `git add #{file}`
+      `git commit -m '#{message} #{file}'`
+    end
+
+    def entries_for(path)
+      Dir.entries(path).reject { |f| f.match /(\.|~)$/ }.sort
+    end
+
+    def root
+      { :children => ['config', 'posts', 'public', 'templates'].map { |f| file_node(f, 1) } }
+    end
+
+    def file_node(path, depth)
+      return root if path.empty?
+
+      stat = File.stat(path)
+
+      hash = {
+        :id => path,
+        :cls => stat.file? ? 'file' : 'folder',
+        :text => File.basename(path),
+        :leaf => stat.file?
+      }
+
+      unless stat.file?
+        hash[:children] = entries_for(path).map do |entry| 
+          file_node(File.join(path, entry), depth - 1)
+        end
+      end
+
+      hash
+    end
+    
+  end
+
+end

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
+
+