Bearbeiten von „Modul:DateTime“

Zur Navigation springen Zur Suche springen
Warnung: Du bist nicht angemeldet. Deine IP-Adresse wird bei Bearbeitungen öffentlich sichtbar. Melde dich an oder erstelle ein Benutzerkonto, damit Bearbeitungen deinem Benutzernamen zugeordnet werden. Ein eigenes Benutzerkonto hat eine ganze Reihe von Vorteilen.

Die Bearbeitung kann rückgängig gemacht werden. Bitte prüfe den Vergleich unten, um sicherzustellen, dass du dies tun möchtest, und veröffentliche dann unten deine Änderungen, um die Bearbeitung rückgängig zu machen.

Aktuelle Version Dein Text
Zeile 1: Zeile 1:
local DateTime  = { serial = "2020-04-08",
--[=[ 2014-02-24
                    suite  = "DateTime",
Date and time utilities
                    item  = 20652535 }
]=]
-- Date and time objects
 
local Failsafe  = DateTime
 
local GlobalMod  = DateTime
 
local Calc      = { }
-- local globals
local Meta      = { }
local DateTime
local Parser    = { }
local Parser    = { }
local Private    = { }
local Private    = { }
local Prototypes = { }
local Prototypes = { }
local Templates  = { }
local World      = { slang      = "en",
local World      = { slang      = "en",
                     monthsLong  = { },
                     monthsLong  = { },
                     monthsParse = { },
                     monthsParse = { } }
                    months4    = { } }
local MaxYear    = 2099
local Nbsp      = mw.ustring.char( 160 )
local Nbsp      = mw.ustring.char( 160 )
local Tab        = mw.ustring.char( 9 )
local Tab        = mw.ustring.char( 9 )
local Frame
World.era = { en = { "BC", "AD" } }
World.era = { en = { "BC", "AD" } }
World.monthsAbbr = {  en = { n = 3 }  }
World.monthsAbbr = {  en = { n = 3 }  }
Zeile 47: Zeile 43:
                         [ "Sep" ] =  9
                         [ "Sep" ] =  9
                       }
                       }
World.months4.en = { [ 6 ] = true,
                    [ 7 ] = true }
World.templates = { [ "ISO" ] =
World.templates = { [ "ISO" ] =
                         { spec = "Y-m-d",
                         { spec = "Y-m-d",
Zeile 55: Zeile 49:
                         { spec = "c" },
                         { spec = "c" },
                     [ "timestamp" ] =
                     [ "timestamp" ] =
                         { spec = "YmdHis" },
                         { spec = "YmdHis" }
                    [ "default" ] =
                        { spec = "H:i, j M Y",
                          long = true },
                    [ "$dmy" ] =
                        { spec = "H:i, j M Y",
                          long = true },
                    [ "$ymd" ] =
                        { spec = "H:i, Y M j",
                          long = true  },
                    [ "$dmyt" ] =
                        { spec = "j M Y, H:i",
                          long = true  },
                    [ "$dmyts" ] =
                        { spec = "j M Y, H:i:s",
                          long = true  },
                    [ "data-sort-type:date" ] =
                        { spec = "j M Y" }
                   }
                   }
World.templates.en = { }
World.templates.en = { }
Zeile 107: Zeile 84:
     HST  = -1000    -- Hawaiian Standard Time
     HST  = -1000    -- Hawaiian Standard Time
}
}
local foreignModule = function ( access, advanced, append, alt, alert )
    -- Fetch global module
    -- Precondition:
    --    access    -- string, with name of base module
    --    advanced  -- true, for require(); else mw.loadData()
    --    append    -- string, with subpage part, if any; or false
    --    alt      -- number, of wikidata item of root; or false
    --    alert    -- true, for throwing error on data problem
    -- Postcondition:
    --    Returns whatever, probably table
    -- 2019-10-20
    local storage = access
    local fun, lucky, r
    if advanced then
        fun = require
    else
        fun = mw.loadData
    end
    if append then
        storage = string.format( "%s/%s", storage, append )
    end
    lucky, r = pcall( fun,  "Module:" .. storage )
    if not lucky then
        local suited
        GlobalMod.globalModules = GlobalMod.globalModules or { }
        suited = GlobalMod.globalModules[ access ]
        if not suited  and
          type( alt ) == "number"  and
          alt > 0 then
            suited = string.format( "Q%d", alt )
            suited = mw.wikibase.getSitelink( suited )
            GlobalMod.globalModules[ access ] = suited or true
        end
        if type( suited ) == "string" then
            storage = suited
            if append then
                storage = string.format( "%s/%s", storage, append )
            end
            lucky, r = pcall( fun, storage )
        end
        if not lucky and alert then
            error( "Missing or invalid page: " .. storage, 0 )
        end
    end
    return r
end -- foreignModule()




Zeile 167: Zeile 95:
     return  mw.ustring.upper( mw.ustring.sub( a, 1, 1 ) )
     return  mw.ustring.upper( mw.ustring.sub( a, 1, 1 ) )
             .. mw.ustring.lower( mw.ustring.sub( a, 2 ) )
             .. mw.ustring.lower( mw.ustring.sub( a, 2 ) )
end -- capitalize()
end -- fault()




Zeile 177: Zeile 105:
     -- Returns:
     -- Returns:
     --    string, HTML span
     --    string, HTML span
     local e = mw.html.create( "span" )
     return string.format( "<span class=\"error\">%s</span>", a )
                    :addClass( "error" )
                    :wikitext( a )
    return tostring( e )
end -- fault()
end -- fault()






local function frame()
DateTime = function ( assign, alien )
    if not Frame then
     -- Create metatable (constructor)
        Frame = mw.getCurrentFrame()
    end
    return Frame
end -- frame()
 
 
 
Meta.localized  = false
Meta.serial    = DateTime.serial
Meta.signature  = "__datetime"
Meta.suite      = "{DateTime}"
Meta.components = { lang  = "string",
                    bc    = "boolean",
                    year  = "number",
                    month = "number",
                    week  = "number",
                    dom  = "number",
                    hour  = "number",
                    min  = "number",
                    sec  = "number",
                    msec  = "number",
                    mysec = "number",
                    zone  = false,
                    leap  = "boolean",
                    jul  = "boolean" }
Meta.order      = { "bc", "year", "month", "week", "dom",
                    "hour", "min", "sec", "msec", "mysec" }
