wp2txt 1.0.2 → 1.1.1

data/lib/wp2txt/utils.rb

@@ -1,183 +1,87 @@
-#!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
-
-require 'strscan'
-require 'find'
-require 'htmlentities'
-
-###################################################
-# global variables to save resource for generating regexps
-# those with a trailing number 1 represent opening tag/markup
-# those with a trailing number 2 represent closing tag/markup
-# those without a trailing number contain both opening/closing tags/markups
-
-$html_decoder = HTMLEntities.new
-
-$entities = ['&nbsp;', '&lt;', '&gt;', '&amp;', '&quot;'].zip([' ', '<', '>', '&', '"'])
-$html_hash  = Hash[*$entities.flatten]
-$html_regex = Regexp.new("(" + $html_hash.keys.join("|") + ")")
-$ml_template_onset_regex = Regexp.new('^\{\{[^\}]*$')
-$ml_template_end_regex   = Regexp.new('\}\}\s*$')
-$ml_link_onset_regex = Regexp.new('^\[\[[^\]]*$')
-$ml_linkend_regex   = Regexp.new('\]\]\s*$')
-$isolated_template_regex = Regexp.new('^\s*\{\{.+\}\}\s*$')
-$isolated_tag_regex = Regexp.new('^\s*\<[^\<\>]+\>.+\<[^\<\>]+\>\s*$')
-$in_link_regex = Regexp.new('^\s*\[.*\]\s*$')
-$in_inputbox_regex  = Regexp.new('<inputbox>.*?<\/inputbox>')
-$in_inputbox_regex1  = Regexp.new('<inputbox>')
-$in_inputbox_regex2  = Regexp.new('<\/inputbox>')
-$in_source_regex  = Regexp.new('<source.*?>.*?<\/source>')
-$in_source_regex1  = Regexp.new('<source.*?>')
-$in_source_regex2  = Regexp.new('<\/source>')
-$in_math_regex  = Regexp.new('<math.*?>.*?<\/math>')
-$in_math_regex1  = Regexp.new('<math.*?>')
-$in_math_regex2  = Regexp.new('<\/math>')
-$in_heading_regex  = Regexp.new('^=+.*?=+$')
-$in_html_table_regex = Regexp.new('<table.*?><\/table>')
-$in_html_table_regex1 = Regexp.new('<table\b')
-$in_html_table_regex2 = Regexp.new('<\/\s*table>')
-$in_table_regex1 = Regexp.new('^\s*\{\|')
-$in_table_regex2 = Regexp.new('^\|\}.*?$')
-$in_unordered_regex  = Regexp.new('^\*')
-$in_ordered_regex    = Regexp.new('^\#')
-$in_pre_regex = Regexp.new('^ ')
-$in_definition_regex  = Regexp.new('^[\;\:]')
-$blank_line_regex = Regexp.new('^\s*$')
-$redirect_regex = Regexp.new('#(?:REDIRECT|転送)\s+\[\[(.+)\]\]', Regexp::IGNORECASE)
-$remove_tag_regex = Regexp.new("\<[^\<\>]*\>")
-$remove_directives_regex = Regexp.new("\_\_[^\_]*\_\_")
-$remove_emphasis_regex = Regexp.new('(' + Regexp.escape("''") + '+)(.+?)\1')
-$chrref_to_utf_regex = Regexp.new('&#(x?)([0-9a-fA-F]+);')
-$mndash_regex = Regexp.new('\{(mdash|ndash|–)\}')
-$remove_hr_regex = Regexp.new('^\s*\-+\s*$')
-$make_reference_regex_a = Regexp.new('<br ?\/>')
-$make_reference_regex_b = Regexp.new('<ref[^>]*\/>')
-$make_reference_regex_c = Regexp.new('<ref[^>]*>')
-$make_reference_regex_d = Regexp.new('<\/ref>')
-$format_ref_regex = Regexp.new('\[ref\](.*?)\[\/ref\]', Regexp::MULTILINE)
-$heading_onset_regex = Regexp.new('^(\=+)\s+')
-$heading_coda_regex = Regexp.new('\s+(\=+)$')
-$list_marks_regex = Regexp.new('\A[\*\#\;\:\ ]+')
-$pre_marks_regex = Regexp.new('\A\^\ ')
-$def_marks_regex = Regexp.new('\A[\;\:\ ]+')
-$onset_bar_regex = Regexp.new('\A[^\|]+\z')
-
-$category_patterns = ["Category", "Categoria"].join("|")
-$category_regex = Regexp.new('[\{\[\|\b](?:' + $category_patterns + ')\:(.*?)[\}\]\|\b]', Regexp::IGNORECASE)
-
-$escape_nowiki_regex = Regexp.new('<nowiki>(.*?)<\/nowiki>', Regexp::MULTILINE)
-$unescape_nowiki_regex = Regexp.new('<nowiki\-(\d+?)>')
-
-$remove_isolated_regex = Regexp.new('^\s*\{\{(.*?)\}\}\s*$')
-$remove_inline_regex = Regexp.new('\{\{(.*?)\}\}')
-$type_code_regex = Regexp.new('\A(?:lang*|\AIPA|IEP|SEP|indent|audio|small|dmoz|pron|unicode|note label|nowrap|ArabDIN|trans|Nihongo|Polytonic)', Regexp::IGNORECASE)
-
-$single_square_bracket_regex = Regexp.new("(#{Regexp.escape('[')}|#{Regexp.escape(']')})", Regexp::MULTILINE)
-$double_square_bracket_regex = Regexp.new("(#{Regexp.escape('[[')}|#{Regexp.escape(']]')})", Regexp::MULTILINE)
-$single_curly_bracket_regex = Regexp.new("(#{Regexp.escape('{')}|#{Regexp.escape('}')})", Regexp::MULTILINE)
-$double_curly_bracket_regex = Regexp.new("(#{Regexp.escape('{{')}|#{Regexp.escape('}}')})", Regexp::MULTILINE)
-$curly_square_bracket_regex = Regexp.new("(#{Regexp.escape('{|')}|#{Regexp.escape('|}')})", Regexp::MULTILINE)
-
-$complex_regex_01 = Regexp.new('\<\<([^<>]++)\>\>\s?')
-$complex_regex_02 = Regexp.new('\[\[File\:((?:[^\[\]]++|\[\[\g<1>\]\])++)\]\]', Regexp::MULTILINE | Regexp::IGNORECASE)
-$complex_regex_03 = Regexp.new('^\[\[((?:[^\[\]]++|\[\[\g<1>\]\])++)^\]\]', Regexp::MULTILINE)
-$complex_regex_04 = Regexp.new('\{\{(?:infobox|efn|sfn|unreliable source|refn|reflist|col(?:umns)?\-list|div col|no col|bar box|formatnum\:|col\||see also\||r\||#)((?:[^{}]++|\{\{\g<1>\}\})++)\}\}', Regexp::MULTILINE | Regexp::IGNORECASE)
-$complex_regex_05 = Regexp.new('\{\{[^{}]+?\n\|((?:[^{}]++|\{\{\g<1>\}\})++)\}\}', Regexp::MULTILINE | Regexp::IGNORECASE)
-
-$cleanup_regex_01 = Regexp.new('\[ref\]\s*\[\/ref\]', Regexp::MULTILINE)
-$cleanup_regex_02 = Regexp.new('^File:.+$')
-$cleanup_regex_03 = Regexp.new('^\|.*$')
-$cleanup_regex_04 = Regexp.new('\{\{.*$')
-$cleanup_regex_05 = Regexp.new('^.*\}\}')
-$cleanup_regex_06 = Regexp.new('\{\|.*$')
-$cleanup_regex_07 = Regexp.new('^.*\|\}')
-$cleanup_regex_08 = Regexp.new('\n\n\n+', Regexp::MULTILINE)
-
-###################################################
+# frozen_string_literal: true
 
