shinmun 0.2 → 0.5

data/test/blog_spec.rb

@@ -0,0 +1,156 @@
+require 'shinmun'
+require 'rack/mock'
+require 'rexml/document'
+require 'rexml/xpath'
+require 'pp'
+
+describe Shinmun::Blog do
+
+  DIR = '/tmp/shinmun-test'
+
+  attr_reader :blog
+
+  before do
+    ENV['RACK_ENV'] = 'production'
+    
+    FileUtils.rm_rf DIR
+
+    Shinmun::Blog.init(DIR)
+    
+    @blog = Shinmun::Blog.new(DIR)
+    
+    blog.config = {
+      :title => 'Title',
+      :description => 'Description',
+      :language => 'en',
+      :author =>  'The Author',
+      :categories => ['Ruby', 'Javascript']
+    }
+    
+    @posts = [blog.create_post(:title => 'New post', :date => '2008-10-10', :category => 'Ruby', :body => 'Body1'),
+              blog.create_post(:title => 'And this', :date => '2008-10-11', :category => 'Ruby', :body => 'Body2'),
+              blog.create_post(:title => 'Again',    :date => '2008-11-10', :category => 'Javascript', :body => 'Body3')]
+
+    @pages = [blog.create_page(:title => 'Page 1', :body => 'Body1'),
+              blog.create_page(:title => 'Page 2', :body => 'Body2')]
+
+    blog.store.load
+  end
+
+  def request(method, uri, options={})
+    @request = Rack::MockRequest.new(blog)    
+    @response = @request.request(method, uri, options)
+  end
+
+  def get(*args)
+    request(:get, *args)
+  end
+
+  def post(*args)
+    request(:post, *args)
+  end  
+
+  def xpath(xml, path)
+    REXML::XPath.match(REXML::Document.new(xml), path)
+  end
+
+  def query(hash)
+    Rack::Utils.build_query(hash)
+  end
+  
+  def assert_listing(xml, list)
+    titles = xpath(xml, "//h2/a")
+    summaries = xpath(xml, "//p")
+
+    list.each_with_index do |(title, summary), i|
+      titles[i].text.should == title
+      summaries[i].text.to_s.strip.should == summary
+    end
+  end
+
+  it "should load templates" do
+    blog.load_template("index.rhtml").should be_kind_of(ERB)
+  end
+
+  it "should find posts for a category" do    
+    category = blog.find_category('ruby')
+    category[:name].should == 'Ruby'
+    
+    category[:posts].should include(@posts[0])
+    category[:posts].should include(@posts[1])
+
+    category = blog.find_category('javascript')
+    category[:name].should == 'Javascript'
+    category[:posts].should include(@posts[2])
+  end
+
+  it "should create a post" do
+    post = blog.create_post(:title => 'New post', :date => '2008-10-10')
+    blog.store.load
+
+    post = blog.find_post(2008, 10, 'new-post')
+    post.should_not be_nil
+    post.title.should == 'New post'
+    post.date.should == Date.new(2008, 10, 10)
+    post.name.should == 'new-post'
+  end
+
+  it "should render posts" do
+    xml = get('/2008/10/new-post').body
+
+    xpath(xml, "//h1")[0].text.should == 'New post'
+    xpath(xml, "//p")[0].text.should == 'Body1'
+  end
+
+  it "should render categories" do
+    get('/categories/ruby.rss')['Content-Type'].should == 'application/rss+xml'
+
+    xml = get('/categories/ruby.rss').body
+
+    xpath(xml, '/rss/channel/title')[0].text.should == 'Ruby'
+    xpath(xml, '/rss/channel/item/title')[0].text.should == 'And this'
+    xpath(xml, '/rss/channel/item/pubDate')[0].text.should == "Sat, 11 Oct 2008 00:00:00 +0000"
+    xpath(xml, '/rss/channel/item/link')[0].text.should == "http://example.org/2008/10/and-this"
+    xpath(xml, '/rss/channel/item/title')[1].text.should == 'New post'
+    xpath(xml, '/rss/channel/item/pubDate')[1].text.should == "Fri, 10 Oct 2008 00:00:00 +0000"
+    xpath(xml, '/rss/channel/item/link')[1].text.should == "http://example.org/2008/10/new-post"
+    
+    assert_listing(get('/categories/ruby').body, [['And this', 'Body2'], ['New post', 'Body1']])
+  end
+
+  it "should render index and archives" do
+    blog.posts_for_month(2008, 10).should_not be_empty
+    blog.posts_for_month(2008, 11).should_not be_empty
+    
+    assert_listing(get('/2008/10').body, [['And this', 'Body2'], ['New post', 'Body1']])
+    assert_listing(get('/').body, [['Again', 'Body3'], ['And this', 'Body2'], ['New post', 'Body1']])
+  end
+
+  it "should render pages" do
+    xml = get('/page-1').body
+    xpath(xml, "//h1")[0].text.should == 'Page 1'
+    xpath(xml, "//p")[0].text.should == 'Body1'
+
+    xml = get('/page-2').body    
+    xpath(xml, "//h1")[0].text.should == 'Page 2'
+    xpath(xml, "//p")[0].text.should == 'Body2'
+  end
+
+  it "should post a comment" do    
+    post "/2008/10/new-post/comments?name=Hans&text=Hallo"
+    post "/2008/10/new-post/comments?name=Peter&text=Servus"
+
+    blog.store.load
+    
+    comments = blog.comments_for(@posts[0])
+
+    comments[0].should_not be_nil
+    comments[0].name.should == 'Hans'
+    comments[0].text.should == 'Hallo'
+
+    comments[1].should_not be_nil
+    comments[1].name.should == 'Peter'
+    comments[1].text.should == 'Servus'
+  end
+  
+end