Meta.tableI    = {    -- instance metatable
    __index    = function ( self, access )
                    local r = self[ Meta.signature ][ access ]
                    if r == nil then
                        if access == "serial" then
                            r = Meta.serial
                        elseif access == "suite" then
                            r = "DateTime"
                        else
                            r = Prototypes[ access ]
                        end
                    end
                    return r
                end,
    __newindex = function ( self, access, assign )
                    if type( access ) == "string" then
                        local data = self[ Meta.signature ]
                        if assign == nil then
                            local val = data[ access ]
                            data[ access ] = nil
                            if not Prototypes.fair( data ) then
                                data[ access ] = val
                            end
                        elseif Prototypes.fair( data,
                                                access,
                                                assign ) then
                            data[ access ] = assign
                        end
                    end
                    return
                end,
    __add      = function ( op1, op2 )
                    return Prototypes.future( op1, op2, true )
                end,
    __eq      = function ( op1, op2 )
                    return Prototypes.flow( op1, op2, "eq" )
                end,
    __lt      = function ( op1, op2 )
                    return Prototypes.flow( op1, op2, "lt" )
                end,
    __le      = function ( op1, op2 )
                    return Prototypes.flow( op1, op2, "le" )
                end,
    __tostring = function ( e )
                    return Prototypes.tostring( e )
                end,
    __call    = function ( func, ... )
                    return Meta.fiat( ... )
                end
} -- Meta.tableI
Meta.tableL    = {    -- library metatable
    __index    = function ( self, access )
                    local r
                    if access == "serial" then
                        r = Meta.serial
                    elseif access == "suite" then
                        r = Meta.suite
                    end
                    return r
                end,
    __newindex = function ()
                    return
                end,
    __tostring = function ()
                    return Meta.suite
                end,
    __call    = function ( func, ... )
                    return Meta.fiat( ... )
                end
} -- Meta.tableL
Meta.fiat = function ( assign, alien, add )
     -- Create instance object (constructor)
     -- Parameter:
     -- Parameter:
     --    assign  -- string, with initial timestamp, or nil
     --    assign  -- string, with initial timestamp, or nil
     --                nil    -- now
     --                nil    -- now
     --                false  -- empty object
     --                false  -- empty object
    --                table  -- clone this object, or copy from raw
    --                          ignore remaining parameters
     --    alien  -- string, with language code, or nil
     --    alien  -- string, with language code, or nil
    --    add    -- string, with interval (PHP strtotime), or nil
     -- Returns:
     -- Returns:
     --    table, as DateTime object
     --    table, as DateTime object
Zeile 299: Zeile 122:
     local r
     local r
     Private.foreign()
     Private.foreign()
     if type( assign ) == "table" then
     r = Private.factory( assign, alien )
        if assign.suite == Meta.suite  and
          getmetatable( assign ) == Meta.tableI then
            r = assign[ Meta.signature ]
        else
            r = Private.from( assign )
        end
    else
        r = Private.factory( assign, alien, add )
    end
     if type( r ) == "table" then
     if type( r ) == "table" then
         r = { [ Meta.signature ] = r }
        local meta = { }
         setmetatable( r, Meta.tableI )
        local s    = "__datetime"
        meta.__index    = function( self, access )
                              return self[ s ][ access ]
                          end
        meta.__newindex = function( self, access, assign )
                              if type( access ) == "string" then
                                  local data = self[ s ]
                                  if assign == nil then
                                      local val = data[ access ]
                                      data[ access ] = nil
                                      if not Prototypes.fair( data ) then
                                          data[ access ] = val
                                      end
                                  elseif Prototypes.fair( data,
                                                          access,
                                                          assign ) then
                                      data[ access ] = assign
                                  end
                              end
                              return
                          end
         r               = { [ s ] = r }
        r.fair          = function ( ... )
                              return Prototypes.fair( ... )
                          end
        r.format        = function ( ... )
                              return Prototypes.format( ... )
                          end
         setmetatable( r, meta )
     end
     end
     return r
     return r
end -- Meta.fiat()
end -- DateTime()
setmetatable( DateTime, Meta.tableL )
DateTime.serial = nil
 
 
 
Calc.months = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
 
 
 
--  Calc.fast = function ( at )
--      -- Quick scan of full ISO stamp
--      -- Parameter:
--      --    apply  -- string, ISO
--      -- Returns:
--      --    table, with numeric components
--      local r = { }
--      r.year  = tonumber( at:sub(  1, 4 ) )
--      r.month = tonumber( at:sub(  6, 2 ) )
--      r.dom  = tonumber( at:sub(  9, 2 ) )
--      r.hour  = tonumber( at:sub( 12, 2 ) )
--      r.min  = tonumber( at:sub( 14, 2 ) )
--      r.sec  = tonumber( at:sub( 17, 2 ) )
--      if at:sub( 19, 1 ) == "." then
--          r.msec = tonumber( at:sub( 20, 3 ) )
--          if #at > 22 then
--              r.mysec = tonumber( at:sub( 23, 3 ) )
--          end
--      end
--      return r
--  end -- Calc.fast()
 
 
 
Calc.fair = function ( adjust )
    -- Normalize numeric components
    -- Parameter:
    --    adjust  -- table, with raw numbers
    local ranges = { year  = { min = -999,
                              max = 9999 },
                    month = { min =  1,
                              max = 12,
                              mod = 12 },
                    dom  = { min =  1,
                              max = 28 },
                    hour  = { mod = 24 },
                    min  = { mod = 60 },
                    sec  = { mod = 60 },
                    msec  = { mod = 1000 },
                    mysec = { mod = 1000 } }
    local m, max, min, move, n, range, s
    for i = 10, 2, -1 do
        s = Meta.order[ i ]
        n = adjust[ s ]
        if n or move then
            range = ranges[ s ]
            if range then
                min = range.min or 0
                max = range.max  or  ( range.mod - 1 )
                if move then
                    n    = ( n or 0 )  +  move
                    move = false
                end
                if n < min  or  n > max then
                    if range.mod then
                        m    = n % range.mod
                        move = ( n - m )  /  range.mod
                        n    = min + m
                    else    -- dom
                        if adjust.month and adjust.year  and
                          adjust.month >= 1  and
                          adjust.month <= 12 and
                          adjust.year > 1900 then
                            if n > 0 then
                                max = Calc.final( adjust )
                                while n > max do
                                    n = n - max
                                    if adjust.month < 12 then
                                        adjust.month = adjust.month + 1
                                    else
                                        adjust.month = 1
                                        adjust.year  = adjust.year + 1
                                    end
                                    max = Calc.final( adjust )
                                end    -- while n <= max
                            else
                                while n < 1 do
                                    if adjust.month == 1 then
                                        adjust.month = 12
                                        adjust.year  = adjust.year - 1
                                    else
                                        adjust.month = adjust.month - 1
                                    end
                                    max = Calc.final( adjust )
                                    n  = n + max
                                end    -- while n < 1
                            end
                        end
                    end
                end
                adjust[ s ] = n
            end
        end
    end -- for i
end -- Calc.fair()
 
 
 
Calc.final = function ( adjust )
    -- Retrieve number of days in particular month
    -- Parameter:
    --    adjust  -- table, with date specification
    -- Returns:
    --    number, of days in month
    local r = Calc.months[ adjust.month ]
    if adjust.month == 2  and
      ( adjust.year % 4 ~= 0  or
        adjust.year % 400 == 0 ) then
        r = 28
    end
    return r
end -- Calc.final()
 
 
 
