The Speculative Wiki - User contributions [en]

List of Triads

2023-12-12T02:51:55Z

Kcreasey:

For the Triads exactly in the flow of the logic that Hegel derives, see [[List of Direct Triads]]

* Being => Essence => Concept
* Logic => Nature => Spirit
* '''Being-in-itself => Being-for-other => Being-for-itself'''
* Subjectivity => Objectivity => Idea

Talk:Main Page

2023-12-02T16:24:26Z

Kcreasey:

== Idea for each aspect individually in the flow of logic ==

* Object in its immediacy
* Object as negated/abstracted?
* Object as mediated/sublated

In order to capture the flow and also the sublated part affects further determinations down the line

Example: Being-for-self as sublated means pure quantity and even quantum are '''not''' limited as being-for-self itself is the affirmative/being form of true infinity.

== Eternal Return ==

Not sure yet exactly how I'll use this, but using Meow Wolf's first art installation "House of Eternal Return", the latter part of that well describes what True Infinity is. It is a loop back upon itself, an return back to itself that continues back to itself.

Self-similarities in path of logic

2023-12-02T16:22:55Z

Kcreasey:

{| class="wikitable"
|+
!First Track
!Second Track
!Third Track
!Fourth Track
|-
|Being
|Something
|
|
|-
|Nothing
|Other
|
|
|-
|Becoming
|Change
|
|
|-
|Stability/Development
|Self-Identity
|
|
|-
|Determinate Being
|Something & Other
|
|
|-
|Quality
|Being-for-other & Being-in-itself
|
|
|}
As each appearent return to a previous concept as further determined, it becomes more obvious this is an actual return with more determinacy through the Being-for-itself/True Infinity loop of return.

List of Triads

2023-12-02T14:57:15Z

Kcreasey: Created page with "For the Triads exactly in the flow of the logic that Hegel derives, see List of Direct Triads * Being => Essence => Concept * Logic => Nature => Spirit * Being-in-itself => Being-for-other => Being-for-itself * Subjectivity => Objectivity => Idea"

For the Triads exactly in the flow of the logic that Hegel derives, see [[List of Direct Triads]]

* Being => Essence => Concept
* Logic => Nature => Spirit
* Being-in-itself => Being-for-other => Being-for-itself
* Subjectivity => Objectivity => Idea

List of Direct Triads

2023-12-02T14:55:33Z

Kcreasey: Kcreasey moved page List of Triads to List of Direct Triads without leaving a redirect: Rephrasing this as the actual flow process. Other non-Direct triads are also going to be documented

=== Doctrine of Being ===
==== Quality ====

* [[Pure Being ⇒ Becoming]]

* [[Becoming ⇒ Determinate Being]]

* [[Determinate Being ⇒ Something]]

* [[Something ⇒ Change]]

* [[Change ⇒ Something & Other]]

* [[Something & Other ⇒ Determination]]

==== Quantity ====

Main Page

2023-12-02T14:54:46Z

Kcreasey:

This is a work in progress of documenting as I follow along with the course of the Logic
* [[List of Triads]]
* [[Negation of the negation]]
* [[Thesis, Antithesis, Synthesis]]
* [[Self-similarities in path of logic]]
* [[Syllogisms]]
* [[Map of Science of Logic]]

