prolog-blockly 1.0.15 → 1.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdcc5d1cdcddd66bb19212426e14a672ad6fc81ef321071397d22c4f1ce7ecce
-  data.tar.gz: 76484a9557a7eb4b4a3f5ef82277f50bd19d079083e349c627b86c575ce4762f
+  metadata.gz: c9f825a09a92f0844d92a5e727d5125a3f5521c60e49a83e290e201fa1f558b5
+  data.tar.gz: 2c1e420db5c725c8f1942367e378bab7e24ff8aca4ca9d7e267addde6a773740
 SHA512:
-  metadata.gz: 62bf95021fd2e7f63130ce1a20989cc5012a28fb5eb5a843ce3d90e4b2ae1fd3d674a5ddb39f8f33630ce38e15be4b0418eafa9abd853cd2d69f1e5f79ce1ebf
-  data.tar.gz: 9d275ffd33446ecd0ab44ce5fb63d3d73bcb6872a7dcf851b7ad11294255c4a31307c0085edbd3e5d95dbd2b9b8039f40939c1f14abe339f2646ee64f319c1c4
+  metadata.gz: 232daaa3bbfb7d3649ac94d628530c4332c360e144ff46a63c7bea4f67d6a9ba121208f2803078c69a40484192f437ac5bb9fc3d35e31c0d85a8a0f8327333fa
+  data.tar.gz: 8305af9ac5b90de74175c7212ced5a74a8e835475cf778d58debe1c80a466cfd3648c2dfc1f0e3a646c477b01f6aaff4e2fe7258e81f23c4b4e9480605d5afbf

data/app/assets/htmls/pl-element-blockly.html

@@ -4311,18 +4311,12 @@ Blockly.MUMUKI_COLORS = {
 	green: "#3FAA9D",
 	dark_green:"#1F879A"
 };
-// reserved
-Blockly.CUSTOM_COLORS.program = Blockly.MUMUKI_COLORS.pink;
-Blockly.CUSTOM_COLORS.interactiveProgram = Blockly.MUMUKI_COLORS.pink;
-Blockly.CUSTOM_COLORS.interactiveBinding = Blockly.MUMUKI_COLORS.pink;
-Blockly.CUSTOM_COLORS.procedure = Blockly.MUMUKI_COLORS.pink;
-Blockly.CUSTOM_COLORS.function = Blockly.MUMUKI_COLORS.pink;
-Blockly.CUSTOM_COLORS.complete = Blockly.MUMUKI_COLORS.pink;
+
 // commands
 Blockly.CUSTOM_COLORS.controlStructure = Blockly.MUMUKI_COLORS.yellow;
 Blockly.CUSTOM_COLORS.primitiveCommand = Blockly.MUMUKI_COLORS.yellow;
 Blockly.CUSTOM_COLORS.primitiveProcedure = Blockly.MUMUKI_COLORS.yellow;
-Blockly.CUSTOM_COLORS.procedure_call = Blockly.MUMUKI_COLORS.yellow;
+Blockly.CUSTOM_COLORS.Fact = Blockly.MUMUKI_COLORS.yellow;
 Blockly.CUSTOM_COLORS.assignation = Blockly.MUMUKI_COLORS.dark_green;
 
 // expressions
@@ -4332,8 +4326,6 @@ Blockly.CUSTOM_COLORS.primitiveExpression = Blockly.MUMUKI_COLORS.blue;
 Blockly.CUSTOM_COLORS.operator = Blockly.MUMUKI_COLORS.blue;
 Blockly.CUSTOM_COLORS.VariableSelector = Blockly.MUMUKI_COLORS.green;
 Blockly.CUSTOM_COLORS.parameter = Blockly.MUMUKI_COLORS.blue;
-Blockly.CUSTOM_COLORS.primitiveFunction = Blockly.MUMUKI_COLORS.blue;
-Blockly.CUSTOM_COLORS.function_call = Blockly.MUMUKI_COLORS.blue;
 Blockly.CUSTOM_COLORS.Not = Blockly.MUMUKI_COLORS.dark_green;
 Blockly.CUSTOM_COLORS.ForAll = Blockly.MUMUKI_COLORS.dark_green;
 
@@ -4350,494 +4342,6 @@ Blockly.createBlockSvg = function(workspace, name, f) {
 	newBlock.render();
 };
 
