The flipper tag takes two arguments: the user to look up and the feature
    to compare against.
173090
def do_flipper(parser, token):
    
    nodelist = parser.parse(('endflipper',))
    tag_name, user_key, feature = token.split_contents()
    parser.delete_first_token()
    return FlipperNode(nodelist, user_key, feature)
504977
def tag_implications(self, name_matches=None, antecedent_name=None,
                         tag_id=None):
        
        params = {
            'search[name_matches]': name_matches,
            'search[antecedent_name]': antecedent_name,
            'search[id]': tag_id
            }
        return self._get('tag_implications.json', params)
902148
private void evaluateTag(StringBuilder buf) {
    // Trim the '{' and '}' bounding characters.
    tag.pos++;
    tag.end--;

    // If this tag has been hidden from the processor, skip over the '-' and
    // emit the tag body.
    if (tag.peek() == Chars.MINUS_SIGN) {
      tag.pos++;
      buf.append('{');
      buf.append(tag.token());
      buf.append('}');
      return;
    }
    
    List<MessageArg> args = getArgs();
    if (args == null || args.size() == 0) {
      return;
    }

    MessageArg arg = args.get(0);

    // Process a short tag like "{1}" by just appending the argument value.
    if (tag.peek() == Chars.EOF) {
      if (arg.resolve()) {
        buf.append(arg.asString());
      }
      return;
    }

    // Parse the formatter name and execute the associated formatting method.
    if (tag.seek(FORMATTER, choice)) {
      String formatter = choice.token().toString();
      tag.jump(choice);
      switch (formatter) {
        case PLURAL:
          evalPlural(arg, true);
          break;

        case SELECTORDINAL:
          evalPlural(arg, false);
          break;

        case SELECT:
          evalSelect(arg);
          break;
          
        case CURRENCY:
        case MONEY:
          evalCurrency(arg);
          break;

        case DATETIME:
          evalDateTime(arg);
          break;
          
        case DATETIME_INTERVAL:
          evalDateTimeInterval(args);
          break;

        case DECIMAL:
        case NUMBER:
          evalNumber(arg);
          break;
          
        case UNIT:
          evalUnit(arg);
          break;
      }
    }
  }
851307
function(one, two) {
        if (one.tag != two.tag) {
            return false;
        } else if (one.text.trim() != two.text.trim()) {
            return false;
        } else if (one._children.length != two._children.length) {
            return false;
        }

        if (!attribMatch(one, two)) return false;

        for (var i = 0; i < one._children.length; i++) {
            if (!module.exports.equalNodes(one._children[i], two._children[i])) {
                return false;
            }
        }

        return true;
    }
690367
def do_rating_by_user(parser, token):
    
    
    bits = token.contents.split()
    if len(bits) != 6:
        raise template.TemplateSyntaxError("'%s' tag takes exactly five arguments" % bits[0])
    if bits[2] != 'on':
        raise template.TemplateSyntaxError("second argument to '%s' tag must be 'on'" % bits[0])
    if bits[4] != 'as':
        raise template.TemplateSyntaxError("fourth argument to '%s' tag must be 'as'" % bits[0])
    return RatingByUserNode(bits[1], bits[3], bits[5])
1321468
def _parse_read_preference(options):
    """"""
    if 'read_preference' in options:
        return options['read_preference']

    name = options.get('readpreference', 'primary')
    mode = read_pref_mode_from_name(name)
    tags = options.get('readpreferencetags')
    max_staleness = options.get('maxstalenessseconds', -1)
    return make_read_preference(mode, tags, max_staleness)
797272
function(element1, element2) {

        while (true) {

            if(element1.tagName !== element2.tagName) {
                return false;
            }
            if(element1 === element2) {
                return true;
            }

            // stop at body tag
            if (element1 === undefined || element1.tagName === 'body'
                || element1.tagName === 'BODY') {
                return false;
            }
            if (element2 === undefined || element2.tagName === 'body'
                || element2.tagName === 'BODY') {
                return false;
            }

            element1 = element1.parentNode;
            element2 = element2.parentNode;
        }
    }
466883
def _first(self, tag):
		'''  '''

		self.getelements()
		for element in self.elements:
			if tag in self.pos(element):
				return element
		return None
883637
def use_comparative_item_view(self):
        """"""
        self._object_views['item'] = COMPARATIVE
        # self._get_provider_session('item_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_item_view()
            except AttributeError:
                pass
465981
function (name, value, tag/*, ...*/) {
    var args = SLICE.call(arguments, 2);
    args[0] = value;
    return this.visit.apply(this, args);
  }
723829
def _check_if_tag_already_exists(self):
        """"""
        version = self.data['new_version']
        if self.vcs.tag_exists(version):
            return True
        else:
            return False
1064787
public static boolean areTagMaskEquals(TagMask tagMask1, TagMask tagMask2) {
		if ((tagMask1 == null && tagMask2 != null)
				|| (tagMask1 != null && tagMask2 == null)) {
			return false;
		} else if (tagMask1 != null && tagMask2 != null) {
			if (tagMask1.getCase() != tagMask2.getCase()) {
				return false;
			} else if (tagMask1.getClazz() != tagMask2.getClazz()) {
				return false;
			} else if (tagMask1.getGender() != tagMask2.getGender()) {
				return false;
			} else if (tagMask1.getMood() != tagMask2.getMood()) {
				return false;
			} else if (tagMask1.getNumber() != tagMask2.getNumber()) {
				return false;
			} else if (tagMask1.getPerson() != tagMask2.getPerson()) {
				return false;
			} else if (tagMask1.getPunctuation() != tagMask2.getPunctuation()) {
				return false;
			} else if (tagMask1.getSyntacticFunction() != tagMask2.getSyntacticFunction()) {
				return false;
			} else if (tagMask1.getTense() != tagMask2.getTense()) {
				return false;
			}
			// TODO complete with the rest of the tag masks (if any)
		}
		return true;
	}
696261
def wf_point_tag?(key, val)
      if key && val && (key.size + val.size < 254) &&
         key =~ /^[\w\-\.:]+$/ && val !~ /\\$/
        return
      end

      raise Wavefront::Exception::InvalidTag
    end
384230
def reverse_lookup(self, value, condition=is_active):
        '''  '''
        label = get_value_label(value, self._picklist, condition=condition)
        return label
1068653
def handle_starttag(self, tagName, attributeList, isSelfClosing=False):
        '''
            
        '''
        newTag = AdvancedHTMLParser.handle_starttag(self, tagName, attributeList, isSelfClosing)
        self._indexTag(newTag)

        return newTag
565885
def show_feature(user, feature):
    
    FeatureFlipper = get_feature_model()
    return FeatureFlipper.objects.show_feature(user, feature)
362839
def match_criterion(self, tag):
        '''
        '''
        return tag.name == self.reference_tag_name and \
            tag.attrs.get('kind', '') == self.reference_tag_kind