-module Wp2txt
+require "strscan"
+require "find"
+require_relative "regex"
 
-  def convert_characters!(text, has_retried = false)
-    begin
-      text << ""
-      chrref_to_utf!(text)
-      special_chr!(text)
-      text.encode!("UTF-8", "UTF-8", invalid: :replace, replace: "")
-
-    rescue # detect invalid byte sequence in UTF-8
-      if has_retried
-        puts "invalid byte sequence detected"
-        puts "******************************"
-        File.open("error_log.txt", "w") do |f|
-          f.write text
-        end
-        exit
-      else
-        text.encode!("UTF-16", "UTF-16", invalid: :replace, replace: "")
-        text.encode!("UTF-16", "UTF-16", invalid: :replace, replace: "")
-        convert_characters!(text, true)
+module Wp2txt
+  def convert_characters(text, has_retried = false)
+    text << ""
+    text = chrref_to_utf(text)
+    text = special_chr(text)
+    text = text.encode("UTF-8", "UTF-8", invalid: :replace, replace: "")
+  rescue StandardError # detect invalid byte sequence in UTF-8
+    if has_retried
+      puts "invalid byte sequence detected"
+      puts "******************************"
+      File.open("error_log.txt", "w") do |f|
+        f.write text
       end
+      exit
+    else
+      text = text.encode("UTF-16", "UTF-16", invalid: :replace, replace: "")
+      text = text.encode("UTF-16", "UTF-16", invalid: :replace, replace: "")
+      convert_characters(text, true)
     end
   end
 
