bunto-import 1.0.0

data/lib/bunto-import/importers/ghost.rb

@@ -0,0 +1,68 @@
+module BuntoImport
+  module Importers
+    class Ghost < Importer
+
+      def self.specify_options(c)
+        c.option 'dbfile', '--dbfile', 'Database file (default: ghost.db)'
+      end
+
+      def self.require_deps
+        BuntoImport.require_with_fallback(%w[
+          rubygems
+          sequel
+          fileutils
+          safe_yaml
+        ])
+      end
+
+      def self.process(options)
+        posts = fetch_posts(options.fetch('dbfile', 'ghost.db'))
+        if !posts.empty?
+          FileUtils.mkdir_p("_posts")
+          FileUtils.mkdir_p("_drafts")
+          posts.each do |post|
+            write_post_to_file(post)
+          end
+        end
+      end
+
+      private
+      def self.fetch_posts(dbfile)
+        db = Sequel.sqlite(dbfile)
+        query = "SELECT `title`, `slug`, `markdown`, `created_at`, `status` FROM posts"
+        db[query]
+      end
+
+      def self.write_post_to_file(post)
+        # detect if the post is a draft
+        draft = post[:status].eql?('draft')
+
+        # Ghost saves the time in an weird format with 3 more numbers.
+        # But the time is correct when we remove the last 3 numbers.
+        date = Time.at(post[:created_at].to_i.to_s[0..-4].to_i)
+
+        # the directory where the file will be saved to. either _drafts or _posts
+        directory = draft ? "_drafts" : "_posts"
+
+        # the filename under which the post is stored
+        filename = File.join(directory, "#{date.strftime('%Y-%m-%d')}-#{post[:slug]}.markdown")
+
+        # the YAML FrontMatter
+        frontmatter = { 'layout' => 'post', 'title' => post[:title] }
+        frontmatter['date'] =  date if !draft # only add the date to the frontmatter when the post is published
+        frontmatter.delete_if { |k,v| v.nil? || v == '' } # removes empty fields
+
+        # write the posts to disk
+        write_file(filename, frontmatter.to_yaml, post[:markdown])
+      end
+
+      def self.write_file(filename, frontmatter, content)
+        File.open(filename, "w") do |f|
+          f.puts frontmatter
+          f.puts "---"
+          f.puts content
+        end
+      end
+    end
+  end
+end

data/lib/bunto-import/importers/google_reader.rb

@@ -0,0 +1,64 @@
+module BuntoImport
+  module Importers
+    class GoogleReader < Importer
+      def self.validate(options)
+        if options['source'].nil?
+          abort "Missing mandatory option --source."
+        end
+      end
+
+      def self.specify_options(c)
+        c.option 'source', '--source', 'Source XML file of Google Reader export'
+      end
+
+      def self.require_deps
+        BuntoImport.require_with_fallback(%w[
+          rubygems
+          rss
+          fileutils
+          safe_yaml
+          open-uri
+          rexml/document
+          date
+        ])
+      end
+
+      # Process the import.
+      #
+      # source - a URL or a local file String.
+      #
+      # Returns nothing.
+      def self.process(options)
+        source = options.fetch('source')
+
+        open(source) do |content|
+          feed = RSS::Parser.parse(content)
+
+          raise "There doesn't appear to be any RSS items at the source (#{source}) provided." unless feed
+
+          feed.items.each do |item|
+            title = item.title.content.to_s
+            formatted_date = Date.parse(item.published.to_s)
+            post_name = title.split(%r{ |!|/|:|&|-|$|,}).map do |i|
+              i.downcase if i != ''
+            end.compact.join('-')
+            name = "#{formatted_date}-#{post_name}"
+
+            header = {
+              'layout' => 'post',
+              'title' => title
+            }
+
+            FileUtils.mkdir_p("_posts")
+
+            File.open("_posts/#{name}.html", "w") do |f|
+              f.puts header.to_yaml
+              f.puts "---\n\n"
+              f.puts item.content.content.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunto-import/importers/joomla.rb

