From bb3fbf271abac1783d048ec2981cf1ebe28d7031 Mon Sep 17 00:00:00 2001
From: simosathan9 <simosathan03@gmail.com>
Date: Thu, 10 Oct 2024 21:18:45 +0300
Subject: [PATCH] Changes for awk blocks

---
 index.html                            |   2 +
 public/blocks/NFBlock.js              |   6 +-
 public/blocks/NRBlock.js              |   5 +-
 public/blocks/awkBlock.js             |   5 +-
 public/blocks/columnBlock.js          |   6 +-
 public/blocks/conditionActionBlock.js |  15 +-
 public/blocks/conditionBlock.js       |  71 +++++++
 public/blocks/sedBlock.js             |   2 +-
 public/js/block.js                    | 288 ++++++++++++++------------
 9 files changed, 266 insertions(+), 134 deletions(-)
 create mode 100644 public/blocks/conditionBlock.js

diff --git a/index.html b/index.html
index fc86398..805e6f3 100644
--- a/index.html
+++ b/index.html
@@ -84,6 +84,7 @@
     <script src="blocks/NFBlock.js"></script>
     <script src="blocks/xargsBlock.js"></script>
     <script src="blocks/conditionActionBlock.js"></script>
+    <script src="blocks/conditionBlock.js"></script>
     <!-- END OF BLOCK DEFINITION -->
     <script>
       document.addEventListener('DOMContentLoaded', () => {
@@ -456,6 +457,7 @@
               { kind: 'block', type: 'NR' },
               { kind: 'block', type: 'NF' },
               { kind: 'block', type: 'xargs' },
+              { kind: 'block', type: 'condition' },
               {
                 kind: 'category',
                 name: [MSG.TEXT_OUTPUT],
diff --git a/public/blocks/NFBlock.js b/public/blocks/NFBlock.js
index f0c6833..48b972a 100644
--- a/public/blocks/NFBlock.js
+++ b/public/blocks/NFBlock.js
@@ -16,7 +16,11 @@ var NFBlock = {
   style: 'Field Processing',
   output: null,
   tooltip: '%{BKY_FIELD_NUMBER_TOOLTIP}',
-  helpUrl: '%{BKY_FIELD_NUMBER_HELPURL}' // URL to further information or documentation.
+  helpUrl: '%{BKY_FIELD_NUMBER_HELPURL}', // URL to further information or documentation.
+  generateCommand: function (block) {
+    var awkCommand = 'NF';
+    return awkCommand;
+  }
 };
 
 Blockly.defineBlocksWithJsonArray([NFBlock]);
diff --git a/public/blocks/NRBlock.js b/public/blocks/NRBlock.js
index 1ec2b17..7c85c4f 100644
--- a/public/blocks/NRBlock.js
+++ b/public/blocks/NRBlock.js
@@ -16,7 +16,10 @@ var NRBlock = {
   style: 'Field Processing',
   output: null,
   tooltip: '%{BKY_RECORD_NUMBER_TOOLTIP}',
-  helpUrl: '%{BKY_RECORD_NUMBER_HELPURL}' // URL to further information or documentation.
+  helpUrl: '%{BKY_RECORD_NUMBER_HELPURL}', // URL to further information or documentation.
+  generateCommand: function (block) {
+    return 'NR';
+  }
 };
 
 Blockly.defineBlocksWithJsonArray([NRBlock]);
diff --git a/public/blocks/awkBlock.js b/public/blocks/awkBlock.js
index e31887e..246bc6a 100644
--- a/public/blocks/awkBlock.js
+++ b/public/blocks/awkBlock.js
@@ -26,7 +26,10 @@ var awkBlock = {
   previousStatement: 'Action',
   nextStatement: 'Action',
   tooltip: '%{BKY_AWK_TOOLTIP}',
-  helpUrl: '%{BKY_AWK_HELPURL}' // URL to further information or documentation.
+  helpUrl: '%{BKY_AWK_HELPURL}', // URL to further information or documentation.
+  generateCommand: function (block) {
+    var awkInput_delimiter = block.getFieldValue('awkInput_delimiter');
+  }
 };
 
 Blockly.defineBlocksWithJsonArray([awkBlock]);
diff --git a/public/blocks/columnBlock.js b/public/blocks/columnBlock.js
index abc70c2..1d09f1c 100644
--- a/public/blocks/columnBlock.js
+++ b/public/blocks/columnBlock.js
@@ -16,7 +16,11 @@ var columnBlock = {
   output: null,
   style: 'Field Processing',
   tooltip: '%{BKY_COLUMN_TOOLTIP}',
-  helpUrl: '%{BKY_COLUMN_HELPURL}'
+  helpUrl: '%{BKY_COLUMN_HELPURL}',
+  generateCommand: function (block) {
+    var text = block.getFieldValue('TEXT');
+    return '$' + text;
+  }
 };
 
 Blockly.defineBlocksWithJsonArray([columnBlock]);
diff --git a/public/blocks/conditionActionBlock.js b/public/blocks/conditionActionBlock.js
index a05ded4..7c1ada6 100644
--- a/public/blocks/conditionActionBlock.js
+++ b/public/blocks/conditionActionBlock.js
@@ -20,7 +20,20 @@ var conditionActionBlock = {
   nextStatement: null,
   style: 'Field Processing',
   tooltip: '%{BKY_CONDITION_ACTION_TOOLTIP}',
-  helpUrl: '%{BKY_CONDITION_ACTION_HELPURL}' // URL to further information or documentation.
+  helpUrl: '%{BKY_CONDITION_ACTION_HELPURL}', // URL to further information or documentation.
+  generateCommand: function (block) {
+    var cond = block.getInputTargetBlock('COND');
+    var condCommand = '';
+    if (cond !== null) {
+      condCommand = handleBlockByType(cond);
+    }
+    var action = block.getInputTargetBlock('DO');
+    actionCommand = '';
+    if (action !== null) {
+      actionCommand = handleBlockByType(action);
+    }
+    return condCommand + ' {' + actionCommand + '}';
+  }
 };
 
 Blockly.defineBlocksWithJsonArray([conditionActionBlock]);
diff --git a/public/blocks/conditionBlock.js b/public/blocks/conditionBlock.js
new file mode 100644
index 0000000..8b6781b
--- /dev/null
+++ b/public/blocks/conditionBlock.js
@@ -0,0 +1,71 @@
+var conditionBlock = {
+  type: 'condition',
+  category: 'Field Processing',
+  message0: '%1', // First message line for left_part
+  args0: [
+    {
+      type: 'input_value',
+      name: 'left_part',
+      check: ['String', 'Number', 'Boolean'] // Allow both String and Number types
+    }
+  ],
+  message1: '%1', // Second message line for operator
+  args1: [
+    {
+      type: 'field_dropdown',
+      name: 'operator',
+      options: [
+        ['==', '=='],
+        ['!=', '!='],
+        ['<', '<'],
+        ['<=', '<='],
+        ['>', '>'],
+        ['>=', '>=']
+      ]
+    }
+  ],
+  message2: '%1', // Third message line for right_part
+  args2: [
+    {
+      type: 'input_value',
+      name: 'right_part',
+      check: ['String', 'Number', 'Boolean'] // Allow both String and Number types
+    }
+  ],
+  style: 'Field Processing',
+  previousStatement: null,
+  generateCommand: function (block) {
+    var awkCondition = '';
+    const leftPartBlock = block.getInputTargetBlock('left_part');
+    const rightPartBlock = block.getInputTargetBlock('right_part');
+
+    const operator = block.getFieldValue('operator');
+    var leftPart = '';
+    var rightPart = '';
+
+    // Retrieve the command for the left part block, if it exists
+    if (leftPartBlock !== null) {
+      leftPart = handleBlockByType(leftPartBlock);
+    }
+    if (leftPart === '') {
+      leftPart = leftPartBlock.getFieldValue('TEXT');
+    }
+    console.log('leftPartBlock:', leftPart);
+
+    // Retrieve the command for the right part block, if it exists
+    if (rightPartBlock !== null) {
+      rightPart = handleBlockByType(rightPartBlock);
+    }
+
+    console.log('leftPart:', leftPart);
+    console.log('operator:', operator);
+    console.log('rightPart:', rightPart);
+
+    // Combine the parts to form the AWK condition
+    awkCondition = leftPart + ' ' + operator + ' ' + rightPart;
+
+    return awkCondition;
+  }
+};
+
+Blockly.defineBlocksWithJsonArray([conditionBlock]);
diff --git a/public/blocks/sedBlock.js b/public/blocks/sedBlock.js
index c7d1382..3afa2be 100644
--- a/public/blocks/sedBlock.js
+++ b/public/blocks/sedBlock.js
@@ -49,7 +49,7 @@ var sedBlock = {
   tooltip: '%{BKY_SED_TOOLTIP}',
   helpUrl: '%{BKY_SED_HELPURL}', // URL to further information or documentation.
   generateCommand: function (block) {
-    let sedCommand = handleBlock(block); // Basic sed command
+    let sedCommand = handleBlockByType(block); // Basic sed command
 
     // Handle pattern and replacement
     let patternBlock = block.getInputTargetBlock('regPattern');
diff --git a/public/js/block.js b/public/js/block.js
index 0c7975f..ef35930 100644
--- a/public/js/block.js
+++ b/public/js/block.js
@@ -14,7 +14,7 @@ function generateCommandFromWorkspace() {
   while (currentBlock) {
     blockCount++;
     var blockDef = window[currentBlock.type + 'Block'];
-    const specificCommand = handleSpecificBlocks(currentBlock);
+    const specificCommand = handleBlockByType(currentBlock);
     try {
       if (filenameBlocks.includes(currentBlock.type)) {
       } else if (
@@ -139,83 +139,6 @@ function handleBlock(block) {
     commandString = commandParts.join('');
   } else if (blockType === 'variables_set') {
     commandString = variable_name + '=' + variable_value + ' |';
-  } else if (blockType === 'awk') {
-    let beginIndex = commandParts.indexOf('BEGIN');
-    let endIndex = commandParts.indexOf('END');
-    let inputDelimIndex = commandParts.findIndex(
-      (element) => typeof element === 'string' && element.includes('-F')
-    );
-
-    let begin = beginIndex !== -1 ? commandParts[beginIndex] : '';
-    let end = endIndex !== -1 ? commandParts[endIndex] : '';
-    let inputDelim =
-      inputDelimIndex !== -1 ? commandParts[inputDelimIndex] : '';
-    if (conditionValue !== '') {
-      commandString =
-        blockType +
-        ' ' +
-        inputDelim +
-        ' ' +
-        "'" +
-        ' ' +
-        begin +
-        ' ' +
-        beginValue +
-        ' ' +
-        conditionValue +
-        ' ' +
-        regexStringValue +
-        ' ' +
-        end +
-        ' ' +
-        endValue +
-        ' ' +
-        "'" +
-        ' ' +
-        filenameValue;
-    } else {
-      let filteredArray = commandParts.filter(
-        (item) =>
-          item !== '' &&
-          item !== null &&
-          item !== undefined &&
-          !item.includes('undefined') &&
-          !item.includes('BEGIN') &&
-          !item.includes('END')
-      );
-      commandString =
-        blockType +
-        ' ' +
-        inputDelim +
-        ' ' +
-        "'" +
-        ' ' +
-        begin +
-        ' ' +
-        beginValue +
-        ' ' +
-        ' ' +
-        regexStringValue +
-        ' ' +
-        end +
-        ' ' +
-        endValue +
-        ' ' +
-        "'" +
-        ' ' +
-        filenameValue;
-    }
-  } else if (blockType === 'find') {
-    commandString =
-      blockType +
-      ' ' +
-      commandParts.join(' ') +
-      ' ' +
-      conditionValue +
-      ' ' +
-      regexStringValue +
-      ' ' +
-      wildcardFilenameValue;
   } else {
     commandString =
       blockType +
@@ -334,24 +257,162 @@ function handleMainBlocks(
 }
 
 function handleSpecificBlocks(currentBlock) {
+  const blockTypesWithCommand = {
+    touch: touchBlock,
+    sed: sedBlock,
+    ln: lnBlock,
+    mv: mvBlock,
+    rm: rmBlock,
+    awk: awkBlock,
+    conditionAction: conditionActionBlock,
+    cut: cutBlock,
+    NR: NRBlock,
+    NF: NFBlock,
+    column: columnBlock,
+    condition: conditionBlock
+  };
+
+  if (blockTypesWithCommand[currentBlock.type]) {
+    return blockTypesWithCommand[currentBlock.type].generateCommand(
+      currentBlock
+    );
+  }
+  return '';
+}
+
+function handleBuiltInBlocks(currentBlock) {
   let generatedCommand = '';
-  // Handle different block types
-  if (currentBlock.type === 'touch') {
-    generatedCommand = touchBlock.generateCommand(currentBlock);
-  } else if (currentBlock.type === 'sed') {
-    generatedCommand = sedBlock.generateCommand(currentBlock);
-  } else if (currentBlock.type === 'ln') {
-    generatedCommand = lnBlock.generateCommand(currentBlock);
-  } else if (currentBlock.type === 'mv') {
-    generatedCommand = mvBlock.generateCommand(currentBlock);
-  } else if (currentBlock.type === 'rm') {
-    generatedCommand = rmBlock.generateCommand(currentBlock);
-  } else if (currentBlock.type === 'cut') {
-    generatedCommand = cutBlock.generateCommand(currentBlock);
+
+  // Helper function to get variable by ID and return its name
+  const getVariableName = (variableId) => {
+    const variableModel =
+      Blockly.getMainWorkspace().getVariableById(variableId);
+    return variableModel ? variableModel.name : '';
+  };
+
+  // Helper function to get operator symbol
+  const getOperatorSymbol = (operatorField) => {
+    const operators = {
+      EQ: '==',
+      NEQ: '!=',
+      LT: '<',
+      LTE: '<=',
+      GT: '>',
+      GTE: '>=',
+      ADD: '+',
+      MINUS: '-',
+      MULTIPLY: '*',
+      DIVIDE: '/',
+      POWER: '^',
+      AND: '&&', // Logical AND
+      OR: '||', // Logical OR
+      NOT: '!' // Logical NOT
+    };
+    return operators[operatorField];
+  };
+
+  switch (currentBlock.type) {
+    // Variables set
+    case 'variables_set': {
+      const variableId = currentBlock.getFieldValue('VAR');
+      const variableSetTo = handleBlockByType(
+        currentBlock.getInputTargetBlock('VALUE')
+      );
+      const variableName = getVariableName(variableId);
+      generatedCommand = `${variableName}=${variableSetTo}`;
+      break;
+    }
+
+    // Variables get
+    case 'variables_get': {
+      const variableId = currentBlock.getFieldValue('VAR');
+      generatedCommand = getVariableName(variableId);
+      break;
+    }
+
+    // Math number
+    case 'math_number': {
+      generatedCommand = currentBlock.getFieldValue('NUM');
+      break;
+    }
+
+    // Math arithmetic
+    case 'math_arithmetic': {
+      const leftBlockCode = handleBlockByType(
+        currentBlock.getInputTargetBlock('A')
+      );
+      const rightBlockCode = handleBlockByType(
+        currentBlock.getInputTargetBlock('B')
+      );
+      const operatorSymbol = getOperatorSymbol(
+        currentBlock.getFieldValue('OP')
+      );
+      generatedCommand = `${leftBlockCode} ${operatorSymbol} ${rightBlockCode}`;
+      break;
+    }
+
+    // Logic compare
+    case 'logic_compare' || 'logic_operation': {
+      const leftBlockCode = handleBlockByType(
+        currentBlock.getInputTargetBlock('A')
+      );
+      const rightBlockCode = handleBlockByType(
+        currentBlock.getInputTargetBlock('B')
+      );
+      const operatorSymbol = getOperatorSymbol(
+        currentBlock.getFieldValue('OP')
+      );
+      generatedCommand = `${leftBlockCode} ${operatorSymbol} ${rightBlockCode}`;
+      break;
+    }
+
+    // Control flow (if) block
+    case 'controls_if': {
+      const conditionBlock = currentBlock.getInputTargetBlock('IF0');
+      const actionBlock = currentBlock.getInputTargetBlock('DO0');
+      let blockCode = '';
+
+      if (conditionBlock) {
+        const leftBlockCode = handleBlockByType(
+          conditionBlock.getInputTargetBlock('A')
+        );
+        const rightBlockCode = handleBlockByType(
+          conditionBlock.getInputTargetBlock('B')
+        );
+        const operatorSymbol = getOperatorSymbol(
+          conditionBlock.getFieldValue('OP')
+        );
+        blockCode = `if (${leftBlockCode} ${operatorSymbol} ${rightBlockCode}) {`;
+      }
+
+      if (actionBlock) {
+        blockCode += handleBlockByType(actionBlock);
+      }
+      blockCode += '}';
+      generatedCommand = blockCode;
+      break;
+    }
   }
   return generatedCommand;
 }
 
+function handleBlockByType(currentBlock) {
+  const builtInBlockTypes = [
+    'variables_set',
+    'variables_get',
+    'math_number',
+    'math_arithmetic',
+    'logic_compare',
+    'controls_if'
+  ];
+
+  if (builtInBlockTypes.includes(currentBlock.type)) {
+    return handleBuiltInBlocks(currentBlock); // Use built-in handler
+  } else {
+    return handleSpecificBlocks(currentBlock); // Use specific handler
+  }
+}
+
 function handleArgumentsBlocks(block) {
   var arguments = '';
   if (block && block.type === 'argumentsCreate') {
@@ -373,6 +434,14 @@ function handleArgumentsBlocks(block) {
   }
 }
 
+function handleConditionActionBlocks(block) {
+  var conditionAction = '';
+  if (block && block.type === 'conditionAction') {
+    let conditionActionPairs = [];
+    for (let i = 0; i < block.itemCount_; i++) {}
+  }
+}
+
 function handleRegexBlocks(block, blockDefinition, patternValue) {
   let commandParts = [];
   const blockName = block.type;
@@ -659,12 +728,6 @@ function getMultiplePrints(block) {
   return prints.join(',');
 }
 
-generator.forBlock['column'] = function (block) {
-  var text = block.getFieldValue('TEXT');
-  var code = '$' + `'${text}'`;
-  return [code, generator.ORDER_ATOMIC];
-};
-
 generator.forBlock['text'] = function (block) {
   var textValue = block.getFieldValue('TEXT');
   var code = '"' + textValue + '"';
@@ -685,37 +748,6 @@ generator.forBlock['arrayCreate'] = function (block) {
   return ['(' + listString + ')', generator.ORDER_ATOMIC];
 };
 
-generator.forBlock['logic_compare'] = function (block) {
-  var leftBlock = block.getInputTargetBlock('A');
-  var rightBlock = block.getInputTargetBlock('B');
-  var leftBlockCode = generator.valueToCode(block, 'A', generator.ORDER_ATOMIC);
-  var rightBlockCode = generator.valueToCode(
-    block,
-    'B',
-    generator.ORDER_ATOMIC
-  );
-  if (leftBlock && leftBlock.type === 'regOutput' && leftBlockCode) {
-    leftBlockCode = '/' + leftBlockCode + '/';
-  }
-
-  // Construct the final code for the logic_compare block
-  var operator = block.getFieldValue('OP');
-
-  // Map the field value to the corresponding symbol
-  var operators = {
-    EQ: '==',
-    NEQ: '!=',
-    LT: '<',
-    LTE: '<=',
-    GT: '>',
-    GTE: '>='
-  };
-  var operatorSymbol = operators[operator];
-
-  var code = leftBlockCode + ' ' + operatorSymbol + ' ' + rightBlockCode;
-  return [code, generator.ORDER_RELATIONAL];
-};
-
 //***********************************
 //EXTENSIONS FOR VALIDATIONS - START
 //***********************************