qiita-export 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6442dd02c9dd12b8a17344ad0a9e3f6dd780c371
+  data.tar.gz: 1463061332a477bf955edcbd435db8a3c0fb6279
+SHA512:
+  metadata.gz: 4668ef573aaa449d7d37248bc060a05700f555fd3bf16158d412b2809f20794130c1e5955d8cf15805966e2801ee861595a56deb79ae0970892007d4b76b943b
+  data.tar.gz: ec2cb0016242ce4a2ee41e0d8926facb234e4f77b06142a4e73371ff3f950f97f6f92995529f25c8618f1b342d14fdde3c6a315e899101b22b80e90e22ecacbd

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/vendor/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in qiita_export.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 akishin
+
+MIT License
+
+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 OR COPYRIGHT HOLDERS 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/README.md

@@ -0,0 +1,51 @@
+# QiitaExport
+
+export tool for Qiita(http://qiita.com/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'qiita_export'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install qiita_export
+```
+
+## Usage
+
+```
+Usage: qiita-export [options]
+    -u, --url=url                    specify the URL for the Qiita(or Qiita Team).
+    -l, --url-list=filepath          specify the file path of the URL list.
+    -U, --user-id=user_id            specify the userid for the Qiita.
+    -k, --kobito=[Kobito.db]         export Kobito.app database.
+    -t, --team=teamname              export Qiita Team articles only.
+    -i, --image                      export with images.
+    -h, --html                       export in html format(experimental).
+    -o, --output-dir=dirpath         specify the full path of destination directory.
+    -a, --api-token=token            specify API token for Qiita.
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/akishin/qiita_export/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+MIT License
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc 'rake spec'
+task :default => [:spec]
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/*_spec.rb'
+  spec.rspec_opts = ['-cfd --backtrace']
+end
+

data/bin/qiita-export

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rubygems'
+require 'qiita-export'
+
+QiitaExport::Config.configure(ARGV)
+if QiitaExport::Config.empty?
+  print QiitaExport::Config.help
+  exit true
+end
+
+begin
+  QiitaExport::Config.validate!
+rescue ArgumentError => e
+  $stderr.puts e.message
+  exit(1)
+end
+
+QiitaExport::Exporter::new.export

data/lib/qiita-export.rb

@@ -0,0 +1,10 @@
+require 'qiita-export/version'
+require 'qiita-export/image'
+require 'qiita-export/article'
+require 'qiita-export/config'
+require 'qiita-export/exporter'
+require 'qiita-export/fetcher/base'
+require 'qiita-export/fetcher/kobito_fetcher'
+require 'qiita-export/fetcher/api_fetcher'
+require 'qiita-export/fetcher/url_fetcher'
+require 'qiita-export/fetcher/user_fetcher'

data/lib/qiita-export/article.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+require 'erb'
+
+module QiitaExport
+  class Article
+    attr_reader :key, :url, :title, :raw_body, :rendered_body, :created_at,
+                :updated_at, :user_id, :images
+
+    HTML_TEMPLATE =<<-"EOS"
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="UTF-8" />
+          <title><%= @title %></title>
+        </head>
+        <body>
+          <h1><%= @title %></h1>
+          <%= @rendered_body %>
+        </body>
+      </html>
+    EOS
+
+    def initialize(key, url, title, raw_body, rendered_body, created_at, updated_at, user_id)
+      @key           = key
+      @url           = url
+      @title         = title
+      @raw_body      = raw_body
+      @rendered_body = rendered_body
+      @created_at    = created_at
+      @updated_at    = updated_at
+      @user_id       = user_id
+      @images        = Image.extract_urls(@key, @raw_body)
+    end
+
+    def save
+      save_dir  = File.join(Config.export_dir_path, Config.team_name(@url), @key)
+
+      FileUtils.makedirs(save_dir) unless Dir.exists?(save_dir)
+
+      file_path = File.join(save_dir, Config.filename(title))
+      File.open(file_path, "w") { |f| f.write export_content }
+      if (Config.image_export?)
+        @images.each { |image| image.save(save_dir) }
+      end
+    end
+
+    private
+
+    def export_content
+      if Config.html_export?
+        replace_img_src!(@rendered_body)
+        ERB.new(HTML_TEMPLATE).result(binding)
+      else
+        @raw_body
+      end
+    end
+
+    def replace_img_src!(html)
+      image_urls = html.scan(/<img[^src]+src="([^"]+)"[^>]+>/).flatten
+      image_urls.each do |image_url|
+        html.gsub!(image_url, "./#{Image::IMAGE_DIR}/#{File.basename(image_url)}")
+      end
+    end
+  end
+end

data/lib/qiita-export/config.rb

@@ -0,0 +1,184 @@
+require 'optparse'
+
+module QiitaExport
+  class Config
+
+    HOME_CONFIG_FILE = "~/.qiita-exportrc"
+    LOCAL_CONFIG_FILE = "./.qiita-exportrc"
+
+    DEFAULT_USER_AGENT = "QiitaExport Gem #{QiitaExport::VERSION}"
+
+    DEFAULT_HEADER = {
+      "User-Agent" => DEFAULT_USER_AGENT
+    }
+
+    DEFAULT_KOBITO_DB = "~/Library/Containers/com.qiita.Kobito/Data/Library/Kobito/Kobito.db"
+
+    class << self
+      def configure(argv)
+        @option = {}
+        @parser = OptionParser.new do |opt|
+          opt.version = QiitaExport::VERSION
+          opt.on('-u', '--url=url',            'specify the URL for the Qiita(or Qiita Team).')   { |v| @option[:url] = v }
+          opt.on('-l', '--url-list=filepath',  'specify the file path of the URL list.')          { |v| @option[:'url-list'] = v }
+          opt.on('-U', '--user-id=user_id',    'specify the userid for the Qiita.')               { |v| @option[:'user-id'] = v }
+          opt.on('-k', '--kobito=[Kobito.db]', 'export Kobito.app database.')                     { |v| @option[:kobito] = v }
+          opt.on('-t', '--team=teamname',      'export Qiita Team articles only.')                { |v| @option[:team] = v }
+          opt.on('-i', '--image',              'export with images.')                             { |v| @option[:image] = v }
+          opt.on('-h', '--html',               'export in html format(experimental).')            { |v| @option[:html] = v }
+          opt.on('-o', '--output-dir=dirpath', 'specify the full path of destination directory.') { |v| @option[:'output-dir'] = v }
+          opt.on('-a', '--api-token=token',    'specify API token for Qiita.')                    { |v| @option[:'api-token'] = v }
+        end
+
+        # load home config
+        @parser.load(File.expand_path(HOME_CONFIG_FILE))
+
+        # load local config
+        @parser.load(File.expand_path(LOCAL_CONFIG_FILE))
+
+        # parse argv
+        @parser.parse!(argv)
+
+        self
+      end
+
+      def empty?
+        @option.empty?
+      end
+
+      def help
+        @parser.help
+      end
+
+      def validate!
+        if present?(@option[:'url-list']) && !File.exist?(@option[:'url-list'])
+          fail ArgumentError.new("-l (#{@option[:'url-list']}) does not exist.")
+        end
+
+        if kobito? && !File.exist?(kobito_db)
+          fail ArgumentError.new("#{kobito_db} does not exist.")
+        end
+
+        if kobito? && api?
+          fail ArgumentError.new("if you specify option --kobito, you cannot specify option --url, --url-list and --user-id.")
+        end
+      end
+
+      def kobito?
+        @option.key?(:kobito)
+      end
+
+      def api?
+        present?(@option[:url]) || present?(@option[:'url-list']) || present?(@option[:'user-id'])
+      end
+
+      def user?
+        present?(@option[:'user-id'])
+      end
+
+      def team?
+        present?(@option[:team])
+      end
+
+      def file_export?
+        present?(@option[:'output-dir'])
+      end
+
+      def html_export?
+        @option[:html]
+      end
+
+      def image_export?
+        @option[:image]
+      end
+
+      def team_url?(url)
+        url !~ /^https?:\/\/qiita\.com/
+      end
+
+      DOMAIN_PATTERN = Regexp.new("https?://([^/]+)/")
+      def team_name(url = nil)
+        if (kobito? || user?) && team?
+          @option[:team]
+        elsif api? && team_url?(url)
+          url.match(DOMAIN_PATTERN)[1].split('.')[0]
+        else
+          ""
+        end
+      end
+
+      def article_urls
+        urls = []
+        urls << @option[:url] if present?(@option[:url])
+
+        if present?(@option[:'url-list'])
+          open(@option[:'url-list']) { |io|
+            io.each_line { |line|
+              url = line.chop
+              next if blank?(url)
+              urls << url
+            }
+          }
+        end
+        urls
+      end
+
+      def kobito_db
+        if blank?(@option[:kobito])
+          File.expand_path(DEFAULT_KOBITO_DB)
+        else
+          File.expand_path(@option[:kobito])
+        end
+      end
+
+      def api_token
+        @option[:'api-token']
+      end
+
+      def has_api_token?
+        present?(@option[:'api-token'])
+      end
+
+      def default_header
+        DEFAULT_HEADER.clone
+      end
+
+      def auth_header
+        header = default_header
+        header["Authorization"] = "Bearer #{api_token}"
+        header
+      end
+
+      def user_id
+        @option[:'user-id']
+      end
+
+      def export_dir_path
+        if user?
+          File.join(File.expand_path(@option[:'output-dir'].strip), user_id)
+        else
+          File.expand_path(@option[:'output-dir'].strip)
+        end
+      end
+
+      def filename(title)
+        return "" if !html_export? && blank?(title)
+        if html_export?
+          "index.html"
+        else
+          "#{title.gsub(/\//, ':')}.md"
+        end
+      end
+
+      private
+
+      def blank?(str)
+        str.nil? || str.empty?
+      end
+
+      def present?(str)
+        !blank?(str)
+      end
+    end
+  end
+end

data/lib/qiita-export/exporter.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+module QiitaExport
+  class Exporter
+
+    def initialize
+    end
+
+    def export
+      fetcher = create_fetcher
+      articles = fetcher.find_articles
+      if (Config.file_export?)
+        export_file(articles)
+      else
+        export_console(articles)
+      end
+    end
+
+    private
+
+    def create_fetcher
+      if Config.kobito?
+        QiitaExport::Fetcher::KobitoFetcher.new
+      elsif Config.user?
+        QiitaExport::Fetcher::UserFetcher.new
+      else
+        QiitaExport::Fetcher::UrlFetcher.new
+      end
+    end
+
+    def export_console(articles)
+      articles.each do |article|
+        $stdout.puts("key: #{article.key} title: #{article.title} url: #{article.url} created_at: #{article.created_at} updated_at: #{article.updated_at}")
+      end
+    end
+
+    def export_file(articles)
+      $stdout.puts "export articles to #{Config.export_dir_path}"
+      FileUtils.makedirs(Config.export_dir_path) unless Dir.exists?(Config.export_dir_path)
+      articles.each do |article|
+        article.save
+      end
+    end
+  end
+end

data/lib/qiita-export/fetcher/api_fetcher.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+require 'json'
+require 'uri'
+
+module QiitaExport::Fetcher
+  class ApiFetcher < Base
+
+    DEFAULT_HOST = "qiita.com"
+
+    protected
+
+    def to_article(res)
+      key           = res['id']
+      url           = res['url']
+      title         = res['title']
+      raw_body      = res['body']
+      rendered_body = res['rendered_body']
+      created_at    = res['created_at']
+      updated_at    = res['updated_at']
+      user_id       = res['user_id']
+
+      ::QiitaExport::Article.new(key, url, title, raw_body, rendered_body, created_at, updated_at, user_id)
+    end
+
+    def article_key(url)
+      File.basename(url)
+    end
+
+    def request_header
+      has_api_token? ? auth_header : default_header
+    end
+
+    def api_domain(url = nil)
+      if url.nil?
+        team? ? "#{team_name}.#{DEFAULT_HOST}" : DEFAULT_HOST
+      else
+        URI.parse(url).host
+      end
+    end
+
+  end
+end

data/lib/qiita-export/fetcher/base.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+require 'forwardable'
+
+module QiitaExport::Fetcher
+  class Base
+    extend Forwardable
+
+    def_delegators :@config, :kobito?, :kobito_db, :file_export?,
+                             :export_dir_path, :team?, :team_name,
+                             :article_urls, :has_api_token?, :api_token,
+                             :user_id, :default_header, :auth_header
+
+    def initialize
+      @config = ::QiitaExport::Config
+    end
+
+    def find_articles
+      raise NotImplementedError.new("You must implement #{self.class}##{__method__}")
+    end
+
+  end
+end

data/lib/qiita-export/fetcher/kobito_fetcher.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+require 'sqlite3'
+require 'time'
+
+module QiitaExport::Fetcher
+  class KobitoFetcher < Base
+
+    SELECT =<<-"EOS"
+      SELECT
+        i.zurl,
+        i.ztitle,
+        i.zraw_body,
+        i.zbody,
+        i.zposted_at,
+        i.zcreated_at,
+        i.zupdated_at,
+        i.zupdated_at_on_qiita,
+        t.zurl_name
+      FROM 
+        zitem i left outer join zteam t on i.zteam = t.z_pk
+      WHERE
+        zin_trash is null
+    EOS
+
+    ORDER = " ORDER BY i.zcreated_at"
+
+    def find_articles
+      where = if team?
+                " and zurl_name = :team"
+              else
+                " and zteam is null"
+              end
+      query = "#{SELECT}#{where}#{ORDER}"
+
+      db = SQLite3::Database.new(kobito_db)
+      db.results_as_hash = true
+
+      stmt = db.prepare(query)
+      stmt.bind_param("team", team_name) if team?
+      rs = stmt.execute
+
+      articles = []
+      while(row = rs.next)
+        articles << to_article(row)
+      end
+      articles
+    ensure
+      stmt.close if stmt
+      db.close   if db
+    end
+
+    private
+
+    def to_article(row)
+      key           = File.basename(row['ZURL'])
+      url           = row['ZURL']
+      title         = row['ZTITLE']
+      raw_body      = row['ZRAW_BODY']
+      rendered_body = row['ZBODY']
+
+      zposted_at           = convert_timestamp(row['ZPOSTED_AT'])
+      zcreated_at          = convert_timestamp(row['ZCREATED_AT'])
+      zupdated_at_on_qiita = convert_timestamp(row['ZUPDATED_AT_ON_QIITA'])
+      zupdated_at          = convert_timestamp(row['ZUPDATED_AT'])
+
+      # puts "key: #{key} zposted_at: #{zposted_at} zcreated_at: #{zcreated_at} zupdated_at_on_qiita: #{zupdated_at_on_qiita} zupdated_at: #{zupdated_at}"
+      ::QiitaExport::Article.new(key, url, title, raw_body, rendered_body, zcreated_at, zupdated_at, 'kobito_user')
+    end
+
+    BASE_DATE = Time.new(2001, 1, 1, 0, 0, 0, 0).to_i
+    def convert_timestamp(timestamp)
+      Time.at(timestamp + BASE_DATE).iso8601
+    end
+  end
+end
+
+

data/lib/qiita-export/fetcher/url_fetcher.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+require 'json'
+require 'open-uri'
+
+module QiitaExport::Fetcher
+  class UrlFetcher < ApiFetcher
+
+    def find_articles
+      articles = []
+      article_urls.each do |url|
+        articles << to_article(find_article(url))
+      end
+      articles
+    end
+
+    private
+
+    def find_article(url)
+      open("https://#{api_domain(url)}/api/v2/items/#{article_key(url)}", request_header) do |io|
+        JSON.parse(io.read)
+      end
+    end
+  end
+end

data/lib/qiita-export/fetcher/user_fetcher.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+require 'json'
+require 'open-uri'
+
+module QiitaExport::Fetcher
+  class UserFetcher < ApiFetcher
+
+    PER_PAGE = 100
+
+    def find_articles
+      articles = []
+      page = 1
+      while true
+        user_articles = find_user_articles(page)
+        break if user_articles.empty?
+
+        user_articles.each do |user_article|
+          articles << to_article(user_article)
+        end
+
+        page += 1
+        sleep(0.3)
+      end
+      articles.sort { |a, b| a.created_at <=> b.created_at }
+    end
+
+    private
+
+    def find_user_articles(page)
+      open("https://#{api_domain}/api/v2/users/#{user_id}/items?page=#{page}&per_page=#{PER_PAGE}", request_header) do |io|
+        JSON.parse(io.read)
+      end
+    end
+  end
+end

data/lib/qiita-export/image.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+require 'fileutils'
+require 'uri'
+
+module QiitaExport
+  class Image
+    attr_reader :key, :url
+
+    IMAGE_DIR = "images"
+
+    def initialize(key, url)
+      @key = key
+      @url = url
+    end
+
+    def self.extract_urls(key, markdown)
+      image_urls = markdown.scan(/!\[.*?\]\((.+?)(?: \".*?\")?\)/).flatten
+      image_urls.map do |image_url|
+        new(key, image_url)
+      end
+    end
+
+    def require_auth?
+      @url !~ /qiita-image-store.s3.amazonaws.com/
+    end
+
+    def request_header
+      require_auth? ? Config.auth_header : Config.default_header
+    end
+
+    def filename
+      "#{File.basename(url)}"
+    end
+
+    def save(path)
+      image_dir = File.join(File.expand_path(path), IMAGE_DIR)
+
+      FileUtils.makedirs(image_dir) unless Dir.exists?(image_dir)
+
+      file_path = File.join(image_dir, filename)
+
+      open(file_path, 'wb') do |out|
+        open(@url, request_header) do |image|
+          out.write(image.read)
+        end
+      end
+    end
+  end
+end

data/lib/qiita-export/version.rb

@@ -0,0 +1,4 @@
+module QiitaExport
+  VERSION = '0.0.1'
+end
+

data/qiita-export.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qiita-export/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "qiita-export"
+  spec.version       = QiitaExport::VERSION
+  spec.authors       = ["Shin Akiyama"]
+  spec.email         = ["akishin999@gmail.com"]
+  spec.summary       = %q{export tool for Qiita}
+  spec.description   = %q{export tool for Qiita}
+  spec.homepage      = "https://github.com/akishin/qiita-export"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.bindir        = 'bin'
+
+  spec.add_dependency "sqlite3"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "3.4.0"
+end

data/spec/qiita-export/config_spec.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+require File.expand_path(File.join('..', 'spec_helper'), File.dirname(__FILE__))
+require 'qiita-export'
+
+describe QiitaExport::Config do
+  let(:valid_url)       { 'http://qiita.com/akishin/items/61630d628f4c8e141ef2' }
+  let(:valid_kobito_db) { File.expand_path(QiitaExport::Config::DEFAULT_KOBITO_DB) }
+  let(:valid_team_name) { 'example' }
+  let(:valid_argv) {
+    [
+      '--url', valid_url,
+      '--kobito', valid_kobito_db,
+      '--image',
+      '--html',
+      '--team', valid_team_name,
+    ]
+  }
+
+  describe ".configure" do
+
+    context "with arguments" do
+      let(:arguments) do
+        valid_argv
+      end
+
+      subject do
+        described_class.configure(arguments)
+      end
+
+      it "returns a QiitaExport::Config" do
+        expect(subject).to eq(QiitaExport::Config)
+      end
+      it { expect(subject.article_urls).to include(valid_url) }
+      it { expect(subject.kobito_db).to eq(valid_kobito_db) }
+      it { expect(subject.api?).to be_truthy }
+      it { expect(subject.image_export?).to be_truthy }
+      it { expect(subject.html_export?).to be_truthy }
+      it { expect(subject.team?).to be_truthy }
+      it { expect(subject.team_name).to eq(valid_team_name) }
+    end
+
+  end
+
+end
+
+

data/spec/qiita-export/image_spec.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+require File.expand_path(File.join('..', 'spec_helper'), File.dirname(__FILE__))
+require 'qiita-export'
+
+describe QiitaExport::Image do
+  let(:valid_key) { '99999999999999999999' }
+  let(:valid_url) { 'http://qiita-image-store.s3.amazonaws.com/example.jpg' }
+
+  describe ".new" do
+
+    context "with arguments" do
+      let(:arguments) do
+        [valid_key, valid_url]
+      end
+
+      subject do
+        described_class.new(*arguments)
+      end
+
+      it "returns a QiitaExport::Image" do
+        expect(subject).to be_an_instance_of(QiitaExport::Image)
+      end
+      it { expect(subject.key).to eq(valid_key) }
+      it { expect(subject.url).to eq(valid_url) }
+    end
+
+    context "without any arguments" do
+      let(:arguments) do
+        []
+      end
+
+      it "raise ArgumentError" do
+        expect {
+          described_class.new(*arguments)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  let(:include_images) {
+    <<-"EOS"
+## Example Markdown
+![foo.png](https://example.com/foo.png "foo.png")
+![bar.png](https://example.com/bar.png)
+    EOS
+  }
+
+  let(:not_include_images) {
+    <<-"EOS"
+## Example Markdown
+### Test1
+### Test2
+    EOS
+  }
+
+  describe ".extract_urls" do
+    context "when there is image urls" do
+      subject do
+        described_class.extract_urls(valid_key, include_images)
+      end
+
+      it { expect(subject).not_to be_empty }
+      it { expect(subject.length).to eq(2) }
+      it { expect(subject.first).to be_an_instance_of(QiitaExport::Image) }
+      it { expect(subject.first.url).to eq('https://example.com/foo.png') }
+      it { expect(subject.last).to be_an_instance_of(QiitaExport::Image) }
+      it { expect(subject.last.url).to eq('https://example.com/bar.png') }
+    end
+
+    context "when there is no image urls" do
+      subject do
+        described_class.extract_urls(valid_key, not_include_images)
+      end
+      it { expect(subject).to be_empty }
+    end
+  end
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rspec'
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+end
+

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: qiita-export
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shin Akiyama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: export tool for Qiita
+email:
+- akishin999@gmail.com
+executables:
+- qiita-export
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/qiita-export
+- lib/qiita-export.rb
+- lib/qiita-export/article.rb
+- lib/qiita-export/config.rb
+- lib/qiita-export/exporter.rb
+- lib/qiita-export/fetcher/api_fetcher.rb
+- lib/qiita-export/fetcher/base.rb
+- lib/qiita-export/fetcher/kobito_fetcher.rb
+- lib/qiita-export/fetcher/url_fetcher.rb
+- lib/qiita-export/fetcher/user_fetcher.rb
+- lib/qiita-export/image.rb
+- lib/qiita-export/version.rb
+- qiita-export.gemspec
+- spec/qiita-export/config_spec.rb
+- spec/qiita-export/image_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/akishin/qiita-export
+licenses:
+- MIT
+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.4.5
+signing_key: 
+specification_version: 4
+summary: export tool for Qiita
+test_files:
+- spec/qiita-export/config_spec.rb
+- spec/qiita-export/image_spec.rb
+- spec/spec_helper.rb