-  def format_wiki!(text, has_retried = false)
-    remove_complex!(text)
-
-    escape_nowiki!(text)
-    process_interwiki_links!(text)
-    process_external_links!(text)
-    unescape_nowiki!(text)
-    remove_directive!(text)
-    remove_emphasis!(text)
-    mndash!(text)
-    remove_hr!(text)
-    remove_tag!(text)
-    correct_inline_template!(text) unless $leave_inline_template
-    remove_templates!(text) unless $leave_inline_template
-    remove_table!(text) unless $leave_table
+  def format_wiki(text, config = {})
+    text = remove_complex(text)
+    text = escape_nowiki(text)
+    text = process_interwiki_links(text)
+    text = process_external_links(text)
+    text = unescape_nowiki(text)
+    text = remove_directive(text)
+    text = remove_emphasis(text)
+    text = mndash(text)
+    text = remove_hr(text)
+    text = remove_tag(text)
+    text = correct_inline_template(text) unless config[:inline]
+    text = remove_templates(text) unless config[:inline]
+    text = remove_table(text) unless config[:table]
+    text
   end
 
-  def cleanup!(text)
-    text.gsub!($cleanup_regex_01){""}
-    text.gsub!($cleanup_regex_02){""}
-    text.gsub!($cleanup_regex_03){""}
-    text.gsub!($cleanup_regex_04){""}
-    text.gsub!($cleanup_regex_05){""}
-    text.gsub!($cleanup_regex_06){""}
-    text.gsub!($cleanup_regex_07){""}
-    text.gsub!($cleanup_regex_08){"\n\n"}
-    text.strip!
+  def cleanup(text)
+    text = text.gsub(CLEANUP_REGEX_01) { "" }
+    text = text.gsub(CLEANUP_REGEX_02) { "" }
+    text = text.gsub(CLEANUP_REGEX_03) { "" }
+    text = text.gsub(CLEANUP_REGEX_04) { "" }
+    text = text.gsub(CLEANUP_REGEX_05) { "" }
+    text = text.gsub(CLEANUP_REGEX_06) { "" }
+    text = text.gsub(CLEANUP_REGEX_07) { "" }
+    text = text.gsub(CLEANUP_REGEX_08) { "\n\n" }
+    text = text.strip
     text << "\n\n"
   end
 
   #################### parser for nested structure ####################
 
   def process_nested_structure(scanner, left, right, &block)
-    test = false
-    buffer = ""
+    buffer = +""
     begin
-      if left == "[" && right == "]"
-        regex = $single_square_bracket_regex
-      elsif left == "[[" && right == "]]"
-        regex = $double_square_bracket_regex
-      elsif left == "{" && right == "}"
-        regex = $single_curly_bracket_regex
-      elsif left == "{{" && right == "}}"
-        regex = $double_curly_bracket_regex
-      elsif left == "{|" && right == "|}"
-        regex = $curly_square_bracket_regex
-      else
-        regex = Regexp.new("(#{Regexp.escape(left)}|#{Regexp.escape(right)})")
-      end
-      while str = scanner.scan_until(regex)
+      regex = if left == "[" && right == "]"
+                SINGLE_SQUARE_BRACKET_REGEX
+              elsif left == "[[" && right == "]]"
+                DOUBLE_SQUARE_BRACKET_REGEX
+              elsif left == "{" && right == "}"
+                SINGLE_CURLY_BRACKET_REGEX
+              elsif left == "{{" && right == "}}"
+                DOUBLE_CURLY_BRACKET_REGEX
+              elsif left == "{|" && right == "|}"
+                CURLY_SQUARE_BRACKET_REGEX
+              else
+                Regexp.new("(#{Regexp.escape(left)}|#{Regexp.escape(right)})")
+              end
+      while (str = scanner.scan_until(regex))
         case scanner[1]
         when left
           buffer << str
           has_left = true
         when right
           if has_left