Calc.future = function ( add )
    -- Parse move interval
    -- Parameter:
    --    add  -- string, with GNU relative items
    -- Returns:
    --    table, with numeric components, or false
    local r, token
    local units = { year      = true,
                    month    = true,
                    fortnight = { slot = "dom", mult = 14 },
                    week      = { slot = "dom", mult = 7 },
                    dom      = true,
                    hour      = true,
                    min      = true,
                    sec      = true }
    local story = string.format( " %s ", add:lower() )
                        :gsub( "%s+", " " )
                        :gsub( " yesterday ", " -1 dom " )
                        :gsub( " tomorrow ",  " 1 dom " )
                        :gsub( "(%l)s ", "%1 " )
                        :gsub( " day ",    " dom " )
                        :gsub( " minute ", " min " )
                        :gsub( " second ", " sec " )
    local feed  = function ()
                      local slice
                      token, slice = story:match( "^( (%S+)) " )
                      return slice
                  end
    local fed  = function ()
                      story = story:sub( #token + 1 )
                  end
    local m, n, s, u
    while true do
        s = feed()
        if s then
            n = 1
            if s:match( "^[+-]?%d+$" ) then
                n = tonumber( s )
                fed()
                s = feed()
            end
            if s then
                u = units[ s ]
            end
            if s and u then
                fed()
                if u ~= true then
                    s = u.slot
                    n = n * u.mult
                end
                if feed() == "ago" then
                    if n > 0 then
                        n = - n
                    end
                    fed()
                end
                r      = r  or  { }
                r[ s ] = ( r[ s ] or 0 )  +  n
            else
                r = false
                break    -- while true
            end
        else
            break    -- while true
        end
    end    -- while true
    return r
end -- Calc.future()




Zeile 526: Zeile 176:
         if amount <= 4 then
         if amount <= 4 then
             r.year = tonumber( analyse )
             r.year = tonumber( analyse )
         elseif amount == 14 then
         elseif n == 14 then
             -- timestamp
             -- timestamp
             r.year  = tonumber( analyse:sub(  1, 4 ) )
             r.year  = tonumber( analyse:sub(  1, 4 ) )
             r.month  = tonumber( analyse:sub(  5, 6 ) )
             r.month  = tonumber( analyse:sub(  5, 2 ) )
             r.dom    = tonumber( analyse:sub(  7, 8 ) )
             r.dom    = tonumber( analyse:sub(  7, 2 ) )
             r.hour  = tonumber( analyse:sub(  9, 10 ) )
             r.hour  = tonumber( analyse:sub(  9, 2 ) )
             r.min    = tonumber( analyse:sub( 11, 12 ) )
             r.min    = tonumber( analyse:sub( 11, 2 ) )
             r.sec    = tonumber( analyse:sub( 13, 14 ) )
             r.sec    = tonumber( analyse:sub( 13, 2 ) )
         else
         else
             r = false
             r = false
         end
         end
     elseif amount == 4 then
     elseif amount == 4 then
         local s, sep, sx = analyse:match( "^(%d+)([%-%.:Ww]?)(.*)$" )
         local s, sep, sx = analyse:match( "^(%d+)([%-%.:w]?)(.*)$" )
         r.year = tonumber( s )
         r.year = tonumber( s )
         if sep == "-" then
         if sep == "-" then
Zeile 568: Zeile 218:
             end
             end
         elseif sep:lower() == "w" then
         elseif sep:lower() == "w" then
             if sx then
             if s then
                 s = sx:match( "^(%d%d?)$" )
                 s = s:match( "^(%d%d?)$" )
                 if s then
                 if s then
                     r.week = tonumber( s )
                     r.week = tonumber( s )
                    if r.week < 1  or  r.week > 53 then
                        r = false
                    end
                 else
                 else
                     r = false
                     r = false
Zeile 583: Zeile 230:
         else
         else
             r = false
             r = false
        end
        if r then
            r.iso = true
         end
         end
     elseif amount == 8 then
     elseif amount == 8 then
Zeile 606: Zeile 250:
                         n      = n .. "00"
                         n      = n .. "00"
                         r.msec = tonumber( n:sub( 1, 3 ) )
                         r.msec = tonumber( n:sub( 1, 3 ) )
                        if #n >= 6 then
                         sz     = s
                            r.mysec = tonumber( n:sub( 4, 6 ) )
                        end
                         sz = s
                     end
                     end
                 end
                 end
Zeile 706: Zeile 347:
         -- 23 Dec 2013
         -- 23 Dec 2013
         s, sx = mw.ustring.match( analyse,
         s, sx = mw.ustring.match( analyse,
                                   "^([%a&;]+%.?) ?(.*)$" )
                                   "^([%a&;]+%.?) (.*)$" )
         if s then
         if s then
             local n = Parser.monthNumber( s )
             local n = Parser.monthNumber( s )
Zeile 725: Zeile 366:
     return r
     return r
end -- Parser.european()
end -- Parser.european()
Parser.isoDate = function ( analyse, assign )
    -- String analysis, retrieve month heading ISO date
    -- Parameter:
    --    analyse  -- string, with heading hyphen
    --    assign  -- table
    -- Returns:
    --    1  -- table, extended if parsed
    --    2  -- stripped string, or false, if invalid text format
    local rO, rS
    if analyse:match( "^%-%-?[0-9]" ) then
        local n, s
        rO = assign
        rS = analyse:sub( 2 )
        s  = rS:match( "^([012][0-9])%-" )
        if s then
            n = tonumber( s )
            if n >= 1  and  n <= 12 then
                rO.month = n
                rS      = rS:sub( 3 )
            else
                rO = false
            end
        end
        if rO then
            if rS:byte( 1, 1 ) == 45 then
                local suffix
                s = rS:match( "^%-([012][0-9])" )
                if s then
                    n  = tonumber( s )
                    if n >= 1  and  n <= 31 then
                        rO.dom = n
                        rS    = rS:sub( 4 )
                    else
                        rO = false
                    end
                else
                    rS:sub( 2 )
                end
            else
                rO = false
            end
            if rO then
                if #rS > 0 then
                    if rO.dom then
                        n = rS:byte( 1, 1 )
                        if n == 32  or  n == 84 then
                            rS = rS:sub( 2 )
                        else
                            rO = false
                        end
                    else
                        rO = false
                    end
                end
            end
        end
    else
        rO = false
    end
    if rO then
        rO.iso = true
    else
        rS = false
    end
    return rO, rS
end -- Parser.isoDate()




Zeile 828: Zeile 400:
                         n = #s2
                         n = #s2
                         if n <= 2  and  #s3 == 4 then
                         if n <= 2  and  #s3 == 4 then
                             rO.dom  = tonumber( s2 )
                             rO.dom  = tonumber( n )
                             rO.year = tonumber( s3 )
                             rO.year = tonumber( s3 )
                             rO.dom2 = ( n == 2 )
                             rO.dom2 = ( n == 2 )
Zeile 939: Zeile 511:
                     if #s == 2 then
                     if #s == 2 then
                         r.min = tonumber( s )
                         r.min = tonumber( s )
                         if sx == "" then
                         if sx == "" then              
                             sx = false
                             sx = false
                         end
                         end
Zeile 968: Zeile 540:
                 s = sx:match( "^%.(%d+)$" )
                 s = sx:match( "^%.(%d+)$" )
                 if s then
                 if s then
                    s  = s .. "00"
                     r.msec = tonumber( s )
                     r.msec = tonumber( s:sub( 1, 3 ) )
                    if #s >= 6 then
                        r.mysec = tonumber( s:sub( 4, 6 ) )
                    end
                 else
                 else
                     r = false
                     r = false
Zeile 1.055: Zeile 623:
             if s then
             if s then
                 sx = analyse:sub( 5 )
                 sx = analyse:sub( 5 )
            else
                local suffix
                s, sx, suffix = analyse:match( "^(%d+)([ ,]?)(.*)$" )
                if s then
                    local j = #sx
                    n = #s
                    if n < 4  and  ( j == 1 or #suffix == 0 ) then
                        sx = analyse:sub( n + j )
                    else
                        s = false
                    end
                end
             end
             end
         end
         end
Zeile 1.139: Zeile 695:
             if rO.zone then
             if rO.zone then
                 rS = s
                 rS = s
            else
                rO = false
             end
             end
         end
         end
Zeile 1.177: Zeile 735:
             end
             end
         else
         else
             local rM, sM = Parser.monthHeading( s, r )
             r, s = Parser.monthHeading( s, r )
             if rM then
             if r and s ~= "" then
                r = rM
                 r = Parser.time( s, r )
            else
                r, sM = Parser.isoDate( s, r )
            end
            if r and sM ~= "" then
                 r = Parser.time( sM, r )
             end
             end
         end
         end
Zeile 1.193: Zeile 746:




Private.factory = function ( assign, alien, add )
Private.factory = function ( assign, alien )
     -- Create DateTime table (constructor)
     -- Create DateTime table (constructor)
     -- Parameter:
     -- Parameter:
Zeile 1.200: Zeile 753:
     --                false  -- empty object
     --                false  -- empty object
     --    alien  -- string, with language code, or nil
     --    alien  -- string, with language code, or nil
    --    add    -- string, with interval (PHP strtotime), or nil
     -- Returns:
     -- Returns:
     --    table, for DateTime object
     --    table, for DateTime object
     --    string or false, if failed
     --    string or false, if failed
     local l    = true
     local l    = true
    local r    = false
     local slang = mw.text.trim( alien or World.slang or "en" )
     local slang = mw.text.trim( alien or World.slang or "en" )
    local r
     if assign == false then
     if assign == false then
         r = { }
         r = { }
     else
     else
         local stamp = ( assign or "now" )
         local stamp = ( assign or "now" )
        local shift
        if add then
            shift = Private.future( add )
        end
        r = false
         if stamp == "now" then
         if stamp == "now" then
             stamp = frame():callParserFunction( "#timel", "c", shift )
             stamp = mw.getCurrentFrame():callParserFunction( "#timel",
            shift = false
                                                            "c" )
        else
            local seconds = stamp:match( "^#(%d+)$" )
            if seconds then
                stamp = os.date( "!%Y-%m-%dT%H:%M:%S",
                                tonumber( seconds ) )
            end
         end
         end
         l, r = pcall( Private.fetch, stamp, slang, shift )
         l, r = pcall( Private.fetch, stamp, slang )
     end
     end
     if l  and  type( r ) == "table" then
     if l  and  type( r ) == "table" then
Zeile 1.238: Zeile 779:




Private.fetch = function ( analyse, alien, add )
Private.fetch = function ( analyse, alien )
     -- Retrieve object from string
     -- Retrieve object from string
     -- Parameter:
     -- Parameter:
     --    analyse  -- string to be interpreted
     --    analyse  -- string to be interpreted
     --    alien    -- string with language code, or nil
     --    alien    -- string with language code, or nil
    --    add      -- table, with interval, or nil
     -- Returns:
     -- Returns:
     --    table, if parsed
     --    table, if parsed
Zeile 1.250: Zeile 790:
     local r
     local r
     if type( analyse ) == "string" then
     if type( analyse ) == "string" then
        local strip = mw.ustring.char( 0x5B, 0x200E, 0x200F, 0x5D )
         r =  analyse:gsub( "&nbsp;", " " )
         r =  analyse:gsub( "&nbsp;", " " )
                     :gsub( "&#160;", " " )
                     :gsub( "&#160;", " " )
                    :gsub( "&#x[aA]0;", " " )
                     :gsub( "&#32;", " " )
                     :gsub( "&#32;", " " )
                     :gsub( Nbsp, " " )
                     :gsub( Nbsp, " " )
                     :gsub( Tab, " " )
                     :gsub( Tab, " " )
                     :gsub( "  +", " " )
                     :gsub( "  +", " " )
                    :gsub( "%[%[", "" )
                    :gsub( "%]%]", "" )
                    :gsub( strip, "" )
         r = mw.text.trim( r )
         r = mw.text.trim( r )
         if r == "" then
         if r == "" then
             r = { }
             r = { }
         else
         else
             local slang = ( alien or "" )
             local slang = ( alien or "" )
            local parser = { en  = "GermanEnglish",
                            de  = "GermanEnglish",
                            frr = "GermanEnglish",
                            nds = "GermanEnglish" }
            local suitable
             if slang == "" then
             if slang == "" then
                 slang = "en"
                 slang = "en"
Zeile 1.279: Zeile 809:
                 end
                 end
             end
             end
             slang   = slang:lower()
             slang = slang:lower()
             suitable = parser[ slang ]
             if slang == "en" or slang == "de" then
            if suitable then
                 local l
                 local l
                 l, r = pcall( Parser[ suitable ], r )
                 l, r = pcall( Parser.GermanEnglish, r )
                 if l and r then
                 if l and r then
                     if not Prototypes.fair( r ) then
                     if not Prototypes.fair( r ) then
                         r = false
                         r = false
                    elseif add then
                        r = Prototypes.future( r, add )
                     end
                     end
                else
                    r = "invalid format"
                 end
                 end
             else
             else
                 r = "unknown language: " .. slang
                 r = "unknown language"
             end
             end
         end
         end
Zeile 1.305: Zeile 830:




Private.flow = function ( at1, at2 )
Private.foreign =  function ()
    -- Compare two objects
    -- Parameter:
    --    at1  -- DateTime
    --    at2  -- DateTime
    -- Returns:
    --    -1, 0, 1 or nil if not comparable
    local r = 0
    if at1.bc or at2.bc and  at1.bc ~= at2.bc then
        if at1.bc then
            r = -1
        else
            r = 1
        end
    else
        local life  = false
        local s, v1, v2
        for i = 2, 10 do
            s  = Meta.order[ i ]
            v1 = at1[ s ]
            v2 = at2[ s ]
            if v1 or v2 then
                if v1 and v2 then
                    if v1 < v2 then
                        r = -1
                    elseif v1 > v2 then
                        r = 1
                    end
                elseif life then
                    if v2 then
                        r = -1
                    else
                        r = 1
                    end
                else
                    r = nil
                end
                if r ~= 0 then
                    if at1.bc and r then
                        r = r * -1
                    end
                    break    -- for i
                end
                life = true
            end
        end -- for i
    end
    return r
end -- Private.flow()
 
 
 
Private.foreign = function ()
     -- Retrieve localization submodule
     -- Retrieve localization submodule
     if not Meta.localized then
     if not World.localization then
         local d = foreignModule( DateTime.suite,
         local l, d = pcall( mw.loadData, "Module:DateTime/local" )
                                false,
         if l then
                                "local",
                                DateTime.item )
         if type( d ) == "table" then
             local wk
             local wk
             if d.slang then
             if d.slang then
                Meta.suite  = string.format( "%s %s",
                                            Meta.suite, d.slang )
                 World.slang = d.slang
                 World.slang = d.slang
             end
             end
Zeile 1.382: Zeile 850:
             end -- for k, v
             end -- for k, v
         end
         end
         Meta.localized = true
         World.localization = true
     end
     end
end -- Private.foreign()
end -- Private.foreign()
Private.from = function ( attempt )
    -- Create valid raw table from arbitrary table
    -- Parameter:
    --    attempt  -- table, to be evaluated
    -- Returns:
    --    table, with valid components, or nil
    local data  = { }
    local r
    for k, v in pairs( Meta.components ) do
        if v then
            v = ( type( attempt[ k ] )  ==  v )
        else
            v = true
        end
        if v then
            data[ k ] = attempt[ k ]
        end
    end -- for k, v
    if Prototypes.fair( data ) then
        r = data
    end
    return r
end -- Private.from()
Private.future = function ( add )
    -- Normalize move interval
    -- Parameter:
    --    add  -- string or number, to be added
    -- Returns:
    --    table, with shift, or false/nil
    local r
    if add then
        local s = type( add )
        if s == "string"  and  add:match( "^%s*[+-]?%d+%.?%d*%s*$" ) then
            r = tonumber( add )
            s = "number"
        end
        if s == "number" then
            if r == 0 then
                r = false
            else
                r = string.format( "%d second",  r or add )
            end
        elseif s == "string" then
            r = add
        else
            r = false
        end
        if r then
            r = Calc.future( r )
        end
    end
    return r
end -- Private.future()
Prototypes.clone = function ( self )
    -- Clone object
    -- Parameter:
    --    self  -- table, with object, to be cloned
    -- Returns:
    --    table, with object
    local r = { [ Meta.signature ] = self[ Meta.signature ] }
    setmetatable( r, Meta.tableI )
    return r
end -- Prototypes.clone()
Prototypes.failsafe = function ( self, atleast )
    -- Retrieve versioning and check for compliance
    -- Precondition:
    --    atleast  -- string, with required version or "wikidata" or "~"
    --                or false
    -- Postcondition:
    --    Returns  string  -- with queried version, also if problem
    --              false  -- if appropriate
    local last  = ( atleast == "~" )
    local since = atleast
    local r
    if last  or  since == "wikidata" then
        local item = Meta.item
        since = false
        if type( item ) == "number"  and  item > 0 then
            local entity = mw.wikibase.getEntity( string.format( "Q%d",
                                                                item ) )
            if type( entity ) == "table" then
                local seek = Failsafe.serialProperty or "P348"
                local vsn  = entity:formatPropertyValues( seek )
                if type( vsn ) == "table"  and
                  type( vsn.value ) == "string"  and
                  vsn.value ~= "" then
                    if last  and
                      vsn.value == ( Meta.serial or DateTime.serial ) then
                        r = false
                    else
                        r = vsn.value
                    end
                end
            end
        end
    end
    if type( r ) == "nil" then
        if not since  or  since <= Meta.serial then
            r = Meta.serial
        else
            r = false
        end
    end
    return r
end -- Prototypes.failsafe()




Zeile 1.508: Zeile 859:
     -- Check formal validity of table
     -- Check formal validity of table
     -- Parameter:
     -- Parameter:
     --    self    -- table, to be checked
     --    self    -- table to be checked
     --    access  -- string or nil, single item to be checked
     --    access  -- string or nil, single item to be checked
     --    assign  -- single access value to be checked
     --    assign  -- single access value to be checked
Zeile 1.515: Zeile 866:
     local r = ( type( self ) == "table" )
     local r = ( type( self ) == "table" )
     if r then
     if r then
         local defs = { year  = { max = MaxYear },
         local defs = { year  = { max = 2099 },
                       month = { min =  1,
                       month = { max = 12 },
                                max = 12 },
                       dom  = { max = 31 },
                      week  = { min =  1,
                                max = 53 },
                       dom  = { min =  1,
                                max = 31 },
                       hour  = { max = 23 },
                       hour  = { max = 23 },
                       min  = { max = 59 },
                       min  = { max = 59 },
                       sec  = { max = 61 },
                       sec  = { max = 61 },
                       msec  = { max = 999 },
                       msec  = { max = 1000 }
                      mysec = { max = 999 }
         }
         }
        local months = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
         local fNum =
         local fNum =
             function ( k, v )
             function ( k, v )
Zeile 1.533: Zeile 880:
                 local dk  = defs[ k ]
                 local dk  = defs[ k ]
                 if dk then
                 if dk then
                     if type( dk.max ) == "number" then
                    local mx = dk.max
                     if type( mx ) == "number" then
                         ret = ( type( v ) == "number" )
                         ret = ( type( v ) == "number" )
                         if ret then
                         if ret then
                            local min
                             ret = ( v >= 0 and  v <= mx
                            if dk.min then
                                min = dk.min
                            else
                                min = 0
                            end
                             ret = ( v >= min and  v <= dk.max
                                     and  math.floor( v ) == v )
                                     and  math.floor( v ) == v )
                             if ret and dk.f then
                             if ret and dk.f then
Zeile 1.571: Zeile 913:
                         end
                         end
                         if m then
                         if m then
                             ret = ( d <= Calc.months[ m ] )
                             ret = ( d <= months[ m ] )
                             if ret then
                             if ret then
                                 local y
                                 local y
Zeile 1.580: Zeile 922:
                                 end
                                 end
                                 if d == 29  and  m == 2  and  y then
                                 if d == 29  and  m == 2  and  y then
                                     if y % 4 ~= 0   or
                                     if y % 4 ~= 0 or  y % 400 == 0 then
                                      ( y % 100 == 0 and
                                        y % 400 ~= 0 ) then
                                         ret = false
                                         ret = false
                                     end
                                     end
Zeile 1.624: Zeile 964:
                         end
                         end
                     end
                     end
                elseif access == "lang" then
                    r = ( type( assign ) == "string" )
                    if r then
                        r = assign:match( "^%l%l%l?-?%a*$" )
                    end
                elseif access == "london" then
                    r = ( type( assign ) == "boolean" )
                 end
                 end
             end
             end
         else
         else
             local life = false
            local order = { "bc", "year", "month", "dom",
             local leak = false
                            "hour", "min", "sec", "msec" }
             local life = false
             local leak = false
             local s, v
             local s, v
             for i = 1, 10 do
             for i = 1, 8 do
                 s = Meta.order[ i ]
                 s = order[ i ]
                 v = self[ s ]
                 v = self[ s ]
                 if v then
                 if v then
Zeile 1.648: Zeile 983:
                         if not fNum( s, v ) then
                         if not fNum( s, v ) then
                             r = false
                             r = false
                             break   -- for i
                             break
                         end
                         end
                         life = true
                         life = true
                         leak = true
                         leak = true
                     end
                     end
                 elseif i == 3 then
                 else
                    if not self.week then
                        life = false
                    end
                elseif i ~= 4 then
                     life = false
                     life = false
                 end
                 end
             end -- for i
             end -- for i
            if self.week  and  ( self.month or self.dom ) then
                r = false
            end
         end
         end
     end
     end
Zeile 1.671: Zeile 999:




Prototypes.figure = function ( self, assign )
Prototypes.format = function ( self, ask, alien )
    -- Assign month by name
    -- Parameter:
    --    self    -- table, to be filled
    --    assign  -- string, with month name
    -- Returns:
    --    number 1...12, if valid;  false, if not
    local r = false
    if type( self ) == "table"  and  type( assign ) == "string" then
        r = Parser.monthNumber( assign )
        if r then
            self.month = r
        end
    end
    return r
end -- Prototypes.figure()
 
 
 
Prototypes.first = function ( self )
    -- Retrieve abbreviated month name in current language
    -- Parameter:
    --    self  -- table, to be evaluated
    -- Returns:
    --    string, if defined;  false, if not
    local r
    if type( self ) == "table"  and  self.month then
        local slang = ( self.lang or World.slang )
        r = World.monthsLong[ slang ]
        if r then
            local brief = World.monthsAbbr[ slang ]
            r = r[ self.month ]
            if brief then
                local ex = brief[ self.month ]
                local s  = brief.suffix
                if ex then
                    r = ex[ 2 ]
                else
                    local n = brief.n or 3
                    r = mw.ustring.sub( r, 1, n )
                end
                if s then
                    r = r .. s
                end
            end
        end
    else
        r = false
    end
    return r
end -- Prototypes.first()
 
 
 
Prototypes.fix = function ( self )
    -- Adapt this object to local time if no explicit zone given
    -- Parameter:
    --    self  -- table, with numbers etc.
    if type( self ) == "table"  and
      not self.zone then
        local seconds = Prototypes.format( self, "Z" )
        Prototypes.future( self,  - tonumber( seconds ) )
    end
end -- Prototypes.fix()
 
 
 
Prototypes.flow = function ( self, another, assert )
    -- Compare this object with another timestamp
    -- Parameter:
    --    self    -- table, with numbers etc.
    --    another  -- DateTime or string or nil (now)
    --    assert  -- nil, or string with operator
    --                      "lt", "le", "eq", "ne", "ge", "gt",
    --                      "<", "<=", "==", "~=", "<>", ">=", "=>", ">"
    -- Returns:
    --    if assert: true or false
    --    else: -1, 0, 1
    --    nil if invalid
    local base, other, r
    if type( self ) == "table" then
        base  = self
        other = another
    elseif type( another ) == "table" then
        base  = another
        other = self
    end
    if base then
        if type( other ) ~= "table" then
            other = Meta.fiat( other )
        end
        if type( other ) == "table" then
            r = Private.flow( base, other )
            if r  and  type( assert ) == "string" then
                local trsl = { lt    = "<",
                              ["<"]  = "<",
                              le    = "<=",
                              ["<="] = "<=",
                              eq    = "=",
                              ["=="] = "=",
                              ne    = "<>",
                              ["<>"] = "<>",
                              ["~="] = "<>",
                              ge    = ">=",
                              [">="] = ">=",
                              ["=>"] = ">=",
                              gt    = ">",
                              [">"]  = ">" }
                local same = trsl[ assert:lower() ]
                if same then
                    local s = "="
                    if r < 0 then
                        s = "<"
                    elseif r > 0 then
                        s = ">"
                    end
                    r = ( same:find( s, 1, true )  ~=  nil )
                else
                    r = nil
                end
            end
        end
    end
    return r
end -- Prototypes.flow()
 
 
 
Prototypes.format = function ( self, ask, adapt )
     -- Format object as string
     -- Format object as string
     -- Parameter:
     -- Parameter:
     --    self  -- table, with numbers etc.
     --    self  -- table, with numbers etc.
     --    ask    -- string, format spec, or nil
     --    ask    -- string, format spec, or nil
     --    adapt -- table, with options, or nil
     --    alien -- string, with language code, or nil
    --              .lang    -- string, with particular language code
    --              .london  -- true: UTC output; default: local
    --              .lonely  -- true: permit lonely hour
     -- Returns:
     -- Returns:
     --    string, or false, if invalid
     --    string, or false, if invalid
     local r = false
     local r = false
     if type( self ) == "table" then
     if type( self ) == "table" then
         local slang = self.lang or "en"
         local slang = ( alien or self.lang )
        local opts  = { lang = slang }
         local babel = mw.language.new( slang )
         local babel
        if type( adapt ) == "table" then
            if type( adapt.lang ) == "string" then
                local i = adapt.lang:find( "-", 3, true )
                if i then
                    slang = adapt.lang:lower()
                    opts.lang = slang:sub( 1,  i - 1 )
                else
                    opts.lang = adapt.lang:lower()
                end
            end
            opts.london = adapt.london
            opts.lonely = adapt.lonely
        end
        babel = mw.language.new( opts.lang:lower() )
         if babel then
         if babel then
             local shift, show, stamp, suffix, limit4, locally
             local show
            local stamp
            local suffix
            local locally
             if self.month then
             if self.month then
                 stamp = World.monthsLong.en[ self.month ]
                 stamp = World.monthsLong.en[ self.month ]
Zeile 1.838: Zeile 1.023:
                 if self.dom then
                 if self.dom then
                     stamp = string.format( "%d %s", self.dom, stamp )
                     stamp = string.format( "%d %s", self.dom, stamp )
                end
                if ask and ask:find( "Mon4", 1, true ) then
                    local mon4 = World.months4[ opts.lang:lower() ]
                    if mon4  and  mon4[ self.month ] then
                        limit4 = true
                    end
                 end
                 end
             elseif self.year then
             elseif self.year then
Zeile 1.849: Zeile 1.028:
             end
             end
             if self.hour then
             if self.hour then
                if stamp then
                 stamp = string.format( "%s %02d:", stamp, self.hour )
                    stamp = stamp .. " "
                else
                    stamp = ""
                end
                 stamp = string.format( "%s%02d:", stamp, self.hour )
                 if self.min then
                 if self.min then
                     stamp = string.format( "%s%02d", stamp, self.min )
                     stamp = string.format( "%s%02d", stamp, self.min )
Zeile 1.861: Zeile 1.035:
                                               stamp, self.sec )
                                               stamp, self.sec )
                         if self.msec then
                         if self.msec then
                             stamp = string.format( "%s.%03d",
                             stamp = string.format( "%s.%d",
                                                   stamp, self.msec )
                                                   stamp, self.msec )
                            if self.mysec then
                                stamp = string.format( "%s%03d",
                                                      stamp,
                                                      self.mysec )
                            end
                         end
                         end
                     end
                     end
