abelard 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 11d17040bfbcb446c38d93ce3ddaf614a55fb7c1
+  data.tar.gz: b40187d7a1c261912e3e2655e7783a6e4b9915c7
+SHA512:
+  metadata.gz: cb41b5744e105884515e1e8e8513bc6601c132a4b332e7981f6fe038df48b7ff7cb797bac6f3ac6c9a5d20d62656c1c46d7f50c361dce387b341591265086edc
+  data.tar.gz: be36ec1cb0beb93e410226221bbe4faacb95aed8f156aec17b2be2b8c6f4803939caa939ef01800463f1119da6c296ceafc5bedc17cbd7165e9c6074375b37e0

data/bin/abelard

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+cmd = ARGV.shift
+
+known = %w( load dump list web )
+
+if ( known.include? cmd )
+  require "abelard/#{cmd}"
+else
+  $stderr.puts "Unknown command #{cmd}"
+  $stderr.puts "Use one of #{known}"
+end

data/lib/abelard/archive.rb

@@ -0,0 +1,17 @@
+require 'yaml'
+
+class Archive
+  def initialize(file)
+    @configfile = file
+    @config = YAML.load_file(file)
+  end
+
+  def dir(blog)
+    Directory.new(@config[blog]["dest"])
+  end
+
+  def available
+    @config.keys
+  end
+
+end

data/lib/abelard/dir.rb

@@ -0,0 +1,166 @@
+require 'libxml'
+require 'time'
+require 'abelard/history'
+
+# known namespaces for xpath search
+NS = [
+  "atom:http://www.w3.org/2005/Atom",
+  "dc:http://purl.org/dc/elements/1.1/",
+  "app:http://purl.org/atom/app#",
+  "wp:http://wordpress.org/export/1.2/"
+]
+
+class Item
+  attr_accessor :timestamp, :title, :file, :doc, :author, :status
+  def initialize(xml, filename)
+    @doc = xml
+    @file = filename
+    timestamp_node = doc.find_first("/atom:entry/atom:published", NS) ||
+                     doc.find_first("/item/pubDate")
+    if timestamp_node
+      @timestamp = Time.parse(timestamp_node.content)
+    else
+      @timestamp = Time.new(0)
+    end
+
+    title_node = doc.find_first("/atom:entry/atom:title", NS) ||
+                 doc.find_first("/item/title")
+    if title_node
+      @title = title_node.content
+    else
+      @title = "Post"
+    end
+
+    author_node = doc.find_first("/atom:entry/atom:author/atom:name", NS) ||
+                  doc.find_first("/item/dc:creator", NS)
+    if author_node
+      @author = author_node.content
+    else
+      @author = 'abelard'
+    end
+
+    @status = :published
+    status_node = doc.find_first("/item/wp:status", NS)
+    if status_node
+      $stderr.puts("raw status #{status_node.content}")
+      if status_node.content == "trash"
+        @status = :trash
+      elsif status_node.content == "draft"
+        @status = :draft
+      end
+    end
+
+    draft_node = doc.find_first("/atom:entry/app:control/app:draft", NS)
+    if draft_node
+      if draft_node.content == "yes"
+        @status = :draft
+      end
+    end
+  end
+
+  def save
+    puts("writing #{file}")
+    doc.save(file, :indent => true, :encoding => LibXML::XML::Encoding::UTF_8)
+  end
+end
+
+class Directory
+  def initialize(path)
+    @path = path
+    @base_doc = read_base_doc
+    @feed_type = case @base_doc.root.name
+                 when "feed"
+                   :atom
+                 when "rss"
+                   :rss
+                 else
+                   :unknown
+                 end
+
+    @git = History.new(self, path)
+  end
+
+  def save
+    @git.commit_posts
+  end
+  
+  def read_base_doc
+    feed = LibXML::XML::Parser.file("#{@path}/feed.xml").parse
+    if feed.root.name == "rss"
+      LibXML::XML::Parser.file("#{@path}/channel-1.xml").parse
+    else
+      feed
+    end
+  end
+
+  def base_doc
+    if ! @base_doc
+      @base_doc = read_base_doc
+    end
+    @base_doc
+  end
+
+  # iterates the Item objects for the feed, in order
+  def each
+    by_date = {}
+    each_unsorted do |post,filename|
+      item = Item.new(post,filename)
+      by_date[item.timestamp] = item
+    end
+    by_date.keys.sort.map { |dt| yield by_date[dt] }
+  end
+  
+  def info
+    inf = {}
+    el = base_doc.find_first("/atom:feed/atom:title", NS) ||
+         base_doc.find_first("/rss/channel/title")
+    inf["title"] = el.content
+    inf
+  end
+
+  def posts_feed
+    feed = read_base_doc
+    case @feed_type
+    when :atom
+      posts_feed_atom(feed)
+    when :rss
+      posts_feed_rss(feed)
+    end
+  end
+
+  def insert_posts(collection)
+    each do |post|
+      $stderr.puts "adding #{post.file}"
+      collection << collection.doc.import(post.doc.root)
+    end
+    collection
+  end
+  
+  def each_unsorted
+    Dir.glob("#{@path}/post-*.xml") do |filename|
+      post = LibXML::XML::Parser.file(filename).parse
+      yield post, filename
+    end
+  end
+  
+  def posts_feed_atom(doc)
+    insert_posts(doc.root)
+    doc
+  end
+
+  def posts_feed_rss(rssdoc)
+    doc = LibXML::XML::Parser.file("#{@path}/channel-1.xml").parse
+    channel = doc.find_first("/rss/channel");
+    insert_posts(channel)
+    doc
+  end
+
+  def sort_entries(repo_entries)
+    by_date = repo_entries.map do |e|
+      { :entry => e,
+        :time => Item.new(LibXML::XML::Parser.file(e.path).parse, e.path ).timestamp }
+    end
+    by_date.sort! { |a,b| a[:time] <=> b[:time] }
+    by_date.map { |hash| hash[:entry] }
+  end
+end

