sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: react
Issue: [RN] Don't receive events on unknown tags
Labels: Type: Needs Investigation,React Core Team

Flow uncovered this:

https://github.com/facebook/react/blob/92b7b172cce9958b846844f0b46fd7bbd8c5140d/packages/react-native-renderer/src/ReactNativeEventEmitter.js#L174-L175

Need to verify if we can just return early and not process the events in this case.
Repository: opencv
Issue: Question about cv::VideoWriter
Labels: priority: low,category: videoio,category: gpu/cuda (contrib),platform: ios/osx

Hi,

i the video_writer.cpp sample i see:
```#if defined(HAVE_OPENCV_CUDACODEC) && defined(WIN32)```
are there any plans to add gpu acceleration (cuda support) to cv::VideoWriter on Mac Osx or Linux?
see: https://github.com/opencv/opencv/blob/master/samples/gpu/video_writer.cpp

the video_writer.cpp sample seems platform independent:
```#if defined(HAVE_OPENCV_CUDACODEC)```
see: https://github.com/opencv/opencv/blob/master/samples/gpu/video_reader.cpp

why does it need windows in video_writer.cpp?

Thanks,
Arnold
Repository: go
Issue: x/net/html: add Escape/Unescape transformers
Labels: Proposal,Proposal-Accepted

The [`golang.org/x/net/html`] package contains two functions similar to the ones in the [`html`] package for escaping and unescaping HTML entities:

```
func EscapeString(string) string
func UnescapeString(string) string
```

unfortunately these require loading entire documents into memory and converting them to a string before attempting to escape them.

It would be nice if there were also an implementation of the [`Transformer`] (and [`SpanningTransformer`]) interface from [`golang.org/x/text/transform`] that could perform escaping / unescaping on long byte streams without requiring buffering the entire stream into memory.

This could either be two functions which return transformers:

```
// Escaper returns a transformer that escapes special characters.
// See EscapeString for more information.
func Escaper() transform.SpanningTransformer

// Unescaper returns a transformer that unescapes special characters.
// See UnescapeString for more information.
func Unescaper() transform.SpanningTransformer
```

or a `Transformer` type which contains all the various helper methods (String, Bytes, etc.) that transformer based packages in the text tree have.

[`golang.org/x/net/html`]: https://godoc.org/golang.org/x/net/html
[`html`]: https://godoc.org/html
[`Transformer`]: https://godoc.org/golang.org/x/text/transform#Transformer
[`SpanningTransformer`]: https://godoc.org/golang.org/x/text/transform#SpanningTransformer
[`golang.org/x/text/transform`]: https://godoc.org/golang.org/x/text/transform

/cc @mpvl
Repository: neovim
Issue: TUI: draw "virtual cursor" instead of using terminal emulator cursor
Labels: enhancement,tui

In terminal mode, users often have a choice of setting up the terminal emulator to display the current cursor position via a caret (`|`), an underline (`_`), or a block (`█`), each with its own tradeoffs.

The caret and underscore are the least obstructive (i.e. one can clearly make out what character is under them) but are also very hard to visually spot when the cursor moves to an unknown location (search for a symbol and then spend 10 seconds playing with the arrow keys trying to obtain a visual indication of where the cursor wound up after the jump). The block is easy to spot, but obscures the character under the block (did I already type `}` and navigate backwards or did I not?). Setting up the terminal to blink the cursor block helps tremendously, but one must still wait for the block to blink before being able to 