-Blockly.Blocks.Program = {
-	init: function () {
-		this.jsonInit({
-			"type": "Program",
-			"message0": "%1 %2 %3",
-			"args0": [
-				{
-					"type": "field_label",
-					"text": "programa"
-				},
-				{
-					"type": "input_dummy"
-				},
-				{
-					"type": "input_statement",
-					"name": "program",
-					"check": ["Statement"]
-				}
-			]
-		})
-		this.setColour(Blockly.CUSTOM_COLORS.Program || Blockly.CUSTOM_COLORS.program);
-		this.setDeletable(true);
-		this.setEditable(true);
-		this.setMovable(true);
-	},
-
-	setDisabledAndUpdateTimestamp: function(disabled) {
-		this.setDisabled(disabled);
-		if (!disabled) this.$timestamp = Date.now();
-	},
-
-	mutationToDom: function() {
-		var container = document.createElement("mutation");
-		container.setAttribute("timestamp", this.$timestamp || Date.now());
-		return container;
-	},
-
-	domToMutation: function(xmlElement) {
-		const timestamp = xmlElement.getAttribute("timestamp");
-		this.$timestamp = timestamp || Date.now();
-	},
-
-};
-
-Blockly.Blocks.InteractiveProgram = {
-	init: function () {
-		this.jsonInit({
-			"type": "InteractiveProgram",
-			"message0": "%1 %2 %3",
-			"args0": [
-				{
-					"type": "field_label",
-					"text": "programa interactivo"
-				},
-				{
-					"type": "input_dummy"
-				},
-				{
-					"type": "input_statement",
-					"name": "interactiveprogram",
-					"check": ["InteractiveBinding"]
-				}
-			]
-		});
-		this.setColour(Blockly.CUSTOM_COLORS.InteractiveProgram || Blockly.CUSTOM_COLORS.interactiveProgram);
-		this.setDeletable(true);
-		this.setEditable(true);
-		this.setMovable(true);
-	},
-
-	customContextMenu: function(options) {
-		options.unshift({ text: `Agregar timeout`, enabled: !this.$timeout, callback: () => {
-			let x = '';
-			while (isNaN(parseInt(x)) || parseInt(x) <= 0)
-				x = prompt("Ingrese un número en milisegundos");
-			x = parseInt(x);
-
-			this._addTimeout(x);
-		}});
-
-		options.unshift({ text: `Agregar inicialización`, enabled: !this.$init, callback: () => {
-			this._addInit();
-		}});
-	},
-
-	setDisabledAndUpdateTimestamp: function(disabled) {
-		this.setDisabled(disabled);
-		if (!disabled) this.$timestamp = Date.now();
-	},
-
-	mutationToDom: function() {
-		var container = document.createElement("mutation");
-		if (this.$init) container.setAttribute("init", this.$init);
-		if (this.$timeout) container.setAttribute("timeout", this.$timeout);
-
-		container.setAttribute("timestamp", this.$timestamp || Date.now());
-		return container;
-	},
-
-	domToMutation: function(xmlElement) {
-		const init = xmlElement.getAttribute("init");
-		const timeout = xmlElement.getAttribute("timeout");
-		const timestamp = xmlElement.getAttribute("timestamp");
-
-		if (init) this._addInit()
-		if (timeout) this._addTimeout(parseInt(timeout));
-		this.$timestamp = timestamp || Date.now();
-	},
-
-	_addInit() {
-		this.$init = true;
-
-		var removeButton = new Blockly.FieldImage(
-			MINUS,
-			16,
-			16,
-			"Eliminar",
-			function() {
-				this.$init = false;
-				this.removeInput("initlabel");
-				this.removeInput("init");
-				this.removeInput("statementsLabel");
-			}.bind(this)
-		);
-
-		this.appendDummyInput("initlabel").appendField('Al inicializar:').appendField(removeButton);
-		this.appendStatementInput('init').setCheck(["Statement"]);
-		this.appendDummyInput("statementsLabel").appendField('Al apretar...');
-		this.moveInputBefore("init", "interactiveprogram");
-		this.moveInputBefore("initlabel", "init");
-		this.moveInputBefore("statementsLabel", "interactiveprogram");
-	},
-
-	_addTimeout(timeout) {
-		this.$timeout = timeout;
-
-		var removeButton = new Blockly.FieldImage(
-			MINUS,
-			16,
-			16,
-			"Eliminar",
-			function() {
-				this.$timeout = undefined;
-				this.removeInput("timeoutlabel");
-				this.removeInput("timeout");
-			}.bind(this)
-		);
-
-		this.appendDummyInput("timeoutlabel").appendField(`Al estar inactivo ${timeout} milisegundos:`).appendField(removeButton);
-		this.appendStatementInput('timeout').setCheck(["Statement"]);
-	}
-};
-
-// -------------------------------------
-// Programa interactivo
-// -------------------------------------
-
-const modifiers = [
-	[ 'SHIFT', 'SHIFT' ],
-	[ 'CTRL', 'CTRL' ],
-	[ 'ALT', 'ALT' ]
-];
-
-const getModifiersInput = (block) => block.inputList[1];
-const getModifierFields = (block) => getModifiersInput(block).fieldRow.slice(2);
-const getModifierDropdownFields = (block) => getModifierFields(block).filter(it => it.constructor === Blockly.FieldDropdown);
-const getModifierValues = (block) => getModifierDropdownFields(block).map(it => it.getValue());
-const getAvailableModifiers = (block) => {
-	const currentModifiers = getModifierValues(block);
-
-	return modifiers.filter(it =>
-		currentModifiers.indexOf(it[1]) === -1
-	);
-};
-const updateModifierMenuGenerators = (block, nameToIgnore) => {
-	const availableModifiers = getAvailableModifiers(block);
-	const dropdowns = getModifierDropdownFields(block);
-
-	for (var dropdown of dropdowns) {
-		if (dropdown.name !== nameToIgnore)
-			dropdown.menuGenerator_ = modifiers.filter(it => {
-				return it[1] === dropdown.getValue() || availableModifiers.some(availableModifier => availableModifier[1] === it[1])
-			});
-
-	}
-}
-
-createInteractiveBinding = (name, keys) => {
-	return {
-		init: function () {
-			this.jsonInit({
-				message0: "%1 %2 %3 %4",
-				type: "InteractiveBinding",
-				previousStatement: "InteractiveBinding",
-				nextStatement: "InteractiveBinding",
-				args0: [
-					{
-						"type": "field_label",
-						"text": "Al apretar " + name
-					},
-          { "type": "input_dummy" },
-          {
-            "type": "field_label",
-            "text": "➣"
-          },
-					{
-						type: "field_dropdown",
-						name: "InteractiveBindingDropdownKey",
-						options: keys.map(it => [it.name, it.code]),
-					}
-				],
-				colour: Blockly.CUSTOM_COLORS.InteractiveBinding || Blockly.CUSTOM_COLORS.interactiveBinding,
-				tooltip: "Escoger una entrada",
-			});
-
-      this.appendStatementInput('block').setCheck(["Statement"]);
-
-      const self = this;
-      const input = this.inputList[0];
-      input.appendField(new Blockly.FieldImage(
-        PLUS,
-        16,
-        16,
-        "Agregar modificador",
-        function() {
-          const modifiersCount = getModifierFields(self).length / 2;
-          if (modifiersCount >= modifiers.length) return;
-
-          self._addModifier();
-        }
-      ));
-      input.appendField(new Blockly.FieldImage(
-        CLEAN,
-        16,
-        16,
-        "Limpiar modificadores",
-        function() {
-          self._cleanModifiers();
-        }
-      ));
-		},
-
-		customContextMenu: function(options) {
-			const modifiersCount = getModifierFields(this).length / 2;
-
-			options.unshift({ text: `Limpiar modificadores`, enabled: modifiersCount > 0, callback: () => {
-				this._cleanModifiers();
-			}});
-			options.unshift({ text: `Agregar modificador`, enabled: modifiersCount < modifiers.length, callback: () => {
-				this._addModifier();
-			}});
-		},
-
-		mutationToDom: function() {
-			var container = document.createElement("mutation");
-			container.setAttribute("modifierscount", getModifierValues(this).length.toString());
-			return container;
-		},
-
-		domToMutation: function(xmlElement) {
-			const $modifiersCount = xmlElement.getAttribute("modifierscount");
-			if ($modifiersCount) {
-				const count = parseInt($modifiersCount);
-				for (var i = 0; i < count; i++)
-					this._addModifier();
-			}
-
-			setTimeout(() => {
-				updateModifierMenuGenerators(this);
-			}, 0);
-		},
-
-		_addModifier() {
-			const availableModifiers = getAvailableModifiers(this);
-
-			const self = this;
-			const id = getModifierValues(this).length + 1;
-			const labelName = "l" + id;
-			const dropdownName = "d" + id;
-
-			getModifiersInput(this).appendField("+").appendField(new Blockly.FieldDropdown(availableModifiers, (newValue) => {
-				setTimeout(() => {
-					updateModifierMenuGenerators(self, dropdownName)
-				}, 0);
-			}));
-
-			const addedFields = getModifierFields(this).slice(-2);
-			addedFields[0].name = labelName;
-			addedFields[1].name = dropdownName;
-
-			updateModifierMenuGenerators(this, dropdownName);
-		},
-
-		_cleanModifiers() {
-			const fieldsToRemove = getModifierFields(this);
-
-			for (var field of fieldsToRemove)
-				getModifiersInput(this).removeField(field.name);
-		}
-	}
-};
-
-Blockly.Blocks.InteractiveLetterBinding = createInteractiveBinding("letra", [
-	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
-].map(it => ({ code: it, name: it })));
-
-Blockly.Blocks.InteractiveNumberBinding = createInteractiveBinding("número", [
-	'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'
-].map(it => ({ code: it, name: it })));
-
-Blockly.Blocks.InteractiveKeyBinding = createInteractiveBinding("tecla", [
-	{ code: 'ARROW_LEFT', name: '←' },
-	{ code: 'ARROW_RIGHT', name: '→' },
-	{ code: 'ARROW_UP', name: '↑' },
-	{ code: 'ARROW_DOWN', name: '↓' },
-	{ code: 'MINUS', name: '-' },
-	{ code: 'SPACE', name: 'Espacio' },
-	{ code: 'ENTER', name: 'Enter' },
-	{ code: 'TAB', name: 'Tab' },
-	{ code: 'BACKSPACE', name: 'Borrar' },
-	{ code: 'DELETE', name: 'Suprimir' },
-	{ code: 'ESCAPE', name: 'Escape' }
-]);
-
-// ------------------------------------------------------
-// Control de flujo de ejecucion:
-// ------------------------------------------------------
-
-Blockly.Blocks.RepeticionSimple = {
-	init: function () {
-		this.jsonInit({
-			type: "Statement",
-			previousStatement: "Statement",
-			nextStatement: "Statement",
-		});
-
-		this.setColour(Blockly.CUSTOM_COLORS.RepeticionSimple || Blockly.CUSTOM_COLORS.controlStructure);
-		this.appendValueInput('count')
-			.appendField('repetir');
-		this.appendDummyInput()
-			.appendField('veces');
-		this.appendStatementInput('block').setCheck(["Statement"]);
-		this.setInputsInline(true);
-	}
-};
-
-Blockly.Blocks.RepeticionCondicional = {
-	init: function () {
-		this.jsonInit({
-			type: "Statement",
-			previousStatement: "Statement",
-			nextStatement: "Statement",
-		});
-
-		this.setColour(Blockly.CUSTOM_COLORS.RepeticionCondicional || Blockly.CUSTOM_COLORS.controlStructure);
-		this.appendValueInput('condicion')
-			.setCheck('Bool')
-			.appendField('repetir hasta que');
-		this.appendStatementInput('block').setCheck(["Statement"]);
-		this.setInputsInline(true);
-	}
-};
-
-Blockly.Blocks.AlternativaSimple = {
-	init: function () {
-		this.jsonInit({
-			type: "Statement",
-			previousStatement: "Statement",
-			nextStatement: "Statement",
-		});
-
-		this.setColour(Blockly.CUSTOM_COLORS.AlternativaSimple || Blockly.CUSTOM_COLORS.controlStructure);
-		this.appendValueInput('condicion')
-			.appendField(Blockly.Msg["CONTROLS_IF_MSG_IF"]);
-		this.appendStatementInput('block').setCheck(["Statement"]);
-		this.setInputsInline(true);
-	}
-};
-
-Blockly.Msg["CONTROLS_IF_MSG_ELSE"] = "si no";
-Blockly.Msg["CONTROLS_IF_MSG_ELSEIF"] = "si no, si";
-Blockly.Msg["CONTROLS_IF_MSG_IF"] = "si";
-Blockly.Msg["CONTROLS_IF_MSG_THEN"] = "";
-delete Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN.compose;
-delete Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN.decompose;
-Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN.updateShape_ = function() {
-	// Delete everything.
-	if (this.getInput('block2')) {
-		this.removeInput('block2');
-	}
-	var i = 1;
-	while (this.getInput('IF' + i)) {
-		this.removeInput('IF' + i);
-		this.removeInput('DO' + i);
-		i++;
-	}
-	// Rebuild block.
-	for (var i = 1; i <= this.elseifCount_; i++) {
-		this.appendValueInput('IF' + i)
-				.appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSEIF);
-		this.appendStatementInput('DO' + i)
-				.setCheck(["Statement"])
-	}
-	if (this.elseCount_) {
-		this.appendStatementInput('block2')
-			.setCheck(["Statement"])
-			.appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSE);
-	}
-};
-Blockly.Extensions.registerMutator(
-	"controls_if_mutator_without_ui",
-	Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN,
-	null,
-	[]
-);
-
-Blockly.Blocks.AlternativaCompleta = {
-	init: function () {
-		this.jsonInit({
-			"type": "Statement",
-			"previousStatement": "Statement",
-			"nextStatement": "Statement",
-			"message0": "%{BKY_CONTROLS_IF_MSG_IF} %1",
-			"args0": [
-				{
-					"type": "input_value",
-					"name": "condicion"
-				}
-			],
-			"message1": "%{BKY_CONTROLS_IF_MSG_THEN} %1",
-			"args1": [
-				{
-					"type": "input_statement",
-					"name": "block1",
-					"check": ["Statement"]
-				}
-			],
-			"colour": "%{BKY_LOGIC_HUE}",
-			"helpUrl": "%{BKY_CONTROLS_IF_HELPURL}",
-			"mutator": "controls_if_mutator_without_ui",
-			"extensions": ["controls_if_tooltip"]
-		});
-
-		this.setColour(Blockly.CUSTOM_COLORS.AlternativaCompleta || Blockly.CUSTOM_COLORS.controlStructure);
-		this.setInputsInline(true);
-
-		this.elseCount_++;
-		this.updateShape_();
-	},
-	customContextMenu: function(options) {
-		options.unshift({ text: `Limpiar ramas 'si no, si'`, enabled: true, callback: () => {
-			this.elseifCount_ = 0;
-
-			this.updateShape_();
-		}});
-
-		options.unshift({ text: `Agregar 'si no, si'`, enabled: true, callback: () => {
-			this.elseifCount_++;
-
-			const valueConnections = [null];
-			const statementConnections = [null];
-			const elseStatementConnection = this.getInput("block2").connection.targetConnection;
-			let k;
-			let input;
-
-			k = 1;
-			while (input = this.getInput("IF" + k)) {
-				valueConnections.push(input.connection.targetConnection);
-				k++;
-			}
-
-			k = 1;
-			while (input = this.getInput("DO" + k)) {
-				statementConnections.push(input.connection.targetConnection);
-				k++;
-			}
-
-			this.updateShape_();
-
-			// Reconnect any child blocks.
-			for (var i = 1; i <= this.elseifCount_; i++) {
-				Blockly.Mutator.reconnect(valueConnections[i], this, 'IF' + i);
-				Blockly.Mutator.reconnect(statementConnections[i], this, 'DO' + i);
-			}
-			Blockly.Mutator.reconnect(elseStatementConnection, this, 'block2');
-		}});
-	}
-};
 
 // ------------------------------------------------------
 // Comandos:
@@ -4861,7 +4365,7 @@ Blockly.Blocks.fact1 = {
 					name: 'PrimerIndividuo'
 				}
 			],
-			colour: Blockly.CUSTOM_COLORS.Fact || Blockly.CUSTOM_COLORS.primitiveCommand,
+			colour: Blockly.CUSTOM_COLORS.Fact,
 			tooltip: 'Es una verdad',
 			inputsInline: true
 		});
@@ -4890,7 +4394,7 @@ Blockly.Blocks.fact2 = {
 					name: 'SegundoIndividuo'
 				}
 			],
-			colour: Blockly.CUSTOM_COLORS.Fact || Blockly.CUSTOM_COLORS.primitiveCommand,
+			colour: Blockly.CUSTOM_COLORS.Fact,
 			tooltip: 'Es una verdad',
 			inputsInline: true
 		});
@@ -4923,7 +4427,7 @@ Blockly.Blocks.fact3 = {
 					name: 'TerceraCondicion'
 				}
 			],
-			colour: Blockly.CUSTOM_COLORS.Fact || Blockly.CUSTOM_COLORS.primitiveCommand,
+			colour: Blockly.CUSTOM_COLORS.Fact,
 			tooltip: 'Es una verdad',
 			inputsInline: true
 		});
@@ -4943,7 +4447,7 @@ Blockly.Blocks.not = {
 					name: 'PrimeraCondicion'
 				}
 			],
