noinspection RubyResolve
335248
def ul_dealers(subj)
      res = '-'
      unless subj.dealers.count.zero?
        res = ''
        subj.dealers.each do |dealer|
          e = "<li>#{dealer.title}</li>"
          res += e
        end
        res = "<ul>#{res}</ul>".html_safe
      end
      res
    end
943563
def determine_resolver(params)
      if params[:resolver]
        Djatoka::Resolver.new(params[:resolver])
      elsif Djatoka.resolver
        Djatoka.resolver
      else
        nil
      end
    end
961832
def with_noop(source, name, noop_message = nil)
      if noop
        say '[noop] ' + noop_message if noop_message
        say "[noop] #{source.count} #{name} would be deleted"
      else
        yield source, name
      end
    end
825789
private boolean defaultResolve() {
        switch (typeString.charAt(0)) {
        case 'I':
            type = int.class;
            return true;
        case 'B':
            type = byte.class;
            return true;
        case 'C':
            type = char.class;
            return true;
        case 'S':
            type = short.class;
            return true;
        case 'Z':
            type = boolean.class;
            return true;
        case 'J':
            type = long.class;
            return true;
        case 'F':
            type = float.class;
            return true;
        case 'D':
            type = double.class;
            return true;
        default:
            type = Object.class;
            return false;
        }
    }
912404
def iresolve(self, *keys):
        '''
        
        '''
        for key in keys:
            missing = self.get_missing_deps(key)
            if missing:
                raise UnresolvableError("Missing dependencies for %s: %s" % (key, missing))

            provider = self._providers.get(key)
            if not provider:
                raise UnresolvableError("Provider does not exist for %s" % key)

            yield provider()
127071
def respond_to?(method_sym, _include_private=false)
      name = method_sym.to_s
      key = :getter?
      if name =~ /^(.*)=$/
        name = Regexp.last_match(1)
        # Use table_map_set() to set these properties
        return false if name == 'table_map' || name == 'table_map_filter'
        key = :setter?
      elsif name =~ /^default_(.*)$/
        name = Regexp.last_match(1)
        key = :default_value?
      end
      begin
        ref = node.cmd_ref.lookup('bgp_af', name)
        ref.send(key)
      rescue IndexError
        super
      end
    end
909579
private Method findResolver(Class type) throws IOException {
        List<Method> resolvers = Util.filter(Index.list(CLIResolver.class, Jenkins.get().getPluginManager().uberClassLoader), Method.class);
        for ( ; type!=null; type=type.getSuperclass())
            for (Method m : resolvers)
                if (m.getReturnType()==type)
                    return m;
        return null;
    }
1173399
@SuppressWarnings("unused")
    private Object readResolve() {
        if (StringUtils.isNotEmpty(topic)) {
            topicObject = new Topic(topic);
            topic = null;
        }

        if (topicObject != null && StringUtils.isEmpty(topicObject.getName())) {
            topicObject = null;
        }

        return this;
    }
1081592
def method_missing(sym, *args, &block)
      if (data && data[sym])
        data[sym]
      else
        super(sym, *args, &block)
      end
    end
1179770
function getResolveHandlers(appName, routes, options) {
    var resolveHandlers = {};
    var me = this;

    _.each(routes, function (route) {

        // if no route name, don't do anything
        if (!route.name) { return; }

        // else generate the UI part based on the name
        var uipart = me.getUIPart(appName, route);

        // if there is no model return without doing anything
        if (!uipart.model) { return; }

        var transOpts = _.extend({
            raw: true,
            defaults: uipart.defaults,
            isClient: true
        }, options);

        // else we want to generate the initial model module
        resolveHandlers[route.name] = _.isFunction(uipart.model) ?
            me.transformers.basic.transform(uipart.model, transOpts) :
            JSON.stringify(uipart.model);
    });

    return resolveHandlers || {};
}
531482
private Object readResolve() {
        Chronology base = getBase();
        return base == null ? getInstanceUTC() : getInstance(base.getZone());
    }
1061490
function after(yd){
  var res;

  yd = Resolver.when(yd);
  if(yd[yielded]) return yd[yielded];
  res = new Resolver();
  yd.listen(res.accept,[],res);
  return yd[yielded] = res.yielded;
}
1087676
function internalResolve ( resolve ) {
	resolve(window.google && window.google.maps ? window.google.maps : false);
}
1354091
def method_missing(sym, *args, &block)
      type = sym.to_s
      if type.start_with?('_') && args.empty? && block.nil?
        constant = Object.const_get(type[1..-1])
        type(constant)
      else
        super
      end
    end
804980
def resolve
    options[:rootpath]   ||= Pathname.pwd
    options[:rootpath]     = Pathname.new(options[:rootpath])
    options[:namespaces] ||= []
    options[:preset]     ||= resolve_preset

    if %w{rails rails-engine}.include?(options[:preset])
      options[:rootpath]     = detect_engine_root                                if options[:preset]     == 'rails-engine'
      options[:namespaces]   = load_rails_default_namespaces(options[:rootpath]) if options[:namespaces] == []
      options[:basepath]   ||= options[:rootpath] + 'config'
    else
      options[:basepath]   ||= options[:rootpath]
    end

    options[:encryption_keys]   = Keys::Encryption.resolve(filenames:  options[:encryption_keys],
                                                           namespaces: options[:namespaces],
                                                           rootpath:   options[:rootpath])
    options[:decryption_keys]   = Keys::Decryption.resolve(filenames:  options[:decryption_keys],
                                                           namespaces: options[:namespaces],
                                                           rootpath:   options[:rootpath])
    options[:basepath]          = Pathname.new(options[:basepath])
    options[:files]           ||= [
                                    options[:basepath] + 'settings*.yml',
                                    options[:basepath] + 'settings',
                                  ]

    options
  end
262620
def resolve(base, unprocessed_string)
      if base.to_a.last == :detach
        Detached.new(color, *base.to_a[0...-1])
      else
        color.decorate(unprocessed_string, *base)
      end
    end
1356059
private Object readResolve() throws ObjectStreamException
	{
		LexLocation existing = uniqueLocations.get(this);

		if (existing == null)
		{
			return this;
		} else
		{
			return existing;
		}
	}