data/lib/abelard/dump.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'abelard/dir.rb'
+
+dir = Directory.new(ARGV[0])
+puts dir.posts_feed.to_s

data/lib/abelard/history.rb

@@ -0,0 +1,142 @@
+# Manage a git repository representing the feed
+
+require 'rugged'
+require 'pathname'
+
+class History
+  # archive is a Directory, dir is a path to store in git
+  def initialize(archive, dir)
+    @archive = archive
+    if File.directory? dir
+      begin
+        repo = Rugged::Repository.discover(dir)
+
+        repo_base = Pathname.new(repo.workdir).realpath.to_s
+        real_dir = Pathname.new(dir).realpath.to_s
+        raise "confused! #{repo_base} #{real_dir}" unless real_dir.start_with?(repo_base)
+        @relative_root = real_dir[repo_base.length+1..-1] || ""
+        $stderr.puts "#{real_dir} in #{repo_base} : #{@relative_root}"
+
+        check_repo_clean(repo, @relative_root)
+      rescue Rugged::RepositoryError
+        repo = Rugged::Repository.init_at(dir)
+        @relative_root = ""
+      end
+    elsif File.exist? dir
+      fail "#{dir} exists as file"
+    else
+      Dir.mkdir(dir)
+      repo = Rugged::Repository.init_at(dir)
+      @relative_root = ""
+    end
+    @repo = repo
+    @dir_path = dir
+  end
+
+  class Entry
+    # dir_fn is the path to the file relative to the feed directory
+    # git_fn is the path to the file relative to the git root
+    # path is the full path
+    
+    attr_reader :git_fn, :dir_fn, :path
+    def initialize(f, root, repository)
+      @git_fn = f
+
+      @dir_fn = if root.empty?
+                  f
+                else
+                  f[root.length+1..-1]
+                end
+
+      @path = repository.workdir + '/' + @dir_fn
+    end
+  end
+
+  def entry(from_git)
+    Entry.new(from_git, @relative_root, @repo)
+  end
+  
+  def check_repo_clean(repo, sub)
+    $stderr.puts "check_repo_clean(#{repo},#{sub})"
+    clean = true
+    repo.status do |file, data|
+      change = classify_file(sub, file)
+      clean = false if change == :real
+    end
+    clean
+  end
+
+  def commit_posts
+    repo = @repo
+    sub = @relative_root
+
+    commits = 0
+    todo = { real: [] }
+    @repo.status do |file, data|
+      change = classify_file(sub, file)
+      todo[change] ||= []
+      todo[change] << file
+    end
+    if todo[:top]
+      todo[:top].each do |file|
+        repo.index.add file
+        repo_entry = entry(file)
+        item = Item.new(LibXML::XML::Parser.file(repo_entry.path).parse, repo_entry.path)
+
+        author = {:email => "#{item.author}@example.org",
+                  :time => item.timestamp,
+                  :name => item.author}
+        parents = []
+        parents << repo.head.target unless repo.head_unborn?
+        commit = Rugged::Commit.create(repo,
+                                       :author => author,
+                                       :message => "feed info",
+                                       :committer => author,
+                                       :parents => parents,
+                                       :tree => repo.index.write_tree(repo),
+                                       :update_ref => "HEAD")
+        commits = commits+1
+      end
+    end
+
+    to_commit = @archive.sort_entries(todo[:real].map { |f| entry(f) })
+    
+    to_commit.each do |entry|
+      file = entry.git_fn
+      repo.index.add file
+      repo_entry = entry(file)
+      item = Item.new(LibXML::XML::Parser.file(repo_entry.path).parse, repo_entry.path)
+
+      author = {:email => "#{item.author}@example.org",
+                :time => item.timestamp,
+                :name => item.author}
+
+      $stderr.puts "Adding #{file}"
+
+      commit = Rugged::Commit.create(repo,
+                                     :author => author,
+                                     :message => "post",
+                                     :committer => author,
+                                     :parents => [repo.head.target],
+                                     :tree => repo.index.write_tree(repo),
+                                     :update_ref => "HEAD")
+      commits = commits+1
+    end
+
+    repo.index.write if commits > 0
+  end
+
+  def classify_file(subdir, file)
+    # normally 1 archive = 1 repo, but if you have a repo of several
+    # archives, ignore file changes outside
+    return :outside unless file.start_with?(subdir)
+
+    filename = Pathname.new(file).basename.to_s
+
+    return :real if filename.start_with?("post-") or filename.start_with?("comment-")
+    return :top if filename.start_with?("feed") or filename.start_with?("channel")
+
+    return :unknown
+  end
+end
+