@@ -0,0 +1,90 @@
+module BuntoImport
+  module Importers
+    class Joomla < Importer
+      def self.validate(options)
+        %w[dbname user].each do |option|
+          if options[option].nil?
+            abort "Missing mandatory option --#{option}."
+          end
+        end
+      end
+
+      def self.specify_options(c)
+        c.option 'dbname', '--dbname', 'Database name'
+        c.option 'user', '--user', 'Database user name'
+        c.option 'password', '--password', "Database user's password (default: '')"
+        c.option 'host', '--host', 'Database host name'
+        c.option 'section', '--section', 'Table prefix name'
+        c.option 'prefix', '--prefix', 'Table prefix name'
+      end
+
+      def self.require_deps
+        BuntoImport.require_with_fallback(%w[
+          rubygems
+          sequel
+          fileutils
+          safe_yaml
+        ])
+      end
+
+      def self.process(options)
+        dbname  = options.fetch('dbname')
+        user    = options.fetch('user')
+        pass    = options.fetch('password', '')
+        host    = options.fetch('host', "localhost")
+        section = options.fetch('section', '1')
+        table_prefix = options.fetch('prefix', "jos_")
+
+        db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host, :encoding => 'utf8')
+
+        FileUtils.mkdir_p("_posts")
+
+        # Reads a MySQL database via Sequel and creates a post file for each
+        # post in wp_posts that has post_status = 'publish'. This restriction is
+        # made because 'draft' posts are not guaranteed to have valid dates.
+        query = "SELECT `title`, `alias`, CONCAT(`introtext`,`fulltext`) as content, `created`, `id` FROM #{table_prefix}content WHERE (state = '0' OR state = '1') AND sectionid = '#{section}'"
+
+        db[query].each do |post|
+          # Get required fields and construct Bunto compatible name.
+          title = post[:title]
+          date = post[:created]
+          content = post[:content]
+          id = post[:id]
+
+          # Construct a slug from the title if alias field empty.
+          # Remove illegal filename characters.
+          if !post[:alias] or post[:alias].empty?
+            slug = sluggify(post[:title])
+          else
+            slug = sluggify(post[:alias])
+          end
+
+          name = "%02d-%02d-%02d-%03d-%s.markdown" % [date.year, date.month, date.day,
+                                                 id,slug]
+
+          # Get the relevant fields as a hash, delete empty fields and convert
+          # to YAML for the header.
+          data = {
+             'layout' => 'post',
+             'title' => title.to_s,
+             'joomla_id' => post[:id],
+             'joomla_url' => post[:alias],
+             'date' => date
+           }.delete_if { |k,v| v.nil? || v == '' }.to_yaml
+
+          # Write out the data and content to file
+          File.open("_posts/#{name}", "w") do |f|
+            f.puts data
+            f.puts "---"
+            f.puts content
+          end
+        end
+      end
+
+      # Borrowed from the Wordpress importer
+      def self.sluggify( title )
+        title = title.downcase.gsub(/[^0-9A-Za-z]+/, " ").strip.gsub(" ", "-")
+      end
+    end
+  end
+end

data/lib/bunto-import/importers/joomla3.rb