Zeile 1.877: Zeile 1.046:
                 end
                 end
             end
             end
             show, suffix = World.templates.formatter( self, ask, opts )
             show, suffix = World.templates.formatter( self, ask, alien )
             if limit4 then
             if self.locally or alien then
                show = show:gsub( "M", "F" )
                 locally = true
            end
            if type( opts.london ) == "boolean" then
                 locally = not opts.london
             else
             else
                 locally = true
                 locally = false
             end
             end
             r = babel:formatDate( show, stamp, locally )
             r = babel:formatDate( show, stamp, locally )
            r = r:gsub( "&#160;$", "" )
             if self.year and self.year < 1000 then
             if self.year and self.year < 1000 then
                 r = r:gsub( string.format( "%04d", self.year ),
                 r = r:gsub( string.format( "%04d", self.year ),
                             tostring( self.year ) )
                             tostring( self.year ) )
            end
            if self.month then
                local bucket, m, suite, x
                if show:find( "F", 1, true ) then
                    suite = "monthsLong"
                elseif show:find( "M", 1, true ) then
                    suite = "monthsAbbr"
                end
                bucket = World[ suite ]
                if bucket then
                    m = bucket[ opts.lang:lower() ]
                    if slang then
                        x = bucket[ slang:lower() ]
                    end
                    if m then
                        local base = m[ self.month ]
                        local ex
                        if x then
                            ex = x[ self.month ]
                        end
                        if suite == "monthsAbbr" then
                            local stop
                            if ex then
                                stop = x.suffix
                                base = ex
                            else
                                stop = m.suffix
                            end
                            if base and stop then
                                local shift, std
                                std  = string.format( "%s%%%s",
                                                      base[ 1 ], stop )
                                shift = string.format( "%s%s",
                                                      base[ 2 ], stop )
                                r = mw.ustring.gsub( r, std, shift )
                            end
                        elseif suite == "monthsLong" then
                            if base and ex then
                                r = mw.ustring.gsub( r, base, ex )
                            end
                        end
                    end
                end
             end
             end
             if suffix then
             if suffix then