-            buffer = buffer[0...-(left.size)]
-            contents = block.call(str[0...-(left.size)])
+            buffer = buffer[0...-left.size]
+            contents = block.call(str[0...-left.size])
             buffer << contents
             break
           else
@@ -187,25 +91,23 @@ module Wp2txt
       end
       buffer << scanner.rest
 
-      if buffer == scanner.string
-        return buffer
-      else
-        scanner.string = buffer
-        return process_nested_structure(scanner, left, right, &block) || ""
-      end
-    rescue => e
-      return scanner.string
+      return buffer if buffer == scanner.string
+
+      scanner.string = buffer
+      process_nested_structure(scanner, left, right, &block) || ""
+    rescue StandardError
+      scanner.string
     end
   end
 
   #################### methods used from format_wiki ####################
-  def escape_nowiki!(str)
+  def escape_nowiki(str)
     if @nowikis
       @nowikis.clear
     else
       @nowikis = {}
     end
-    str.gsub!($escape_nowiki_regex) do
+    str.gsub(ESCAPE_NOWIKI_REGEX) do
       nowiki = $1
       nowiki_id = nowiki.object_id
       @nowikis[nowiki_id] = nowiki
@@ -213,16 +115,16 @@ module Wp2txt
     end
   end
 
-  def unescape_nowiki!(str)
-    str.gsub!($unescape_nowiki_regex) do
+  def unescape_nowiki(str)
+    str.gsub(UNESCAPE_NOWIKI_REGEX) do
       obj_id = $1.to_i
       @nowikis[obj_id]
     end
   end
 
-  def process_interwiki_links!(str)
+  def process_interwiki_links(str)
     scanner = StringScanner.new(str)
-    result = process_nested_structure(scanner, "[[", "]]") do |contents|
+    process_nested_structure(scanner, "[[", "]]") do |contents|
       parts = contents.split("|")
       case parts.size
       when 1
@@ -232,12 +134,11 @@ module Wp2txt
         parts.join("|")
       end
     end
-    str.replace(result)
   end
 
-  def process_external_links!(str)
+  def process_external_links(str)
     scanner = StringScanner.new(str)
-    result = process_nested_structure(scanner, "[", "]") do |contents|
+    process_nested_structure(scanner, "[", "]") do |contents|
       if /\A\s.+\s\z/ =~ contents
         " (#{contents.strip}) "
       else
@@ -250,119 +151,115 @@ module Wp2txt
         end
       end
     end
-    str.replace(result)
   end
 
   #################### methods used from format_article ####################
 
-  def remove_templates!(str)
-    scanner = StringScanner.new(str)
-    result = process_nested_structure(scanner, "{{", "}}") do |contents|
+  def remove_templates(str)
+    scanner1 = StringScanner.new(str)
+    result = process_nested_structure(scanner1, "{{", "}}") do
       ""
     end
-    scanner = StringScanner.new(result)
-    result = process_nested_structure(scanner, "{", "}") do |contents|
+    scanner2 = StringScanner.new(result)
+    process_nested_structure(scanner2, "{", "}") do
       ""
     end
-    str.replace(result)
   end
 
-  def remove_table!(str)
+  def remove_table(str)
     scanner = StringScanner.new(str)
-    result = process_nested_structure(scanner, "{|", "|}") do |contents|
+    process_nested_structure(scanner, "{|", "|}") do
       ""
     end
-    str.replace(result)
   end
 
-  def special_chr!(str)
-    str.replace $html_decoder.decode(str)
+  def special_chr(str)
+    HTML_DECODER.decode(str)
   end
 
-  def remove_inbetween!(str, tagset = ['<', '>'])
+  def remove_inbetween(str, tagset = ["<", ">"])
     tagsets = Regexp.quote(tagset.uniq.join(""))
     regex = /#{Regexp.escape(tagset[0])}[^#{tagsets}]*#{Regexp.escape(tagset[1])}/
