sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: vscode
Issue: isWatching/background task as preLaunchTask in launch.json
Labels: feature-request,tasks

It would be nice to have a watcher task as preLaunchTask in launch.json. At the moment this is not possible because the launch task will not start before the preLaunchTask ends.
A long running preLaunchTask should have a regex similar to problemMatcher to wait for a specific text in the output window before executing the launch task.
In my scenario I'm running webpack dev server as a watcher task. I want this task to run if <kbd>F5</kbd> is hit and the preLaunchTask is not running. To delay the debugger launch it would be useful to test for a specific string in the output window `webpack: bundle is now VALID.`
Repository: go
Issue: x/review/git-codereview: Change-Id hook silently doesn't run anymore when codereview.cfg is not present
Labels: NeedsInvestigation

This is a regression introduced in
https://go-review.googlesource.com/#/c/19560/

Before that change, if the hooks were installed for a private `foobar.com` Gerrit origin (i.e. not `googlesource.com`), they would all run. After that change, the hook code tries to figure out if Gerrit is in use, and when not, the Change-Id line is silently not added. Unfortunately, the heuristic to determine if Gerrit is in use (`haveGerrit()`) errs on the negative side. Consequently `git-codereview mail` is rejected by Gerrit because of the missing Change-Id. The failure is hard to debug because the hooks seem correctly installed, and it is especially annoying as git-codereview may have removed old working hooks in the past [1] to install its own.