Zeile 1.945: Zeile 1.067:




Prototypes.full = function ( self )
World.templates.formatter = function ( assigned, ask, alien )
    -- Retrieve month name in current language
    -- Parameter:
    --    self  -- table, to be evaluated
    -- Returns:
    --    string, if defined;  false, if not
    local r
    if type( self ) == "table"  and  self.month then
        local slang = ( self.lang or World.slang )
        r = World.monthsLong[ slang ]
        if r then
            r = r[ self.month ]
        end
    else
        r = false
    end
    return r
end -- Prototypes.full()
 
 
 
Prototypes.future = function ( self, add, allocate )
    -- Relative move by interval
    -- Parameter:
    --    self      -- table, to be used as base
    --    add      -- string or number, to be added
    --    allocate  -- true, if a clone shall be returned
    -- Returns:
    --    table, with shift
    local r, raw, rel, shift
    if type( self ) == "table" then
        r    = self
        shift = add
    elseif type( add ) == "table" then
        r    = add
        shift = self
    end
    if r then
        if r[ Meta.signature ] then
            raw = r[ Meta.signature ]
        else
            raw = r
        end
        if type( shift ) == "table" then
            rel = shift
        else
            rel = Private.future( shift )
        end
    end
    if raw and rel then
        if allocate then
            r  = Prototypes.clone( r )
            raw = r[ Meta.signature ]
        end
        for k, v in pairs( rel ) do
            raw[ k ] = ( raw[ k ] or 0 )  +  v
        end -- for k, v
        Calc.fair( raw )
        r[ Meta.signature ] = raw
    end
    return r