data/test/post_spec.rb

@@ -0,0 +1,32 @@
+require 'shinmun'
+
+describe Shinmun::Post do
+
+  POST = <<-END
+--- 
+category: Javascript
+date: 2008-09-09
+tags: template, engine, json
+title: Patroon - a Javascript Template Engine
+---
+Patroon is a template engine written in Javascript in about 100 lines
+of code. It takes existing DOM nodes annotated with CSS classes and
+expand a data object according to simple rules. Additionally you may
+use traditional string interpolation inside attribute values and text
+nodes.
+END
+
+  it 'should parse and dump in the same way' do
+    Shinmun::Post.new(:type => 'md', :src => POST).dump.should == (POST)
+  end
+
+  it "should parse the yaml header" do
+    post = Shinmun::Post.new(:type => 'md', :src => POST)
+    post.title.should == 'Patroon - a Javascript Template Engine'
+    post.category.should == 'Javascript'
+    post.date.should == Date.new(2008,9,9)
+    post.tags.should == 'template, engine, json'
+    post.tag_list.should == ['template', 'engine', 'json']
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: shinmun
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: "0.5"
 platform: ruby
 authors: 
 - Matthias Georgi
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-17 00:00:00 +01:00
+date: 2010-02-07 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: BlueCloth
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -23,6 +24,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: rubypants
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -30,7 +32,27 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-description: Shinmun is a blog engine, which renders text files using a markup 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.
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: coderay
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: git-based blog engine.
 email: matti.georgi@gmail.com
 executables: 
 - shinmun
@@ -39,24 +61,37 @@ extensions: []
 extra_rdoc_files: 
 - README.md
 files: 
-- .gitignore
-- LICENSE
 - README.md
 - Rakefile
+- assets/print.css
+- assets/styles.css
 - bin/shinmun
+- config.ru
 - lib/shinmun.rb
-- lib/shinmun/admin_controller.rb
-- lib/shinmun/aggregations/delicious.rb
-- lib/shinmun/aggregations/flickr.rb
 - lib/shinmun/blog.rb
-- lib/shinmun/cache.rb
+- lib/shinmun/bluecloth_coderay.rb
 - lib/shinmun/comment.rb
-- lib/shinmun/controller.rb
+- lib/shinmun/handlers.rb
 - lib/shinmun/helpers.rb
 - lib/shinmun/post.rb
-- lib/shinmun/template.rb
+- lib/shinmun/routes.rb
+- templates/index.rhtml
+- templates/page.rhtml
+- templates/404.rhtml
+- templates/_comments.rhtml
+- templates/category.rhtml
+- templates/_comment_form.rhtml
+- templates/post.rhtml
+- templates/index.rxml
+- templates/category.rxml
+- templates/archive.rhtml
+- templates/layout.rhtml
+- test/blog_spec.rb
+- test/post_spec.rb
 has_rdoc: true
-homepage: http://shinmun.rubyforge.org
+homepage: http://github.com/georgi/shinmun
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -76,10 +111,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: shinmun
-rubygems_version: 1.1.1
+rubyforge_project: 
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
-summary: a small blog engine
+specification_version: 3
+summary: git-based blog engine
 test_files: []
 

data/.gitignore

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

data/LICENSE

@@ -1,18 +0,0 @@
-Copyright (c) 2008 Matthias Georgi <http://www.matthias-georgi.de>
- 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
- 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
- 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/shinmun/admin_controller.rb

@@ -1,161 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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/cache.rb

@@ -1,59 +0,0 @@
-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