Recently while using [vis](https://github.com/martanne/vis), I saw a different approach that doesn't require (as far as I can tell) cooperation from the terminal emulator to pull off. The actual cursor is hidden, and instead the block corresponding to where the cursor should be is rendered in reverse/negative. This is perhaps best illustrated with screenshots:

**Underline mode**

Can you find the cursor?

![image](https://user-images.githubusercontent.com/606923/32418063-6787d3fa-c228-11e7-82c8-87fe84481a24.png)

**Block mode**

Do you think you can see everything in the buffer in the screenshot below?

![image](https://user-images.githubusercontent.com/606923/32417996-9abadbd8-c227-11e7-9948-07adbeebcf03.png)

... because this is what you see when the cursor blinks:

![image](https://user-images.githubusercontent.com/606923/32418027-01eea5f0-c228-11e7-88d5-c542961d58dc.png)

**Inverted Block**

How vis solves the problem

![image](https://user-images.githubusercontent.com/606923/32417999-a6534052-c227-11e7-8a33-b3c9e023dc85.png)

In vis, the cursor does not blink, but that can also be easily implemented with a timer that alternates between inverse and actual colors for the cursor position.

I think this is a tremendous usability gain and would urge consideration of adopting this feature.
Repository: godot
Issue: Cannot Keyframe "Visible Characters" Attribute In The RichText Node
Labels: discussion,topic:animation

I tried keyframing a type-writer text effect in my game for a cut-scene using the RichText node and it does not seem to work. Is this a known issue? I was trying to keyframe the "Visible Characters" attribute.
Repository: rust
Issue: [std::char] Add MAX_UTF8_LEN and MAX_UTF16_LEN
Labels: E-easy,T-libs-api,C-feature-accepted

# Background
UTF-8 encoding on any character can take up to 4 bytes (`u8`). UTF-16 encoding can take up to 2 words (`u16`). This is a promise from the encoding specs, and an assumption made in many places inside rust libs and applications.

Currently, there's lots of *magic* numbers 4 and 2 everywhere in the code, creating buffer long enough to encode a character into as UTF-8 or UTF-16.

## Examples
https://github.com/rust-lang/rust/blob/b7041bfab3a83702a8026fb7a18d8ea7d54cc648/src/libcore/tests/char.rs#L236-L239

https://github.com/rust-lang/rust/blob/b7041bfab3a83702a8026fb7a18d8ea7d54cc648/src/libcore/tests/char.rs#L253-L256

# Proposal
Add the followings public definitions to `std::char` and `core::char` to be used inside the rust codebase and publicly.

```rust
pub const MAX_UTF8_LEN: usize = 4;
pub const MAX_UTF16_LEN: usize = 2;
```

# Why should we do this?
This will allow the code to be written like this:
```rust
let mut buf = [0; char::MAX_UTF16_LEN];
let b = input.encode_utf16(&mut buf);
```

This will guide users—without them knowing too much details of UTF-8/UTF-16 encodings—to allocate the correct amount of memory while writing the code, instead of waiting until some runtime error is raise, which actually may not happen in basic tests and discovered externally. Also, it increases readability for anyone reading such code.

Besides using these max-length values for char-level allocations, user can also use them for pre-allocate memory for encoding some chars list into UTF-8/UTF-16.

# How we teach this?
The std/core libs will be updated to use these values wherever possible (see [this list](https://gist.github.com/behnam/64484153914d862a2c75d57d15fc58e4)), and docs for encoding-related functions in `char` module are updated to evangelize using these values when allocating memory to be used by the encoding functions.

* https://doc.rust-lang.org/std/primitive.char.html#method.len_utf8
* https://doc.rust-lang.org/std/primitive.char.html#method.len_utf16
* https://doc.rust-lang.org/std/primitive.char.html#method.encode_utf8
* https://doc.rust-lang.org/std/primitive.char.html#method.encode_utf16

# Alternatives

### 1) Only update the docs
We can just update the function docs to talk about these max-length values, but not name them as a `const` value.

### 2) New functions for allocations with max limit
Although this can be handy for some users, it would be limited to only one use-case of these numbers and not helpful for other operations.

----

What do you think?

<!-- TRIAGEBOT_START -->

<!-- TRIAGEBOT_ASSIGN_START -->

<!-- TRIAGEBOT_ASSIGN_DATA_START$${"user":"NoobProgrammer31"}$$TRIAGEBOT_ASSIGN_DATA_END -->

<!-- TRIAGEBOT_ASSIGN_END -->
<!-- TRIAGEBOT_END -->
Repository: neovim
Issue: TUI: better terminal-type detection
Labels: enhancement,ux,tui

In #7473 we incorrectly decided that a terminal supported colon-delimited RGB sequences. We need a more reliable way to detect support for that. And other capabilities, where possible.

Vim "term response" handling: https://github.com/neovim/neovim/issues/6279

- `may_req_ambiguous_char_width()` [src](https://github.com/vim/vim/blob/93343725b5fa1cf580a24302455980faacae8ee2/src/term.c#L3570)
- `req_codes_from_term`, `check_for_codes_from_term` [src](https://github.com/vim/vim/blob/93343725b5fa1cf580a24302455980faacae8ee2/src/term.c#L6428                                                         
)

colon-delimited RGB:

- Motivation for colon delimiters: https://github.com/kovidgoyal/kitty/issues/160#issuecomment-341902195 
    - See also https://github.com/neovim/neovim/issues/7473#issuecomment-341899848
- detect via [DECRQSS](https://github.com/neovim/neovim/issues/7490#issuecomment-348645326)

cursor capability:

- Vim patch to detect xterm-compatible cursor capability: https://github.com/vim/vim/pull/2126
- Related: https://github.com/neovim/neovim/pull/5556
Repository: go
Issue: cmd/vendor/github.com/google/pprof/internal/driver: TestHttpsInsecure fails
Labels: Testing,OS-Windows

### What version of Go are you using (`go version`)?

go version devel +bb98331 Mon Nov 6 01:35:58 2017 +0000 windows/386

### What operating system and processor architecture are you using (`go env`)?

Windows XP 32 bit

```
set GOARCH=386
set GOBIN=
set GOCACHE=go-build
set GOEXE=.exe
set GOHOSTARCH=386
set GOHOSTOS=windows
set GOOS=windows
set GOPATH=C:\Documents and Settings\aa\dev\
set GORACE=
set GOROOT=C:\Documents and Settings\aa\dev\go
set GOTMPDIR=
set GOTOOLDIR=C:\Documents and Settings\aa\dev\go\pkg\tool\windows_386
set GCCGO=gccgo
set GO386=sse2
set CC=gcc
set CXX=g++
set CGO_ENABLED=1
set CGO_CFLAGS=-g -O2
set CGO_CPPFLAGS=
set CGO_CXXFLAGS=-g -O2
set CGO_FFLAGS=-g -O2
set CGO_LDFLAGS=-g -O2
set PKG_CONFIG=pkg-config
set GOGCCFLAGS=-m32 -mthreads -fmessage-length=0 -fdebug-prefix-map=C:\DOCUME~1\aa\LOCALS~1\Temp\go-build119289778=/tmp/go-build -gno-record-gcc-switches
```

### What did you do?

I run

```
go test -short -v -run=TestHttpsInsecure cmd/vendor/github.com/google/pprof/internal/driver
```

command

### What did you expect to see?

```
PASS
```

### What did you see instead?

```
=== RUN   TestHttpsInsecure
--- FAIL: TestHttpsInsecure (15.11s)
        fetch_test.go:420: fetchProfiles(https+insecure://127.0.0.1:2343/debug/pprof/profile) got non-symbolized profile: len(p.Function)==0
FAIL
exit status 1
FAIL    cmd/vendor/github.com/google/pprof/internal/driver      15.261s
```

Alex
Repository: vue
Issue: Create a package for building custom renderers
Labels: intend to implement,feature request

### What problem does this feature solve?
As the author of nativescript-vue I had to set up a similar build setup as Vue's in order to be able to import certain parts of Vue directly into nativescript-vue. The main source of issues was the aliases used across the Vue repository (which do make sense btw!). 

To solve that issue, I would love to have an official package for creating (and registering) custom renderers into Vue, which would enclose most of the Vue specific logic of patching / hydrating etc.

A good example of what I have in mind would be the react's package that does it: https://github.com/facebook/react/tree/master/packages/react-reconciler

I would love to get some work done on this, but I'd work with the core team to make sure the best possible quality.



### What does the proposed API look like?
```js
// my custom renderer
// for example: nativescript-vue.js
import VueRenderer from 'vue-renderer'

// a class for creating native views in NativeScript
import ViewUtils from './ViewUtils.js'

export default new VueRenderer({
  // Node operations
  createElement(tagName) {},
  createElementNS(namespace, tagName) {},
  createTextNode(text) {},
  createComment(text) {},
  insertBefore(parentNode, newNode, referenceNode) {},
  removeChild(node, child) {},
  appendChild(node, child) {},
  parentNode(node) {},
  nextSibling(node) {},
  tagName(node) {},
  setTextContent(node, text) {},
  setAttribute(node, attribute, value) {},

  // Additional methods that need to be specified
  // but for example:
  createRoot() {} // this would get called to create the root element for the root Vue instance
})
```

```js
// then in userland we could just do
import Vue from 'vue'
import NativescriptVue from 'nativescript-vue'

Vue.use(NativescriptVue)


new Vue({
  render(h) => h('label', { text: 'Hello World' })
})
```

<!-- generated by vue-issues. DO NOT REMOVE -->
Repository: flutter
Issue: Documentation for location of non-positioned children in RenderStack is wrong
Labels: framework,d: api docs,P2,team-framework,triaged-framework

The second paragraph of RenderStack's documentation says that:

> /// The final location of non-positioned children is determined by the alignment
/// parameter. The left of each non-positioned child becomes the
/// difference between the child's width and the stack's width scaled by
/// alignment.x. The top of each non-positioned child is computed
/// similarly and scaled by alignment.y. So if the alignment x and y properties
/// are 0.0 (the default) then the non-positioned children remain in the
/// upper-left corner. If the alignment x and y properties are 0.5 then the
/// non-positioned children are centered within the stack.

Sounds like it describes alignment for FractionalOffset. Current implementation uses Alignment.

I am not a native English speaker, and feels hard to express the intention.
Repository: go
Issue: context: relax recommendation against putting Contexts in structs
Labels: Documentation,help wanted,NeedsInvestigation

This is a follow-on from discussion in #14660.

Right now the context package documentation says

> Do not store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it. The Context should be the first parameter, typically named ctx: [...]

This advice seems overly restrictive. @bradfitz wrote in that issue:

> While we've told people not to add contexts to structs, I think that guidance is over-aggressive. The real advice is not to *store* contexts. They should be passed along like parameters. But if the struct is essentially just a parameter, it's okay. I think this concern can be addressed with package-level documentation and examples.

Let's address this concern with package-level documentation.

Also see @rsc's comment at https://github.com/golang/go/issues/14660#issuecomment-200145301.

/cc @Sajmani @bradfitz @rsc
Repository: opencv
Issue: No controls for # of threads work when using AREA resizer
Labels: feature,category: core,platform: ios/osx


##### System information (version)
- OSX 10.11
- Clang
- OpenCV 3.2.0

##### Detailed description

OpenCV runs work for AREA resizer on 8 threads regardless of how `cv::setNumThreads` is invoked or `OPENCV_FOR_THREADS_NUM` is set. It is seemingly impossible to produce a single-threaded AREA resizer in OpenCV.

##### Steps to reproduce
```
cv::setNumThreads(1);
cv::resize(mat, dst, width, height, CV_INTER_AREA);
```

runs on 8 threads instead of 1.
Repository: angular
Issue: Add value change options to ControlValueAccessor writeValue and onChange
Labels: feature,freq2: medium,area: forms,feature: under consideration

## I'm submitting a...
<!-- Check one of the following options with "x" -->
<pre><code>
[ ] Regression (a behavior that used to work and stopped working in a new release)
[ ] Bug report  <!-- Please search GitHub for a similar issue or PR before submitting -->
[x] Feature request
[ ] Documentation issue or request
[ ] Support request => Please do not submit support request here, instead see https://github.com/angular/angular/blob/master/CONTRIBUTING.md#question
</code></pre>

## Current behavior
A component that implements `ControlValueAccessor` and transforms values to stay in bounds cannot respect `{ emitEvent: false }` option when value patched, it will always emit an event if the `onChange` function is called.

## Expected behavior
If a value is patched to a component that is out-of-bounds and cannot be displayed the component should be able to to transform the incoming value and also respect the option `{ emitEvent: false }`.

[updateControl](https://github.com/angular/angular/blob/1cfa79ca4e21788e0323baf544704ee7ef7d63ea/packages/forms/src/directives/shared.ts#L100) should use an options object like patchValue/setValue.

## Minimal reproduction of the problem with instructions
http://plnkr.co/edit/GyJLgvBkpPdD1y74lZOH?p=preview
In the reproduction you'll notice that when a value outside of the bounds is passed it will update the model. In doing so it will emit a change event to the console even if the new value was patched using `{ emitEvent: false }`.

## What is the motivation / use case for changing the behavior?
The default HTML5 slider will set the value of the slider to the max value if a value higher than the max is set. If I wanted to create a custom slider that followed the same behavior I couldn't do this without emitting an event even if `patchValue(outofboundsvalue, { emitEvent: false });` is used.

## Environment

<pre><code>
Angular version: latest
I'm currently using 4.3.3, example plnkr uses latest.

Browser:
- [x] Chrome (desktop) version 61
This will be the same behavior in all browsers, but I've only tested with Chrome.
</code></pre>

Others:
I'm not sure if this type of writeValue functionality is an anti-pattern or if a custom validator should be used instead. An HTML5 input fields will update a passed value to stay in bounds so I'm assuming Angular form components should have the option to do the same.

Also, not sure if this is a bug or intentional, so I labeled as feature request for now.
Repository: TypeScript
Issue: Reconsider if we need to cache file system entries given that we have tweaked triggers for watch
Labels: Infrastructure

Determine if we still need to cache file system entries in the directory or non caching has similar performance given that watch triggers and invokes have changed since the cached directory structure host implementation
Repository: TypeScript
Issue: URLSearchParams/Headers constructor also receives iterables including Map
Labels: Suggestion,Help Wanted,Domain: lib.d.ts,Experience Enhancement

**TypeScript Version:**  master

**Code**

```ts
new Headers(new Map([['abc', 'bcd']])).get('abc')
new Headers({ [Symbol.iterator]() { return new Map([['abc', 'bcd']]).entries() } }).get('abc')
```

**Expected behavior:** Both returns `bcd` so should pass without errors

**Actual behavior:** 'not assignable' error
Repository: angular
Issue: Validator.pattern adds ^ and $ for you for strings - not for patterns
Labels: breaking changes,help wanted,freq2: medium,area: forms,type: confusing,forms: validators,P4

See https://github.com/angular/angular/blame/6e8e3bd2488eb0896932fe1a10afefbb0dccbca9/packages/forms/src/validators.ts#L148

It is not really intuitive to add `^` and `$` if the pattern is a string and not a regex expression. I doubt that this behavior is in any way wanted.

See https://github.com/angular/angular/issues/10150 and https://github.com/angular/angular/issues/15751
Repository: rust
Issue: Can't compile core for msp430 - LLVM ERROR
Labels: A-LLVM,T-compiler,A-target-specs,C-bug,WG-embedded,requires-nightly,O-msp430

``` console
$ rustup default nightly-2017-11-04

$ rustup component add rust-src

$ cp -r $(rustc --print sysroot)/lib/rustlib/src/rust/src .

$ cd src/libcore

$ cargo build --target msp430-none-elf
   Compiling core v0.0.0 (file:///home/japaric/tmp/src/libcore)
LLVM ERROR: Cannot select: t3: ch = AtomicFence t0, Constant:i16<7>, Constant:i16<1>
  t1: i16 = Constant<7>
  t2: i16 = Constant<1>
In function: _ZN4core4sync6atomic5fence17h15543a17f4e17a82E
error: Could not compile `core`.
```

found while bisecting #45834

cc @pftbest
Repository: rust
Issue: Stack overflow in fmt::Display impl
Labels: E-hard,A-lints,T-compiler,C-feature-request

It's possible to write a impl of fmt::Display which compiles successfully and produces a stack overflow.

A minimal repro is available here: https://play.rust-lang.org/?gist=fb115e1e625e1b8038cdd13c5f9cdbb8&version=stable

The code is here for completeness of the bug report:
```rust
use std::fmt;

fn main() {
    println!("Hello, world!");
    let test = Test::Alpha;
    println!("Preparing to stack overflow");
    let test_string = test.to_string();
    println!("test string: {}", test_string);
}

pub enum Test {
  Alpha,
  Bravo,
}

impl fmt::Display for Test {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.to_string())
  }
}
```

I would expect an error at compile time

Instead the error occurs at runtime as a stack overflow.

## Meta

```
rustc 1.21.0 (3b72af97e 2017-10-09)
binary: rustc
commit-hash: 3b72af97e42989b2fe104d8edbaee123cdf7c58f
commit-date: 2017-10-09
host: x86_64-apple-darwin
release: 1.21.0
LLVM version: 4.0
```

```
thread 'main' has overflowed its stack
fatal runtime error: stack overflow
Abort trap: 6
```
Repository: opencv
Issue: OpenCV 3.2 Persistence.hpp error when trying to write a uint64_t
Labels: category: build/install,RFC,incomplete

<!--
If you have a question rather than reporting a bug please go to http://answers.opencv.org where you get much faster responses.
If you need further assistance please read [How To Contribute](https://github.com/opencv/opencv/wiki/How_to_contribute).

This is a template helping you to create an issue which can be processed as quickly as possible. This is the bug reporting section for the OpenCV library.
-->

##### System information (version)
<!-- Example

-->
- OpenCV => 3.2
- Operating System / Platform => Windows 64 Bit
- Compiler => Visual Studio 2015
##### Detailed description

I am running a code that ran well until I changed a parameter from ```int``` to ```uint64_t```. The parameter is ```timeCreated```. All the other parameters are ```int``` and ```doubles```. The code is as follows 
##### Steps to reproduce

    ```
    void blah::PrintObject( cv::FileStorage& fout )
       {   fout << "ID"                                                  << id;
           fout << "timeCreated "                                << timeCreated;
           fout << "numUpdatedTimeSteps"               << numUpdatedTimeSteps;
           fout << "numTimesUpdatedThisTimeStep"  << numTimesUpdatedThisTimeStep;
           fout << "time"                                               << time;
        }

The error I obtain is:
```3>C:\Software\OpenCV_3.2.0\Windows_VS2015_x64_build\include\opencv2/core/persistence.hpp(1113): error C2668: 'cv::write': ambiguous call to overloaded function```

As soon as I replace 
```fout << "timeCreated "                                << timeCreated;```
by
```fout << "timeCreated "                                << static_cast<int>(timeCreated);```
everything compiles just fine. So my question is: How I make it work for  ``` uint64_t```?
Repository: flutter
Issue: Create a multi-staged sequential builder layout-er 
Labels: c: new feature,framework,customer: google,P3,team-framework,triaged-framework

Combine components of `LayoutBuilder` and `MultiChildLayoutDelegate` to sequentially build a child, lay it out, then take the layout info from that child and feed into the build and layout of the next child until there are no more children.