end -- Prototypes.future()
 
 
 
Prototypes.tostring = function ( self )
    -- Stringify yourself
    -- Parameter:
    --    self  -- table, to be stringified
    -- Returns:
    --    string
    local dels = { false, "", "-", "-", "", "", ":", ":", ".", "" }
    local wids = { false, 4,  2,  2,  2,  2,  2,  2,  3,  3  }
    local s    = ""
    local n, r, spec
    local f = function ( a )
                  n = self[ Meta.order[ a ] ]
                  s = s .. dels[ a ]
                  if n then
                      spec = string.format( "%%s%%0%dd", wids[ a ] )
                      s    = string.format( spec, s, n )
                  end
              end -- f()
    for i = 2, 5 do
        f( i )
    end -- for i
    r = s
    s = ""
    for i = 6, 10 do
        f( i )
    end -- for i
    if s == "::." then
        r = r:gsub( "%-+$", "" )
    else
        if r == "--" then
            r = s
        else
            r = string.format( "%sT%s", r, s )
        end
    end
    r = r:gsub( "%.$", "" )
    return r
end -- Prototypes.tostring()
 
 
 
Prototypes.valueOf = function ( self )
    -- Returns yourselves primitive value (primitive table)
    -- Parameter:
    --    self  -- table, to be dumped
    -- Returns:
    --    table, or false
    local r
    if type( self ) == "table" then
        r = self[ Meta.signature ]
    end
    return r or false
