GET /circles/new
512741
def new
      respond_to do |format|
        format.html { render :new, locals: { circle: Circle.new } }
      end
    end
59880
def map_new(w: int, h: int) -> tcod.map.Map:
    
    return tcod.map.Map(w, h)
97936
def fetch_queries(queries)
      raise ArgumentError, 'Error: Must have queries' unless queries.is_a?(Array)
      build = CircleCi::Build.new @username, @reponame, nil, @build, @config
      artifacts = build.artifacts

      if artifacts.nil?
        STDERR.puts 'Error: No artifacts'
        return Results.new
      end
      parse(artifacts: artifacts, queries: queries)
    end
1314880
function getS() {
  const type = NodeType.SType;
  const token = tokens[pos];
  const line = token.ln;
  const column = token.col;
  const content = joinValues(pos, tokens[pos].ws_last);

  pos = tokens[pos].ws_last + 1;

  return newNode(type, content, line, column);
}
17627
function _newGraphSONMapper() {
        return Tinkerpop.GraphSONMapper.buildP()
            .then(function (builder) {
            return builder.embedTypesP(true);
        })
            .then(function (builder) {
            return builder.createP();
        });
    }
729698
function (x, y, r) {
		return this.symbol('circle').attr({ x: x, y: y, r: r});
	}
1036883
def new(self, string=None, *args, **kwargs):
        """"""
        if len(self):
            hobj = _ChainedHashAlgorithm(self, *args, **kwargs)
        else:
            hobj = _NopHashAlgorithm(*args, **kwargs)
        if string is not None:
            hobj.update(string)
        return hobj
900207
function(node, circle, settings) {
      var prefix = settings('prefix') || '';

      // Applying changes
      // TODO: optimize - check if necessary
      circle.setAttributeNS(null, 'cx', node[prefix + 'x']);
      circle.setAttributeNS(null, 'cy', node[prefix + 'y']);
      circle.setAttributeNS(null, 'r', node[prefix + 'size']);

      // Updating only if not freestyle
      if (!settings('freeStyle'))
        circle.setAttributeNS(
          null, 'fill', node.color || settings('defaultNodeColor'));

      // Showing
      circle.style.display = '';

      return this;
    }
357996
def new(cls) -> 'Generator':
        
        logger = logging.getLogger(__name__)
        logger.debug("Generator::new: >>>")

        c_instance = c_void_p()
        do_call(cls.new_handler, byref(c_instance))

        res = cls(c_instance)

        logger.debug("Generator::new: <<< res: %r", res)
        return res
260442
def new(self, verbose=False):
        

        response=api(url=self.__url+"/new", verbose=verbose)
        return response
1025971
function(r, n) {
  /* the Raphael set is obligatory, containing all you want to display */
  var set = r.set().push(
    /* custom objects go here */
    r.rect(n.point[0]-30, n.point[1]-13, 50, 50)
    .attr({"fill": "#fa8", "stroke-width": 2, r: 9}))
    .push(r.text(n.point[0], n.point[1] + 15, n.id)
          .attr({"font-size":"20px"}));
          return set;
}
1261632
function (x, y, r) {
		var attr = isObject(x) ?
			x :
			{
				x: x,
				y: y,
				r: r
			};

		return this.createElement('circle').attr(attr);
	}
197842
function(x, y) {
    var type = (this._target || this).type;
    return type == 'radial' || type == 'circle' ?
      this.attr('r', new SVG.Number(x)) :
      this.rx(x).ry(y == null ? x : y)
  }
896747
function () {
    if (this.data instanceof SAT.Circle) {
      this.displayAttrs.cx = this.data.pos.x;
      this.displayAttrs.cy = this.data.pos.y;
      this.displayAttrs.r = this.data.r;
    } else {
      this.displayAttrs.path = poly2path(this.data);
    }
    this.display.attr(this.displayAttrs);
  }
1172996
function create({
    pending = false, // eslint-disable-line no-shadow
    refreshing = false, // eslint-disable-line no-shadow
    fulfilled = false, // eslint-disable-line no-shadow
    rejected = false, // eslint-disable-line no-shadow
    value = null,
    reason = null,
}) {
    return {
        pending,
        refreshing,
        fulfilled,
        rejected,
        value,
        reason,
    };
}
1019252
function (x, y, r) {
    return new BVG('circle', x.constructor.name === 'Object' ? x : {
      x: x,
      y: y,
      r: r
    }, function (tag, data) {
      tag.setAttribute('cx', data.x);
      tag.setAttribute('cy', data.y);
      tag.setAttribute('r', data.r);
    });
  }
708142
function tryStringify(arg) {
  try {
    return JSON.stringify(arg);
  } catch (err) {
    // Populate the circular error message lazily
    if (!CIRCULAR_ERROR_MESSAGE) {
      try {
        const a = {}; a.a = a; JSON.stringify(a);
      } catch (err) {
        CIRCULAR_ERROR_MESSAGE = err.message;
      }
    }
    if (err.name === 'TypeError' && err.message === CIRCULAR_ERROR_MESSAGE) {
      return '[Circular]';
    }
    throw err;
  }
}