Parses era data from Can I Use raw database
@param  {Object} data
@return {Array}
519259
function parseEra(data) {
		// some runtimes (like Mozilla Rhino) does not preserves
		// key order so we have to sort values manually
		return Object.keys(data.eras).sort(function(a, b) {
			return parseInt(a.substr(1)) - parseInt(b.substr(1));
		});
	}
45525
function dataToObjects (data) {
  if (!data) return null
  if (data instanceof Array) {
    return data.map(function(doc) { 
      return doc.toObject()
    })
  }
  return data.toObject()
}
398851
function extractFixturesData( data ) {
    return Promise.map( data.section(), function( section ) {
      var markup  = section.markup();
      var ext     = path.extname( markup );
      var testDir = data.data.files[0].split("/")
            .filter(function(dir, i) {
              return i <= 2;
            })
            .concat([path.dirname( markup ), (path.basename( markup, ext ) + ext) ])
            .join('/');
  
      return Promise.props({
        header : section.header(),
        description : section.description(),
        markup : fs.readFileAsync( testDir, 'utf8' ).then( mustache.render ),
        name : path.basename( section.markup(), path.extname( section.markup() ) )
      });
   });
  }
313987
def parse_radl(data):
    
    if not isinstance(data, list):
        if os.path.isfile(data):
            f = open(data)
            data = "".join(f.readlines())
            f.close()
        data = json.loads(data)
    data = encode_simple(data)
    res = RADL()
    for aspect in [p_aspect(a) for a in data]:
        res.add(aspect)
    return res
918173
function parseCommand(data) {
  var command,
      str = data.toString('utf8', 0, data.length);

  command = str.split('\n');
  return command[0];
}
550486
function camelCaseData(data) {
  const result = {};
  const keys = Object.keys(data);
  keys.forEach((k) => {
    const key = camelCase(k);
    const value = data[k];
    if (isObject(value)) {
      result[key] = camelCaseData(value);
    } else {
      result[key] = value;
    }
  });
  return result;
}
1022605
function(data) {
    return Promise.each(normalizer(data), function(datum) {
      return Promise.retry(function() {
        return compose.pull(datum.compose, datum.project, datum.opts);
      });
    })
    .then(function() {
      return Promise.each(normalizer(data), function(datum) {
        return Promise.retry(function() {
          return compose.build(datum.compose, datum.project, datum.opts);
        });
      });
    });
  }
751040
public static Map<String, Object> parseData(String data) {
		Map<String, Object> ret = new HashMap<String, Object>();
		String[] split = data.split("&");
		for (String s : split) {
			int idx = s.indexOf('=');
			try {
				if (idx != -1) {
					ret.put(URLDecoder.decode(s.substring(0, idx), "UTF-8"), URLDecoder.decode(s.substring(idx + 1), "UTF-8"));
				} else {
					ret.put(URLDecoder.decode(s, "UTF-8"), "true");
				}
			} catch (UnsupportedEncodingException e) {
				// Why.
			}
		}
		return ret;
	}
569039
private function convertData(array $data = null)
    {
        if (!is_array($data)) {
            return $data;
        }

        foreach ($data as $key => $val) {
            /** convert dbrefs */
            if (is_array($val) && isset($val['$ref']) && isset($val['$id'])) {
                $data[$key] = $this->convertData(
                    $this->resolveObject($val['$ref'], $val['$id'])
                );
            } elseif (is_array($val)) {
                $data[$key] = $this->convertData($val);
            }
            /** convert mongodate to text dates **/
            if ($val instanceof \MongoDate) {
                $data[$key] = $this->dateConverter->formatDateTime($val->toDateTime());
            }
            /** convert mongoid */
            if ($val instanceof \MongoId) {
                $data[$key] = (string) $val;
            }
        }

        return $data;
    }
146936
def parse(data = nil)
      data ||= @raw_data
    
      # wrapper array holding hashes of css tags/rules
      css_out = []
      # clear initial spaces
      data.strip_side_space!.strip_space!
    
      # split on end of assignments
      data.split('}').each_with_index do |assignments, index|
        # split again to separate tags from rules
        tags, styles = assignments.split('{').map{|a| a.strip_side_space!}
        unless styles.blank?
          # clean up tags and apply namespaces as needed
          tags.strip_selector_space!
          tags.gsub!(/\./, ".#{namespace}") unless namespace.blank?
      
          # split on semicolon to iterate through each rule
          rules = []
          styles.split(';').each do |key_val_pair|
            unless key_val_pair.nil?
              # split by property/val and append to rules array with correct declaration
              property, value = key_val_pair.split(':', 2).map{|kv| kv.strip_side_space!}
              break unless property && value
              rules << "#{property}:#{value};"
            end
          end
          # now keeps track of index as hashes don't keep track of position (which will be fixed in Ruby 1.9)
          css_out << {:tags => tags, :rules => rules.join, :idx => index} unless tags.blank? || rules.to_s.blank?
        end
      end
      css_out
    end
966118
function (data) {
      var parse = function() {
        var parsed = lazy.extend({}, lazy.parseFilepath(this.path), data);
        if (typeof parsed.ext === 'undefined') {
          parsed.ext = parsed.extname;
        }
        return parsed;
      }.bind(this);
      return this.fragmentCache('path', parse);
    }
427973
private function parseReturnData($data)
    {
        $format = strtolower(Config::get("FORMAT"));
        switch ($format) {
            case "json":
                return RV\Json::parse($data);
                break;
            case "xml":
                return RV\Xml::parse($data);
                break;
        }
    }
1055656
function (data) {
    var str = '', start = true;
    var jsondata = '';
    for (var key in data) {
      if (typeof (jsondata = JSON.stringify(data[key])) === 'string') {
        str += (start? '': '&');
        str += encodeURIComponent(key) + '=' + encodeURIComponent(jsondata);
        if (start) { start = false; }
      }
    }
    return str;
  }
525102
def _parse(self, data):
        
        self.description = data['description']
        self.in_gallery = data['in_gallery']
        self.mod_time = int(time.time())
        self.title = data['title']
695443
function(data) {
		if( typeof data == "string" ) {
			var transformed = {};
			$.each(data.split(/\s/), function() {
				transformed[this] = true;
			});
			data = transformed;
		}
		return data;
	}
780065
function ParseMetaData(countryCode, md) {
    var array = eval(md.replace(BACKSLASH, "\\\\"));
    md = ParseArray(array,
                    META_DATA_ENCODING,
                    { countryCode: countryCode });
    regionCache[md.region] = md;
    return md;
  }
477691
function parse (str, options) {
  if (typeof str !== 'string') throw new TypeError('str is required!');

  var splitData = split(str);
  var raw = splitData.data;

  if (!raw) return { _content: str };

  var data;

  data = parseYAML(raw, options);

  if (!data) return { _content: str };

  data._content = splitData.content;

  return data;
}