-    str.gsub!(regex, "")
+    str.gsub(regex, "")
   end
 
-  def remove_tag!(str)
-    str.gsub!($remove_tag_regex, "")
+  def remove_tag(str)
+    str.gsub(REMOVE_TAG_REGEX, "")
   end
 
-  def remove_directive!(str)
-    str.gsub!($remove_directives_regex, "")
+  def remove_directive(str)
+    str.gsub(REMOVE_DIRECTIVES_REGEX, "")
   end
 
-  def remove_emphasis!(str)
-    str.gsub!($remove_emphasis_regex) do
+  def remove_emphasis(str)
+    str.gsub(REMOVE_EMPHASIS_REGEX) do
       $2
     end
   end
 
-  def chrref_to_utf!(num_str)
-    begin
-      num_str.gsub!($chrref_to_utf_regex) do
-        if $1 == 'x'
-          ch = $2.to_i(16)
-        else
-          ch = $2.to_i
-        end
-        hi = ch>>8
-        lo = ch&0xff
-        u = "\377\376" << lo.chr << hi.chr
-        u.encode("UTF-8", "UTF-16")
-      end
-    rescue StandardError
-      return nil
+  def chrref_to_utf(num_str)
+    num_str.gsub(CHRREF_TO_UTF_REGEX) do
+      ch = if $1 == "x"
+             $2.to_i(16)
+           else
+             $2.to_i
+           end
+      hi = ch >> 8
+      lo = ch & 0xff
+      u = +"\377\376" << lo.chr << hi.chr
+      u.encode("UTF-8", "UTF-16")
     end
-    return true
+  rescue StandardError
+    num_str
   end
 
-  def mndash!(str)
-    str.gsub!($mndash_regex, "–")
+  def mndash(str)
+    str.gsub(MNDASH_REGEX, "–")
   end
 
-  def remove_hr!(str)
-    str.gsub!($remove_hr_regex, "")
+  def remove_hr(str)
+    str.gsub(REMOVE_HR_REGEX, "")
   end
 
-  def remove_ref!(str)
-    str.gsub!($format_ref_regex){""}
+  def remove_ref(str)
+    str.gsub(FORMAT_REF_REGEX) { "" }
   end
 
-  def remove_html!(str)
-    str.gsub!(/<[^<>]+\/>/){""}
+  def remove_html(str)
+    res = +str.dup
+    res.gsub!(%r{<[^<>]+/>}) { "" }
     ["div", "gallery", "timeline", "noinclude"].each do |tag|
-      scanner = StringScanner.new(str)
-      result = process_nested_structure(scanner, "<#{tag}", "#{tag}>") do |contents|
+      scanner = StringScanner.new(res)
+      result = process_nested_structure(scanner, "<#{tag}", "#{tag}>") do
         ""
       end
-      str.replace(result)
+      res.replace(result)
     end
+    res
   end
 
-  def remove_complex!(str)
-    str.gsub!($complex_regex_01){"《#{$1}》"}
-    str.gsub!($complex_regex_02){""}
-    str.gsub!($complex_regex_03){""}
-    str.gsub!($complex_regex_04){""}
-    str.gsub!($complex_regex_05){""}
+  def remove_complex(str)
+    str = str.gsub(COMPLEX_REGEX_01) { "《#{$1}》" }
+    str = str.gsub(COMPLEX_REGEX_02) { "" }
+    str = str.gsub(COMPLEX_REGEX_03) { "" }
+    str = str.gsub(COMPLEX_REGEX_04) { "" }
+    str.gsub(COMPLEX_REGEX_05) { "" }
   end
 
-  def make_reference!(str)
-    str.gsub!($make_reference_regex_a){"\n"}
-    str.gsub!($make_reference_regex_b){""}
-    str.gsub!($make_reference_regex_c){"[ref]"}
-    str.gsub!($make_reference_regex_d){"[/ref]"}
+  def make_reference(str)
+    str = str.gsub(MAKE_REFERENCE_REGEX_A) { "\n" }
+    str = str.gsub(MAKE_REFERENCE_REGEX_B) { "" }
+    str = str.gsub(MAKE_REFERENCE_REGEX_C) { "[ref]" }
+    str.gsub(MAKE_REFERENCE_REGEX_D) { "[/ref]" }
   end
 
