wordpress-exporter 0.0.1

data/lib/converters/markup_converter.rb

@@ -0,0 +1,35 @@
+require 'reverse_markdown'
+
+module Contentful
+  module Converter
+    class MarkupConverter
+      Encoding.default_external = 'utf-8'
+
+      attr_reader :config, :logger
+
+      def initialize(config)
+        @config = config
+        @logger = Logger.new(STDOUT)
+      end
+
+      def convert_markup_to_markdown
+        Dir.glob("#{config.entries_dir}/post/*") do |post_file_path|
+          logger.info("Converting #{post_file_path} markups...")
+          convert_post_content(post_file_path)
+        end
+      end
+
+      def convert_post_content(post_file_path)
+        post_data = JSON.parse(File.read(post_file_path))
+        post_data['content'] = ReverseMarkdown.convert post_data['content']
+        overwrite_file(post_file_path, post_data)
+      end
+
+      def overwrite_file(path, data)
+        File.open(path, 'w') do |file|
+          file.write(JSON.pretty_generate(data))
+        end
+      end
+    end
+  end
+end

data/lib/migrator.rb

@@ -0,0 +1,30 @@
+require_relative 'configuration'
+require_relative 'wordpress/export'
+require_relative 'converters/contentful_model_to_json'
+require_relative 'converters/markup_converter'
+
+class Migrator
+  attr_reader :exporter, :settings, :converter, :markup_converter
+
+  def initialize(settings)
+    @settings = Contentful::Configuration.new(settings)
+    @exporter = Contentful::Exporter::Wordpress::Export.new(@settings)
+    @converter = Contentful::Converter::ContentfulModelToJson.new(@settings)
+    @markup_converter = Contentful::Converter::MarkupConverter.new(@settings)
+  end
+
+  def run(action, opts = {})
+    case action.to_s
+      when '--extract-to-json'
+        exporter.export_blog
+        omit_flag = opts[:omit_content_model].present?
+        converter.create_content_type_json(omit_flag) unless omit_flag
+      when '--convert-content-model-to-json'
+        converter.convert_to_import_form
+      when '--create-contentful-model-from-json'
+        converter.create_content_type_json
+      when '--convert-markup'
+        markup_converter.convert_markup_to_markdown
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Version
+  VERSION = '0.0.1'
+end

data/lib/wordpress/blog.rb

@@ -0,0 +1,83 @@
+require 'time'
+require 'logger'
+
+module Contentful
+  module Exporter
+    module Wordpress
+      class Blog
+        attr_reader :xml, :settings
+
+        def initialize(xml_document, settings)
+          @xml = xml_document
+          @settings = settings
+        end
+
+        def blog_extractor
+          create_directory(settings.data_dir)
+          extract_blog
+        end
+
+        def link_entry(entries)
+          entries.each do |entry|
+            entry.keep_if { |key, _v| key if key == :id }
+            entry.merge!(type: 'Entry')
+          end
+        end
+
+        def link_asset(asset)
+          asset.keep_if { |key, _v| key if key == :id }
+          asset.merge!(type: 'File')
+        end
+
+        def create_directory(path)
+          FileUtils.mkdir_p(path) unless File.directory?(path)
+        end
+
+        def write_json_to_file(path, data)
+          File.open(path, 'w') do |file|
+            file.write(JSON.pretty_generate(data))
+          end
+        end
+
+        def output_logger
+          Logger.new(STDOUT)
+        end
+
+        private
+
+        def extract_blog
+          output_logger.info('Extracting blog data...')
+          create_directory("#{settings.entries_dir}/blog")
+          blog = extracted_data
+          write_json_to_file("#{settings.entries_dir}/blog/blog_1.json", blog)
+        end
+
+        def extracted_data
+          {
+            id: 'blog_id',
+            title: title,
+            posts: link_entry(posts),
+            categories: link_entry(categories),
+            tags: link_entry(tags)
+          }
+        end
+
+        def posts
+          Post.new(xml, settings).post_extractor
+        end
+
+        def categories
+          Category.new(xml, settings).categories_extractor
+        end
+
+        def tags
+          Tag.new(xml, settings).tags_extractor
+        end
+
+        def title
+          xml.at_xpath('//title').text
+        end
+      end
+    end
+  end
+end