end -- Prototypes.valueOf()
 
 
 
Templates.flow = function ( frame, action )
    -- Comparison invokation
    -- Parameter:
    --    frame  -- object
    -- Returns:
    --    string, either "" or "1"
    local r
    local s1 = frame.args[ 1 ]
    local s2 = frame.args[ 2 ]
    if s1 then
        s1 = mw.text.trim( s1 )
        if s1 == "" then
            s1 = false
        end
    end
    if s2 then
        s2 = mw.text.trim( s2 )
        if s2 == "" then
            s2 = false
        end
    end
    if s1 or s2 then
        local l
        Frame = frame
        l, r = pcall( Prototypes.flow,
                      Meta.fiat( s1 ), s2, action )
        if r == true then
            r = "1"
        end
    end
    return r or ""
end -- Templates.flow()
 
 
 
World.templates.formatter = function ( assigned, ask, adapt )
     -- Retrieve format specification string
     -- Retrieve format specification string
     -- Parameter:
     -- Parameter:
     --    assigned  -- table, with numbers etc.
     --    assigned  -- table, with numbers etc.
     --    ask      -- string, format spec, or nil
     --    ask      -- string, format spec, or nil
     --    adapt     -- table, with options
     --    alien     -- string, with language code, or nil
    --                  .lang    -- string, with particular language code
    --                  .lonely  -- true: permit lonely hour
     -- Returns:
     -- Returns:
     --    1  -- string
     --    1  -- string
Zeile 2.115: Zeile 1.079:
     if not ask  or  ask == "" then
     if not ask  or  ask == "" then
         r1 = "c"
         r1 = "c"
    elseif ask == "*" then
        if World.present then
            if assigned.hour then
                if assigned.dom or assigned.month or assigned.year then
                    if World.present.both and
                      World.present.date and
                      World.present.time then
                        r1 = World.present.both
                                    :gsub( "$date", World.present.date )
                                    :gsub( "$time", World.present.time )
                    else
                        r1 = World.present.date
                    end
                end
                r1 = r1 or World.present.time
            else
                r1 = World.present.date
            end
        end
        r1 = r1 or "c"
     else
     else
         local template = World.templates[ ask ]
         local template = World.templates[ ask ]
         r1 = ask
         r1 = ask
         if not template then
         if not template then
             local slang = ( adapt.lang or assigned.lang or World.slang )
             local slang = ( alien or assigned.lang or World.slang )
             local tmp  = World.templates[ slang ]
             local tmp  = World.templates[ slang ]
             if tmp then
             if tmp then
                 template = tmp[ ask ]
                 template = tmp[ ask ]
            end
            if not template then
                local i = slang:find( "-", 3, true )
                if i then
                    slang = slang:sub( 1,  i - 1 ):lower()
                    tmp  = World.templates[ slang ]
                    if tmp then
                        template = tmp[ ask ]
                    end
                end
             end
             end
         end
         end
         if type( template ) == "table" then
         if type( template ) == "table" then
            local low = ( ask == "ISO" or ask == "ISO-T" )
             r1 = template.spec
             r1 = template.spec
             if assigned.year then
             if assigned.year then
                 if not assigned.dom then
                 if not assigned.dom then
                     r1 = r1:gsub( "[ .%-]?[dDjlNwz][ .,%-]*", "" )
                     r1 = r1:gsub( "[ .]?[jJ][ .,%-]*", "" )
                           :gsub( "^&#160;", "" )
                           :gsub( "^&#160;", "" )
                     if not assigned.month then
                     if not assigned.month then
                         r1 = r1:gsub( "[ .%-]?[FmMnt][ .%-]*", "" )
                         r1 = r1:gsub( "[ .%-]?[fFmM][ .%-]*", "" )
                     end
                     end
                 end
                 end
Zeile 2.169: Zeile 1.102:
                 r1 = r1:gsub( " ?[yY] ?", "" )
                 r1 = r1:gsub( " ?[yY] ?", "" )
                 if not assigned.dom then
                 if not assigned.dom then
                     r1 = r1:gsub( "[ .]?[dDjlNwz][ .,%-]*", "" )
                     r1 = r1:gsub( "[ .]?[jJ][ .,%-]*", "" )
                             :gsub( "^&#160;", "" )
                             :gsub( "^&#160;", "" )
                 end
                 end
             end
             end
             if template.lift and
             if template.lift then
              ( assigned.dom or
                local spec = "T. Monat JJJJ hh:mm:ss Zone"
                not ( assigned.month or assigned.year or assigned.bc )
              ) then
                 local stamp = false
                 local stamp = false
                 if assigned.hour then
                local low  = ( ask == "ISO" or ask == "ISO-T" )
                     if assigned.min then
                 if ask ~= spec then
                        stamp = "H:i"
                     spec = false
                        if assigned.sec then
                end
                            stamp = "H:i:s"
                if assigned.hour and assigned.min then
                            if assigned.msec then
                    stamp = "H:i"
                                stamp = string.format( "%s.%03d",
                    if assigned.sec then
                                                      stamp,
                        stamp = "H:i:s"
                                                      assigned.msec )
                        if assigned.msec then
                                if assigned.mysec then
                            stamp = string.format( "%s.%d",
                                    stamp = string.format( "%s.%03d",
                                                  stamp, assigned.msec )
                                                          stamp,
                                                        assigned.mysec )
                                end
                            end
                         end
                         end
                    elseif adapt.lonely then
                        stamp = "H"
                     end
                     end
                 end
                 end
                 if low or ask:find( "hh:mm:ss", 1, true ) then
                 if low or spec then
                     if stamp then
                     if stamp then
                         r1 = string.format( "%s %s", r1, stamp )
                         r1 = string.format( "%s %s", r1, stamp )