-			colour: Blockly.CUSTOM_COLORS.Not || Blockly.CUSTOM_COLORS.primitiveCommand,
+			colour: Blockly.CUSTOM_COLORS.Not,
 			tooltip: 'Niega la condición',
 			inputsInline: true
 		});
@@ -4967,111 +4471,13 @@ Blockly.Blocks.forall = {
 					name: 'SegundaCondicion'
 				}
 			],
-			colour: Blockly.CUSTOM_COLORS.ForAll || Blockly.CUSTOM_COLORS.primitiveCommand,
+			colour: Blockly.CUSTOM_COLORS.ForAll,
 			tooltip: 'Para todo lo primero, se cumple lo segundo.',
 			inputsInline: true
 		});
 	}
 };
 
-Blockly.Blocks.Sacar= {
-	init: function () {
-		this.jsonInit({
-			type: "Statement",
-			previousStatement: "Statement",
-			nextStatement: "Statement",
-			message0: 'Sacar %1',
-			args0: [
-				{
-					type: 'input_value',
-					name: 'COLOR'
-				}
-			],
-			colour: Blockly.CUSTOM_COLORS.Sacar || Blockly.CUSTOM_COLORS.primitiveCommand,
-			tooltip: 'Sacar color de casillero.',
-			inputsInline: true
-		});
-	}
-};
-
-Blockly.Blocks.Mover = {
-	init: function () {
-		this.jsonInit({
-			type: "Statement",
-			previousStatement: "Statement",
-			nextStatement: "Statement",
-			message0: 'Mover %1',
-			args0: [
-				{
-					type: 'input_value',
-					name: 'DIRECCION'
-				}
-			],
-			colour: Blockly.CUSTOM_COLORS.Mover || Blockly.CUSTOM_COLORS.primitiveCommand,
-			tooltip: 'Mover en una dirección.',
-			inputsInline: true
-		});
-	}
-};
-
-Blockly.Blocks.IrAlBorde = {
-	init: function () {
-		this.jsonInit({
-			type: "Statement",
-			previousStatement: "Statement",
-			nextStatement: "Statement",
-			message0: 'Ir al borde %1',
-			args0: [
-				{
-					type: 'input_value',
-					name: 'DIRECCION'
-				}
-			],
-			colour: Blockly.CUSTOM_COLORS.IrAlBorde || Blockly.CUSTOM_COLORS.primitiveCommand,
-			tooltip: 'Ir al borde del tablero.',
-			inputsInline: true
-		});
-	}
-};
-
-Blockly.Blocks.VaciarTablero = {
-	init: function () {
-		this.jsonInit({
-			type: "Statement",
-			previousStatement: "Statement",
-			nextStatement: "Statement",
-			message0: 'Vaciar tablero',
-			colour: Blockly.CUSTOM_COLORS.VaciarTablero || Blockly.CUSTOM_COLORS.primitiveCommand,
-			tooltip: 'Vaciar el tablero.',
-			inputsInline: true
-		});
-	}
-};
-
-Blockly.Blocks.BOOM = {
-	init: function () {
-		this.jsonInit({
-			"type": "Statement",
-			"previousStatement": "Statement",
-			"nextStatement": "Statement",
-			"lastDummyAlign0": "RIGHT",
-			"message0": "Hacer ¡BOOM! porque:  %1 %2",
-			"args0": [
-				{
-					"type": "input_dummy"
-				},
-				{
-					"type": "field_input",
-					"name": "boomDescription",
-					"text": "Ingresar motivo..."
-				}
-			],
-			"inputsInline": false,
-			"colour": Blockly.CUSTOM_COLORS.BOOM || Blockly.CUSTOM_COLORS.primitiveCommand,
-			"tooltip": "Este comando hace que estalle todo."
-		});
-	}
-};
 
 Blockly.Blocks.makeShadowEventListener = function(event){
 	if(event.blockId == this.id && event.newParentId){
@@ -5167,94 +4573,7 @@ function createLiteralSelectorBlock(type,values){
 
 Blockly.Blocks.IndividuoSelector = createLiteralSelectorBlock('Individuo');
 Blockly.Blocks.VariableSelector = createLiteralSelectorBlock('Variable');
-Blockly.Blocks.ColorSelector = createLiteralSelectorBlock('Color',['Rojo','Verde','Negro','Azul']);
-Blockly.Blocks.DireccionSelector = createLiteralSelectorBlock('Direccion',['Este','Oeste','Norte','Sur']);
-Blockly.Blocks.BoolSelector = createLiteralSelectorBlock('Bool',['True','False']);
 
-function createSingleParameterExpressionBlock(blockText,returnType, colorType = "operator"){
-	return {
-		init: function () {
-			this.jsonInit({
-				message0: blockText + ' %1',
-				args0: [
-					{
-						type: 'input_value',
-						name: 'VALUE'
-					}
-				],
-				colour: Blockly.CUSTOM_COLORS[this.type] || Blockly.CUSTOM_COLORS[colorType],
-				inputsInline: true,
-				output: returnType
-			})
-		}
-	};
-}
-
-Blockly.Blocks.hayBolitas = createSingleParameterExpressionBlock('hay bolitas','Bool', "primitiveExpression");
-Blockly.Blocks.puedeMover = createSingleParameterExpressionBlock('puede mover','Bool', "primitiveExpression");
-Blockly.Blocks.nroBolitas = createSingleParameterExpressionBlock('numero de bolitas','Number', "primitiveExpression");
-
-// ------------------------------------------------------
-// Operaciones:
-// ------------------------------------------------------
-
-Blockly.Blocks.OperadorDeComparacion = {
-	init: function () {
-		this.jsonInit({
-			message0: '%1 %2 %3 %4',
-			args0: [
-				{
-					type: 'input_value',
-					name: 'arg1'
-				},
-				{
-					type: 'field_dropdown',
-					name: 'RELATION',
-					options: [['==', '=='], ['/=', '/='], ['<=', '<='], ['<', '<'], ['>=', '>='], ['>', '>']]
-				},
-				{
-					type: 'input_dummy'
-				},
-				{
-					type: 'input_value',
-					name: 'arg2'
-				}
-			],
-			colour: Blockly.CUSTOM_COLORS.OperadorDeComparacion || Blockly.CUSTOM_COLORS.operator,
-			inputsInline: false,
-			output: 'Bool'
-		});
-	}
-};
-
-Blockly.Blocks.OperadorNumerico = {
-	init: function () {
-		this.jsonInit({
-			message0: '%1 %2 %3 %4',
-			args0: [
-				{
-					type: 'input_value',
-					name: 'arg1'
-				},
-				{
-					type: 'field_dropdown',
-					name: 'OPERATOR',
-					options: [['+', '+'], ['-', '-'], ['*', '*'], ['div', 'div'], ['mod', 'mod'], ['^', '^']]
-				},
-				{
-					type: 'input_dummy'
-				},
-				{
-					type: 'input_value',
-					name: 'arg2'
-				}
-			],
-			colour: Blockly.CUSTOM_COLORS.OperadorNumerico || Blockly.CUSTOM_COLORS.operator,
-			inputsInline: false,
-			output: 'Number'
-		});
-	}
-};
 
 Blockly.Blocks.OperadorLogico = {
 	init: function () {
@@ -5392,9 +4711,15 @@ Blockly.Blocks.variables_get = {
 	}
 };
 
-Blockly.Blocks.siguiente = createSingleParameterExpressionBlock('siguiente','*');
-Blockly.Blocks.previo = createSingleParameterExpressionBlock('previo','*');
-Blockly.Blocks.opuesto = createSingleParameterExpressionBlock('opuesto','*');
+
+
+
+
+
+
+
+//Deberiamos immplementar una sanitizacion par ablockly, asi se esta haciendo en gobstone
+
 
 
 // Necesario para sanitizar nombres de procedimientos.
@@ -5501,6 +4826,13 @@ function uncapitalize(text) {
 	}
 	return text.charAt(0).toLowerCase() + text.substr(1);
 }
+
+function capitalize(text) {
+    if(!text || typeof text !== "string") {
+        return '';
+    }
+    return text.charAt(0).toUpperCase() + text.substr(1);
+}
 /**
  * Retorna la funcion que genera el codigo para un bloque tipo PRED(arg1, arg2, ...)
  */
@@ -5510,7 +4842,7 @@ function factBlockCodeGenerator(procName, args, newLine) {
 		var sep = '';
 		args.forEach(function (arg, index) {
 		  var childBlock = block.childBlocks_[index]
-		  code += sep + (uncapitalize(childBlock.getFieldValue('Individuo')) || childBlock.getFieldValue('Variable'));
+		  code += sep + (uncapitalize(childBlock.getFieldValue('Individuo')) || capitalize(childBlock.getFieldValue('Variable')));
 		  sep = ', ';
 		});
 		code += newLine ? ').\n' : ').';
@@ -5545,7 +4877,6 @@ function notBlockCodeGenerator(procName, args, newLine) {
 	return function (block) {
 		var code = "\n" + procName + '(';
 		var sep = '';
-		debugger;
 		args.forEach(function (arg) {
 		  var statementCode = Blockly.PrologLanguage.statementToCode(block, arg, false);
 		  if(statementCode.split("\n").length > 2) {
@@ -5562,30 +4893,7 @@ function notBlockCodeGenerator(procName, args, newLine) {
 	// return callGenerator(procName, args, true);
 }
 window.forallBlockCodeGenerator = forallBlockCodeGenerator;
-/**
- * Retorna la funcion que genera el codigo para un bloque tipo function(arg1, arg2, ...)
- */
-function functionBlockCodeGenerator(procName, args) {
-	return callGenerator(procName, args, false, Blockly.PrologLanguage.ORDER_FUNCTION_CALL);
-}
-window.functionBlockCodeGenerator = functionBlockCodeGenerator;
 
-/**
- * Retorna la funcion que genera el codigo para un bloque tipo Expr(arg1, arg2, ...)
- */
-function exprParamsBlockCodeGenerator(expr, args) {
-	return callGenerator(expr, args, false, Blockly.PrologLanguage.ORDER_FUNCTION_CALL);
-}
-
-/**
- * Retorna la funcion que genera el codigo para un bloque tipo selector de literales
- */
-
-function literalSelectorBlockCodeGenerator(type) {
-	return function(block) {
-		return [block.getFieldValue(type), Blockly.PrologLanguage.ORDER_ATOMIC];
-	};
-}
 
 function individuoSelectorBlockCodeGenerator(type) {
 	return function(block) {
@@ -5801,15 +5109,9 @@ Blockly.PrologLanguage.fact3 = factBlockCodeGenerator('fact', ['PrimerIndividuo'
 Blockly.PrologLanguage.forall = forallBlockCodeGenerator('forall', ['PrimeraCondicion', 'SegundaCondicion']);
 Blockly.PrologLanguage.not = notBlockCodeGenerator('not', ['PrimeraCondicion']);
 
-Blockly.PrologLanguage.ComandoCompletar = b => 'BOOM("El programa todavía no está completo")\n';
-Blockly.PrologLanguage.ExpresionCompletar = b => ['boom("El programa todavía no está completo")',Blockly.PrologLanguage.ORDER_FUNCTION_CALL];
-Blockly.PrologLanguage.AsociacionDeTeclaCompletar = b => ''
 
 Blockly.PrologLanguage.IndividuoSelector = individuoSelectorBlockCodeGenerator('Individuo');
 Blockly.PrologLanguage.VariableSelector = variableSelectorBlockCodeGenerator('Variable');
-Blockly.PrologLanguage.ColorSelector = literalSelectorBlockCodeGenerator('Color');
-Blockly.PrologLanguage.DireccionSelector = literalSelectorBlockCodeGenerator('Direccion');
-Blockly.PrologLanguage.BoolSelector = literalSelectorBlockCodeGenerator('Bool');
 
 Blockly.PrologLanguage.OperadorDeComparacion = function (block) {
 	var code =
@@ -5858,9 +5160,6 @@ Blockly.PrologLanguage.OperadorLogico = function(block) {
 	return [code, order];
 };
 
-Blockly.PrologLanguage.siguiente = exprParamsBlockCodeGenerator('siguiente',['VALUE']);
-Blockly.PrologLanguage.previo = exprParamsBlockCodeGenerator('previo',['VALUE']);
-Blockly.PrologLanguage.opuesto = exprParamsBlockCodeGenerator('opuesto',['VALUE']);
 
 Blockly.PrologLanguage.math_number = function (block) {
 	// Numeric value.
@@ -5874,153 +5173,34 @@ Blockly.PrologLanguage.Program = function (block) {
 	return codigo;
 };
 
-Blockly.PrologLanguage.InteractiveProgram = function (block) {
-	let program = Blockly.PrologLanguage.statementToCode(block, 'interactiveprogram');
-
-	let init = '';
-	if (block.$init)
-		init = `  INIT -> {\n${Blockly.PrologLanguage.statementToCode(block, 'init')}  }\n`;
-
-	let timeout = '';
-	if (block.$timeout)
-		timeout = `  TIMEOUT(${block.$timeout}) -> {\n${Blockly.PrologLanguage.statementToCode(block, 'timeout')}  }\n`;
-
-	let codigo = `interactive program {\n${init}${program}${timeout}}\n`;
-	return codigo;
-};
-
-Blockly.PrologLanguage.InteractiveLetterBinding = function (block) {
-	let key = block.getFieldValue('InteractiveBindingDropdownKey');
-
-	const order = ["CTRL", "ALT", "SHIFT"];
-	const modifier = block.inputList[1]
-		.fieldRow
-		.slice(2)
-		.filter(it => it.constructor === Blockly.FieldDropdown)
-		.map(it => order.indexOf(it.getValue()))
-		.sort()
-		.map(it => order[it])
-		.join("_");
-
-	if (modifier !== "")
-		key = modifier + "_" + key;
-
-	const code = Blockly.PrologLanguage.statementToCode(block, 'block');
-
-	return `K_${key} -> {\n${code}}\n`;
-};
-Blockly.PrologLanguage.InteractiveNumberBinding = Blockly.PrologLanguage.InteractiveLetterBinding;
-Blockly.PrologLanguage.InteractiveKeyBinding = Blockly.PrologLanguage.InteractiveLetterBinding;
-
-Blockly.PrologLanguage.RepeticionSimple = function (block) {
-	let body = Blockly.PrologLanguage.statementToCode(block, 'block');
-	var count = Blockly.PrologLanguage.valueToCode(block, 'count',
-	Blockly.PrologLanguage.ORDER_NONE) || '';
-
-	let codigo = `repeat(${count}) {\n${body}}\n`;
-	return codigo;
-};
-
-Blockly.PrologLanguage.RepeticionCondicional = function (block) {
-	let body = Blockly.PrologLanguage.statementToCode(block, 'block');
-	var condicion = Blockly.PrologLanguage.valueToCode(block, 'condicion',
-	Blockly.PrologLanguage.ORDER_NONE) || '';
-
-	let codigo = `while (not (${condicion})) {\n${body}}\n`;
-	return codigo;
-};
-
-Blockly.PrologLanguage.AlternativaSimple = function (block) {
-	let body = Blockly.PrologLanguage.statementToCode(block, 'block');
-	var condicion = Blockly.PrologLanguage.valueToCode(block, 'condicion',
-	Blockly.PrologLanguage.ORDER_NONE) || '';
-
-	let codigo = `if (${condicion}) {\n${body}}\n`;
-	return codigo;
-};
-
-Blockly.PrologLanguage.AlternativaCompleta = function (block) {
-	const elseIfCount = block.elseifCount_;
-	let body1 = Blockly.PrologLanguage.statementToCode(block, 'block1');
-	let body2 = Blockly.PrologLanguage.statementToCode(block, 'block2');
-
-	const elseIfBodies = Array.apply(null, Array(elseIfCount))
-		.map(function (_, i) {
-			const id = i + 1;
-			return {
-				condition: Blockly.PrologLanguage.valueToCode(block, "IF" + id,
-	Blockly.PrologLanguage.ORDER_NONE),
-				body: Blockly.PrologLanguage.statementToCode(block, "DO" + id)
-			};
-		}).map(function({ condition, body }) {
-			return ` elseif (${condition}) {\n${body}}`;
-		}).join("");
-
-	var condicion = Blockly.PrologLanguage.valueToCode(block, 'condicion',
-	Blockly.PrologLanguage.ORDER_NONE) || '';
-
-	let codigo = `if (${condicion}) {\n${body1}}${elseIfBodies} else {\n${body2}}\n`;
-	return codigo;
-};
-
-Blockly.PrologLanguage.hayBolitas = exprParamsBlockCodeGenerator('hayBolitas', ['VALUE']);
-Blockly.PrologLanguage.nroBolitas = exprParamsBlockCodeGenerator('nroBolitas', ['VALUE']);
-Blockly.PrologLanguage.puedeMover = exprParamsBlockCodeGenerator('puedeMover', ['VALUE']);
-
 var formatCallName = function (name, capitalizeFirst, type = Blockly.PROCEDURE_CATEGORY_NAME) {
-	if(!name) throw new Error(type + " name is empty");
-	var safe = Blockly.PrologLanguage.variableDB_.getName(name, type);
-	return (capitalizeFirst ? safe[0].toUpperCase() : safe[0].toLowerCase()) + safe.slice(1);
+    if(!name) throw new Error(type + " name is empty");
+    var safe = Blockly.PrologLanguage.variableDB_.getName(name, type);
+    return (capitalizeFirst ? safe[0].toUpperCase() : safe[0].toLowerCase()) + safe.slice(1);
 };
 
 var makeParameterList = function (block) {
-	return block.arguments_.join(', ');
+    return block.arguments_.join(', ');
 };
 
 Blockly.PrologLanguage.procedures_defnoreturn = function (block) {
-  var procName = formatCallName(block.getFieldValue('NAME'),false);
-  var name = procName;
-  while(Number(name.slice(-1))) {
-	  name = name.slice(0, -1);
-  }
-  var body_lines = Blockly.PrologLanguage.statementToCode(block, 'STACK');
-  var body2 = body_lines.split("\n").slice(1).join(",\n") + '.';
-  var body_final = body2.replace(/\.\./g, ".").replace(/\.,/g, ",");
-
-  var code = name + '(' + makeParameterList(block) + ')' + ':- \n' + body_final + '\n';
-
-  code = Blockly.PrologLanguage.scrub_(block, code);
-  Blockly.PrologLanguage.definitions_[procName] = code;
-
-  return null;
-};
-
-Blockly.PrologLanguage.procedures_defnoreturn_nobody = function (block) {
-  var name = formatCallName(block.getFieldValue('NAME'),false);
-  var code = name + '(' + makeParameterList(block) + ').';
-  code = Blockly.PrologLanguage.scrub_(block, code);
-  Blockly.PrologLanguage.definitions_[name] = code;
-  return null;
-};
-
-Blockly.PrologLanguage.procedures_defreturn = function (block) {
-	var name = formatCallName(block.getFieldValue('NAME'),false);
-	var body = Blockly.PrologLanguage.statementToCode(block, 'STACK');
-	var returnValue = Blockly.PrologLanguage.valueToCode(block, 'RETURN');
+    var procName = formatCallName(block.getFieldValue('NAME'),false);
+    var name = procName;
+    while(Number(name.slice(-1))) {
+        name = name.slice(0, -1);
+    }
+    var body_lines = Blockly.PrologLanguage.statementToCode(block, 'STACK');
+    var body2 = body_lines.split("\n").slice(1).join(",\n") + '.';
+    var body_final = body2.replace(/\.\./g, ".").replace(/\.,/g, ",");
 
-	var code = 'function ' + name + '(' + makeParameterList(block) + ') {\n' +
-		body + '  return (' + returnValue + ')\n}\n';
+    var code = name + '(' + makeParameterList(block) + ')' + ':- \n' + body_final + '\n';
 
-	code = Blockly.PrologLanguage.scrub_(block, code);
-	Blockly.PrologLanguage.definitions_[name] = code;
+    code = Blockly.PrologLanguage.scrub_(block, code);
+    Blockly.PrologLanguage.definitions_[procName] = code;
 
-	return null;
+    return null;
 };
 
-Blockly.PrologLanguage.procedures_defnoreturnnoparams = Blockly.PrologLanguage.procedures_defnoreturn;
-Blockly.PrologLanguage.procedures_defreturnsimplewithparams = Blockly.PrologLanguage.procedures_defreturn;
-Blockly.PrologLanguage.procedures_defreturnsimple = Blockly.PrologLanguage.procedures_defreturn;
-
 var predicateCall = function(block, capitalizeFirst, newLine) {
 	var procName = formatCallName(block.getFieldValue('NAME'),false);
 	var args = [];
@@ -6032,17 +5212,6 @@ var predicateCall = function(block, capitalizeFirst, newLine) {
 	return code;
 }
 
-Blockly.PrologLanguage.procedures_callnoreturn = function (block) {
-	return predicateCall(block, true, true);
-};
-Blockly.PrologLanguage.procedures_callreturn = function (block) {
-	return [predicateCall(block, false), Blockly.PrologLanguage.ORDER_FUNCTION_CALL];
-};
-
-Blockly.PrologLanguage.procedures_callnoreturnnoparams = Blockly.PrologLanguage.procedures_callnoreturn;
-Blockly.PrologLanguage.procedures_callreturnsimplewithparams = Blockly.PrologLanguage.procedures_callreturn;
-Blockly.PrologLanguage.procedures_callreturnsimple = Blockly.PrologLanguage.procedures_callreturn;
-
 Blockly.PrologLanguage.variables_get = function (block) {
 	var code = formatCallName(block.getFieldValue('VAR'),false,Blockly.VARIABLE_CATEGORY_NAME);
 	return [code, Blockly.PrologLanguage.ORDER_ATOMIC];
@@ -6050,45 +5219,19 @@ Blockly.PrologLanguage.variables_get = function (block) {
 
 Blockly.PrologLanguage.Asignacion = function(block) {
   var varValue = Blockly.PrologLanguage.valueToCode(block, 'varValue', Blockly.PrologLanguage.ORDER_ASSIGNMENT);
-  var code = formatCallName(block.getFieldValue('varName'),false,Blockly.VARIABLE_CATEGORY_NAME)  +
+  var varName = formatCallName(block.getFieldValue('varName'),false,Blockly.VARIABLE_CATEGORY_NAME);
+  var code = capitalize(varName)  +
   	' is ' + varValue;
   return "\n" + code;
 };
 </script>
   <script>Blockly.PrologLanguage.blockIDAliases = {
-  "ComandosPrimitivos": "Comandos primitivos",
-  "ProcedimientosPrimitivos": "Procedimientos primitivos",
-  "MisProcedimientos": "Mis procedimientos",
-  "ExpresionesPrimitivas": "Expresiones primitivas",
-  "FuncionesPrimitivas": "Funciones primitivas",
   "CategoriaAsignacion":"Asignación",
   "Color":"ColorSelector",
   "Individuo":"IndividuoSelector",
   "Variable":"VariableSelector",
-  "Direccion":"DireccionSelector",
-  "Numero":"math_number",
-  "Booleano":"BoolSelector",
-  "ExpresionesPrimitivas": "Expresiones primitivas",
-  "FuncionesPrimitivas": "Funciones primitivas",
-  "MisFunciones": "Mis funciones",
   "OperadorDeNegacion": "not",
-  "OperadorSiguiente": "siguiente",
-  "OperadorPrevio": "previo",
-  "OperadorOpuesto": "opuesto",
-  "DefinicionesDeProgramas": "Programas",
-  "DefinicionDeProgramaComun": "Program",
-  "DefinicionDeProgramaInteractivo": "InteractiveProgram",
-  "DefinicionDeAsociacionDeTeclaLetra": "InteractiveLetterBinding",
-  "DefinicionDeAsociacionDeTeclaNumero": "InteractiveNumberBinding",
-  "DefinicionDeAsociacionDeTeclaEspecial": "InteractiveKeyBinding",
-  "DefinicionesDeProcedimientos": "Procedimientos",
-  "DefinicionDeProcedimientoSimple": "procedures_defnoreturnnoparams",
-  "DefinicionDeProcedimientoParametrizado": "procedures_defnoreturn",
-  "DefinicionesDeFunciones": "Funciones",
-  "DefinicionDeFuncionSimple": "procedures_defreturnsimple",
-  "DefinicionDeFuncionSimpleParametrizada": "procedures_defreturnsimplewithparams",
-  "DefinicionDeFuncionParametrizada": "procedures_defreturn"
-};
+ };
 
 Blockly.PrologLanguage.aliasForBlockID = function(id){
   return  this.blockIDAliases[id] || id;

data/lib/prolog/blockly/version.rb

@@ -1,5 +1,5 @@
 module Prolog
   module Blockly
-    VERSION = "1.0.15"
+    VERSION = "1.0.16"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prolog-blockly
 version: !ruby/object:Gem::Version
-  version: 1.0.15
+  version: 1.0.16
 platform: ruby
 authors:
 - Agustin Pina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-04 00:00:00.000000000 Z
+date: 2018-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler