Modul:Text

local Text = { serial = "2018-11-14",

              suite  = "Text" }

--[=[ Text utilities ]=]

-- local globals local PatternCJK = false local PatternCombined = false local PatternLatin = false local PatternTerminated = false local RangesLatin = false local SeekQuote = false

local function factoryQuote()

   -- Create quote definitions
   if not Text.quoteLang then
       local lucky, quoting = pcall( mw.loadData,
                                     "Module:Text/quoting" )
       if type( quoting ) == "table" then
           Text.quoteLang = quoting.langs
           Text.quoteType = quoting.types
       end
       if type( Text.quoteLang ) ~= "table" then
           Text.quoteLang = { }
       end
       if type( Text.quoteType ) ~= "table" then
           Text.quoteType = { }
       end
       if type( Text.quoteLang.en ) ~= "string" then
           Text.quoteLang.en = "ld"
       end
       if type( Text.quoteType[ Text.quoteLang.en ] ) ~= "table" then
           Text.quoteType[ Text.quoteLang.en ] = { { 8220, 8221 },
                                                   { 8216, 8217 } }
       end
   end

end -- factoryQuote()

local function fiatQuote( apply, alien, advance )

   -- Quote text
   -- Parameter:
   --     apply    -- string, with text
   --     alien    -- string, with language code
   --     advance  -- number, with level 1 or 2
   local r = apply
   local suite
   factoryQuote()
   suite = Text.quoteLang[ alien ]
   if not suite then
       local slang = alien:match( "^(%l+)-" )
       if slang then
           suite = Text.quoteLang[ slang ]
       end
       if not suite then
           suite = Text.quoteLang.en
       end
   end
   if suite then
       local quotes = Text.quoteType[ suite ]
       if quotes then
           local space
           if quotes[ 3 ] then
               space = " "
           else
               space = ""
           end
           quotes = quotes[ advance ]
           if quotes then
               r = mw.ustring.format( "%s%s%s%s%s",
                                      mw.ustring.char( quotes[ 1 ] ),
                                      space,
                                      apply,
                                      space,
                                      mw.ustring.char( quotes[ 2 ] ) )
           end
       else
           mw.log( "fiatQuote() " .. suite )
       end
   end
   return r

end -- fiatQuote()

Text.char = function ( apply, again, accept )

   -- Create string from codepoints
   -- Parameter:
   --     apply   -- table (sequence) with numerical codepoints, or nil
   --     again   -- number of repetitions, or nil
   --     accept  -- true, if no error messages to be appended
   -- Returns: string
   local r
   if type( apply ) == "table" then
       local bad   = { }
       local codes = { }
       local s
       for k, v in pairs( apply ) do
           s = type( v )
           if s == "number" then
               if v < 32  and  v ~= 9  and  v ~= 10 then
                   v = tostring( v )
               else
                   v = math.floor( v )
                   s = false
               end
           elseif s ~= "string" then
               v = tostring( v )
           end
           if s then
               table.insert( bad, v )
           else
               table.insert( codes, v )
           end
       end -- for k, v
       if #bad == 0 then
           if #codes > 0 then
               r = mw.ustring.char( unpack( codes ) )
               if again then
                   if type( again ) == "number" then
                       local n = math.floor( again )
                       if n > 1 then
                           r = r:rep( n )
                       elseif n < 1 then
                           r = ""
                       end
                   else
                       s = "bad repetitions: " .. tostring( again )
                   end
               end
           end
       else
           s = "bad codepoints: " .. table.concat( bad, " " )
       end
       if s  and  not accept then
           r = tostring(  mw.html.create( "span" )
                                 :addClass( "error" )
                                 :wikitext( s ) )
       end
   end
   return r or ""

end -- Text.char()

Text.concatParams = function ( args, apply, adapt )

   -- Concat list items into one string
   -- Parameter:
   --     args   -- table (sequence) with numKey=string
   --     apply  -- string (optional); separator (default: "|")
   --     adapt  -- string (optional); format including "%s"
   -- Returns: string
   local collect = { }
   for k, v in pairs( args ) do
       if type( k ) == "number" then
           v = mw.text.trim( v )
           if v ~= "" then
               if adapt then
                   v = mw.ustring.format( adapt, v )
               end
               table.insert( collect, v )
           end
       end
   end -- for k, v
   return table.concat( collect,  apply or "|" )

end -- Text.concatParams()

Text.containsCJK = function ( analyse )

   -- Is any CJK code within?
   -- Parameter:
   --     analyse  -- string
   -- Returns: true, if CJK detected
   local r
   if not patternCJK then
       patternCJK = mw.ustring.char( 91,
                                      13312, 45,  40959,
                                     131072, 45, 178207,
                                     93 )
   end
   if mw.ustring.find( analyse, patternCJK ) then
       r = true
   else
       r = false
   end
   return r

end -- Text.containsCJK()

Text.getPlain = function ( adjust )

   -- Remove wikisyntax from string, except templates
   -- Parameter:
   --     adjust  -- string
   -- Returns: string
   local i = adjust:find( "",  i + 3,  true )
       if j then
           r = r:sub( 1, i ) .. r:sub( j + 3 )
       else
           r = r:sub( 1, i )
       end
       i = r:find( "