Zeile 2.204: Zeile 1.129:
                 end
                 end
                 if stamp then
                 if stamp then
                     if low or template.long then
                    local dewiki = ( ask == "dewiki" or spec )
                     if low or dewiki then
                         local scheme
                         local scheme
                         if template.long then
                         if dewiki then
                             scheme = mw.language.getContentLanguage()
                             scheme = "de"
                            scheme = scheme.code
                         end
                         end
                         r2 = World.zones.formatter( assigned, scheme )
                         r2 = World.zones.formatter( assigned, scheme )
Zeile 2.215: Zeile 1.140:
             end
             end
             if type ( assigned.bc ) == "boolean" then
             if type ( assigned.bc ) == "boolean" then
                 local eras = World.era[ adapt.lang ]  or  World.era.en
                 local eras = World.era[ alien ]  or  World.era.en
                 local i
                 local i
                 if not r2 then
                 if not r2 then
Zeile 2.254: Zeile 1.179:
             if #s == 1 then
             if #s == 1 then
                 -- "YXWVUTSRQPONZABCDEFGHIKLM"
                 -- "YXWVUTSRQPONZABCDEFGHIKLM"
                 move = World.zones[ "!" ]:find( s, 1, true )
                 move = World.zones[ "!" ]:find( s )
                 if move then
                 if move then
                     move          = ( move - 13 ) * 100
                     move          = ( move - 13 ) * 100
Zeile 2.269: Zeile 1.194:
                   if tmp then
                   if tmp then
                       code = tmp[ s ]
                       code = tmp[ s ]
                  end
                  if not code  and
                      slang ~= "en"  and
                      World.zones.en then
                      code = World.zones.en[ s ]
                   end
                   end
                 end
                 end
Zeile 2.330: Zeile 1.250:
local p = { }
local p = { }


function p.test( args, alien )
function p.test( args )
    local slang = args.lang or alien
    local obj  = Meta.fiat( args[ 1 ], false, args.shift )
     local r
     local r
     if type( obj ) == "table" then
    local o = DateTime( args[ 1 ], "de" )
     if type( o ) == "table" then
         local spec  = args[ 2 ]
         local spec  = args[ 2 ]
         local opt
         local slang = args[ 3 ]
         if spec then
         if spec then
             spec = mw.text.trim( spec )
             spec = mw.text.trim( spec )
         end
         end
         if slang then
         if slang then
             opt = { lang = mw.text.trim( slang ) }
             slang = mw.text.trim( slang )
         end
         end
         r = obj:format( spec, opt )
         r = o:format( spec, slang )
     else
     else
         r = ( args.noerror or "0" )
         r = ( args.noerror or "0" )
         if r == "0" then
         if r == "0" then
             r = fault( "Format invalid" )
             r = fault( "Format nicht erkannt" )
         else
         else
             r = ""
             r = ""
Zeile 2.354: Zeile 1.273:
     return r
     return r
end -- p.test
end -- p.test
function p.failsafe( frame )
    local s = type( frame )
    local r, since
    if s == "table" then
        since = frame.args[ 1 ]
    elseif s == "string" then
        since = mw.text.trim( since )
        if since == "" then
            since = false
        end
    end
    return Prototypes.failsafe( false, since )  or  ""
end -- p.failsafe






function p.format( frame )
function p.format( frame )
    --    1      -- stamp
    --    2      -- spec
    --    lang
    --    shift
    --    noerror
     local l, r
     local l, r
     local v = { frame.args[ 1 ],
     local v = { frame.args[ 1 ],
                 frame.args[ 2 ],
                 frame.args[ 2 ],
                 shift  = frame.args.shift,
                 frame.args[ 3 ],
                 noerror = frame.args.noerror }
                 noerror = frame.args.noerror }
     if not v[ 1 ]  or  v[ 1 ] == "now" then
     if not v[ 1 ]  or  v[ 1 ] == "now" then
         v[ 1 ] = frame:callParserFunction( "#timel", "c", v.shift )
         v[ 1 ] = frame:callParserFunction( "#timel", "c" )
        v.shift = false
     end
     end
    Frame  = frame
     l, r = pcall( p.test, v )
     l, r = pcall( p.test, v,  frame.args[ 3 ] or frame.args.lang )
     if not l then
     if not l then
         r = fault( r )
         r = fault( r )
Zeile 2.398: Zeile 1.294:




function p.lt( frame )
p.DateTime = function ( ... )
    return Templates.flow( frame, "lt" )
     return DateTime( ... )
end -- p.lt
function p.le( frame )
    return Templates.flow( frame, "le" )
end -- p.le
function p.eq( frame )
     return Templates.flow( frame, "eq" )
end -- p.eq
function p.ne( frame )
    return Templates.flow( frame, "ne" )
end -- p.ne
function p.ge( frame )
    return Templates.flow( frame, "ge" )
end -- p.ge
function p.gt( frame )
    return Templates.flow( frame, "gt" )
end -- p.gt
 
 
 
p.DateTime = function ()
    return DateTime
end -- p.DateTime
end -- p.DateTime


return p
return p

Bitte beachte, dass alle Beiträge im Regiowiki von anderen Mitwirkenden bearbeitet, geändert oder gelöscht werden können. Reiche hier keine Texte ein, falls Du nicht willst, dass diese ohne Einschränkung geändert werden können.

Mit dem Speichern dieser Seite stimmst Du den Nutzungsbedingungen zu und versicherst, dass Du den Beitrag selbst verfasst hast bzw. dass er keine fremden Rechte verletzt, und willigst ein, ihn unter der Creative Commons Attribution/Share-Alike Lizenz 3.0 zu veröffentlichen. Übertrage ohne Genehmigung keine urheberrechtlich geschützten Inhalte!

Du stimmst einer Autorennennung mindestens durch URL oder Verweis auf den Artikel zu. Wenn Du nicht möchtest, dass Dein Text weiterbearbeitet und weiterverbreitet wird bzw. den Nutzungsbedingungen nicht zustimmst, dann speichere ihn nicht.

Abbrechen Bearbeitungshilfe (wird in einem neuen Fenster geöffnet)

[] [[]] | {{}} {{{}}} – — “” ‘’ «» ‹› „“ ‚‘ · • × ° € ← → § ~~~~ <s></s> <small></small> <sup></sup> <sub></sub> <tt></tt> <code></code> <pre></pre> &nbsp; [[Kategorie:]] [[Datei:]] [[Media:]] {{DEFAULTSORT:}} {{NAMESPACE}} {{PAGENAME}} #REDIRECT[[]] <gallery></gallery> <!-- --> <nowiki></nowiki> <code><nowiki></nowiki></code> <includeonly></includeonly> <noinclude></noinclude> <onlyinclude></onlyinclude> <translate></translate> <tvar|></> <languages/>

Folgende Vorlagen werden auf dieser Seite verwendet:

Abgerufen von „https://regiowiki.at/wiki/Modul:DateTime“