data/lib/wordpress/category.rb

@@ -0,0 +1,54 @@
+require_relative 'blog'
+
+module Contentful
+  module Exporter
+    module Wordpress
+      class Category < Blog
+        def initialize(xml, settings)
+          @xml = xml
+          @settings = settings
+        end
+
+        def categories_extractor
+          output_logger.info 'Extracting blog categories...'
+          create_directory("#{settings.entries_dir}/category")
+          extract_categories
+        end
+
+        private
+
+        def extract_categories
+          categories.each_with_object([]) do |category, categories|
+            normalized_category = extracted_category(category)
+            write_json_to_file("#{settings.entries_dir}/category/#{id(category)}.json", normalized_category)
+            categories << normalized_category
+          end
+        end
+
+        def extracted_category(category)
+          {
+            id: id(category),
+            nicename: nice_name(category),
+            name: name(category)
+          }
+        end
+
+        def categories
+          xml.xpath('//wp:category').to_a
+        end
+
+        def id(category)
+          "category_#{category.xpath('wp:term_id').text}"
+        end
+
+        def nice_name(category)
+          category.xpath('wp:category_nicename').text
+        end
+
+        def name(category)
+          category.xpath('wp:cat_name').text
+        end
+      end
+    end
+  end
+end

data/lib/wordpress/export.rb

@@ -0,0 +1,30 @@
+require 'nokogiri'
+require 'open-uri'
+require 'fileutils'
+require 'json'
+
+require_relative 'blog'
+require_relative 'post'
+require_relative 'category'
+require_relative 'tag'
+require_relative 'post_category_domain'
+require_relative 'post_attachment'
+
+module Contentful
+  module Exporter
+    module Wordpress
+      class Export
+        attr_reader :wordpress_xml, :settings
+
+        def initialize(settings)
+          @settings = settings
+          @wordpress_xml = Nokogiri::XML(File.open(settings.wordpress_xml))
+        end
+
+        def export_blog
+          Blog.new(wordpress_xml, settings).blog_extractor
+        end
+      end
+    end
+  end
+end

data/lib/wordpress/post.rb

@@ -0,0 +1,94 @@
+require_relative 'blog'
+
+module Contentful
+  module Exporter
+    module Wordpress
+      class Post < Blog
+        attr_reader :xml, :settings
+
+        def initialize(xml, settings)
+          @xml = xml
+          @settings = settings
+        end
+
+        def post_extractor
+          output_logger.info 'Extracting posts...'
+          create_directory("#{settings.entries_dir}/post")
+          extract_posts
+        end
+
+        def post_id(post)
+          "post_#{post.xpath('wp:post_id').text}"
+        end
+
+        private
+
+        def extract_posts
+          posts.each_with_object([]) do |post_xml, posts|
+            normalized_post = extract_data(post_xml)
+            write_json_to_file("#{settings.entries_dir}/post/#{post_id(post_xml)}.json", normalized_post)
+            posts << normalized_post
+          end
+        end
+
+        def posts
+          xml.xpath('//item').to_a
+        end
+
+        def extract_data(xml_post)
+          post_entry = basic_post_data(xml_post)
+          assign_content_elements_to_post(xml_post, post_entry)
+          post_entry
+        end
+
+        def attachment(xml_post)
+          PostAttachment.new(xml_post, settings).attachment_extractor
+        end
+
+        def tags(xml_post)
+          PostCategoryDomain.new(xml, xml_post, settings).extract_tags
+        end
+
+        def categories(xml_post)
+          PostCategoryDomain.new(xml, xml_post, settings).extract_categories
+        end
+
+        def basic_post_data(xml_post)
+          created = Date.strptime(created_at(xml_post))
+          {
+            id: post_id(xml_post),
+            title: title(xml_post),
+            wordpress_url: url(xml_post),
+            content: content(xml_post),
+            created_at: created
+          }
+        end
+
+        def assign_content_elements_to_post(xml_post, post_entry)
+          attachment = attachment(xml_post)
+          tags = link_entry(tags(xml_post))
+          categories = link_entry(categories(xml_post))
+          post_entry.merge!(attachment: link_asset(attachment)) unless attachment.nil?
+          post_entry.merge!(tags: tags) unless tags.empty?
+          post_entry.merge!(categories: categories) unless categories.empty?
+        end
+
+        def title(xml_post)
+          xml_post.xpath('title').text
+        end
+
+        def url(xml_post)
+          xml_post.xpath('link').text
+        end
+
+        def content(xml_post)
+          xml_post.xpath('content:encoded').text
+        end
+
+        def created_at(xml_post)
+          xml_post.xpath('wp:post_date').text
+        end
+      end
+    end
+  end
+end