One workaround is to create a `codereview.cfg` file in repo's root with a valid gerrit value. But it's not that great because for most installations it should be self-evident what is the Gerrit origin, it feels like a unwarranted burden on a lot of people (see: #15073) to introduce that file in many old and new gerrit repos.

The hard problem seems to be the runtime determination of what hooks should be running. Specifically, in the change above, Russ described how he wants the "issue" hook to run on non-Gerrit repo, but not the Change-Id one.

I propose to remove runtime determination of what hooks should run in favor of explicit configuration. i.e. `git-codereview hooks` would evolve to the following:
- Like current behavior, any git-codereview sub-command would install all the hooks, if and only if a valid Gerrit is detected.
- Like current behavior, if `git-codereview hooks` is run manually, it would force hooks installation regardless of `haveGerrit()` value. But, unlike current behavior it would also enable all the hook functions: issuerepo, gofmt, change-id. (See below how hooks are enabled).
- If arguments are passed to `git-codereview hooks`, where arguments could be any sub-set of 'issuerepo', 'gofmt' and 'change-id', then it would only enable those.

The git hook script should probably stay a simple exec as it is today, because it is hard to replace and extend in the future. On the other hand, git provides a very powerful `git config` set of commands that git-coderereview could run on behalf of the user to set and get the different expected behaviors. https://go-review.googlesource.com/#/c/19684/ proposes something similar for reading the configuration, although I suggest we take it further and lean on the dedicated git interfaces to do the writing and reading.

I'm happy to work on a CL if that solution is deemed acceptable.
1. https://github.com/golang/review/blob/77ae237af753cd4f4820e67cdf058aea410bccc7/git-codereview/hook.go#L31
Repository: go
Issue: spec: when exactly do we evaluate the LHS variable in a tuple assignment?
Labels: NeedsFix

Please answer these questions before submitting your issue. Thanks!
1. What version of Go are you using (`go version`)?
   gccgo version 4.9.3
2. What operating system and processor architecture are you using (`go env`)?
   Ubuntu 14.04 on AWS t2.micro
3. What did you do?
   If possible, provide a recipe for reproducing the error.
   A complete runnable program is good.
   A link on play.golang.org is best.

Deleting from a slice as suggested by https://github.com/golang/go/wiki/SliceTricks, raises an index out of bound error when compiling with gccgo. The following toy program works fine using GC but not with GCCGO: 

```
package main

import "fmt"

func main() {
    xs := []int{0,1,2,3,4}
    i := 2
    xs, xs[len(xs)-1] = append(xs[:i], xs[i+1:]...), 0
    fmt.Println(xs)
}
```

https://play.golang.org/p/f039m1h7Z1

Note: while this toy example is a slice of ints, I'm using the delete code for removing an entry from a slice of pointers. The bug is in `xs[len(xs)-1] = 0`.
1. What did you expect to see?

`[0 1 3 4]`
1. What did you see instead?

```
panic: runtime error: index out of range

goroutine 1 [running]:
main.main
    /home/ubuntu/Go/src/bad/remove.go:8
```
Repository: flutter
Issue: Add support for magic tap
Labels: c: new feature,platform-ios,framework,a: accessibility,P3,team-ios,triaged-ios

iOS accessibility has the notion of a context-sensitive "perform the action that makes the most sense here" action -- they call it the Magic Tap.

Per the [iOS Developer Library](https://developer.apple.com/library/ios/featuredarticles/ViewControllerPGforiPhoneOS/SupportingAccessibility.html):

> Magic Tap. A two-finger double-tap that performs the most-intended action.

This can be used, for example, to allow the user to play and pause music in a music app without hunting for the play/pause button.
Repository: go
Issue: compress/flate: add 3-byte matching for higher compression levels
Labels: NeedsInvestigation

Using `9af83462`

The recent changes to `compress/flate` has provided pretty good improvements overall to the compression speeds, but I have noticed a few extraordinary cases where the compression ratio suffers significantly.

This [spreadsheet compares the output sizes](https://docs.google.com/spreadsheets/d/15kBp7rWX4FhC3K4CK0-mOsMObVOK_e0-3D97p_sWFBg/edit?usp=sharing) from go1.6 to current go.tip on a number of compression benchmarks. All tests were done using the `flate.DefaultCompression` setting.

Most notably, the [clegg.tiff image from the ACT corpus](http://compression.ca/act/act-files.html) experiences a 44% increase in output size (511928 to 741046 bytes).

I think it would be worthwhile to understand what causes this fairly significant regression in compression ratio before the go1.7 release.

cc @nigeltao @klauspost
Repository: go
Issue: encoding/json: support decoding to []int from []string by applying tag ,string
Labels: NeedsDecision,FeatureRequest

Please answer these questions before submitting your issue. Thanks!
1. What version of Go are you using (`go version`)?
   1.6
2. What operating system and processor architecture are you using (`go env`)?
   set GOARCH=amd64
   set GOBIN=
   set GOEXE=.exe
   set GOHOSTARCH=amd64
   set GOHOSTOS=windows
   set GOOS=windows
   set GOPATH=D:\litead\oxygen
   set GORACE=
   set GOROOT=C:\go
   set GOTOOLDIR=C:\go\pkg\tool\windows_amd64
   set GO15VENDOREXPERIMENT=1
   set CC=gcc
   set GOGCCFLAGS=-m64 -mthreads -fmessage-length=0
   set CXX=g++
   set CGO_ENABLED=1
3. What did you do?
   If possible, provide a recipe for reproducing the error.
   A complete runnable program is good.
   A link on play.golang.org is best.
   [https://play.golang.org/p/A4CLM3P6Dw](https://play.golang.org/p/A4CLM3P6Dw)
4. What did you expect to see?
   decode the int64 slice successfully
5. What did you see instead?
   an error:
   
   > json: cannot unmarshal string into Go value of type int64

according to the documentation, the behavior is correct, but this makes it hard to decode an int64 slice (although there are workarounds). It will be good if 'string' tag could also be applied to slices.
Repository: angular
Issue: Support for Dynamic Content Projection
Labels: feature,state: Needs Design,area: core,core: content projection,feature: under consideration

# Use Case

`<ng-content>` allows for static (compile time resolution) projection of content. There are cases where the projection needs to be controlled programmatically. A common example is when the parent component would like to wrap/decorate the child components during projection.
# Mental Model

The mental model would be that `<ng-content>` is for fast static projection, but for dynamic projection one would use a query to get a hold of the child components in the form of `ViewRef`s which could then be inserted programmatically at any location in the tree.
# Possible Solution
- `ContentViewRef` extends `ViewRef`
- `@Content(selector)` Provides a way to select direct children content elements using CSS selectors. (This would be after directives such as `ngFor` would unroll the content, and it would be in the correct order.)
- This would allow selection of elements rather than directives. These `ContentViewRef`s could then be reinserted to any `ViewContainerRef`
- We would need `ngViewOutlet` (similar to `ngTemplateOutlet`).

``` ts
@Component({
  template: `
  <div *ngFor="let view of allViews">
    <template ngViewOutlet="view"></template>
  </div>
  <ng-content><!-- project non selected nodes, such as text nodes --></ng-content>
`
})
class MySelect {
  @Content('*') allViews: ContentViewRef[];

  // another example
  @Content('my-option') optionViews: ContentViewRef[];
}
```

``` ts
@Component({
  selector: 'app',
  template: `
<my-select>
     Option
    <my-option>header</my-option>
    <my-option *ngFor="let item in items">unrolled items {{item}}</my-option>
    <my-option-group>
        <my-option>
            foo <b>bar</b>
            <other-directive />
</my-option>
        <my-separator></my-separator>
        <my-option></my-option>
</my-option-group>
</my-select>
`
})
class App {}
```
Repository: rust
Issue: confusing lifetime inference
Labels: A-type-system,C-enhancement,A-diagnostics,A-lifetimes,T-compiler,T-types

Consider following snippet:

``` rust
use std::error::Error;

use std::io::{self, ErrorKind};

fn caused_of<'a>(mut err: &'a (Error + 'static)) -> Option<&'a io::Error> {
    loop {
        match err.downcast_ref::<io::Error>() {
            None => match err.cause() {
                None => return None,
                Some(cause) => err = cause,
            },
            d => return d,
        }
    }
}

fn main() {
    let e = io::Error::new(ErrorKind::Other, "oh no!");
    println!("{:?}", caused_of(&e));
}

```

According to [Book](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision), cause's lifetime should be err's lifetime. which is 'a, so it should be safe to assign cause to err directly. But I got following warnnings:

```
test.rs:8:34: 8:39 error: cannot infer an appropriate lifetime for autoref due to conflicting requirements [E0495]
test.rs:8                       None => match err.cause() {
                                           ^~~~~
test.rs:8:30: 8:41 note: first, the lifetime cannot outlive the method call at 8:29...
test.rs:8                       None => match err.cause() {
                                       ^~~~~~~~~~~
test.rs:8:30: 8:33 note: ...so that method receiver is valid for the method call
test.rs:8                       None => match err.cause() {
                                       ^~~
test.rs:5:75: 15:25 note: but, the lifetime must be valid for the lifetime 'a as defined on the block at 5:74...
test.rs:5 fn caused_of<'a>(mut err: &'a (Error + 'static)) -> Option<&'a io::Error> {
                                                                                    ^
test.rs:10:48: 10:53 note: ...so that trait type parameters matches those specified on the impl (expected std::ops::CoerceUnsized<&'a std::error::Error + 'static>, found std::ops::CoerceUnsized<&std::error::Error + 'static>)
test.rs:10                                                      Some(cause) => err = cause,
                                                          ^~~~~
error: aborting due to previous error
```

Am I missing something here?
Repository: youtube-dl
Issue: Support site film.qq.com
Labels: site-support-request,geo-restricted,account-needed

## Please follow the guide below
- You will be asked some questions and requested to provide some information, please read them **carefully** and answer honestly
- Put an `x` into all the boxes [ ] relevant to your _issue_ (like that [x])
- Use _Preview_ tab to see how your issue will actually look like

---
### Make sure you are using the _latest_ version: run `youtube-dl --version` and ensure your version is _2016.05.01_. If it's not read [this FAQ entry](https://github.com/rg3/youtube-dl/blob/master/README.md#how-do-i-update-youtube-dl) and update. Issues with outdated version will be rejected.
- [x] I've **verified** and **I assure** that I'm running youtube-dl **2016.05.01**
### Before submitting an _issue_ make sure you have:
- [x] At least skimmed through [README](https://github.com/rg3/youtube-dl/blob/master/README.md) and **most notably** [FAQ](https://github.com/rg3/youtube-dl#faq) and [BUGS](https://github.com/rg3/youtube-dl#bugs) sections
- [x] [Searched](https://github.com/rg3/youtube-dl/search?type=Issues) the bugtracker for similar issues including closed ones
### What is the purpose of your _issue_?
- [ ] Bug report (encountered problems with youtube-dl)
- [x] Site support request (request for adding support for a new site)
- [ ] Feature request (request for a new functionality)
- [ ] Question
- [ ] Other

Single video:http://film.qq.com/cover/q/qoudfsxphflt789.html
Repository: nvm
Issue: `nvm upgrade`?
Labels: feature requests

Would it be possible to add something like `nvm upgrade`? I imagine it would upgrade to the latest minor/patch version of the currently active version (or just latest patch for v0.x), and would be functionally equivalent to something like `nvm install [major version] --reinstall-packages-from=$(nvm version)`. There could also be an optional switch to delete the old version.

I've been using this in my profile, which isn't quite as nice as I have to specify the new version to install:

``` bash
# nvm-upgrade NEW_VERSION
#
# Installs the specified version of node via nvm, reinstalling all global
# packages from the currently activated version of node. Does not delete
# the previous node version.
function nvm-upgrade() {
  nvm install $1 --reinstall-packages-from=`nvm version`
  nvm use $1
  npm install -g npm
  npm upgrade -g
}
```
Repository: neovim
Issue: slow movement, highlighting on long lines
Labels: performance,bug-vim,syntax,display,normal-mode

- Neovim version: 0.1.4
-  Vim behaves differently? Vim version: 7.4.1797-1
- Operating system/version: Arch Linux 4.4.8-1-lts
- Terminal name/version: xterm
- `$TERM`: xterm
### Actual behaviour

Extremely slow cursor movement in files with long lines (e.g. [englishdictionary.sql](https://sourceforge.net/projects/mysqlenglishdictionary/files/englishdictionary.sql/download)). Apparently caused by very inefficient highlighting (slow regexps?).
### Expected behaviour

Cursor movement at normal speed (i.e. without getting stuck indefinitely).
### Steps to reproduce using `nvim -u NORC`

```
nvim -u NORC englishdictionary.sql
```

Vim behavior is the same, i.e. bad.

The reason why I'm raising this issue is to propose some timeout for highlighting. I'm working quite a lot with such long-line files and it's pain without highlighting and even more with it.

Even some hack as switching off highlighting for lines longer than some configurable _N_ would be fine, because my goal is to edit the file and work with it (and with the indefinitely hung nvim it's impossible to run `:syntax off`).
Repository: youtube-dl
Issue: post-processing merge should preserve "encoded date" metadata
Labels: request,postprocessors

- [ x] I've **verified** and **I assure** that I'm running youtube-dl **2016.05.10**
- [x ] At least skimmed through [README](https://github.com/rg3/youtube-dl/blob/master/README.md) and **most notably** [FAQ](https://github.com/rg3/youtube-dl#faq) and [BUGS](https://github.com/rg3/youtube-dl#bugs) sections
- [ x] [Searched](https://github.com/rg3/youtube-dl/search?type=Issues) the bugtracker for similar issues including closed ones
### What is the purpose of your _issue_?
- [x ] Feature request (request for a new functionality)

When merging/muxing youtube video components into a single file, the "Encoded date" / "Tagged date" is set to the year 1904, even though the source video and audio have proper encoding dates.

Applying `--postprocessor-args "-map_metadata 0"` via ffmpeg will copy it over, but this should be a default behavior.

Proposed solution: include `-map_metadata 0` by default or use `-metadata creation_time="DATE"`, where `DATE` is ISO-8601
Repository: opencv
Issue: cv::gpu::ORB_GPU::buildScalePyramids fails with small images
Labels: bug,affected: 2.4,category: gpu/cuda (contrib)

In OpenCV 2.4, in the `gpu::ORB_GPU` class, orb.cpp file, there is an issue that occurs with small images when using the defaults. [On line 535](https://github.com/Itseez/opencv/blob/2.4/modules/gpu/src/orb.cpp#L535)

```
Rect inner(edgeThreshold_, edgeThreshold_, 
                 sz.width - 2 * edgeThreshold_, sz.height - 2 * edgeThreshold_); 
```

Given the default values of 8 levels and a 1.2 scale factor, we get a scale of 0.232568039, which we multiple the input `image.rows` and `image.cols` by. However, with a default edge threshold of 31, if `sz.width` or `sz.height` is less than 62, we get a rectangle with a negative width or height, so the next line, `buf_(inner)` will throw an assert:

> OpenCV Error: Assertion failed (0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.cols && 0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.rows) in GpuMat

Calculating backwards, that means that the image must have both dimension greater than 266 pixels, or else the program will fail.

Note that the CPU version seems to address this problem in [lkpyramid.cpp, line 820](https://github.com/Itseez/opencv/blob/2.4/modules/video/src/lkpyramid.cpp#L820):

```
if( sz.width <= winSize.width || sz.height <= winSize.height )
```

I'm not sure what the best fix is for the GPU case, but for now I will address this by either:

```
scaleFactor = min(pow(min(image.rows, image.cols)/62.0, 1/8.0), 1.2);
```

or:

```
nLevels = min(int(ceil(log(min(image.rows, image.cols)/62.0)/log(1.2))), 8);
```

I'll see which gives the best results, but the `nLevels` follows the CPU code more closely.
Repository: go
Issue: syscall: Windows Errno.Temporary and Errno.Timeout are incomplete
Labels: ExpertNeeded,help wanted,OS-Windows,NeedsInvestigation,early-in-cycle

 What version of Go are you using (`go version`)?
go version go1.6 windows/amd64

I read src/syscall/syscall_windows.go and find Errno.Temporary() just check EINTR, EMFILE and Errno.Timeout, but the src/syscall/syscall_unix.go, Errno.Temporary() additional check ECONNRESET and ECONNABORTED.

so why different between windows and linux?

Sorry my poor English.
Repository: kubernetes
Issue: Make API field defaulting and validation less error-prone
Labels: priority/backlog,sig/api-machinery,area/swagger,lifecycle/frozen

There are frequent errors in API field specification, such as:
- default vs inferred (e.g., `fsType`: https://github.com/kubernetes/kubernetes/blob/master/pkg/api/v1/types.go#L557); note that implicitly inferred is discouraged
- default vs required
- required/optional vs omitempty
- omitempty vs. pointers
- documentation vs actual defaulting and validation code

For examples of multiple errors in one type, see:
https://github.com/kubernetes/kubernetes/issues/18885#issuecomment-218376807

One way to make defaulting and validation less error prone would to be allow them to be specified declaratively, on API fields using tags or comments. Protocol buffers allow literal default values to be specified (though, unlike in Kubernetes, they aren't conveyed on the wire; non-literals, such as fields defaulted from other fields, can't be specified this way). Declarative validation, where possible (i.e., simple rules), was previously requested by #8116. 

Since omitempty and pointer rules are apparently non-obvious, I think we should require specification of required vs optional and then either verify that the other properties are consistent or autogenerate them. 

Auto-fixing field names in documentation is covered by #19319.

cc @lavalamp @thockin @kubernetes/sig-api-machinery
Repository: You-Dont-Know-JS
Issue: "async & performance" and "es6 & beyond": update "TCO"
Labels: for second edition

A&P Ch6, E&B Ch7

Many things to update here, including:
- "TCO" is the wrong term, should have been PTC (proper tail calls)
- TCO is about optional optimizations on top of PTC
- potentially the STC changes post ES6
- tail calls isn't about reusing stack frames, but about throwing away the current one before making the next one
Repository: go
Issue: x/crypto/ssh: No support for Window Dimension Change Message
Labels: help wanted,NeedsFix,FeatureRequest

Please answer these questions before submitting your issue. Thanks!
1. What version of Go are you using (`go version`)?
   go version go1.6.1 darwin/amd64
2. What operating system and processor architecture are you using (`go env`)?
   darwin/amd64
3. What did you do?
   If possible, provide a recipe for reproducing the error.
   A complete runnable program is good.
   A link on play.golang.org is best.

Simply a part of the RFC 4254 document that was not implemented; would want a method on an ssh.Session object to send messages such as this.
1. What did you expect to see?
   N/A
2. What did you see instead?
   Not yet implemented.
Repository: java-design-patterns
Issue: IODA architectural pattern
Labels: info: help wanted,epic: pattern,type: feature

## Description
The IODA (Input, Operations, Data, and Access) design pattern focuses on separating the concerns of input, operations, data, and access within a software system. This pattern promotes cleaner, more maintainable code by isolating different aspects of the system, thus making it easier to manage and scale.

### Main Elements of the Pattern:
1. **Input**: Handles all the input operations, including user interactions and data input from external sources.
2. **Operations**: Manages the business logic and core operations of the application.
3. **Data**: Responsible for the data management, including data structures and in-memory data handling.
4. **Access**: Handles the persistence layer, including database interactions and external service integrations.

### References:
- [Project Contribution Guidelines](https://github.com/iluwatar/java-design-patterns/wiki)
- [IODA Architecture Overview](https://geekswithblogs.net/gwbarchive/the-ioda-architecture/)
- [IODA Architecture by Example](http://geekswithblogs.net/theArchitectsNapkin/archive/2015/05/02/ioda-architecture-by-example.aspx)
- [IODA Architecture](http://www.infoq.com/news/2015/05/ioda-architecture)

## Acceptance Criteria
1. The implementation should include clearly defined classes or modules for Input, Operations, Data, and Access.
2. Each component should be independently testable, with unit tests covering the core functionalities of Input, Operations, Data, and Access.
3. Ensure adherence to the project's coding standards and contribution guidelines as outlined in the project's documentation.
Repository: TypeScript
Issue: ES6 modules cannot use "await" as an identifier
Labels: Bug,ES6

According to http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words
"await is only treated as a FutureReservedWord when Module is the goal symbol of the syntactic grammar."

This code should be illegal I think:
http://www.typescriptlang.org/play/#src=import%20'foo'%3B%0A%0Alet%20await%20%3D%203%3B

Came up when discussing TS semantics with @ajklein (v8 ES6 module expert).