C++ (Cpp) mustache_spec_parse_data示例

示例#1

文件： test_spec.cpp 项目： cgvarela/libmustache

void mustache_spec_parse_data(yaml_document_t * document, yaml_node_t * node, mustache::Data * data)
{
  if( node->type == YAML_MAPPING_NODE ) {
    yaml_node_pair_t * pair;
    
    data->init(mustache::Data::TypeMap, 0);
    
    for( pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair++ ) {
      yaml_node_t * keyNode = yaml_document_get_node(document, pair->key);
      yaml_node_t * valueNode = yaml_document_get_node(document, pair->value);
      char * keyValue = reinterpret_cast<char *>(keyNode->data.scalar.value);
      mustache::Data * child = new mustache::Data();
      mustache_spec_parse_data(document, valueNode, child);
      data->data.insert(std::pair<std::string,mustache::Data*>(keyValue,child));
    }
  } else if( node->type == YAML_SEQUENCE_NODE ) {
    yaml_node_item_t * item;
    int nItems = node->data.sequence.items.top - node->data.sequence.items.start;
    data->init(mustache::Data::TypeArray, nItems);
    int i = 0;
    for( item = node->data.sequence.items.start; item < node->data.sequence.items.top; item ++) {
      mustache::Data * child = new mustache::Data();
      data->array.push_back(child);
      yaml_node_t * valueNode = yaml_document_get_node(document, *item);
      mustache_spec_parse_data(document, valueNode, child);
    }
    data->length = data->array.size();
  } else if( node->type == YAML_SCALAR_NODE ) {
    char * keyValue = reinterpret_cast<char *>(node->data.scalar.value);
    if( strcmp(keyValue, "0") == 0 ||
        strcmp(keyValue, "false") == 0 ) {
      data->init(mustache::Data::TypeString, 0);
    } else {
      data->init(mustache::Data::TypeString, node->data.scalar.length);
      data->val->assign(keyValue);
      mustache::trimDecimal(*(data->val));
    }
  }
}

示例#2

文件： test_spec.cpp 项目： cgvarela/libmustache

void mustache_spec_parse_test(yaml_document_t * document, yaml_node_t * node)
{
  if( node->type != YAML_MAPPING_NODE ) {
    return;
  }
  
  MustacheSpecTest * test = new MustacheSpecTest;
  
  yaml_node_pair_t * pair;
  for( pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair++ ) {
    yaml_node_t * keyNode = yaml_document_get_node(document, pair->key);
    yaml_node_t * valueNode = yaml_document_get_node(document, pair->value);
    char * keyValue = reinterpret_cast<char *>(keyNode->data.scalar.value);
    
    if( valueNode->type == YAML_SCALAR_NODE ) {
      char * valueValue = reinterpret_cast<char *>(valueNode->data.scalar.value);
      if( strcmp(keyValue, "name") == 0 ) {
        test->name.assign(valueValue);
      } else if( strcmp(keyValue, "desc") == 0 ) {
        test->desc.assign(valueValue);
      } else if( strcmp(keyValue, "template") == 0 ) {
        test->tmpl.assign(valueValue);
      } else if( strcmp(keyValue, "expected") == 0 ) {
        test->expected.assign(valueValue);
      }
    } else if( valueNode->type == YAML_MAPPING_NODE ) {
      if( strcmp(keyValue, "data") == 0 ) {
        mustache_spec_parse_data(document, valueNode, &test->data);
      } else if( strcmp(keyValue, "partials") == 0 ) {
        mustache_spec_parse_partials(document, valueNode, &test->partials);
      }
    }
  }
  
  mustache::Mustache mustache;
  mustache::Compiler compiler;
  mustache::VM vm;
  
  // Tokenize
  mustache::Node root;
  mustache.tokenize(&test->tmpl, &root);
  
  // Compile
  mustache::Compiler::vectorToBuffer(compiler.compile(&root, &test->partials), &test->compiled, &test->compiled_length);
  
  // Execute the test
  for( int i = 0; i < execNum; i++ ) {
    test->output.clear();
    mustache.render(&root, &test->data, &test->partials, &test->output);
  }
  
  // Execute the test in VM mode
  for( int i = 0; i < execNum; i++ ) {
    test->compiled_output.clear();
    vm.execute(test->compiled, test->compiled_length, &test->data, &test->compiled_output);
  }
  
  // Output result
  test->print();
  tests.push_back(test);
}

示例#3

文件： test_spec.cpp 项目： jbboehr/libmustache

void mustache_spec_parse_test(yaml_document_t * document, yaml_node_t * node)
{
  if( node->type != YAML_MAPPING_NODE ) {
    return;
  }
  
  MustacheSpecTest * test = new MustacheSpecTest;
  
  yaml_node_pair_t * pair;
  for( pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair++ ) {
    yaml_node_t * keyNode = yaml_document_get_node(document, pair->key);
    yaml_node_t * valueNode = yaml_document_get_node(document, pair->value);
    char * keyValue = reinterpret_cast<char *>(keyNode->data.scalar.value);
    
    if( valueNode->type == YAML_SCALAR_NODE ) {
      char * valueValue = reinterpret_cast<char *>(valueNode->data.scalar.value);
      if( strcmp(keyValue, "name") == 0 ) {
        test->name.assign(valueValue);
      } else if( strcmp(keyValue, "desc") == 0 ) {
        test->desc.assign(valueValue);
      } else if( strcmp(keyValue, "template") == 0 ) {
        test->tmpl.assign(valueValue);
      } else if( strcmp(keyValue, "expected") == 0 ) {
        test->expected.assign(valueValue);
      }
    } else if( valueNode->type == YAML_MAPPING_NODE ) {
      if( strcmp(keyValue, "data") == 0 ) {
        mustache_spec_parse_data(document, valueNode, &test->data);
      } else if( strcmp(keyValue, "partials") == 0 ) {
        mustache_spec_parse_partials(document, valueNode, &test->partials);
      }
    }
  }
  
  mustache::Mustache mustache;
  bool isLambdaSuite = 0 == strcmp(currentSuite, "~lambdas.yml");
  
  // Load lambdas?
  if( isLambdaSuite ) {
    load_lambdas_into_test_data(&test->data, test->name);
  }

  // This test isn't supported yet
  if (test->name == "Implicit Iterator - Array") {
    return;
  }

  // Tokenize
  mustache::Node root;
  mustache.tokenize(&test->tmpl, &root);
  
  // Execute the test
  for( int i = 0; i < execNum; i++ ) {
    test->output.clear();
    mustache.render(&root, &test->data, &test->partials, &test->output);
  }
  
  // Output result
  test->print();
  tests.push_back(test);
}