@@ -0,0 +1,91 @@
+module BuntoImport
+  module Importers
+    class Joomla3 < Importer
+      def self.validate(options)
+        %w[dbname user prefix].each do |option|
+          if options[option].nil?
+            abort "Missing mandatory option --#{option}."
+          end
+        end
+      end
+
+      def self.specify_options(c)
+        c.option 'dbname', '--dbname', 'Database name'
+        c.option 'user', '--user', 'Database user name'
+        c.option 'password', '--password', "Database user's password (default: '')"
+        c.option 'host', '--host', 'Database host name'
+        c.option 'category', '--category', 'ID of the category'
+        c.option 'prefix', '--prefix', 'Table prefix name'
+      end
+
+      def self.require_deps
+        BuntoImport.require_with_fallback(%w[
+          rubygems
+          sequel
+          fileutils
+          safe_yaml
+        ])
+      end
+
+      def self.process(options)
+        dbname  = options.fetch('dbname')
+        user    = options.fetch('user')
+        pass    = options.fetch('password', '')
+        host    = options.fetch('host', "localhost")
+        cid	    = options.fetch('category', 0)
+        table_prefix = options.fetch('prefix', "jos_")
+
+        db = Sequel.mysql(dbname, :user => user, :password => pass, :host => host, :encoding => 'utf8')
+
+        FileUtils.mkdir_p("_posts")
+
+        # Reads a MySQL database via Sequel and creates a post file for each
+        # post in #__content that is published.
+        query = "SELECT `cn`.`title`, `cn`.`alias`, `cn`.`introtext`, CONCAT(`cn`.`introtext`,`cn`.`fulltext`) AS `content`, "
+		query << "`cn`.`created`, `cn`.`id`, `ct`.`title` AS `category`, `u`.`name` AS `author` "
+		query << "FROM `#{table_prefix}content` AS `cn` JOIN `#{table_prefix}categories` AS `ct` ON `cn`.`catid` = `ct`.`id` "
+		query << "JOIN `#{table_prefix}users` AS `u` ON `cn`.`created_by` = `u`.`id` "
+		query << "WHERE (`cn`.`state` = '1' OR `cn`.`state` = '2') " # Only published and archived content items to be imported
+
+		if cid > 0
+			query << " AND `cn`.`catid` = '#{cid}' "
+		else 
+			query << " AND `cn`.`catid` != '2' " #Filter out uncategorized content
+		end
+
+        db[query].each do |post|
+          # Get required fields and construct Bunto compatible name.
+          title = post[:title]
+          slug = post[:alias]
+          date = post[:created]
+		  author = post[:author]
+		  category = post[:category]
+          content = post[:content]
+		  excerpt = post[:introtext]
+          name = "%02d-%02d-%02d-%s.markdown" % [date.year, date.month, date.day,
+                                                 slug]
+
+          # Get the relevant fields as a hash, delete empty fields and convert
+          # to YAML for the header.
+          data = {
+             'layout' => 'post',
+             'title' => title.to_s,
+             'joomla_id' => post[:id],
+             'joomla_url' => slug,
+             'date' => date,
+			 'author' => author,
+			 'excerpt' => excerpt.strip.to_s,
+			 'category' => category
+           }.delete_if { |k,v| v.nil? || v == '' }.to_yaml
+
+          # Write out the data and content to file
+          File.open("_posts/#{name}", "w") do |f|
+            f.puts data
+            f.puts "---"
+            f.puts content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunto-import/importers/jrnl.rb

@@ -0,0 +1,125 @@
+module BuntoImport
+  module Importers
+    class Jrnl < Importer
+
+      def self.require_deps
+        BuntoImport.require_with_fallback(%w[
+          time
+          rubygems
+          safe_yaml
+        ])
+      end
+
+      def self.specify_options(c)
+        c.option 'file', '--file FILENAME', 'Journal file (default: "~/journal.txt")'
+        c.option 'time_format', '--time_format FORMAT', 'Time format of your journal (default: "%Y-%m-%d %H:%M")'
+        c.option 'extension', '--extension EXT', 'Output extension (default: "md")'
+        c.option 'layout', '--layout NAME', 'Output post layout (default: "post")'
+      end
+
+      # Reads a jrnl file and creates a new post for each entry
+      # The following overrides are available:
+      # :file         path to input file
+      # :time_format  the format used by the jrnl configuration
+      # :extension    the extension format of the output files
+      # :layout       explicitly set the layout of the output
+      def self.process(options)
+        file        = options.fetch('file', "~/journal.txt")
+        time_format = options.fetch('time_format', "%Y-%m-%d %H:%M")
+        extension   = options.fetch('extension', "md")
+        layout      = options.fetch('layout', "post")
+
+        date_length = Time.now.strftime(time_format).length
+
+        # convert relative to absolute if needed
+        file = File.expand_path(file)
+
+        abort "The jrnl file was not found. Please make sure '#{file}' exists. You can specify a different file using the --file switch." unless File.file?(file)
+
+        input = File.read(file)
+        entries = input.split("\n\n");
+
+        entries.each do |entry|
+          # split dateline and body
+          # content[0] has the date and title
+          # content[1] has the post body
+          content = entry.split("\n")
+
+          body = get_post_content(content)
+          date = get_date(content[0], date_length)
+          title = get_title(content[0], date_length)
+          slug = create_slug(title)
+          filename = create_filename(date, slug, extension)
+          meta = create_meta(layout, title, date) # prepare YAML meta data
+
+          write_file(filename, meta, body) # write to file
+        end
+      end
+
+      # strip body from jrnl entry
+      def self.get_post_content(content)
+        return content[1]
+      end
+
+      # strip timestamp from the dateline
+      def self.get_date(content, offset)
+        return content[0, offset]
+      end
+
+      # strip title from the dateline
+      def self.get_title(content, offset)
+        return content[offset + 1, content.length]
+      end
+
+      # generate slug
+      def self.create_slug(title)
+        return title.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
+      end
+
+      # generate filename
+      def self.create_filename(date, slug, extension)
+        return "#{Time.parse(date).strftime("%Y-%m-%d")}-#{slug}.#{extension}"
+      end
+
+      # Prepare YAML meta data
+      #
+      # layout  - name of the layout
+      # title   - title of the entry
+      # date    - date of entry creation
+      #
+      # Examples
+      #
+      #   create_meta("post", "Entry 1", "2013-01-01 13:00")
+      #   # => "---\nlayout: post\ntitle: Entry 1\ndate: 2013-01-01 13:00\n"
+      #
+      # Returns array converted to YAML
+      def self.create_meta(layout, title, date)
+        data = {
+          'layout'        => layout,
+          'title'         => title,
+          'date'          => Time.parse(date).strftime("%Y-%m-%d %H:%M %z")
+        }.to_yaml
+        return data;
+      end
+
+      # Writes given data to file
+      #
+      # filename    - name of the output file
+      # meta        - YAML header data
+      # body        - jrnl entry content
+      #
+      # Examples
+      #
+      #   write_file("2013-01-01-entry-1.md", "---\nlayout: post\ntitle: Entry 1\ndate: 2013-01-01 13:00\n", "This is the first entry for my new journal")
+      #
+      # Writes file to _posts/filename
+      def self.write_file(filename, meta, body)
+        File.open("_posts/#{filename}", "w") do |f|
+          f.puts meta
+          f.puts "---\n\n"
+          f.puts body
+        end
+      end
+    end
+  end
+end

data/lib/bunto-import/importers/marley.rb

@@ -0,0 +1,72 @@
+module BuntoImport
+  module Importers
+    class Marley < Importer
+      def self.validate(options)
+        if options['marley_data_dir'].nil?
+          Bunto.logger.abort_with "Missing mandatory option --marley_data_dir."
+        else
+          unless File.directory?(options['marley_data_dir'])
+            raise ArgumentError, "marley dir '#{options['marley_data_dir']}' not found"
+          end
+        end
+      end
+
+      def self.regexp
+        { :id    => /^\d{0,4}-{0,1}(.*)$/,
+          :title => /^#\s*(.*)\s+$/,
+          :title_with_date => /^#\s*(.*)\s+\(([0-9\/]+)\)$/,
+          :published_on => /.*\s+\(([0-9\/]+)\)$/,
+          :perex => /^([^\#\n]+\n)$/,
+          :meta  => /^\{\{\n(.*)\}\}\n$/mi # Multiline Regexp
+        }
+      end
+
+      def self.require_deps
+        BuntoImport.require_with_fallback(%w[
+          fileutils
+          safe_yaml
+        ])
+      end
+
+      def self.specify_options(c)
+        c.option 'marley_data_dir', '--marley_data_dir DIR', 'The dir containing your marley data'
+      end
+
+      def self.process(options)
+        marley_data_dir = options.fetch('marley_data_dir')
+
+        FileUtils.mkdir_p "_posts"
+
+        posts = 0
+        Dir["#{marley_data_dir}/**/*.txt"].each do |f|
+          next unless File.exists?(f)
+
+          #copied over from marley's app/lib/post.rb
+          file_content  = File.read(f)
+          meta_content  = file_content.slice!( self.regexp[:meta] )
+          body          = file_content.sub( self.regexp[:title], '').sub( self.regexp[:perex], '').strip
+
+          title = file_content.scan( self.regexp[:title] ).first.to_s.strip
+          prerex = file_content.scan( self.regexp[:perex] ).first.to_s.strip
+          published_on = DateTime.parse( post[:published_on] ) rescue File.mtime( File.dirname(f) )
+          meta          = ( meta_content ) ? YAML::load( meta_content.scan( self.regexp[:meta]).to_s ) : {}
+          meta['title'] = title
+          meta['layout'] = 'post'
+
+          formatted_date = published_on.strftime('%Y-%m-%d')
+          post_name =  File.dirname(f).split(%r{/}).last.gsub(/\A\d+-/, '')
+
+          name = "#{formatted_date}-#{post_name}"
+          File.open("_posts/#{name}.markdown", "w") do |f|
+            f.puts meta.to_yaml
+            f.puts "---\n"
+            f.puts "\n#{prerex}\n\n" if prerex
+            f.puts body
+          end
+          posts += 1
+        end
+        "Created #{posts} posts!"
+      end
+    end
+  end
+end