data/lib/abelard/list.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'abelard/dir.rb'
+CONFIG_FILE = "blogfeeds.yaml"
+
+dest=''
+if ARGV.length > 0 then
+  if (ARGV[0] == '-h') then
+    $stderr.puts("abelard list -d <dir>\nabelard list <config-entry>
+abelard list\n")
+  else  
+    if (ARGV[0] == '-d') then
+      dest = ARGV[1]
+    else
+      configs = YAML.load_file(CONFIG_FILE)
+      conf = configs[ARGV[0]]
+    dest = conf['dest']
+    end
+    dir = Directory.new(dest)
+    dir.each do |item|
+      printf("%s %s\n", item.timestamp.strftime("%Y-%m-%d"), item.title)
+    end
+  end
+else
+  configs = YAML.load_file(CONFIG_FILE)
+  configs.each do |name, conf|
+    puts("#{name}: #{conf['urls'].first}")
+  end
+end
+

data/lib/abelard/load.rb

@@ -0,0 +1,360 @@
+#!/usr/bin/env ruby
+require 'libxml'
+require 'net/http'
+require 'yaml'
+
+require 'abelard/dir.rb'
+require 'abelard/postxml.rb'
+
+CONFIG_FILE = "blogfeeds.yaml"
+
+Debug = true
+
+
+module Splitter
+  def item(xmlnode, filename)
+    filedoc = LibXML::XML::Document.new()
+    filedoc.root = xmlnode.copy(true)
+    item = Item.new(filedoc, filename)
+  end    
+
+  # deprecated
+  def write_item(xmlnode, file)
+    filedoc = LibXML::XML::Document.new()
+    filedoc.root = xmlnode.copy(true)
+    puts("writing #{file}")
+    filedoc.save(file, :indent => true, :encoding => LibXML::XML::Encoding::UTF_8)
+  end
+
+  # stream the document to a string and reparse it to clean up redundant namespaces
+  def write_doc_clean(doc, file)
+    cleandoc = LibXML::XML::Parser.string(doc.to_s, :options => LibXML::XML::Parser::Options::NSCLEAN).parse
+    cleandoc.save(file)
+  end
+end
+
+class Splitter_rss
+  include Splitter
+  NS = ['wp:http://wordpress.org/export/1.2/'];
+
+  def initialize(document, destination)
+    @doc = document
+    @dest = destination
+  end
+
+  def extract_comments(item)
+    # In a wordpress export, the comments are in wp:comment elements
+    basename = Post_id_rss.new(item)
+
+    all = []
+    comment_nodes = item.find("wp:comment", NS)
+    comment_nodes.each do |node|
+      comment_doc = LibXML::XML::Document.new()
+      comment_doc.root = node.remove!
+      approved = comment_doc.find_first("/wp:comment/wp:comment_approved", NS)
+      author_email = comment_doc.find_first("/wp:comment/wp:comment_author_email", NS)
+      author_ip = comment_doc.find_first("/wp:comment/wp:comment_author_IP", NS)
+      id = comment_doc.find_first("/wp:comment/wp:comment_id", NS)
+
+      # delete some sensitive fields
+      author_email.remove! if (author_email)
+      author_ip.remove! if (author_ip)
+      
+      if (approved && (approved.content == '1'))
+        filename = basename.as_comment(id.content)
+
+        all << Item.new(comment_doc, "#{@dest}/#{filename}")
+      end
+    end
+    all
+  end
+
+  def split_items
+    channel_count = 1
+    rss = @doc.root
+    @parent = LibXML::XML::Document.new()
+    root = LibXML::XML::Node.new(rss.name)
+    @parent.root = root
+    rss.attributes.each { |a| root.attributes[a.name] = a.value }
+    rss.children.select(&:element?).each do |channel|
+      if (channel.name == "channel")
+        root << channel.clone # shallow copy for feed.xml
+        
+        channelself = XmlUtil::self_link(channel)
+        is_comments = (channelself =~ /comments/)
+        
+        copy = LibXML::XML::Node.new(channel.name)
+        channel.attributes.each { |a| copy.attributes[a.name] = a.value }
+        channel.children.select(&:element?).each do |node|
+          $stderr.puts(node.name)
+          if (node.name == "item")
+            # attachments dont get saved as posts
+            if ( node.find("wp:attachment_url", "wp:http://wordpress.org/export/1.2/").length > 0 )
+              $stderr.puts("skipping attachment")
+            else
+              # in a wordpress export file, comments are included inside the post item
+              comments = extract_comments(node)
+              save(node)
+              comments.each { |c| c.save }
+            end
+          else
+            copy << node.copy(true)
+          end
+        end
+        ch_copy = root.copy(true)
+        ch_copy << copy
+        unless is_comments
+          channel_doc = LibXML::XML::Document.new()
+          channel_doc.root = ch_copy
+          channel_doc.save("#{@dest}/channel-#{channel_count}.xml")
+        end
+        channel_count = channel_count + 1
+      else
+        root << channel
+      end
+    end
+    @parent.save("#{@dest}/feed.xml")
+  end
+
+  def save(node)
+    filename = Post_id_rss.new(node).to_s
+    new_item = item(node, "#{@dest}/#{filename}")
+    if new_item.status == :published
+      new_item.save
+    else
+      $stderr.puts("skipping #{filename} as status #{new_item.status}")
+    end
+  end
+end    
+
+class Splitter_atom
+  include Splitter
+  def initialize(document, destination)
+    @doc = document
+    @dest = destination
+  end
+
+  def split_items
+    feed = @doc.root
+
+    feedself = XmlUtil::self_link(feed)
+
+    @feed_type = nil # unknown
+    @feed_type = "post" if (feedself =~ %r{/posts/default$})
+    @feed_type = "comment" if (feedself =~ %r{/comments/default$})
+    
+    @parent = LibXML::XML::Document.new()
+    root = LibXML::XML::Node.new(feed.name)
+    @parent.root = root
+    feed.namespaces.definitions.each {|ns| LibXML::XML::Namespace.new(root, ns.prefix, ns.href)}
+    feed.attributes.each { |a| root.attributes[a.name] = a.value }
+
+    feed.children.select(&:element?).each do |node|
+      if (node.name == "entry")
+        save(node)
+      else
+        root << @parent.import(node)
+      end
+    end
+
+    write_doc_clean(@parent, "#{@dest}/feed.xml")
+  end
+
+  def save(node)
+	id = node.children.find { |n| n.name == "id" }
+	id = id && id.content
+
+	path = XmlUtil::self_link(node)
+
+	case node.name
+	when "entry"
+	  category = XmlUtil::child_attribute(node, "category", "term")
+
+	  if @feed_type
+		entry_type = @feed_type 
+	  else
+		entry_type = category.split('#').last if category
+	  end
+	  
+	  case entry_type
+	  when "post"
+		postnumber = path.split('/').last
+		filename = "#{@dest}/post-#{postnumber}.xml"
+		write_item(node, filename)
+	  when "comment"
+		pathsplit = path.split('/')
+		postnumber = pathsplit[-4]
+		commentnumber = pathsplit[-1]
+		filename = "#{@dest}/comment-#{postnumber}-#{commentnumber}.xml"
+		write_item(node,filename)
+	  end
+	end
+  end
+end
+
+class SourceBase
+  def process(parser, destination)
+    doc = parser.parse
+
+    case doc.root.name
+    when "feed"
+      atom = Splitter_atom.new(doc, destination)
+      atom.split_items
+    when "rss"
+      rss = Splitter_rss.new(doc, destination)
+      rss.split_items
+    else
+      puts "don't know what to do with element #{doc.root.name}"
+    end
+
+    archive = Directory.new(destination)
+    archive.save
+  end
+end
+
+class FileSource < SourceBase
+  def initialize(filename, dest)
+    @file = filename
+    @dest = dest
+  end
+
+  def load
+    ensure_dest(@dest)
+    parser = LibXML::XML::Parser.file(@file)
+    process(parser, @dest)
+  end
+end
+    
+class Source < SourceBase
+  def initialize(conf_in)
+    if conf_in.respond_to?(:keys)
+      @conf = conf_in
+    else
+      @conf = get_config(conf_in) || die("No config for #{conf_in}")
+    end
+  end
+
+  def load
+    conf = @conf
+    dest = conf["dest"] || die("No 'dest' directory defined")
+    urls = conf["urls"] || die("No urls defined")
+
+    ensure_dest(dest)
+  
+    fetcher = Fetcher.new
+    fetcher.user = conf["user"]
+    fetcher.password = conf["password"]
+  
+    urls.each do |urlpath|
+      url = URI(urlpath)
+      fetcher.get(url) do |response|
+        write_raw(response.body, "#{dest}/raw.xml") if Debug
+        parser = LibXML::XML::Parser.string(response.body)
+        process(parser, dest)
+      end
+    end
+  end
+
+  def all_configs
+    YAML.load_file(CONFIG_FILE) || {}
+  end
+
+  def get_config(key)
+    configuration_file = all_configs
+    configuration_file[key]
+  end
+
+  def save_config(key, conf)
+    configuration_data = all_configs
+    if configuration_data.has_key? key
+      die("Already have config for #{key}")
+    else
+      configuration_data[key] = conf
+      open(CONFIG_FILE, 'w+') do |conf_file|
+        conf_file.puts(configuration_data.to_yaml)
+      end
+    end
+  end
+  
+  def write_raw(data, filename)
+    File.open(filename, "w") { |f| f.write(data) }
+  end
+end
+
+def die(error)
+  puts error
+  exit 1
+end
+
+# Wrap an HTTP session, handle making a request and
+# following any redirects
+class Fetcher
+  def initialize
+    @host = nil
+    @session = nil
+    @user = nil
+    @password = nil
+  end  
+  attr_accessor :user, :password
+  
+  def get(url, max_depth=3)
+    if (url.host != @host)
+      @host = url.host
+      @session = Net::HTTP.new(@host, url.port)
+      @session.use_ssl = (url.scheme == 'https')
+    end
+    request = Net::HTTP::Get.new(url)
+    request.basic_auth(user, password) if user
+
+    msg = "Reading (#{url.to_s})"
+    msg << " as #{user}" if user
+    $stderr.puts(msg)
+    
+    feedxml = @session.request(request)
+    if (feedxml.is_a? Net::HTTPOK)
+      yield feedxml
+    elsif (feedxml.is_a? Net::HTTPMovedPermanently )
+      new_url = feedxml['Location']
+      if ( new_url == url.to_s ) then
+        puts("Confused! redirect to same url #{new_url}")
+      else
+        if ( max_depth == 0 )
+          puts("Too many redirects")
+        else
+          puts("Redirecting to #{new_url}")
+          get(URI(new_url), max_depth-1) { |r| yield r }
+        end
+      end
+    else
+      puts("GET returned #{feedxml.code}")
+        puts(feedxml.body)
+    end
+  end
+end
+
+def ensure_dest(dest)
+  Dir::mkdir(dest) unless File.directory?(dest)
+  unless File.directory?(dest)
+    $stderr.puts "Could not create directory #{dest}"
+  end
+end
+
+if ARGV.empty? 
+  $stderr.puts "Syntax:\nabelard load -f <filename> <destination>\nabelard load {-n <url>} ... <destination>\nabelard load <config>"
+  exit(1)
+elsif ARGV[0] == "-f"
+  source = FileSource.new(ARGV[1], ARGV[2])
+elsif ARGV[0] == '-n'
+  urls = []
+  while ARGV[0] == '-n'
+    ARGV.shift
+    urls << ARGV.shift
+  end
+  conf = {"urls" => urls, "dest" => ARGV[0]}
+  source = Source.new(conf)
+  source.save_config(conf["dest"],conf)
+else
+  key = ARGV[0]
+  source = Source.new(key)
+end
+source.load

data/lib/abelard/postxml.rb

@@ -0,0 +1,80 @@
+require 'uri'
+
+module XmlUtil
+  def self.child_content(node, elementname)
+    el = node.children.find { |n| n.name == elementname }
+    el && el.content
+  end
+  def self.child_attribute(node, elementname, attributename)
+    el = node.children.find { |n| n.name == elementname }
+    attr = el && el.attributes.get_attribute("term")
+    attr && attr.value
+  end
+  def self.with_attribute(node, attributename, attributevalue)
+    a = node.attributes.get_attribute(attributename)
+    a && (a.value == attributevalue)
+  end
+  def self.self_link(node)
+    el = node.children.find { |l| (l.name == "link") && with_attribute(l, "rel", "self") }
+    el && el.attributes.get_attribute("href").value
+  end
+end
+
+
+class Post_id_rss
+  attr_reader :idurl
+  def initialize(postxml)
+    #XmlUtil::child_content(postxml, "post_id") ||
+    @idurl = XmlUtil::child_content(postxml, "guid")
+    @raw = postxml.to_s
+  end
+
+  def to_s
+    if !idurl
+      improvise
+    else
+      postnumber = post_match
+      commenturl = /\?p(age_id)?=(\d+)(\.xml)?#comment-(.*)$/.match(idurl) ||
+                   /^(.*)\/(\d{4}\/.*)\/#(comment)-(.*)$/.match(idurl)
+      
+      if commenturl
+        postnumber = commenturl[2].sub(/^\//,'').sub(/\.xml$/,'').gsub('/','-')
+        commentnumber = commenturl[4]
+        "comment-#{postnumber}-#{commentnumber}.xml"
+      else 
+        "post-#{postnumber}.xml"
+      end
+    end
+  end
+
+  def post_match
+    posturl = /\?p(age_id)?=(\d+)(\.xml)?$/.match(idurl)
+    if posturl
+      posturl[2]
+    else
+      sanitize
+    end
+  end
+  
+  def as_comment(commentnumber)
+    "comment-#{post_match}-#{commentnumber}.xml"
+  end
+
+  def sanitize
+    uri = URI(idurl)
+    $stderr.puts("Could not parse url #{idurl}") unless ( uri )
+    if ( uri.scheme == "tag" )
+      return idurl.split('-').last
+    end
+
+    build = uri.path.sub(/^\//,'').sub(/\.xml$/,'').gsub('/','-')
+    build.concat('-' + uri.query.gsub(/[?&]/,'-')) if uri.query
+    build.concat('-' + uri.fragment) if uri.fragment
+    build
+  end
+
+  def improvise
+    "post-%016x.xml" % @raw.hash
+  end
+end
+

data/lib/abelard/web.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require 'sinatra/base'
+require 'yaml'
+require 'abelard/dir.rb'
+require 'abelard/archive.rb'
+
+CONFIG_FILE="blogfeeds.yaml"
+
+
+
+class FeedServer < Sinatra::Base
+archive = Archive.new(CONFIG_FILE)
+set :bind, "0.0.0.0"
+
+get '/' do
+  template = <<ERB
+<html><body><h2>Feeds</h2><dl>
+<% archive.available.each do |blog| %>
+<dt><%= blog %></dt>
+<dd><%= archive.dir(blog).info["title"] %></dd>
+<dd><a href="/<%= blog %>/posts">posts</a></dd>
+<% end %>
+</dl></body></html>
+ERB
+  erb template, :locals => { :archive => archive }
+end
+
+get '/*/posts' do |blog|
+  headers "Content-Type" => "application/atom+xml"
+  archive.dir(blog).posts_feed.to_s
+end
+  
+run!
+end
+

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: abelard
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Anomaly UK
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+description: Persist blogs and similar web content as sharable git repositories
+email: anomalyuk@tesco.net
+executables:
+- abelard
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/abelard
+- lib/abelard/archive.rb
+- lib/abelard/dir.rb
+- lib/abelard/dump.rb
+- lib/abelard/history.rb
+- lib/abelard/list.rb
+- lib/abelard/load.rb
+- lib/abelard/postxml.rb
+- lib/abelard/web.rb
+homepage: http://anomalyuk.blogspot.com/
+licenses:
+- GPL-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Abelard blog archiver
+test_files: []