== Other sources ==
[https://speculativescience.github.io/en/#!index.md The Speculative Science] - Another attempt at a Wiki on the Science of Logic

[https://hegel.net/ Hegel.net] - A site for navigating the Logic; uses triangles as visual aids for the syllogistic nature of the logic. Does perchance miss some negation transitions in this process

Talk:Main Page

2023-12-02T13:51:59Z

Kcreasey:

Talk:Main Page

2023-12-02T13:50:19Z

Kcreasey:

Talk:Main Page

2023-12-02T13:50:14Z

Kcreasey:

== Idea for each aspect individually in the flow of logic ==

* Object in it's immediacy
* Object as negated/abstracted?
* Object as mediated/sublated

In order to capture the flow and also the sublated part affects further determinations down the line
Example: Being-for-self as sublated means pure quantity and even quantum are '''not''' limited as being-for-self itself is the affirmative/being form of true infinity.

Talk:Main Page

2023-12-02T13:50:00Z

Kcreasey:

== Idea for each aspect individually in the flow of logic ==

Object in it's immediacy
Object as negated/abstracted?
Object as mediated/sublated

In order to capture the flow and also the sublated part affects further determinations down the line
Example: Being-for-self as sublated means pure quantity and even quantum are '''not''' limited as being-for-self itself is the affirmative/being form of true infinity.

Talk:Main Page

2023-12-02T13:49:41Z

Kcreasey: Created page with "Idea for each aspect individually in the flow of logic Object in it's immediacy Object as negated/abstracted? Object as mediated/sublated In order to capture the flow and also the sublated part affects further determinations down the line Example: Being-for-self as sublated means pure quantity and even quantum are '''not''' limited as being-for-self itself is the affirmative/being form of true infinity."

Idea for each aspect individually in the flow of logic

Object in it's immediacy
Object as negated/abstracted?
Object as mediated/sublated

In order to capture the flow and also the sublated part affects further determinations down the line
Example: Being-for-self as sublated means pure quantity and even quantum are '''not''' limited as being-for-self itself is the affirmative/being form of true infinity.

Template:Infobox triad

2023-11-28T13:37:33Z

Kcreasey: Still working to fix why Houlgate isn't showing up

{{Infobox
| title = {{PAGENAME}}
| headerstyle = background: #ddddff
| autoheaders = y

| header1 = Science of Logic
| data2 = {{SoL divisions|{{{soldivision|}}}}}

| header3 = Triad
| label4 = {{{thesislabel|}}}
| data4 = {{#if: {{{thesis|}}} | [[{{{thesis}}}]] }}
| label5 = A
| data5 = {{#if: {{{thesisa|}}} | [[{{{thesisa}}}]] }}
| label6 = B
| data6 = {{#if: {{{thesisb|}}} | [[{{{thesisb}}}]] }}
| label7 = {{{antithesislabel|}}}
| data7 = {{#if: {{{antithesis|}}} | [[{{{antithesis}}}]] }}
| label8 = A
| data8 = {{#if: {{{antithesisa|}}} | [[{{{antithesisa}}}]] }}
| label9 = B
| data9 = {{#if: {{{antithesisb|}}} | [[{{{antithesisb}}}]] }}
| label10 = {{{sublationlabel|}}}
| data10 = {{#if: {{{sublation|}}} | [[{{{sublation}}}]] }}
| label11 = A
| data11 = {{#if: {{{sublationa|}}} | [[{{{sublationa}}}]] }}
| label12 = B
| data12 = {{#if: {{{sublationb|}}} | [[{{{sublationb}}}]] }}
| header13 = Nav
| data14 = {{#if: {{{prev|}}} | [[{{{prev}}}]] | (Beginning) }}
| data15 = {{#if: {{{next|}}} | [[{{{next}}}]] | (End) }}
| header16 = Hegel
| data17 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Science of Logic | header2 = {{{slstart}}}-{{{slend}}} | label3 = Miller | data3 = p.{{{millerpage}}}-{{{millerend}}} | label4 = Giovanni | data4 = p.{{{giovannipage}}}-{{{giovanniend}}} }}
| data18 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Encyclopedia Logic I | header2 = §{{{subsection}}}-{{{subsectionend}}} | label3 = Wallace | data3 = p.{{{wallacepage}}}-{{{wallacepage}}} | label4 = Hackett | data4 = p.{{{hackettpage}}}-{{{hackettend}}} }}
| header19 = Houlgate
| label20: The Opening to the Logic
| data20: t{{#if: {{{hotl|}}}| Chp. {{{hotl}}} [p.{{{hotlstart}}}-{{{hotlend}}} }}
| label21: On Being
| data21: {{#if: {{{honbv|}}}| Vol. {{{honbv}}}, Chp. {{{honbc}}} [p.{{{honbstart}}}-{{{honbend}}} }}
}}

Module:String

2023-11-28T13:36:40Z

Kcreasey: Created page with "--[[ This module is intended to provide access to basic string functions. Most of the functions provided here can be invoked with named parameters, unnamed parameters, or a mixture. If named parameters are used, Mediawiki will automatically remove any leading or trailing whitespace from the parameter. Depending on the intended use, it may be advantageous to either preserve or remove such whitespace. Global options ignore_errors: If set to 'true' or 1, any error c..."

--[[

This module is intended to provide access to basic string functions.

Most of the functions provided here can be invoked with named parameters,
unnamed parameters, or a mixture. If named parameters are used, Mediawiki will
automatically remove any leading or trailing whitespace from the parameter.
Depending on the intended use, it may be advantageous to either preserve or
remove such whitespace.

Global options
ignore_errors: If set to 'true' or 1, any error condition will result in
an empty string being returned rather than an error message.

error_category: If an error occurs, specifies the name of a category to
include with the error message. The default category is
[Category:Errors reported by Module String].

no_category: If set to 'true' or 1, no category will be added if an error
is generated.

Unit tests for this module are available at Module:String/tests.
]]

local str = {}

--[[
len

This function returns the length of the target string.

Usage:
{{#invoke:String|len|target_string|}}
OR
{{#invoke:String|len|s=target_string}}

Parameters
s: The string whose length to report

If invoked using named parameters, Mediawiki will automatically remove any leading or
trailing whitespace from the target string.
]]
function str.len( frame )
local new_args = str._getParameters( frame.args, {'s'} )
local s = new_args['s'] or ''
return mw.ustring.len( s )
end

--[[
sub

This function returns a substring of the target string at specified indices.

Usage:
{{#invoke:String|sub|target_string|start_index|end_index}}
OR
{{#invoke:String|sub|s=target_string|i=start_index|j=end_index}}

Parameters
s: The string to return a subset of
i: The first index of the substring to return, defaults to 1.
j: The last index of the string to return, defaults to the last character.

The first character of the string is assigned an index of 1. If either i or j
is a negative value, it is interpreted the same as selecting a character by
counting from the end of the string. Hence, a value of -1 is the same as
selecting the last character of the string.

If the requested indices are out of range for the given string, an error is
reported.
]]
function str.sub( frame )
local new_args = str._getParameters( frame.args, { 's', 'i', 'j' } )
local s = new_args['s'] or ''
local i = tonumber( new_args['i'] ) or 1
local j = tonumber( new_args['j'] ) or -1

local len = mw.ustring.len( s )

-- Convert negatives for range checking
if i < 0 then
i = len + i + 1
end
if j < 0 then
j = len + j + 1
end

if i > len or j > len or i < 1 or j < 1 then
return str._error( 'String subset index out of range' )
end
if j < i then
return str._error( 'String subset indices out of order' )
end

return mw.ustring.sub( s, i, j )
end

--[[
This function implements that features of {{str sub old}} and is kept in order
to maintain these older templates.
]]
function str.sublength( frame )
local i = tonumber( frame.args.i ) or 0
local len = tonumber( frame.args.len )
return mw.ustring.sub( frame.args.s, i + 1, len and ( i + len ) )
end

--[[
_match

This function returns a substring from the source string that matches a
specified pattern. It is exported for use in other modules

Usage:
strmatch = require("Module:String")._match
sresult = strmatch( s, pattern, start, match, plain, nomatch )

Parameters
s: The string to search
pattern: The pattern or string to find within the string
start: The index within the source string to start the search. The first
character of the string has index 1. Defaults to 1.
match: In some cases it may be possible to make multiple matches on a single
string. This specifies which match to return, where the first match is
match= 1. If a negative number is specified then a match is returned
counting from the last match. Hence match = -1 is the same as requesting
the last match. Defaults to 1.
plain: A flag indicating that the pattern should be understood as plain
text. Defaults to false.
nomatch: If no match is found, output the "nomatch" value rather than an error.

For information on constructing Lua patterns, a form of [regular expression], see:

* http://www.lua.org/manual/5.1/manual.html#5.4.1
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Ustring_patterns

]]
-- This sub-routine is exported for use in other modules
function str._match( s, pattern, start, match_index, plain_flag, nomatch )
if s == '' then
return str._error( 'Target string is empty' )
end
if pattern == '' then
return str._error( 'Pattern string is empty' )
end
start = tonumber(start) or 1
if math.abs(start) < 1 or math.abs(start) > mw.ustring.len( s ) then
return str._error( 'Requested start is out of range' )
end
if match_index == 0 then
return str._error( 'Match index is out of range' )
end
if plain_flag then
pattern = str._escapePattern( pattern )
end

local result
if match_index == 1 then
-- Find first match is simple case
result = mw.ustring.match( s, pattern, start )
else
if start > 1 then
s = mw.ustring.sub( s, start )
end

local iterator = mw.ustring.gmatch(s, pattern)
if match_index > 0 then
-- Forward search
for w in iterator do
match_index = match_index - 1
if match_index == 0 then
result = w
break
end
end
else
-- Reverse search
local result_table = {}
local count = 1
for w in iterator do
result_table[count] = w
count = count + 1
end

result = result_table[ count + match_index ]
end
end

if result == nil then
if nomatch == nil then
return str._error( 'Match not found' )
else
return nomatch
end
else
return result
end
end

--[[
match

This function returns a substring from the source string that matches a
specified pattern.

Usage:
{{#invoke:String|match|source_string|pattern_string|start_index|match_number|plain_flag|nomatch_output}}
OR
{{#invoke:String|match|s=source_string|pattern=pattern_string|start=start_index
|match=match_number|plain=plain_flag|nomatch=nomatch_output}}

Parameters
s: The string to search
pattern: The pattern or string to find within the string
start: The index within the source string to start the search. The first
character of the string has index 1. Defaults to 1.
match: In some cases it may be possible to make multiple matches on a single
string. This specifies which match to return, where the first match is
match= 1. If a negative number is specified then a match is returned
counting from the last match. Hence match = -1 is the same as requesting
the last match. Defaults to 1.
plain: A flag indicating that the pattern should be understood as plain
text. Defaults to false.
nomatch: If no match is found, output the "nomatch" value rather than an error.

If invoked using named parameters, Mediawiki will automatically remove any leading or
trailing whitespace from each string. In some circumstances this is desirable, in
other cases one may want to preserve the whitespace.

If the match_number or start_index are out of range for the string being queried, then
this function generates an error. An error is also generated if no match is found.
If one adds the parameter ignore_errors=true, then the error will be suppressed and
an empty string will be returned on any failure.

For information on constructing Lua patterns, a form of [regular expression], see:

* http://www.lua.org/manual/5.1/manual.html#5.4.1
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Ustring_patterns

]]
-- This is the entry point for #invoke:String|match
function str.match( frame )
local new_args = str._getParameters( frame.args, {'s', 'pattern', 'start', 'match', 'plain', 'nomatch'} )
local s = new_args['s'] or ''
local start = tonumber( new_args['start'] ) or 1
local plain_flag = str._getBoolean( new_args['plain'] or false )
local pattern = new_args['pattern'] or ''
local match_index = math.floor( tonumber(new_args['match']) or 1 )
local nomatch = new_args['nomatch']

return str._match( s, pattern, start, match_index, plain_flag, nomatch )
end

--[[
pos

This function returns a single character from the target string at position pos.

Usage:
{{#invoke:String|pos|target_string|index_value}}
OR
{{#invoke:String|pos|target=target_string|pos=index_value}}

Parameters
target: The string to search
pos: The index for the character to return

If invoked using named parameters, Mediawiki will automatically remove any leading or
trailing whitespace from the target string. In some circumstances this is desirable, in
other cases one may want to preserve the whitespace.

The first character has an index value of 1.

If one requests a negative value, this function will select a character by counting backwards
from the end of the string. In other words pos = -1 is the same as asking for the last character.

A requested value of zero, or a value greater than the length of the string returns an error.
]]
function str.pos( frame )
local new_args = str._getParameters( frame.args, {'target', 'pos'} )
local target_str = new_args['target'] or ''
local pos = tonumber( new_args['pos'] ) or 0

if pos == 0 or math.abs(pos) > mw.ustring.len( target_str ) then
return str._error( 'String index out of range' )
end

return mw.ustring.sub( target_str, pos, pos )
end

--[[
str_find

This function duplicates the behavior of {{str_find}}, including all of its quirks.
This is provided in order to support existing templates, but is NOT RECOMMENDED for
new code and templates. New code is recommended to use the "find" function instead.

Returns the first index in "source" that is a match to "target". Indexing is 1-based,
and the function returns -1 if the "target" string is not present in "source".

Important Note: If the "target" string is empty / missing, this function returns a
value of "1", which is generally unexpected behavior, and must be accounted for
separatetly.
]]
function str.str_find( frame )
local new_args = str._getParameters( frame.args, {'source', 'target'} )
local source_str = new_args['source'] or ''
local target_str = new_args['target'] or ''

if target_str == '' then
return 1
end

local start = mw.ustring.find( source_str, target_str, 1, true )
if start == nil then
start = -1
end

return start
end

--[[
find

This function allows one to search for a target string or pattern within another
string.

Usage:
{{#invoke:String|find|source_str|target_string|start_index|plain_flag}}
OR
{{#invoke:String|find|source=source_str|target=target_str|start=start_index|plain=plain_flag}}

Parameters
source: The string to search
target: The string or pattern to find within source
start: The index within the source string to start the search, defaults to 1
plain: Boolean flag indicating that target should be understood as plain
text and not as a Lua style regular expression, defaults to true

If invoked using named parameters, Mediawiki will automatically remove any leading or
trailing whitespace from the parameter. In some circumstances this is desirable, in
other cases one may want to preserve the whitespace.

This function returns the first index >= "start" where "target" can be found
within "source". Indices are 1-based. If "target" is not found, then this
function returns 0. If either "source" or "target" are missing / empty, this
function also returns 0.

This function should be safe for UTF-8 strings.
]]
function str.find( frame )
local new_args = str._getParameters( frame.args, {'source', 'target', 'start', 'plain' } )
local source_str = new_args['source'] or ''
local pattern = new_args['target'] or ''
local start_pos = tonumber(new_args['start']) or 1
local plain = new_args['plain'] or true

if source_str == '' or pattern == '' then
return 0
end

plain = str._getBoolean( plain )

local start = mw.ustring.find( source_str, pattern, start_pos, plain )
if start == nil then
start = 0
end

return start
end

--[[
replace

This function allows one to replace a target string or pattern within another
string.

Usage:
{{#invoke:String|replace|source_str|pattern_string|replace_string|replacement_count|plain_flag}}
OR
{{#invoke:String|replace|source=source_string|pattern=pattern_string|replace=replace_string|
count=replacement_count|plain=plain_flag}}

Parameters
source: The string to search
pattern: The string or pattern to find within source
replace: The replacement text
count: The number of occurences to replace, defaults to all.
plain: Boolean flag indicating that pattern should be understood as plain
text and not as a Lua style regular expression, defaults to true
]]
function str.replace( frame )
local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } )
local source_str = new_args['source'] or ''
local pattern = new_args['pattern'] or ''
local replace = new_args['replace'] or ''
local count = tonumber( new_args['count'] )
local plain = new_args['plain'] or true

if source_str == '' or pattern == '' then
return source_str
end
plain = str._getBoolean( plain )

if plain then
pattern = str._escapePattern( pattern )
replace = mw.ustring.gsub( replace, "%%", "%%%%" ) --Only need to escape replacement sequences.
end

local result

if count ~= nil then
result = mw.ustring.gsub( source_str, pattern, replace, count )
else
result = mw.ustring.gsub( source_str, pattern, replace )
end

return result
end

--[[
simple function to pipe string.rep to templates.
]]
function str.rep( frame )
local repetitions = tonumber( frame.args[2] )
if not repetitions then
return str._error( 'function rep expects a number as second parameter, received "' .. ( frame.args[2] or '' ) .. '"' )
end
return string.rep( frame.args[1] or '', repetitions )
end

--[[
escapePattern

This function escapes special characters from a Lua string pattern. See [1]
for details on how patterns work.

[1] https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns

Usage:
{{#invoke:String|escapePattern|pattern_string}}

Parameters
pattern_string: The pattern string to escape.
]]
function str.escapePattern( frame )
local pattern_str = frame.args[1]
if not pattern_str then
return str._error( 'No pattern string specified' )
end
local result = str._escapePattern( pattern_str )
return result
end

--[[
count
This function counts the number of occurrences of one string in another.
]]
function str.count(frame)
local args = str._getParameters(frame.args, {'source', 'pattern', 'plain'})
local source = args.source or ''
local pattern = args.pattern or ''
local plain = str._getBoolean(args.plain or true)
if plain then
pattern = str._escapePattern(pattern)
end
local _, count = mw.ustring.gsub(source, pattern, '')
return count
end

--[[
endswith
This function determines whether a string ends with another string.
]]
function str.endswith(frame)
local args = str._getParameters(frame.args, {'source', 'pattern'})
local source = args.source or ''
local pattern = args.pattern or ''
if pattern == '' then
-- All strings end with the empty string.
return "yes"
end
if mw.ustring.sub(source, -mw.ustring.len(pattern), -1) == pattern then
return "yes"
else
return ""
end
end

--[[
join

Join all non empty arguments together; the first argument is the separator.
Usage:
{{#invoke:String|join|sep|one|two|three}}
]]
function str.join(frame)
local args = {}
local sep
for _, v in ipairs( frame.args ) do
if sep then
if v ~= '' then
table.insert(args, v)
end
else
sep = v
end
end
return table.concat( args, sep or '' )
end

--[[
Helper function that populates the argument list given that user may need to use a mix of
named and unnamed parameters. This is relevant because named parameters are not
identical to unnamed parameters due to string trimming, and when dealing with strings
we sometimes want to either preserve or remove that whitespace depending on the application.
]]
function str._getParameters( frame_args, arg_list )
local new_args = {}
local index = 1
local value

for _, arg in ipairs( arg_list ) do
value = frame_args[arg]
if value == nil then
value = frame_args[index]
index = index + 1
end
new_args[arg] = value
end

return new_args
end

--[[
Helper function to handle error messages.
]]
function str._error( error_str )
local frame = mw.getCurrentFrame()
local error_category = frame.args.error_category or 'Errors reported by Module String'
local ignore_errors = frame.args.ignore_errors or false
local no_category = frame.args.no_category or false

if str._getBoolean(ignore_errors) then
return ''
end

local error_str = '<strong class="error">String Module Error: ' .. error_str .. '</strong>'
if error_category ~= '' and not str._getBoolean( no_category ) then
error_str = '[[Category:' .. error_category .. ']]' .. error_str
end

return error_str
end

--[[
Helper Function to interpret boolean strings
]]
function str._getBoolean( boolean_str )
local boolean_value

if type( boolean_str ) == 'string' then
boolean_str = boolean_str:lower()
if boolean_str == 'false' or boolean_str == 'no' or boolean_str == '0'
or boolean_str == '' then
boolean_value = false
else
boolean_value = true
end
elseif type( boolean_str ) == 'boolean' then
boolean_value = boolean_str
else
error( 'No boolean value found' )
end
return boolean_value
end

--[[
Helper function that escapes all pattern characters so that they will be treated
as plain text.
]]
function str._escapePattern( pattern_str )
return mw.ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" )
end

return str

Template:Remove first word

2023-11-28T13:36:02Z

Kcreasey: Created page with "{{<includeonly>safesubst:</includeonly>#invoke:String|replace|source={{{1}}}|pattern=^[^{{{sep|%s}}}]*{{{sep|%s}}}*|replace=|plain=false}}<noinclude>{{Documentation}}</noinclude>"

{{<includeonly>safesubst:</includeonly>#invoke:String|replace|source={{{1}}}|pattern=^[^{{{sep|%s}}}]*{{{sep|%s}}}*|replace=|plain=false}}<noinclude>{{Documentation}}</noinclude>

Template:Str left

2023-11-28T13:34:10Z

Kcreasey: Created page with "<includeonly>{{safesubst:padleft:|{{{2|1}}}|{{{1}}}}}</includeonly><noinclude> {{documentation}}  </noinclude>"

<includeonly>{{safesubst:padleft:|{{{2|1}}}|{{{1}}}}}</includeonly><noinclude>
{{documentation}}

</noinclude>

Template:Infobox triad

2023-11-28T13:32:31Z

Kcreasey:

{{Infobox
| title = {{PAGENAME}}
| headerstyle = background: #ddddff
| autoheaders = n

| header1 = Science of Logic
| data2 = {{SoL divisions|{{{soldivision|}}}}}

| header3 = Triad
| label4 = {{{thesislabel|}}}
| data4 = {{#if: {{{thesis|}}} | [[{{{thesis}}}]] }}
| label5 = A
| data5 = {{#if: {{{thesisa|}}} | [[{{{thesisa}}}]] }}
| label6 = B
| data6 = {{#if: {{{thesisb|}}} | [[{{{thesisb}}}]] }}
| label7 = {{{antithesislabel|}}}
| data7 = {{#if: {{{antithesis|}}} | [[{{{antithesis}}}]] }}
| label8 = A
| data8 = {{#if: {{{antithesisa|}}} | [[{{{antithesisa}}}]] }}
| label9 = B
| data9 = {{#if: {{{antithesisb|}}} | [[{{{antithesisb}}}]] }}
| label10 = {{{sublationlabel|}}}
| data10 = {{#if: {{{sublation|}}} | [[{{{sublation}}}]] }}
| label11 = A
| data11 = {{#if: {{{sublationa|}}} | [[{{{sublationa}}}]] }}
| label12 = B
| data12 = {{#if: {{{sublationb|}}} | [[{{{sublationb}}}]] }}
| header13 = Nav
| data14 = {{#if: {{{prev|}}} | [[{{{prev}}}]] | (Beginning) }}
| data15 = {{#if: {{{next|}}} | [[{{{next}}}]] | (End) }}
| header16 = Hegel

| header19 = Houlgate
| label20: The Opening to the Logic
| data20: t{{#if: {{{hotl|}}}| Chp. {{{hotl}}} [p.{{{hotlstart}}}-{{{hotlend}}} }}
| label21: On Being
| data21: {{#if: {{{honbv|}}}| Vol. {{{honbv}}}, Chp. {{{honbc}}} [p.{{{honbstart}}}-{{{honbend}}} }}
}}

Template:Infobox triad

2023-11-28T13:29:52Z

Kcreasey:

{{Infobox
| title = {{PAGENAME}}
| headerstyle = background: #ddddff
| autoheaders = n

| header1 = Science of Logic
| data2 = {{SoL divisions|{{{soldivision|}}}}}

| header3 = Triad
| label4 = {{{thesislabel|}}}
| data4 = {{#if: {{{thesis|}}} | [[{{{thesis}}}]] }}
| label5 = A
| data5 = {{#if: {{{thesisa|}}} | [[{{{thesisa}}}]] }}
| label6 = B
| data6 = {{#if: {{{thesisb|}}} | [[{{{thesisb}}}]] }}
| label7 = {{{antithesislabel|}}}
| data7 = {{#if: {{{antithesis|}}} | [[{{{antithesis}}}]] }}
| label8 = A
| data8 = {{#if: {{{antithesisa|}}} | [[{{{antithesisa}}}]] }}
| label9 = B
| data9 = {{#if: {{{antithesisb|}}} | [[{{{antithesisb}}}]] }}
| label10 = {{{sublationlabel|}}}
| data10 = {{#if: {{{sublation|}}} | [[{{{sublation}}}]] }}
| label11 = A
| data11 = {{#if: {{{sublationa|}}} | [[{{{sublationa}}}]] }}
| label12 = B
| data12 = {{#if: {{{sublationb|}}} | [[{{{sublationb}}}]] }}
| header13 = Nav
| data14 = {{#if: {{{prev|}}} | [[{{{prev}}}]] | (Beginning) }}
| data15 = {{#if: {{{next|}}} | [[{{{next}}}]] | (End) }}
| header16 = Hegel
| data17 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Science of Logic | header2 = {{{slstart}}}-{{{slend}}} | label3 = Miller | data3 = p.{{{millerpage}}}-{{{millerend}}} | label4 = Giovanni | data4 = p.{{{giovannipage}}}-{{{giovanniend}}} }}
| data18 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Encyclopedia Logic I | header2 = §{{{subsection}}}-{{{subsectionend}}} | label3 = Wallace | data3 = p.{{{wallacepage}}}-{{{wallacepage}}} | label4 = Hackett | data4 = p.{{{hackettpage}}}-{{{hackettend}}} }}
| header19 = Houlgate
| label20: The Opening to the Logic
| data20: t{{#if: {{{hotl|}}}| Chp. {{{hotl}}} [p.{{{hotlstart}}}-{{{hotlend}}} }}
| label21: On Being
| data21: {{#if: {{{honbv|}}}| Vol. {{{honbv}}}, Chp. {{{honbc}}} [p.{{{honbstart}}}-{{{honbend}}} }}
}}

Template:Infobox triad

2023-11-28T13:29:12Z

Kcreasey:

{{Infobox
| title = {{PAGENAME}}
| headerstyle = background: #ddddff
| autoheaders = y

| header1 = Science of Logic
| data2 = {{SoL divisions|{{{soldivision|}}}}}

| header3 = Triad
| label4 = {{{thesislabel|}}}
| data4 = {{#if: {{{thesis|}}} | [[{{{thesis}}}]] }}
| label5 = A
| data5 = {{#if: {{{thesisa|}}} | [[{{{thesisa}}}]] }}
| label6 = B
| data6 = {{#if: {{{thesisb|}}} | [[{{{thesisb}}}]] }}
| label7 = {{{antithesislabel|}}}
| data7 = {{#if: {{{antithesis|}}} | [[{{{antithesis}}}]] }}
| label8 = A
| data8 = {{#if: {{{antithesisa|}}} | [[{{{antithesisa}}}]] }}
| label9 = B
| data9 = {{#if: {{{antithesisb|}}} | [[{{{antithesisb}}}]] }}
| label10 = {{{sublationlabel|}}}
| data10 = {{#if: {{{sublation|}}} | [[{{{sublation}}}]] }}
| label11 = A
| data11 = {{#if: {{{sublationa|}}} | [[{{{sublationa}}}]] }}
| label12 = B
| data12 = {{#if: {{{sublationb|}}} | [[{{{sublationb}}}]] }}
| header13 = Nav
| data14 = {{#if: {{{prev|}}} | [[{{{prev}}}]] | (Beginning) }}
| data15 = {{#if: {{{next|}}} | [[{{{next}}}]] | (End) }}
| header16 = Hegel
| data17 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Science of Logic | header2 = {{{slstart}}}-{{{slend}}} | label3 = Miller | data3 = p.{{{millerpage}}}-{{{millerend}}} | label4 = Giovanni | data4 = p.{{{giovannipage}}}-{{{giovanniend}}}}}
| data18 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Encyclopedia Logic I | header2 = §{{{subsection}}}-{{{subsectionend}}} | label3 = Wallace | data3 = p.{{{wallacepage}}}-{{{wallacepage}}} | label4 = Hackett | data4 = p.{{{hackettpage}}}-{{{hackettend}}}}}
|header19 = Houlgate
|label20: The Opening to the Logic
|data20: t{{#if: {{{hotl|}}}| Chp. {{{hotl}}} [p.{{{hotlstart}}}-{{{hotlend}}} }}
|label21: On Being
|data21: {{#if: {{{honbv|}}}| Vol. {{{honbv}}}, Chp. {{{honbc}}} [p.{{{honbstart}}}-{{{honbend}}} }}
}}

Pure Being ⇒ Becoming

2023-11-28T13:28:08Z

Kcreasey:

{{Infobox triad
|soldivision=being
|thesislabel=Being
|antithesislabel=Negation
|sublationlabel=Sublation
|thesis=Pure Being
|antithesis=Pure Nothing
|sublation=Becoming
|sublationa=Coming-To-Be
|sublationb=Ceasing-To-Be
|next=Becoming ⇒ Determinate Being
|millerpage=82
|millerend=108
|giovannipage=59
|giovanniend=82
|subsection=86
|subsectionend=89
|wallacepage=124
|wallaceend=134
|hackettpage=136
|hackettend=146
|slstart=1.1.1.1.A
|slend=1.1.1.3
|hotl=14|hotlstart=263|hotlend=283}}

== Accents ==
Being is ''<u>pure</u>'', indeterminate ''<u>immediacy</u>''.

Nothing is pure, ''<u>indeterminate</u>'' immediacy.

Map of Science of Logic

2023-11-28T13:15:07Z

Kcreasey:

Widget:SoLMap

2023-11-28T13:14:35Z

Kcreasey: Created page with "<iframe style="border:none" width="800" height="450" src="https://whimsical.com/embed/TmsM6oqDahcVK6HaprJrDB"></iframe>"

Map of Science of Logic

2023-11-28T13:06:11Z

Kcreasey: Created page with "https://whimsical.com/science-of-logic-TmsM6oqDahcVK6HaprJrDB"

https://whimsical.com/science-of-logic-TmsM6oqDahcVK6HaprJrDB

Main Page

2023-11-28T13:03:27Z

Kcreasey:

This is a work in progress of documenting as I follow along with the course of the Logic
* [[List of Triads]]
* [[Negation of the negation]]
* [[Thesis, Antithesis, Synthesis]]
* [[Self-similarities in path of logic]]
* [[Rough Patterns]]
* [[Syllogisms]]
* [[Map of Science of Logic]]

== Other sources ==
[https://speculativescience.github.io/en/#!index.md The Speculative Science] - Another attempt at a Wiki on the Science of Logic

[https://hegel.net/ Hegel.net] - A site for navigating the Logic; uses triangles as visual aids for the syllogistic nature of the logic. Does perchance miss some negation transitions in this process

List of Direct Triads

2023-11-28T13:02:33Z

Kcreasey:

Stability

2023-11-28T13:01:36Z

Kcreasey: Created page with "At this point, this seems to be the logical term to use for "vanishing of the vanishing". This seems somehow different than Nothing or Other when it comes to the kind of property it is. More akin self-relating"

At this point, this seems to be the logical term to use for "vanishing of the vanishing".
This seems somehow different than Nothing or Other when it comes to the kind of property it is. More akin self-relating

Becoming ⇒ Determinate Being

2023-11-28T12:59:47Z

Kcreasey:

{{Infobox triad
|thesislabel=Being
|thesis=Becoming
|antithesislabel=Negation
|antithesis=Stability
|sublationlabel=Sublation
|sublation=Determinate Being
|prev=Pure Being ⇒ Becoming
|next=Determinate Being ⇒ Something
|millerpage=
|millerend=
|giovannipage=
|giovanniend=
|subsection=
|subsectionend=
|wallacepage=
|wallaceend=
|hackettpage=
|hackettend=
|soldivision=being}}
== Accents ==

Template:Infobox triad

2023-11-28T12:58:31Z

Kcreasey:

{{Infobox
| title = {{PAGENAME}}
| headerstyle = background: #ddddff
| autoheaders = y

| header1 = Science of Logic
| data2 = {{SoL divisions|{{{soldivision|}}}}}

| header3 = Triad
| label4 = {{{thesislabel|}}}
| data4 = {{#if: {{{thesis|}}} | [[{{{thesis}}}]] }}
| label5 = A
| data5 = {{#if: {{{thesisa|}}} | [[{{{thesisa}}}]] }}
| label6 = B
| data6 = {{#if: {{{thesisb|}}} | [[{{{thesisb}}}]] }}
| label7 = {{{antithesislabel|}}}
| data7 = {{#if: {{{antithesis|}}} | [[{{{antithesis}}}]] }}
| label8 = A
| data8 = {{#if: {{{antithesisa|}}} | [[{{{antithesisa}}}]] }}
| label9 = B
| data9 = {{#if: {{{antithesisb|}}} | [[{{{antithesisb}}}]] }}
| label10 = {{{sublationlabel|}}}
| data10 = {{#if: {{{sublation|}}} | [[{{{sublation}}}]] }}
| label11 = A
| data11 = {{#if: {{{sublationa|}}} | [[{{{sublationa}}}]] }}
| label12 = B
| data12 = {{#if: {{{sublationb|}}} | [[{{{sublationb}}}]] }}
| header13 = Nav
| data14 = {{#if: {{{prev|}}} | [[{{{prev}}}]] | (Beginning) }}
| data15 = {{#if: {{{next|}}} | [[{{{next}}}]] | (End) }}
| header16 = Hegel
| data17 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Science of Logic | header2 = {{{slstart}}}-{{{slend}}} | label3 = Miller | data3 = p.{{{millerpage}}}-{{{millerend}}} | label4 = Giovanni | data4 = p.{{{giovannipage}}}-{{{giovanniend}}}}}
| data18 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Encyclopedia Logic I | header2 = §{{{subsection}}}-{{{subsectionend}}} | label3 = Wallace | data3 = p.{{{wallacepage}}}-{{{wallacepage}}} | label4 = Hackett | data4 = p.{{{hackettpage}}}-{{{hackettend}}}}}
|header19 = Houlgate
|label20: The Opening to the Logic
|data20: {{#if: {{{hotl|}}}| Chp. {{{hotl}}} [p.{{{hotlstart}}}-{{{hotlend}}} }}
|label21: On Being
|data21: {{#if: {{{honbv|}}}| Vol. {{{honbv}}}, Chp. {{{honbc}}} [p.{{{honbstart}}}-{{{honbend}}} }}
}}

Template:Infobox triad

2023-11-28T12:46:25Z

Kcreasey:

{{Infobox
| title = {{PAGENAME}}
| headerstyle = background: #ddddff
| autoheaders = y

| header1 = Science of Logic
| data2 = {{SoL divisions|{{{soldivision|}}}}}

| header3 = Triad
| label4 = {{{thesislabel|}}}
| data4 = {{#if: {{{thesis|}}} | [[{{{thesis}}}]] }}
| label5 = A
| data5 = {{#if: {{{thesisa|}}} | [[{{{thesisa}}}]] }}
| label6 = B
| data6 = {{#if: {{{thesisb|}}} | [[{{{thesisb}}}]] }}
| label7 = {{{antithesislabel|}}}
| data7 = {{#if: {{{antithesis|}}} | [[{{{antithesis}}}]] }}
| label8 = A
| data8 = {{#if: {{{antithesisa|}}} | [[{{{antithesisa}}}]] }}
| label9 = B
| data9 = {{#if: {{{antithesisb|}}} | [[{{{antithesisb}}}]] }}
| label10 = {{{sublationlabel|}}}
| data10 = [[{{{sublation|}}}]]
| label11 = A
| data11 = [[{{{sublationa|}}}]]
| label12 = B
| data12 = [[{{{sublationb|}}}]]
| header13 = Nav
| data14 = [[{{{prev|}}}]]
| data15 = [[{{{next|}}}]]
| header16 = Hegel
| data17 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Science of Logic | header2 = {{{slstart}}}-{{{slend}}} | label3 = Miller | data3 = p.{{{millerpage}}}-{{{millerend}}} | label4 = Giovanni | data4 = p.{{{giovannipage}}}-{{{giovanniend}}}}}
| data18 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Encyclopedia Logic I | header2 = §{{{subsection}}}-{{{subsectionend}}} | label3 = Wallace | data3 = p.{{{wallacepage}}}-{{{wallacepage}}} | label4 = Hackett | data4 = p.{{{hackettpage}}}-{{{hackettend}}}}}
|header19 = Houlgate
|label20: The Opening to the Logic
|data20: {{#if: {{{hotl|}}}| Chp. {{{hotl}}} [p.{{{hotlstart}}}-{{{hotlend}}} }}
|label21: On Being
|data21: {{#if: {{{honbv|}}}| Vol. {{{honbv}}}, Chp. {{{honbc}}} [p.{{{honbstart}}}-{{{honbend}}} }}
}}

Template:Infobox triad

2023-11-28T12:43:10Z

Kcreasey:

{{Infobox
| title = {{PAGENAME}}
| headerstyle = background: #ddddff
| autoheaders = y

| header1 = Science of Logic
| data2 = {{SoL divisions|{{{soldivision|}}}}}

| header3 = Triad
| label4 = {{{thesislabel|}}}
| data4 = [[{{{thesis|}}}]]
| label5 = A
| data5 = [[{{{thesisa|}}}]]
| label6 = B
| data6 = [[{{{thesisb|}}}]]
| label7 = {{{antithesislabel|}}}
| data7 = [[{{{antithesis|}}}]]
| label8 = A
| data8 = [[{{{antithesisa|}}}]]
| label9 = B
| data9 = [[{{{antithesisb|}}}]]
| label10 = {{{sublationlabel|}}}
| data10 = [[{{{sublation|}}}]]
| label11 = A
| data11 = [[{{{sublationa|}}}]]
| label12 = B
| data12 = [[{{{sublationb|}}}]]
| header13 = Nav
| data14 = [[{{{prev|}}}]]
| data15 = [[{{{next|}}}]]
| header16 = Hegel
| data17 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Science of Logic | header2 = {{{slstart}}}-{{{slend}}} | label3 = Miller | data3 = p.{{{millerpage}}}-{{{millerend}}} | label4 = Giovanni | data4 = p.{{{giovannipage}}}-{{{giovanniend}}}}}
| data18 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Encyclopedia Logic I | header2 = §{{{subsection}}}-{{{subsectionend}}} | label3 = Wallace | data3 = p.{{{wallacepage}}}-{{{wallacepage}}} | label4 = Hackett | data4 = p.{{{hackettpage}}}-{{{hackettend}}}}}
|header19 = Houlgate
|label20: The Opening to the Logic
|data20: {{#if: {{{hotl|}}}| Chp. {{{hotl}}} [p.{{{hotlstart}}}-{{{hotlend}}} }}
|label21: On Being
|data21: {{#if: {{{honbv|}}}| Vol. {{{honbv}}}, Chp. {{{honbc}}} [p.{{{honbstart}}}-{{{honbend}}} }}
}}

Template:Infobox triad

2023-11-27T23:47:52Z

Kcreasey:

{{Infobox
| title = {{PAGENAME}}
| headerstyle = background: #ddddff
| autoheaders = y

| header1 = Science of Logic
| data2 = {{SoL divisions|{{{soldivision|}}}}}

| header3 = Triad
| label4 = {{{thesislabel|}}}
| data4 = {{{thesis|}}}
| label5 = A
| data5 = {{{thesisa|}}}
| label6 = B
| data6 = {{{thesisb|}}}
| label7 = {{{antithesislabel|}}}
| data7 = {{{antithesis|}}}
| label8 = A
| data8 = {{{antithesisa|}}}
| label9 = B
| data9 = {{{antithesisb|}}}
| label10 = {{{sublationlabel|}}}
| data10 = {{{sublation|}}}
| label11 = A
| data11 = {{{sublationa|}}}
| label12 = B
| data12 = {{{sublationb|}}}
| header13 = Nav
| data14 = {{{prev|}}}
| data15 = {{{next|}}}
| header16 = Hegel
| data17 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Science of Logic | header2 = {{{slstart}}}-{{{slend}}} | label3 = Miller | data3 = p.{{{millerpage}}}-{{{millerend}}} | label4 = Giovanni | data4 = p.{{{giovannipage}}}-{{{giovanniend}}}}}
| data18 = {{Infobox | subbox = yes | headerstyle = background: #CDCDFE| header1 = Encyclopedia Logic I | header2 = §{{{subsection}}}-{{{subsectionend}}} | label3 = Wallace | data3 = p.{{{wallacepage}}}-{{{wallacepage}}} | label4 = Hackett | data4 = p.{{{hackettpage}}}-{{{hackettend}}}}}
|header19 = Houlgate
|label20: The Opening to the Logic
|data20: {{#if: {{{hotl|}}}| Chp. {{{hotl}}} [p.{{{hotlstart}}}-{{{hotlend}}} }}
|label21: On Being
|data21: {{#if: {{{honbv|}}}| Vol. {{{honbv}}}, Chp. {{{honbc}}} [p.{{{honbstart}}}-{{{honbend}}} }}
}}

Template:Infobox triad

2023-11-27T23:43:12Z

Kcreasey: Kcreasey moved page Template:Infobox triad2 to Template:Infobox triad without leaving a redirect: Moving template into place

Pure Being ⇒ Becoming

2023-11-27T23:42:33Z

Kcreasey:

{{Infobox triad
|soldivision=being
|thesislabel=Being
|antithesislabel=Negation
|sublationlabel=Sublation
|thesis=Pure Being
|antithesis=Pure Nothing
|sublation=Becoming
|sublationa=Coming-To-Be
|sublationb=Ceasing-To-Be
|next=Becoming ⇒ Determinate Being
|millerpage=82
|millerend=108
|giovannipage=59
|giovanniend=82
|subsection=86
|subsectionend=89
|wallacepage=124
|wallaceend=134
|hackettpage=136
|hackettend=146
|slstart=1.1.1.1.A
|slend=1.1.1.3
}}

== Accents ==
Being is ''<u>pure</u>'', indeterminate ''<u>immediacy</u>''.

Nothing is pure, ''<u>indeterminate</u>'' immediacy.

Template:Infobox triad

2023-11-27T23:41:57Z

Kcreasey:

Pure Being ⇒ Becoming

2023-11-27T23:35:32Z

Kcreasey:

{{Infobox triad
|soldivision=being
|being=Pure Being
|negation=Pure Nothing
|sublation=Becoming
|sublation_a=Ceasing-To-Be
|sublation_b=Coming-To-Be
|next=Becoming ⇒ Determinate Being
|millerpage=82
|millerend=108
|giovannipage=59
|giovanniend=82
|subsection=86
|subsectionend=89
|wallacepage=124
|wallaceend=134
|hackettpage=136
|hackettend=146
|slstart=1.1.1.1.A
|slend=1.1.1.3
}}
{{Infobox triad2
|soldivision=being
|thesislabel=Being
|antithesislabel=Negation
|sublationlabel=Sublation
|thesis=Pure Being
|antithesis=Pure Nothing
|sublation=Becoming
|sublationa=Coming-To-Be
|sublationb=Ceasing-To-Be
|next=Becoming ⇒ Determinate Being
|millerpage=82
|millerend=108
|giovannipage=59
|giovanniend=82
|subsection=86
|subsectionend=89
|wallacepage=124
|wallaceend=134
|hackettpage=136
|hackettend=146
|slstart=1.1.1.1.A
|slend=1.1.1.3
}}

== Accents ==
Being is ''<u>pure</u>'', indeterminate ''<u>immediacy</u>''.

Nothing is pure, ''<u>indeterminate</u>'' immediacy.

Template:Infobox triad

2023-11-27T23:35:01Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:33:37Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:27:49Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:25:14Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:22:07Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:20:26Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:20:07Z

Kcreasey:

Template:Plainlist

2023-11-27T23:19:49Z

Kcreasey: Created page with "<templatestyles src="Plainlist/styles.css"/><div class="plainlist {{{class|}}}" {{#if:{{{style|}}}{{{indent|}}}|style="{{#if:{{{indent|}}}|margin-left: {{#expr:{{{indent}}}*1.6}}em;}} {{{style|}}}"}}>{{#if:{{{1|}}}| {{{1}}} </div>}}<noinclude></div> {{documentation}} </noinclude>"

<templatestyles src="Plainlist/styles.css"/><div class="plainlist {{{class|}}}" {{#if:{{{style|}}}{{{indent|}}}|style="{{#if:{{{indent|}}}|margin-left: {{#expr:{{{indent}}}*1.6}}em;}} {{{style|}}}"}}>{{#if:{{{1|}}}|
{{{1}}}
</div>}}<noinclude></div>
{{documentation}}
</noinclude>

Template:Infobox triad

2023-11-27T23:18:55Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:17:50Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:17:05Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:16:35Z

Kcreasey:

Template:Infobox triad

2023-11-27T23:16:13Z

Kcreasey:

Module:Arguments

2023-11-27T23:15:33Z

Kcreasey: Created page with "-- This module provides easy processing of arguments passed to Scribunto from -- #invoke. It is intended for use by other Lua modules, and should not be -- called from #invoke directly. local libraryUtil = require('libraryUtil') local checkType = libraryUtil.checkType local arguments = {} -- Generate four different tidyVal functions, so that we don't have to check the -- options every time we call it. local function tidyValDefault(key, val) if type(val) == 'string'..."

-- This module provides easy processing of arguments passed to Scribunto from
-- #invoke. It is intended for use by other Lua modules, and should not be
-- called from #invoke directly.

local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType

local arguments = {}

-- Generate four different tidyVal functions, so that we don't have to check the
-- options every time we call it.

local function tidyValDefault(key, val)
if type(val) == 'string' then
val = val:match('^%s*(.-)%s*$')
if val == '' then
return nil
else
return val
end
else
return val
end
end

local function tidyValTrimOnly(key, val)
if type(val) == 'string' then
return val:match('^%s*(.-)%s*$')
else
return val
end
end

local function tidyValRemoveBlanksOnly(key, val)
if type(val) == 'string' then
if val:find('%S') then
return val
else
return nil
end
else
return val
end
end

local function tidyValNoChange(key, val)
return val
end

local function matchesTitle(given, title)
local tp = type( given )
return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
end

local translate_mt = { __index = function(t, k) return k end }

function arguments.getArgs(frame, options)
checkType('getArgs', 1, frame, 'table', true)
checkType('getArgs', 2, options, 'table', true)
frame = frame or {}
options = options or {}

--[[
-- Set up argument translation.
--]]
options.translate = options.translate or {}
if getmetatable(options.translate) == nil then
setmetatable(options.translate, translate_mt)
end
if options.backtranslate == nil then
options.backtranslate = {}
for k,v in pairs(options.translate) do
options.backtranslate[v] = k
end
end
if options.backtranslate and getmetatable(options.backtranslate) == nil then
setmetatable(options.backtranslate, {
__index = function(t, k)
if options.translate[k] ~= k then
return nil
else
return k
end
end
})
end

--[[
-- Get the argument tables. If we were passed a valid frame object, get the
-- frame arguments (fargs) and the parent frame arguments (pargs), depending
-- on the options set and on the parent frame's availability. If we weren't
-- passed a valid frame object, we are being called from another Lua module
-- or from the debug console, so assume that we were passed a table of args
-- directly, and assign it to a new variable (luaArgs).
--]]
local fargs, pargs, luaArgs
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
if options.wrappers then
--[[
-- The wrappers option makes Module:Arguments look up arguments in
-- either the frame argument table or the parent argument table, but
-- not both. This means that users can use either the #invoke syntax
-- or a wrapper template without the loss of performance associated
-- with looking arguments up in both the frame and the parent frame.
-- Module:Arguments will look up arguments in the parent frame
-- if it finds the parent frame's title in options.wrapper;
-- otherwise it will look up arguments in the frame object passed
-- to getArgs.
--]]
local parent = frame:getParent()
if not parent then
fargs = frame.args
else
local title = parent:getTitle():gsub('/sandbox$', '')
local found = false
if matchesTitle(options.wrappers, title) then
found = true
elseif type(options.wrappers) == 'table' then
for _,v in pairs(options.wrappers) do
if matchesTitle(v, title) then
found = true
break
end
end
end

-- We test for false specifically here so that nil (the default) acts like true.
if found or options.frameOnly == false then
pargs = parent.args
end
if not found or options.parentOnly == false then
fargs = frame.args
end
end
else
-- options.wrapper isn't set, so check the other options.
if not options.parentOnly then
fargs = frame.args
end
if not options.frameOnly then
local parent = frame:getParent()
pargs = parent and parent.args or nil
end
end
if options.parentFirst then
fargs, pargs = pargs, fargs
end
else
luaArgs = frame
end

-- Set the order of precedence of the argument tables. If the variables are
-- nil, nothing will be added to the table, which is how we avoid clashes
-- between the frame/parent args and the Lua args.
local argTables = {fargs}
argTables[#argTables + 1] = pargs
argTables[#argTables + 1] = luaArgs

--[[
-- Generate the tidyVal function. If it has been specified by the user, we
-- use that; if not, we choose one of four functions depending on the
-- options chosen. This is so that we don't have to call the options table
-- every time the function is called.
--]]
local tidyVal = options.valueFunc
if tidyVal then
if type(tidyVal) ~= 'function' then
error(
"bad value assigned to option 'valueFunc'"
.. '(function expected, got '
.. type(tidyVal)
.. ')',
2
)
end
elseif options.trim ~= false then
if options.removeBlanks ~= false then
tidyVal = tidyValDefault
else
tidyVal = tidyValTrimOnly
end
else
if options.removeBlanks ~= false then
tidyVal = tidyValRemoveBlanksOnly
else
tidyVal = tidyValNoChange
end
end

--[[
-- Set up the args, metaArgs and nilArgs tables. args will be the one
-- accessed from functions, and metaArgs will hold the actual arguments. Nil
-- arguments are memoized in nilArgs, and the metatable connects all of them
-- together.
--]]
local args, metaArgs, nilArgs, metatable = {}, {}, {}, {}
setmetatable(args, metatable)

local function mergeArgs(tables)
--[[
-- Accepts multiple tables as input and merges their keys and values
-- into one table. If a value is already present it is not overwritten;
-- tables listed earlier have precedence. We are also memoizing nil
-- values, which can be overwritten if they are 's' (soft).
--]]
for _, t in ipairs(tables) do
for key, val in pairs(t) do
if metaArgs[key] == nil and nilArgs[key] ~= 'h' then
local tidiedVal = tidyVal(key, val)
if tidiedVal == nil then
nilArgs[key] = 's'
else
metaArgs[key] = tidiedVal
end
end
end
end
end

--[[
-- Define metatable behaviour. Arguments are memoized in the metaArgs table,
-- and are only fetched from the argument tables once. Fetching arguments
-- from the argument tables is the most resource-intensive step in this
-- module, so we try and avoid it where possible. For this reason, nil
-- arguments are also memoized, in the nilArgs table. Also, we keep a record
-- in the metatable of when pairs and ipairs have been called, so we do not
-- run pairs and ipairs on the argument tables more than once. We also do
-- not run ipairs on fargs and pargs if pairs has already been run, as all
-- the arguments will already have been copied over.
--]]

metatable.__index = function (t, key)
--[[
-- Fetches an argument when the args table is indexed. First we check
-- to see if the value is memoized, and if not we try and fetch it from
-- the argument tables. When we check memoization, we need to check
-- metaArgs before nilArgs, as both can be non-nil at the same time.
-- If the argument is not present in metaArgs, we also check whether
-- pairs has been run yet. If pairs has already been run, we return nil.
-- This is because all the arguments will have already been copied into
-- metaArgs by the mergeArgs function, meaning that any other arguments
-- must be nil.
--]]
if type(key) == 'string' then
key = options.translate[key]
end
local val = metaArgs[key]
if val ~= nil then
return val
elseif metatable.donePairs or nilArgs[key] then
return nil
end
for _, argTable in ipairs(argTables) do
local argTableVal = tidyVal(key, argTable[key])
if argTableVal ~= nil then
metaArgs[key] = argTableVal
return argTableVal
end
end
nilArgs[key] = 'h'
return nil
end

metatable.__newindex = function (t, key, val)
-- This function is called when a module tries to add a new value to the
-- args table, or tries to change an existing value.
if type(key) == 'string' then
key = options.translate[key]
end
if options.readOnly then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; the table is read-only',
2
)
elseif options.noOverwrite and args[key] ~= nil then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; overwriting existing arguments is not permitted',
2
)
elseif val == nil then
--[[
-- If the argument is to be overwritten with nil, we need to erase
-- the value in metaArgs, so that __index, __pairs and __ipairs do
-- not use a previous existing value, if present; and we also need
-- to memoize the nil in nilArgs, so that the value isn't looked
-- up in the argument tables if it is accessed again.
--]]
metaArgs[key] = nil
nilArgs[key] = 'h'
else
metaArgs[key] = val
end
end

local function translatenext(invariant)
local k, v = next(invariant.t, invariant.k)
invariant.k = k
if k == nil then
return nil
elseif type(k) ~= 'string' or not options.backtranslate then
return k, v
else
local backtranslate = options.backtranslate[k]
if backtranslate == nil then
-- Skip this one. This is a tail call, so this won't cause stack overflow
return translatenext(invariant)
else
return backtranslate, v
end
end
end

metatable.__pairs = function ()
-- Called when pairs is run on the args table.
if not metatable.donePairs then
mergeArgs(argTables)
metatable.donePairs = true
end
return translatenext, { t = metaArgs }
end

local function inext(t, i)
-- This uses our __index metamethod
local v = t[i + 1]
if v ~= nil then
return i + 1, v
end
end

metatable.__ipairs = function (t)
-- Called when ipairs is run on the args table.
return inext, t, 0
end

return args
end

return arguments

Module:TableTools

2023-11-27T23:14:52Z

Kcreasey: Created page with "------------------------------------------------------------------------------------ -- TableTools -- -- -- -- This module includes a number of functions for dealing with Lua tables. -- -- It is a meta-module, meant to be called from other Lua modules, and should not -- -- be called directly from #invoke...."

------------------------------------------------------------------------------------
-- TableTools --
-- --
-- This module includes a number of functions for dealing with Lua tables. --
-- It is a meta-module, meant to be called from other Lua modules, and should not --
-- be called directly from #invoke. --
------------------------------------------------------------------------------------

local libraryUtil = require('libraryUtil')

local p = {}

-- Define often-used variables and functions.
local floor = math.floor
local infinity = math.huge
local checkType = libraryUtil.checkType
local checkTypeMulti = libraryUtil.checkTypeMulti

------------------------------------------------------------------------------------
-- isPositiveInteger
--
-- This function returns true if the given value is a positive integer, and false
-- if not. Although it doesn't operate on tables, it is included here as it is
-- useful for determining whether a given table key is in the array part or the
-- hash part of a table.
------------------------------------------------------------------------------------
function p.isPositiveInteger(v)
return type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity
end

------------------------------------------------------------------------------------
-- isNan
--
-- This function returns true if the given number is a NaN value, and false if
-- not. Although it doesn't operate on tables, it is included here as it is useful
-- for determining whether a value can be a valid table key. Lua will generate an
-- error if a NaN is used as a table key.
------------------------------------------------------------------------------------
function p.isNan(v)
return type(v) == 'number' and v ~= v
end

------------------------------------------------------------------------------------
-- shallowClone
--
-- This returns a clone of a table. The value returned is a new table, but all
-- subtables and functions are shared. Metamethods are respected, but the returned
-- table will have no metatable of its own.
------------------------------------------------------------------------------------
function p.shallowClone(t)
checkType('shallowClone', 1, t, 'table')
local ret = {}
for k, v in pairs(t) do
ret[k] = v
end
return ret
end

------------------------------------------------------------------------------------
-- removeDuplicates
--
-- This removes duplicate values from an array. Non-positive-integer keys are
-- ignored. The earliest value is kept, and all subsequent duplicate values are
-- removed, but otherwise the array order is unchanged.
------------------------------------------------------------------------------------
function p.removeDuplicates(arr)
checkType('removeDuplicates', 1, arr, 'table')
local isNan = p.isNan
local ret, exists = {}, {}
for _, v in ipairs(arr) do
if isNan(v) then
-- NaNs can't be table keys, and they are also unique, so we don't need to check existence.
ret[#ret + 1] = v
else
if not exists[v] then
ret[#ret + 1] = v
exists[v] = true
end
end
end
return ret
end

------------------------------------------------------------------------------------
-- numKeys
--
-- This takes a table and returns an array containing the numbers of any numerical
-- keys that have non-nil values, sorted in numerical order.
------------------------------------------------------------------------------------
function p.numKeys(t)
checkType('numKeys', 1, t, 'table')
local isPositiveInteger = p.isPositiveInteger
local nums = {}
for k in pairs(t) do
if isPositiveInteger(k) then
nums[#nums + 1] = k
end
end
table.sort(nums)
return nums
end

------------------------------------------------------------------------------------
-- affixNums
--
-- This takes a table and returns an array containing the numbers of keys with the
-- specified prefix and suffix. For example, for the table
-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will return
-- {1, 3, 6}.
------------------------------------------------------------------------------------
function p.affixNums(t, prefix, suffix)
checkType('affixNums', 1, t, 'table')
checkType('affixNums', 2, prefix, 'string', true)
checkType('affixNums', 3, suffix, 'string', true)

local function cleanPattern(s)
-- Cleans a pattern so that the magic characters ()%.[]*+-?^$ are interpreted literally.
return s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1')
end

prefix = prefix or ''
suffix = suffix or ''
prefix = cleanPattern(prefix)
suffix = cleanPattern(suffix)
local pattern = '^' .. prefix .. '([1-9]%d*)' .. suffix .. '$'

local nums = {}
for k in pairs(t) do
if type(k) == 'string' then
local num = mw.ustring.match(k, pattern)
if num then
nums[#nums + 1] = tonumber(num)
end
end
end
table.sort(nums)
return nums
end

------------------------------------------------------------------------------------
-- numData
--
-- Given a table with keys like {"foo1", "bar1", "foo2", "baz2"}, returns a table
-- of subtables in the format
-- {[1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'}}.
-- Keys that don't end with an integer are stored in a subtable named "other". The
-- compress option compresses the table so that it can be iterated over with
-- ipairs.
------------------------------------------------------------------------------------
function p.numData(t, compress)
checkType('numData', 1, t, 'table')
checkType('numData', 2, compress, 'boolean', true)
local ret = {}
for k, v in pairs(t) do
local prefix, num = mw.ustring.match(tostring(k), '^([^0-9]*)([1-9][0-9]*)$')
if num then
num = tonumber(num)
local subtable = ret[num] or {}
if prefix == '' then
-- Positional parameters match the blank string; put them at the start of the subtable instead.
prefix = 1
end
subtable[prefix] = v
ret[num] = subtable
else
local subtable = ret.other or {}
subtable[k] = v
ret.other = subtable
end
end
if compress then
local other = ret.other
ret = p.compressSparseArray(ret)
ret.other = other
end
return ret
end

------------------------------------------------------------------------------------
-- compressSparseArray
--
-- This takes an array with one or more nil values, and removes the nil values
-- while preserving the order, so that the array can be safely traversed with
-- ipairs.
------------------------------------------------------------------------------------
function p.compressSparseArray(t)
checkType('compressSparseArray', 1, t, 'table')
local ret = {}
local nums = p.numKeys(t)
for _, num in ipairs(nums) do
ret[#ret + 1] = t[num]
end
return ret
end

------------------------------------------------------------------------------------
-- sparseIpairs
--
-- This is an iterator for sparse arrays. It can be used like ipairs, but can
-- handle nil values.
------------------------------------------------------------------------------------
function p.sparseIpairs(t)
checkType('sparseIpairs', 1, t, 'table')
local nums = p.numKeys(t)
local i = 0
local lim = #nums
return function ()
i = i + 1
if i <= lim then
local key = nums[i]
return key, t[key]
else
return nil, nil
end
end
end

------------------------------------------------------------------------------------
-- size
--
-- This returns the size of a key/value pair table. It will also work on arrays,
-- but for arrays it is more efficient to use the # operator.
------------------------------------------------------------------------------------
function p.size(t)
checkType('size', 1, t, 'table')
local i = 0
for _ in pairs(t) do
i = i + 1
end
return i
end

local function defaultKeySort(item1, item2)
-- "number" < "string", so numbers will be sorted before strings.
local type1, type2 = type(item1), type(item2)
if type1 ~= type2 then
return type1 < type2
elseif type1 == 'table' or type1 == 'boolean' or type1 == 'function' then
return tostring(item1) < tostring(item2)
else
return item1 < item2
end
end
------------------------------------------------------------------------------------
-- keysToList
--
-- Returns an array of the keys in a table, sorted using either a default
-- comparison function or a custom keySort function.
------------------------------------------------------------------------------------
function p.keysToList(t, keySort, checked)
if not checked then
checkType('keysToList', 1, t, 'table')
checkTypeMulti('keysToList', 2, keySort, {'function', 'boolean', 'nil'})
end

local arr = {}
local index = 1
for k in pairs(t) do
arr[index] = k
index = index + 1
end

if keySort ~= false then
keySort = type(keySort) == 'function' and keySort or defaultKeySort
table.sort(arr, keySort)
end

return arr
end

------------------------------------------------------------------------------------
-- sortedPairs
--
-- Iterates through a table, with the keys sorted using the keysToList function.
-- If there are only numerical keys, sparseIpairs is probably more efficient.
------------------------------------------------------------------------------------
function p.sortedPairs(t, keySort)
checkType('sortedPairs', 1, t, 'table')
checkType('sortedPairs', 2, keySort, 'function', true)

local arr = p.keysToList(t, keySort, true)

local i = 0
return function ()
i = i + 1
local key = arr[i]
if key ~= nil then
return key, t[key]
else
return nil, nil
end
end
end

------------------------------------------------------------------------------------
-- isArray
--
-- Returns true if the given value is a table and all keys are consecutive
-- integers starting at 1.
------------------------------------------------------------------------------------
function p.isArray(v)
if type(v) ~= 'table' then
return false
end
local i = 0
for _ in pairs(v) do
i = i + 1
if v[i] == nil then
return false
end
end
return true
end

------------------------------------------------------------------------------------
-- isArrayLike
--
-- Returns true if the given value is iterable and all keys are consecutive
-- integers starting at 1.
------------------------------------------------------------------------------------
function p.isArrayLike(v)
if not pcall(pairs, v) then
return false
end
local i = 0
for _ in pairs(v) do
i = i + 1
if v[i] == nil then
return false
end
end
return true
end

------------------------------------------------------------------------------------
-- invert
--
-- Transposes the keys and values in an array. For example, {"a", "b", "c"} ->
-- {a = 1, b = 2, c = 3}. Duplicates are not supported (result values refer to
-- the index of the last duplicate) and NaN values are ignored.
------------------------------------------------------------------------------------
function p.invert(arr)
checkType("invert", 1, arr, "table")
local isNan = p.isNan
local map = {}
for i, v in ipairs(arr) do
if not isNan(v) then
map[v] = i
end
end

return map
end

------------------------------------------------------------------------------------
-- listToSet
--
-- Creates a set from the array part of the table. Indexing the set by any of the
-- values of the array returns true. For example, {"a", "b", "c"} ->
-- {a = true, b = true, c = true}. NaN values are ignored as Lua considers them
-- never equal to any value (including other NaNs or even themselves).
------------------------------------------------------------------------------------
function p.listToSet(arr)
checkType("listToSet", 1, arr, "table")
local isNan = p.isNan
local set = {}
for _, v in ipairs(arr) do
if not isNan(v) then
set[v] = true
end
end

return set
end

------------------------------------------------------------------------------------
-- deepCopy
--
-- Recursive deep copy function. Preserves identities of subtables.
------------------------------------------------------------------------------------
local function _deepCopy(orig, includeMetatable, already_seen)
-- Stores copies of tables indexed by the original table.
already_seen = already_seen or {}

local copy = already_seen[orig]
if copy ~= nil then
return copy
end

if type(orig) == 'table' then
copy = {}
for orig_key, orig_value in pairs(orig) do
copy[_deepCopy(orig_key, includeMetatable, already_seen)] = _deepCopy(orig_value, includeMetatable, already_seen)
end
already_seen[orig] = copy

if includeMetatable then
local mt = getmetatable(orig)
if mt ~= nil then
local mt_copy = _deepCopy(mt, includeMetatable, already_seen)
setmetatable(copy, mt_copy)
already_seen[mt] = mt_copy
end
end
else -- number, string, boolean, etc
copy = orig
end
return copy
end

function p.deepCopy(orig, noMetatable, already_seen)
checkType("deepCopy", 3, already_seen, "table", true)
return _deepCopy(orig, not noMetatable, already_seen)
end

------------------------------------------------------------------------------------
-- sparseConcat
--
-- Concatenates all values in the table that are indexed by a number, in order.
-- sparseConcat{a, nil, c, d} => "acd"
-- sparseConcat{nil, b, c, d} => "bcd"
------------------------------------------------------------------------------------
function p.sparseConcat(t, sep, i, j)
local arr = {}

local arr_i = 0
for _, v in p.sparseIpairs(t) do
arr_i = arr_i + 1
arr[arr_i] = v
end

return table.concat(arr, sep, i, j)
end

------------------------------------------------------------------------------------
-- length
--
-- Finds the length of an array, or of a quasi-array with keys such as "data1",
-- "data2", etc., using an exponential search algorithm. It is similar to the
-- operator #, but may return a different value when there are gaps in the array
-- portion of the table. Intended to be used on data loaded with mw.loadData. For
-- other tables, use #.
-- Note: #frame.args in frame object always be set to 0, regardless of the number
-- of unnamed template parameters, so use this function for frame.args.
------------------------------------------------------------------------------------
function p.length(t, prefix)
-- requiring module inline so that [[Module:Exponential search]] which is
-- only needed by this one function doesn't get millions of transclusions
local expSearch = require("Module:Exponential search")
checkType('length', 1, t, 'table')
checkType('length', 2, prefix, 'string', true)
return expSearch(function (i)
local key
if prefix then
key = prefix .. tostring(i)
else
key = i
end
return t[key] ~= nil
end) or 0
end

------------------------------------------------------------------------------------
-- inArray
--
-- Returns true if valueToFind is a member of the array, and false otherwise.
------------------------------------------------------------------------------------
function p.inArray(arr, valueToFind)
checkType("inArray", 1, arr, "table")
-- if valueToFind is nil, error?

for _, v in ipairs(arr) do
if v == valueToFind then
return true
end
end
return false
end

return p

Module:List

2023-11-27T23:14:10Z

Kcreasey: Created page with "local libUtil = require('libraryUtil') local checkType = libUtil.checkType local mTableTools = require('Module:TableTools') local p = {} local listTypes = { ['bulleted'] = true, ['unbulleted'] = true, ['horizontal'] = true, ['ordered'] = true, ['horizontal_ordered'] = true } function p.makeListData(listType, args) -- Constructs a data table to be passed to p.renderList. local data = {} -- Classes and TemplateStyles data.classes = {} data.templatestyles = ''..."

local libUtil = require('libraryUtil')
local checkType = libUtil.checkType
local mTableTools = require('Module:TableTools')

local p = {}

local listTypes = {
['bulleted'] = true,
['unbulleted'] = true,
['horizontal'] = true,
['ordered'] = true,
['horizontal_ordered'] = true
}

function p.makeListData(listType, args)
-- Constructs a data table to be passed to p.renderList.
local data = {}

-- Classes and TemplateStyles
data.classes = {}
data.templatestyles = ''
if listType == 'horizontal' or listType == 'horizontal_ordered' then
table.insert(data.classes, 'hlist')
data.templatestyles = mw.getCurrentFrame():extensionTag{
name = 'templatestyles', args = { src = 'Hlist/styles.css' }
}
elseif listType == 'unbulleted' then
table.insert(data.classes, 'plainlist')
data.templatestyles = mw.getCurrentFrame():extensionTag{
name = 'templatestyles', args = { src = 'Plainlist/styles.css' }
}
end
table.insert(data.classes, args.class)

-- Main div style
data.style = args.style

-- Indent for horizontal lists
if listType == 'horizontal' or listType == 'horizontal_ordered' then
local indent = tonumber(args.indent)
indent = indent and indent * 1.6 or 0
if indent > 0 then
data.marginLeft = indent .. 'em'
end
end

-- List style types for ordered lists
-- This could be "1, 2, 3", "a, b, c", or a number of others. The list style
-- type is either set by the "type" attribute or the "list-style-type" CSS
-- property.
if listType == 'ordered' or listType == 'horizontal_ordered' then
data.listStyleType = args.list_style_type or args['list-style-type']
data.type = args['type']

-- Detect invalid type attributes and attempt to convert them to
-- list-style-type CSS properties.
if data.type
and not data.listStyleType
and not tostring(data.type):find('^%s*[1AaIi]%s*$')
then
data.listStyleType = data.type
data.type = nil
end
end

-- List tag type
if listType == 'ordered' or listType == 'horizontal_ordered' then
data.listTag = 'ol'
else
data.listTag = 'ul'
end

-- Start number for ordered lists
data.start = args.start
if listType == 'horizontal_ordered' then
-- Apply fix to get start numbers working with horizontal ordered lists.
local startNum = tonumber(data.start)
if startNum then
data.counterReset = 'listitem ' .. tostring(startNum - 1)
end
end

-- List style
-- ul_style and ol_style are included for backwards compatibility. No
-- distinction is made for ordered or unordered lists.
data.listStyle = args.list_style

-- List items
-- li_style is included for backwards compatibility. item_style was included
-- to be easier to understand for non-coders.
data.itemStyle = args.item_style or args.li_style
data.items = {}
for _, num in ipairs(mTableTools.numKeys(args)) do
local item = {}
item.content = args[num]
item.style = args['item' .. tostring(num) .. '_style']
or args['item_style' .. tostring(num)]
item.value = args['item' .. tostring(num) .. '_value']
or args['item_value' .. tostring(num)]
table.insert(data.items, item)
end

return data
end

function p.renderList(data)
-- Renders the list HTML.

-- Return the blank string if there are no list items.
if type(data.items) ~= 'table' or #data.items < 1 then
return ''
end

-- Render the main div tag.
local root = mw.html.create('div')
for _, class in ipairs(data.classes or {}) do
root:addClass(class)
end
root:css{['margin-left'] = data.marginLeft}
if data.style then
root:cssText(data.style)
end

-- Render the list tag.
local list = root:tag(data.listTag or 'ul')
list
:attr{start = data.start, type = data.type}
:css{
['counter-reset'] = data.counterReset,
['list-style-type'] = data.listStyleType
}
if data.listStyle then
list:cssText(data.listStyle)
end

-- Render the list items
for _, t in ipairs(data.items or {}) do
local item = list:tag('li')
if data.itemStyle then
item:cssText(data.itemStyle)
end
if t.style then
item:cssText(t.style)
end
item
:attr{value = t.value}
:wikitext(t.content)
end

return data.templatestyles .. tostring(root)
end

function p.renderTrackingCategories(args)
local isDeprecated = false -- Tracks deprecated parameters.
for k, v in pairs(args) do
k = tostring(k)
if k:find('^item_style%d+$') or k:find('^item_value%d+$') then
isDeprecated = true
break
end
end
local ret = ''
if isDeprecated then
ret = ret .. '[[Category:List templates with deprecated parameters]]'
end
return ret
end

function p.makeList(listType, args)
if not listType or not listTypes[listType] then
error(string.format(
"bad argument #1 to 'makeList' ('%s' is not a valid list type)",
tostring(listType)
), 2)
end
checkType('makeList', 2, args, 'table')
local data = p.makeListData(listType, args)
local list = p.renderList(data)
local trackingCategories = p.renderTrackingCategories(args)
return list .. trackingCategories
end

for listType in pairs(listTypes) do
p[listType] = function (frame)
local mArguments = require('Module:Arguments')
local origArgs = mArguments.getArgs(frame, {
valueFunc = function (key, value)
if not value or not mw.ustring.find(value, '%S') then return nil end
if mw.ustring.find(value, '^%s*[%*#;:]') then
return value
else
return value:match('^%s*(.-)%s*$')
end
return nil
end
})
-- Copy all the arguments to a new table, for faster indexing.
local args = {}
for k, v in pairs(origArgs) do
args[k] = v
end
return p.makeList(listType, args)
end
end

return p