-  def correct_inline_template!(str)
+  def correct_inline_template(str)
     scanner = StringScanner.new(str)
-    result = process_nested_structure(scanner, "{{", "}}") do |contents|
+    process_nested_structure(scanner, "{{", "}}") do |contents|
       parts = contents.split("|")
       if /\A(?:lang|fontsize)\z/i =~ parts[0]
         parts.shift
-      elsif /\Alang\-/i =~ parts[0]
+      elsif /\Alang-/i =~ parts[0]
         parts.shift
       elsif /\Alang=/i =~ parts[1]
         parts.shift
@@ -373,27 +270,25 @@ module Wp2txt
       else
         begin
           keyval = parts[1].split("=")
-          if keyval.size > 1
-            out = keyval[1]
-          else
-            out = parts[1] || ""
-          end
-        rescue
+          out = if keyval.size > 1
+                  keyval[1]
+                else
+                  parts[1] || ""
+                end
+        rescue StandardError
           out = parts[1] || ""
         end
       end
-
       out.strip
     end
-    str.replace result
   end
 
-#################### file related utilities ####################
+  #################### file related utilities ####################
 
   # collect filenames recursively
   def collect_files(str, regex = nil)
     regex ||= //
-    text_array = Array.new
+    text_array = []
     Find.find(str) do |f|
       text_array << f if regex =~ f
     end
@@ -401,11 +296,11 @@ module Wp2txt
   end
 
   # modify a file using block/yield mechanism
-  def file_mod(file_path, backup = false, &block)
+  def file_mod(file_path, backup = false)
     File.open(file_path, "r") do |fr|
       str = fr.read
       newstr = yield(str)
-      str = newstr unless newstr == nil
+      str = newstr if nil? newstr
       File.open("temp", "w") do |tf|
         tf.write(str)
       end
@@ -417,32 +312,31 @@ module Wp2txt
   end
 
   # modify files under a directry (recursive)
-  def batch_file_mod(dir_path, &block)
+  def batch_file_mod(dir_path)
     if FileTest.directory?(dir_path)
       collect_files(dir_path).each do |file|
         yield file if FileTest.file?(file)
       end
-    else
-      yield dir_path if FileTest.file?(dir_path)
+    elsif FileTest.file?(dir_path)
+      yield dir_path
     end
   end
 
   # take care of difference of separators among environments
   def correct_separator(input)
-    if input.is_a?(String)
-      ret_str = String.new
+    case input
+    when String
       if RUBY_PLATFORM.index("win32")
-        ret_str = input.gsub("/", "\\")
+        input.gsub("/", "\\")
       else
-        ret_str = input.gsub("\\", "/")
+        input.gsub("\\", "/")
       end
-      return ret_str
-    elsif input.is_a?(Array)
-      ret_array = Array.new
+    when Array
+      ret_array = []
       input.each do |item|
         ret_array << correct_separator(item)
       end
-      return ret_array
+      ret_array
     end
   end
 
@@ -451,17 +345,14 @@ module Wp2txt
     maxwidth = 0
 
     files.each do |f|
-      width = f.slice(/\-(\d+)\z/, 1).to_s.length.to_i
+      width = f.slice(/-(\d+)\z/, 1).to_s.length.to_i
       maxwidth = width if maxwidth < width
-    end
-
-    files.each do |f|
-      newname= f.sub(/\-(\d+)\z/) do
-        "-" + sprintf("%0#{maxwidth}d", $1.to_i)
+      newname = f.sub(/-(\d+)\z/) do
+        "-" + format("%0#{maxwidth}d", $1.to_i)
       end
       File.rename(f, newname + ".#{ext}")
     end
-    return true
+    true
   end
 
   # convert int of seconds to string in the format 00:00:00
@@ -473,8 +364,6 @@ module Wp2txt
     h = int / 3600
     m = (int - h * 3600) / 60
     s = int % 60
-    str = sprintf("%02d:%02d:%02d", h, m, s)
-    return str
+    format("%02d:%02d:%02d", h, m, s)
   end
-
 end

data/lib/wp2txt/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Wp2txt
-  VERSION = "1.0.2"
+  VERSION = "1.1.1"
 end