Módulo:Mooc/Data/Item

Item

Item é uma classe básica no MOOC. Ela serve como modelo de armazenamento de dados para um item MOOC e como um analisador. portanto, ela não possui apenas funçÕes get e set para ter acesso a certos dados do template, mas também tem métodos para interpretar linhas do MOOCIndex e preenchê-lo com o conteúdo extraído. A infância item será passado ao template que acessa o modelo que renderiza os dados que a infância item contém.

constructor (init)

Cria um novo contêiner preenchido com os espaços do cabeçalho passado.

Parâmetros:

• [Mooc/Data/Item.Header] header: cabeçalho dos dados do item que será guardado

getParams

Permite acesso aos parâmetros extraídos do índex.

Retorna: Tabela que contém os valores dos parâmetros acessíveis através do nome.

load

Carrega os campos do item nas linhas do índice MOOC, sem separação. Como o item já foi criado, o cabeçalho não está incluído nessas linhas e já foi atribuído ao item. A implementação padrão extrai todos os parâmetros, mas ignora itens relacionados (filhos).

Parâmetros:

• [Table:String] content: linhas do MOOCIndex que representam o item

extractParams

Extrai todos os parâmetros das linhas do MOOCIdex para o item atual, ignorando as relacionadas (filhas). Este método é usado uma vez pelo analisador. Templates usam getParams para obter a tabela.

Parâmetros:

• [Table:String->String] content: linhas do MOOCIndex que representam o item

Retorna: Tabela que contém os valores dos parâmetros acessíveis através do nome.

TYPE

Cada classe de modelo possui um campo definido para o tipo de item que a classe representa. O campo pode ser usado para registrar um manipulador de tipos para esta classe.

Type

A classe de tipo de item é responsável por vincular as chamadas da página wiki para o analisador e as implementações de modelos. Isso é feito usando identificadores, uma vez que Strings são os únicos argumentos de invocação de script possíveis.

constructor (init)

Cria um novo tipo com o identificador específico.

Parâmetros:

• [String] identifier: identifica o novo tipo de item

isType

Verifica se este tipo corresponde ao identificador fornecido por um usuário.

Parâmetros:

• [String] typeIdentifier: identifica o tipo que o usuário deseja

Retorna: Verdadeiro se o tipo está de acordo com o identificado ou falso, em caso contrário.

Header

O cabeçalho do item é um contêiner simples contendo dados para identificar um item dentro do MOOC.

constructor (init)

Cria um novo cabeçalho de item.

Parâmetros:

• [String] name: nome do item
• [String] typeIdentifier: identificador que determina o tipo de item
• [String] path: caminho do item dentro do MOOC

getLevel

Obtém o nível do item dentro do MOOC, dependendo do número de "=".

Parâmetros:

• [String] itemHeader: linha de cabeçalho do item cujo nível deve ser calculado

Retorna: nível de item começando com 1 ou 0 se a linha passada não tiver cabeçalho de item

parseHeader

Carrega a instância de Mooc/Data/Item.Header a partir da linha do cabeçalho do item.

Parâmetros:

• [String] headerLine: linha de cabeçalho do item que deve ser carregada
• [String] parentPath: caminho da página progenitora do item

parseItem

Analisa um item do tipo pelo qual o analisador foi registrado.

Parâmetros:

• [Mooc/Data/Item.Header] header: cabeçalho do item
• [Boolean] load: determina se load deve ser chamado ou não. Somente informações básicas estão disponíveis se o item não for carregado: nome, tipo e caminho (URL)
• [Table:String->Mooc/TypeHandler] typeHandlers: manipuladores de tipo para analisar itens adicionais, como itens relacionados (filhos), se necessário

Retorna: tem analisado que está totalmente carregado, se especificado

parseIndex

Obtido pelo MOOC para analisar todos os itens associados ao item que serão renderizados. O tipo do item segmentado é do tipo para o qual o analisador foi registrado.

Parâmetros:

• [Table:String->Table] index: extraiu o MOOCIndex, incluindo todos os itens associados
• [Table:String->Mooc/TypeHandler] typeHandlers: manipuladores de tipo para analisar itens adicionais, como itens relacionados (filhos), se necessário

---

require("Módulo:Exceção");
local inheritance = require("Módulo:Herança");

---

local Header = inheritance.extend(inheritance.Class);

function Header:init(name, typeIdentifier, parent, path, level)
	self.name = name;
	self.typeIdentifier = typeIdentifier;
	self.parent = parent;
	self.path = path;
	self.level = level;
end

function Header:getName()
	return self.name;
end

function Header:getTypeIdentifier()
	return self.typeIdentifier;
end

function Header:getParent()
	return self.parent;
end

function Header:getPath()
	return self.path;
end

function Header:getUrl()
	local relUrl = string.gsub(self.path, " ", "_");
	return relUrl;
end

function Header:getLevel()
	return self.level;
end

function Header:getSection()
	return self.section;
end

function Header:setSection(newSection)
	self.section = newSection;
end

---

local Type = inheritance.extend(inheritance.Class);

function Type:init(identifier)
  self.identifier = identifier;
end

function Type:getIdentifier()
  return self.identifier;
end

function Type:isType(typeIdentifier)
  if self.identifier == typeIdentifier then
    return true;
  end
  return false;
end

---

local Item = inheritance.extend(Header);

function Item:init(header)
  Header.init(self, header:getName(), header:getTypeIdentifier(), header:getParent(), header:getPath(), header:getLevel());
  self:setSection(header:getSection());
end

function Item:getParams()
  return self.params;
end

function Item:setParams(params)
  self.params = params;
end

function Item:getChildren()
  return self.children;
end

function Item:addChild(child)
  if self.children == nil then
    self.children = {}
  end
  table.insert(self.children, child);
end

---

function Item.parseHeader(headerLine, parent)
  local iSplit = string.find(headerLine, "|", 1, true);
  if not iSplit then
    throw("failed to parse header: name separator is missing");
  end
  
  local parentPath = parent:getPath();
  local level = parent:getLevel() + 1;
  local typeIdentifier = string.sub(headerLine, level + 1, iSplit - 1);
  local name = string.sub(headerLine, iSplit + 1, -level - 1);
  local itemPath = name;
  if parentPath ~= "" then
    itemPath = parentPath .. "/" .. name;
  end
  
  return Header(name, typeIdentifier, parent, itemPath, level);
end

Item.Header = Header;
Item.Type = Type;

return Item;