transformer /////////////////////////////
13855
public static MissingAuthorizationDto fromInfo(MissingAuthorization info) {
    MissingAuthorizationDto dto = new MissingAuthorizationDto();

    dto.setPermissionName(info.getViolatedPermissionName());
    dto.setResourceId(info.getResourceId());
    dto.setResourceName(info.getResourceType());

    return dto;
  }
887386
function transformer(tree, file) {
        var duplicates = getDuplicates(tree, phrases)
        var overuse = getOveruse(duplicates, limit)

        search(tree, overuse, function (match, position, parent, phrase) {
            var suggestions = patterns[phrase];
            var value = quotation(nlcstToString(match), '“', '”');

            var reason = 'Replace ' + value + ' with ' +
                quotation(suggestions, '“', '”').join(', ');

            var message = file.warn(reason, {
                'start': match[0].position.start,
                'end': match[match.length - 1].position.end
            });

            message.ruleId = phrase;
            message.source = 'retext-overuse';
            message.actual = value.slice(1, -1);
            message.expected = suggestions;
        });
    }
493832
function transformer (selection) {
    const type = quantum.isSelection(selection) ? selection.type() : undefined
    const entityTransform = transformMap[type] || defaultTransform
    return entityTransform(selection, transformer, meta) // bootstrap to itself to  make the transformer accessible to children
  }
739879
function transformer(data, id) {
	function checkValue(obj) {
		if (!obj || typeof obj !== 'object') {
			return;
		}

		var keys = Object.keys(obj);

		if (keys.indexOf('value') !== -1) {
			obj.values = {};
			obj.values[id] = obj.value;
			delete obj.value;
			return;
		}

		for (var i = 0; i < keys.length; i++) {
			checkValue(obj[keys[i]]);
		}
	}

	checkValue(data);

	return data;
}
300981
public static <T extends Transformer> TransformerDescriptor<T> ofTransformer(final Class<T> transformerClass) {
        return new AnnotationBasedTransformerComponentDescriptor<>(transformerClass);
    }
882023
public static <T extends Transformer<?>> TransformerBeanDescriptor<T> ofTransformer(Class<T> transformerClass) {
        return new AnnotationBasedTransformerBeanDescriptor<T>(transformerClass);
    }
362312
public Transformer[] getDataProviderOutputTransformers() {
        Transformer[] transformers;

        if (dataProviderOutputTransformers == null) {
            transformers = null;
        } else {
            transformers = dataProviderOutputTransformers.toArray(new Transformer[dataProviderOutputTransformers.size
                    ()]);
        }

        return transformers;
    }
216231
protected function resolveTransformer(Model $model, $transformer = null)
    {
        $transformer = $transformer ?: $this->resolveTransformerFromModel($model);

        if (is_string($transformer)) {
            $transformer = new $transformer;
        }

        return $this->parseTransformer($transformer, $model);
    }
1144324
private void addFileToTransform(Map<Transformer,Map<String,Set<URI>>> gs, Transformer t, Source s) {
        Map<String,Set<URI>> fs = gs.get(t);
        if (fs == null) {
            fs = new HashMap<String,Set<URI>>();
            gs.put(t, fs);
        }
        Set<URI> ss = fs.get(s.pkg().name());
        if (ss == null) {
            ss = new HashSet<URI>();
            fs.put(s.pkg().name(), ss);
        }
        ss.add(s.file().toURI());
    }
623976
function getTransformer(name) {
    if (name in transformers) {
      return transformers[name]
    }
    const transformer = toTransformer(name)
    transformers[name] = transformer ? jstransformer(transformer) : false
    return transformers[name]
  }
37856
public static void toWriter(Node node, Writer writer) throws TransformerException {
		toWriter(node, writer, new HashMap<String, String>());
	}
104942
function transform(flapjack, pluginOptions, runtimeOptions) {
    var name = runtimeOptions.transformer;
    var transformer = transformerFactory.getTransformer(name, clientPlugin, pluginOptions);
    var options = _.extend({}, pluginOptions, runtimeOptions);
    return transformer.transform(flapjack, options);
}
91396
def add_transformers(line):
    '''
    '''
    assert FROM_EXPERIMENTAL.match(line)

    line = FROM_EXPERIMENTAL.sub(' ', line)
    # we now have: " transformer1 [,...]"
    line = line.split("#")[0]    # remove any end of line comments
    # and insert each transformer as an item in a list
    for trans in line.replace(' ', '').split(','):
        import_transformer(trans)
488978
protected <R, T extends Transformer<Transformed<R>>> Iterable<T> getTransformer(Class<T> transformerClass) {
        return Providers.getAllRankedSortedProviders(manager, transformerClass);
    }
337767
public function resolveTransformer()
    {
        if (is_string($this->resolver)) {
            return $this->container->make($this->resolver);
        } elseif (is_callable($this->resolver)) {
            return call_user_func($this->resolver, $this->container);
        } elseif (is_object($this->resolver)) {
            return $this->resolver;
        }

        throw new RuntimeException('Unable to resolve transformer binding.');
    }
534962
public void setPresetTransformer(String transformerName){
        for(Transformer t : Transformer.values()){
            if(t.equals(transformerName)){
                setPresetTransformer(t);
                return;
            }
        }
    }
608793
public void setPresetTransformer(Transformer ts){
        //
        // special thanks to https://github.com/ToxicBakery/ViewPagerTransforms
        //
        BaseTransformer t = null;
        switch (ts){
            case Default:
                t = new DefaultTransformer();
                break;
            case Accordion:
                t = new AccordionTransformer();
                break;
            case Background2Foreground:
                t = new BackgroundToForegroundTransformer();
                break;
            case CubeIn:
                t = new CubeInTransformer();
                break;
            case DepthPage:
                t = new DepthPageTransformer();
                break;
            case Fade:
                t = new FadeTransformer();
                break;
            case FlipHorizontal:
                t = new FlipHorizontalTransformer();
                break;
            case FlipPage:
                t = new FlipPageViewTransformer();
                break;
            case Foreground2Background:
                t = new ForegroundToBackgroundTransformer();
                break;
            case RotateDown:
                t = new RotateDownTransformer();
                break;
            case RotateUp:
                t = new RotateUpTransformer();
                break;
            case Stack:
                t = new StackTransformer();
                break;
            case Tablet:
                t = new TabletTransformer();
                break;
            case ZoomIn:
                t = new ZoomInTransformer();
                break;
            case ZoomOutSlide:
                t = new ZoomOutSlideTransformer();
                break;
            case ZoomOut:
                t = new ZoomOutTransformer();
                break;
        }
        setPagerTransformer(true,t);
    }