data/lib/wordpress/post_attachment.rb

@@ -0,0 +1,44 @@
+require_relative 'post'
+
+module Contentful
+  module Exporter
+    module Wordpress
+      class PostAttachment < Post
+        attr_reader :post, :settings
+
+        def initialize(post, settings)
+          @post = post
+          @settings = settings
+        end
+
+        def attachment_extractor
+          create_directory("#{settings.assets_dir}/attachment_post")
+          asset = { id: attachment_id, description: attachment_description, url: attachment_url }
+          unless asset[:url].nil?
+            write_json_to_file("#{settings.assets_dir}/attachment_post/#{attachment_id}.json", asset)
+            asset
+          end
+        end
+
+        private
+
+        def attachment_url
+          post.at_xpath('wp:attachment_url').text unless post.at_xpath('wp:attachment_url').nil?
+        end
+
+        def attachment_id
+          "attachment_#{post_id(post)}"
+        end
+
+        def attachment_description
+          meta_arr = post.xpath('wp:postmeta').to_a
+          unless meta_arr.empty?
+            meta_arr.each do |meta|
+              return meta.at_xpath('wp:meta_value').text if meta.at_xpath('wp:meta_key').text == '_wp_attachment_image_alt'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wordpress/post_category_domain.rb

@@ -0,0 +1,71 @@
+require_relative 'post'
+
+module Contentful
+  module Exporter
+    module Wordpress
+      class PostCategoryDomain < Post
+        attr_reader :post, :xml, :settings
+
+        def initialize(xml, post, settings)
+          @xml = xml
+          @post = post
+          @settings = settings
+        end
+
+        def extract_tags
+          output_logger.info 'Extracting post tags...'
+          post_domains('category[domain=post_tag]').each_with_object([]) do |tag, tags|
+            normalized_tag = normalized_data(tag, '//wp:tag')
+            tags << normalized_tag unless normalized_tag.empty?
+          end
+        end
+
+        def extract_categories
+          output_logger.info 'Extracting post categories...'
+          post_domains('category[domain=category]').each_with_object([]) do |category, categories|
+            normalized_categories = normalized_data(category, '//wp:category')
+            categories << normalized_categories unless normalized_categories.empty?
+          end
+        end
+
+        private
+
+        def post_domains(domain)
+          post.css(domain).to_a
+        end
+
+        def blog_domains(domain)
+          xml.xpath(domain).to_a
+        end
+
+        def id(domain, prefix)
+          "#{prefix}#{domain.xpath('wp:term_id').text}"
+        end
+
+        def name(domain, name_path)
+          domain.xpath(name_path).text
+        end
+
+        def domain_id(domain, domain_path)
+          prefix_id = prefix_id(domain_path)
+          name_path = domain_path_name(domain_path)
+          blog_domains(domain_path).each do |blog_domain|
+            return id(blog_domain, prefix_id) if name(blog_domain, name_path) == domain.text
+          end
+        end
+
+        def normalized_data(domain, path)
+          { id: domain_id(domain, path) }
+        end
+
+        def prefix_id(domain_path)
+          '//wp:category' == domain_path ? 'category_' : 'tag_'
+        end
+
+        def domain_path_name(domain_path)
+          '//wp:category' == domain_path ? 'wp:cat_name' : 'wp:tag_name'
+        end
+      end
+    end
+  end
+end