beenull/browsh
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
browsh/interfacer/Gopkg.lock

88 lines
3.1 KiB
Plaintext
Raw Normal View History

First working draft of Golang interfacer After weighing up the options it seems that Golang's termbox-go TTY library has better support for terminals, and it's cross-platform out of the box. So this commit is the first working version where the interfacer launches a websocket server, makes a connection to the webextension and listens to STDIN from the CLI, sending all input to the webextenstion.
2018-01-07 03:21:29 +00:00
# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
Replaced Termbox-go with Tcell This was primarily to get native diff'ed frame rendering. Termbox-go doesn't support true colours, thus the switch to Tcell, but as it turns out Tcell claims to have wider platform support, so it looks like an especially good change. So now the CLI will only try to update the terminal screen when cells actually change. This has some significant performant gains, especially when using Browsh over SSH. Also note that this required a complete change of the frame data structure sent over the websocket. Previously it was a little structured, but now it is just a plain 1 dimensional array of pure strings, even the RGB components are sent as integers in strings. If I can find a way to unmarshal mixed arrays in Golang then it'll be worth sending a mixed JSON array to save some compute overhead.
2018-02-14 02:33:39 +00:00
[[projects]]
branch = "master"
name = "github.com/gdamore/encoding"
packages = ["."]
revision = "b23993cbb6353f0e6aa98d0ee318a34728f628b9"
[[projects]]
branch = "master"
name = "github.com/gdamore/tcell"
packages = [".","terminfo"]
Added Firefox paths for Windows and OSX Also updated Gopkg dep versions. And version bump to 1.0.0pre1!
2018-06-10 12:16:28 +00:00
revision = "b3cebc399d6f98536af845ed8a5144ab586f6759"
Replaced Termbox-go with Tcell This was primarily to get native diff'ed frame rendering. Termbox-go doesn't support true colours, thus the switch to Tcell, but as it turns out Tcell claims to have wider platform support, so it looks like an especially good change. So now the CLI will only try to update the terminal screen when cells actually change. This has some significant performant gains, especially when using Browsh over SSH. Also note that this required a complete change of the frame data structure sent over the websocket. Previously it was a little structured, but now it is just a plain 1 dimensional array of pure strings, even the RGB components are sent as integers in strings. If I can find a way to unmarshal mixed arrays in Golang then it'll be worth sending a mixed JSON array to save some compute overhead.
2018-02-14 02:33:39 +00:00
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
[[projects]]
name = "github.com/go-errors/errors"
packages = ["."]
Lots of new integration tests
2018-04-06 15:16:15 +00:00
revision = "a6af135bd4e28680facf08a3d206b454abc877a4"
version = "v1.0.1"
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
First working draft of Golang interfacer After weighing up the options it seems that Golang's termbox-go TTY library has better support for terminals, and it's cross-platform out of the box. So this commit is the first working version where the interfacer launches a websocket server, makes a connection to the webextension and listens to STDIN from the CLI, sending all input to the webextenstion.
2018-01-07 03:21:29 +00:00
[[projects]]
name = "github.com/gorilla/websocket"
packages = ["."]
revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b"
version = "v1.2.0"
Replaced Termbox-go with Tcell This was primarily to get native diff'ed frame rendering. Termbox-go doesn't support true colours, thus the switch to Tcell, but as it turns out Tcell claims to have wider platform support, so it looks like an especially good change. So now the CLI will only try to update the terminal screen when cells actually change. This has some significant performant gains, especially when using Browsh over SSH. Also note that this required a complete change of the frame data structure sent over the websocket. Previously it was a little structured, but now it is just a plain 1 dimensional array of pure strings, even the RGB components are sent as integers in strings. If I can find a way to unmarshal mixed arrays in Golang then it'll be worth sending a mixed JSON array to save some compute overhead.
2018-02-14 02:33:39 +00:00
[[projects]]
name = "github.com/lucasb-eyer/go-colorful"
packages = ["."]
Added Firefox paths for Windows and OSX Also updated Gopkg dep versions. And version bump to 1.0.0pre1!
2018-06-10 12:16:28 +00:00
revision = "345fbb3dbcdb252d9985ee899a84963c0fa24c82"
version = "v1.0"
Replaced Termbox-go with Tcell This was primarily to get native diff'ed frame rendering. Termbox-go doesn't support true colours, thus the switch to Tcell, but as it turns out Tcell claims to have wider platform support, so it looks like an especially good change. So now the CLI will only try to update the terminal screen when cells actually change. This has some significant performant gains, especially when using Browsh over SSH. Also note that this required a complete change of the frame data structure sent over the websocket. Previously it was a little structured, but now it is just a plain 1 dimensional array of pure strings, even the RGB components are sent as integers in strings. If I can find a way to unmarshal mixed arrays in Golang then it'll be worth sending a mixed JSON array to save some compute overhead.
2018-02-14 02:33:39 +00:00
First working draft of Golang interfacer After weighing up the options it seems that Golang's termbox-go TTY library has better support for terminals, and it's cross-platform out of the box. So this commit is the first working version where the interfacer launches a websocket server, makes a connection to the webextension and listens to STDIN from the CLI, sending all input to the webextenstion.
2018-01-07 03:21:29 +00:00
[[projects]]
name = "github.com/mattn/go-runewidth"
packages = ["."]
revision = "9e777a8366cce605130a531d2cd6363d07ad7317"
version = "v0.0.2"
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
[[projects]]
name = "github.com/onsi/ginkgo"
packages = [".","config","internal/codelocation","internal/containernode","internal/failer","internal/leafnodes","internal/remote","internal/spec","internal/spec_iterator","internal/specrunner","internal/suite","internal/testingtproxy","internal/writer","reporters","reporters/stenographer","reporters/stenographer/support/go-colorable","reporters/stenographer/support/go-isatty","types"]
Added Firefox paths for Windows and OSX Also updated Gopkg dep versions. And version bump to 1.0.0pre1!
2018-06-10 12:16:28 +00:00
revision = "fa5fabab2a1bfbd924faf4c067d07ae414e2aedf"
version = "v1.5.0"
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
[[projects]]
name = "github.com/onsi/gomega"
packages = [".","format","internal/assertion","internal/asyncassertion","internal/oraclematcher","internal/testingtsupport","matchers","matchers/support/goraph/bipartitegraph","matchers/support/goraph/edge","matchers/support/goraph/node","matchers/support/goraph/util","types"]
Added Firefox paths for Windows and OSX Also updated Gopkg dep versions. And version bump to 1.0.0pre1!
2018-06-10 12:16:28 +00:00
revision = "62bff4df71bdbc266561a0caee19f0594b17c240"
version = "v1.4.0"
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
First working draft of Golang interfacer After weighing up the options it seems that Golang's termbox-go TTY library has better support for terminals, and it's cross-platform out of the box. So this commit is the first working version where the interfacer launches a websocket server, makes a connection to the webextension and listens to STDIN from the CLI, sending all input to the webextenstion.
2018-01-07 03:21:29 +00:00
[[projects]]
branch = "master"
Replaced Termbox-go with Tcell This was primarily to get native diff'ed frame rendering. Termbox-go doesn't support true colours, thus the switch to Tcell, but as it turns out Tcell claims to have wider platform support, so it looks like an especially good change. So now the CLI will only try to update the terminal screen when cells actually change. This has some significant performant gains, especially when using Browsh over SSH. Also note that this required a complete change of the frame data structure sent over the websocket. Previously it was a little structured, but now it is just a plain 1 dimensional array of pure strings, even the RGB components are sent as integers in strings. If I can find a way to unmarshal mixed arrays in Golang then it'll be worth sending a mixed JSON array to save some compute overhead.
2018-02-14 02:33:39 +00:00
name = "github.com/shibukawa/configdir"
First working draft of Golang interfacer After weighing up the options it seems that Golang's termbox-go TTY library has better support for terminals, and it's cross-platform out of the box. So this commit is the first working version where the interfacer launches a websocket server, makes a connection to the webextension and listens to STDIN from the CLI, sending all input to the webextenstion.
2018-01-07 03:21:29 +00:00
packages = ["."]
Replaced Termbox-go with Tcell This was primarily to get native diff'ed frame rendering. Termbox-go doesn't support true colours, thus the switch to Tcell, but as it turns out Tcell claims to have wider platform support, so it looks like an especially good change. So now the CLI will only try to update the terminal screen when cells actually change. This has some significant performant gains, especially when using Browsh over SSH. Also note that this required a complete change of the frame data structure sent over the websocket. Previously it was a little structured, but now it is just a plain 1 dimensional array of pure strings, even the RGB components are sent as integers in strings. If I can find a way to unmarshal mixed arrays in Golang then it'll be worth sending a mixed JSON array to save some compute overhead.
2018-02-14 02:33:39 +00:00
revision = "e180dbdc8da04c4fa04272e875ce64949f38bd3e"
First working draft of Golang interfacer After weighing up the options it seems that Golang's termbox-go TTY library has better support for terminals, and it's cross-platform out of the box. So this commit is the first working version where the interfacer launches a websocket server, makes a connection to the webextension and listens to STDIN from the CLI, sending all input to the webextenstion.
2018-01-07 03:21:29 +00:00
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
[[projects]]
branch = "master"
name = "golang.org/x/net"
packages = ["html","html/atom","html/charset"]
Added Firefox paths for Windows and OSX Also updated Gopkg dep versions. And version bump to 1.0.0pre1!
2018-06-10 12:16:28 +00:00
revision = "1e491301e022f8f977054da4c2d852decd59571f"
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
[[projects]]
branch = "master"
name = "golang.org/x/sys"
packages = ["unix"]
Added Firefox paths for Windows and OSX Also updated Gopkg dep versions. And version bump to 1.0.0pre1!
2018-06-10 12:16:28 +00:00
revision = "9527bec2660bd847c050fda93a0f0c6dee0800bb"
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
Launch and install webextension from client This means that Browsh can now be entirely run just by running the CLI binary. The client launches Firefox as a subprocess, then connects to it via the Marionette protocol, installs the webextension and finally triggers a new tab with, currently, the Google homepage in it. I was trying to set this up for automated testing as well by installing the built webextension as a temporary addon, because otherwise you need to sign the extension everytime with a unique semantic version. However for some reason I can't quite recreate the environment that MDN's `web-ext` creates. The extension installs fine but fails to load the `content.js` script, I can't find a backtrace or any other details about the failure. So for now, we're just going to have to use `web-ext` as seperate process and have the client connect to that. Which is what one should do during development anyway, so it's not a huge loss.
2018-01-21 03:56:05 +00:00
[[projects]]
Replaced Termbox-go with Tcell This was primarily to get native diff'ed frame rendering. Termbox-go doesn't support true colours, thus the switch to Tcell, but as it turns out Tcell claims to have wider platform support, so it looks like an especially good change. So now the CLI will only try to update the terminal screen when cells actually change. This has some significant performant gains, especially when using Browsh over SSH. Also note that this required a complete change of the frame data structure sent over the websocket. Previously it was a little structured, but now it is just a plain 1 dimensional array of pure strings, even the RGB components are sent as integers in strings. If I can find a way to unmarshal mixed arrays in Golang then it'll be worth sending a mixed JSON array to save some compute overhead.
2018-02-14 02:33:39 +00:00
name = "golang.org/x/text"
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
packages = ["encoding","encoding/charmap","encoding/htmlindex","encoding/internal","encoding/internal/identifier","encoding/japanese","encoding/korean","encoding/simplifiedchinese","encoding/traditionalchinese","encoding/unicode","internal/gen","internal/tag","internal/utf8internal","language","runes","transform","unicode/cldr"]
Lots of new integration tests
2018-04-06 15:16:15 +00:00
revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
version = "v0.3.0"
Launch and install webextension from client This means that Browsh can now be entirely run just by running the CLI binary. The client launches Firefox as a subprocess, then connects to it via the Marionette protocol, installs the webextension and finally triggers a new tab with, currently, the Google homepage in it. I was trying to set this up for automated testing as well by installing the built webextension as a temporary addon, because otherwise you need to sign the extension everytime with a unique semantic version. However for some reason I can't quite recreate the environment that MDN's `web-ext` creates. The extension installs fine but fails to load the `content.js` script, I can't find a backtrace or any other details about the failure. So for now, we're just going to have to use `web-ext` as seperate process and have the client connect to that. Which is what one should do during development anyway, so it's not a huge loss.
2018-01-21 03:56:05 +00:00
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
[[projects]]
name = "gopkg.in/yaml.v2"
packages = ["."]
Lots of new integration tests
2018-04-06 15:16:15 +00:00
revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
version = "v2.2.1"
Move integration tests to Golang CLI client After moving to Tcell and implementing its screen diff updates, we can no longer watch STDOUT to get frames during integration tests. Instead we need to use Tcell's SimulationScreen and which has a GetContents() method. This is actually also a much more robust way of being able to see what Browsh actually outputs during testing.
2018-02-17 05:52:03 +00:00
First working draft of Golang interfacer After weighing up the options it seems that Golang's termbox-go TTY library has better support for terminals, and it's cross-platform out of the box. So this commit is the first working version where the interfacer launches a websocket server, makes a connection to the webextension and listens to STDIN from the CLI, sending all input to the webextenstion.
2018-01-07 03:21:29 +00:00
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
Lots of new integration tests
2018-04-06 15:16:15 +00:00
inputs-digest = "d45276f27c8406a168f3f82f609de071ef087fef39e2135d2e2a87b00f15b0bd"
First working draft of Golang interfacer After weighing up the options it seems that Golang's termbox-go TTY library has better support for terminals, and it's cross-platform out of the box. So this commit is the first working version where the interfacer launches a websocket server, makes a connection to the webextension and listens to STDIN from the CLI, sending all input to the webextenstion.
2018-01-07 03:21:29 +00:00
solver-name = "gps-cdcl"
solver-version = 1
Reference in a new issue Copy permalink