Esempio n. 1
0
func TestBranchRender2(t *testing.T) {

	cb := ctests.New(t).SetApp(true, true, false)
	defer cb.Finish()

	b := NewBranchView(cb.Ctx(), models.NewBranchModel(cb.Ctx(), &models.RootContents{Name: "a"}))
	expected := elem.Div(
		prop.Class("node"),
		NewBranchControlView(cb.Ctx(), models.NewBranchModel(cb.Ctx(), nil)),
		elem.Div(
			prop.Class("children"),
		),
	)
	equal(t, expected, b.Render())

}
Esempio n. 2
0
func TestBranchNotifySelectFileClick(t *testing.T) {
	cb := ctests.New(t).SetApp(true, false, false)
	defer cb.Finish()

	setupForSuccessfulFileLoad(t, cb)

	m := models.NewBranchModel(cb.Ctx(), &models.AsyncContents{FileContents: models.FileContents{NodeContents: models.NodeContents{Name: "a"}, Filename: "b"}})
	b := NewBranchView(cb.Ctx(), m)

	cb.ExpectDispatched(
		&actions.LoadFileSent{Branch: b.model},
		&actions.LoadFileSuccess{Branch: b.model},
		&actions.BranchOpening{Branch: b.model},
		&actions.BranchSelected{Branch: b.model, Loaded: true},
	)

	done := cb.GetApp().Notifier.NotifyWithData(
		b.model,
		stores.BranchSelecting,
		&stores.BranchSelectOperationData{Op: models.BranchOpClickToggle},
	)
	<-done

	cb.AssertAppSuccess()

}
Esempio n. 3
0
func TestBranchControlView_Render(t *testing.T) {

	cb := ctests.New(t).SetApp(true, false, false)
	defer cb.Finish()

	b := NewBranchControlView(cb.Ctx(), models.NewBranchModel(cb.Ctx(), &models.RootContents{Name: "a"}))

	expected := elem.Div(
		elem.Anchor(
			vecty.ClassMap{
				"toggle": true,
				"empty":  true,
			},
			event.Click(nil),
		),
		elem.Div(
			vecty.ClassMap{
				"node-content": true,
			},
			elem.Span(
				prop.Class("node-label"),
				event.Click(nil),
				vecty.Text("a"),
			),
			elem.Span(
				prop.Class("badge"),
				vecty.Style("display", "none"),
			),
		),
	)
	equal(t, expected, b.Render())

	cb.AssertAppSuccess()

}
Esempio n. 4
0
File: branch.go Progetto: kego/ke
func (s *BranchStore) NewNodeBranchModel(ctx context.Context, n *node.Node, name string) *models.BranchModel {
	b := models.NewBranchModel(ctx, &models.NodeContents{
		Node: n,
		Name: name,
	})
	s.AppendNodeBranchModelChildren(b, n)
	s.nodeBranches[n] = b
	return b
}
Esempio n. 5
0
func TestBranchView_Unmount(t *testing.T) {
	cb := ctests.New(t).SetApp(true, true, false)
	defer cb.Finish()

	b := NewBranchView(cb.Ctx(), models.NewBranchModel(cb.Ctx(), &models.RootContents{Name: "a"}))

	c := mock_vecty.NewMockComponent(cb.GetMock())
	c.EXPECT().Unmount()
	b.Body = c
	b.Unmount()
	assert.Nil(t, b.Notifs)
}
Esempio n. 6
0
func TestBranchNotifyOpen(t *testing.T) {
	cb := ctests.New(t).SetApp(true, false, false)
	defer cb.Finish()

	b := NewBranchView(cb.Ctx(), models.NewBranchModel(cb.Ctx(), &models.RootContents{Name: "a"}))

	cb.GetConnection().EXPECT().Go(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)

	cb.ExpectDispatched(&actions.BranchOpened{Branch: b.model, Loaded: false})

	done := cb.GetApp().Notifier.Notify(b.model, stores.BranchOpening)
	<-done

	cb.AssertAppSuccess()
}
Esempio n. 7
0
func testBranchReconcile(t *testing.T, notif flux.Notif) {
	cb := ctests.New(t).SetApp(true, false, false)
	defer cb.Finish()

	b := NewBranchView(cb.Ctx(), models.NewBranchModel(cb.Ctx(), &models.RootContents{Name: "a"}))

	cb.ExpectReconcile(&b.Composite)
	cb.ExpectNoneDispatched()

	done := cb.GetApp().Notifier.Notify(b.model, notif)
	<-done

	cb.AssertAppSuccess()

}
Esempio n. 8
0
func TestBranchNotifyOpenFile(t *testing.T) {
	cb := ctests.New(t).SetApp(true, false, false)
	defer cb.Finish()

	setupForSuccessfulFileLoad(t, cb)

	b := NewBranchView(cb.Ctx(), models.NewBranchModel(cb.Ctx(), &models.AsyncContents{FileContents: models.FileContents{NodeContents: models.NodeContents{Name: "a"}, Filename: "b"}}))

	cb.ExpectDispatched(
		&actions.LoadFileSent{Branch: b.model},
		&actions.LoadFileSuccess{Branch: b.model},
		&actions.BranchOpened{Branch: b.model, Loaded: true},
	)

	done := cb.GetApp().Notifier.Notify(b.model, stores.BranchOpening)
	<-done

	cb.AssertAppSuccess()

}
Esempio n. 9
0
func TestBranchNotifySelect(t *testing.T) {
	cb := ctests.New(t).SetApp(true, false, false)
	defer cb.Finish()

	b := NewBranchView(cb.Ctx(), models.NewBranchModel(cb.Ctx(), &models.RootContents{Name: "a"}))

	cb.ExpectDispatched(
		&actions.BranchSelected{Branch: b.model, Loaded: false},
	)

	done := cb.GetApp().Notifier.NotifyWithData(
		b.model,
		stores.BranchSelecting,
		&stores.BranchSelectOperationData{Op: models.BranchOpClickLabel},
	)
	<-done

	cb.AssertAppSuccess()

}
Esempio n. 10
0
File: branch.go Progetto: kego/ke
func (s *BranchStore) Handle(payload *flux.Payload) bool {
	previous := s.selected
	switch action := payload.Action.(type) {
	case *actions.ChangeView:
		s.view = action.View
		s.selected = s.Root()
		payload.Notify(nil, ViewChanged)
	case *actions.Add:
		payload.Wait(s.app.Nodes)
		switch action.Direction() {
		case actions.New, actions.Redo:
			child, parent, err := mutateAppendBranch(s, action.Parent, action.Node, action.BranchName, action.BranchFile)
			if err != nil {
				s.app.Fail <- kerr.Wrap("LDBMBRHWHB", err)
				break
			}
			if child != nil {
				if ancestor := child.EnsureVisible(); ancestor != nil {
					payload.NotifyWithData(ancestor, BranchOpened, &BranchDescendantSelectData{
						Branch: child,
						Op:     models.BranchOpChildAdded,
					})
				}
				s.selected = child
				payload.Notify(previous, BranchUnselectControl)
				payload.Notify(s.selected, BranchSelectControl)
				payload.Notify(s.selected, BranchSelected)
			}
			if parent != nil {
				payload.Notify(parent, BranchChildAdded)
			}
		case actions.Undo:
			_, parent, err := mutateDeleteBranch(s, action.Node)
			if err != nil {
				s.app.Fail <- kerr.Wrap("NLFWVSNNTY", err)
				break
			}
			if parent != nil {
				payload.Notify(parent, BranchChildDeleted)
				s.selected = parent
				payload.Notify(previous, BranchUnselectControl)
				payload.Notify(s.selected, BranchSelectControl)
				payload.Notify(s.selected, BranchSelected)
			}
		}
	case *actions.Delete:
		payload.Wait(s.app.Nodes)
		switch action.Direction() {
		case actions.New, actions.Redo:
			branch, parent, err := mutateDeleteBranch(s, action.Node)
			if err != nil {
				s.app.Fail <- kerr.Wrap("QTXPXAKXHH", err)
				break
			}
			if branch != nil {
				action.BranchIndex = branch.Index
				if nci, ok := branch.Contents.(models.NodeContentsInterface); ok {
					action.BranchName = nci.GetName()
				}
				if fci, ok := branch.Contents.(models.FileContentsInterface); ok {
					action.BranchFile = fci.GetFilename()
				}
			}
			if parent != nil {
				payload.Notify(parent, BranchChildDeleted)
				s.selected = parent
				payload.Notify(previous, BranchUnselectControl)
				payload.Notify(s.selected, BranchSelectControl)
				payload.Notify(s.selected, BranchSelected)
			}
		case actions.Undo:
			child, parent, err := mutateInsertBranch(s, action.Parent, action.Node, action.BranchIndex, action.BranchName, action.BranchFile)
			if err != nil {
				s.app.Fail <- kerr.Wrap("OOGOEWKPIL", err)
				break
			}
			if child != nil {
				if ancestor := child.EnsureVisible(); ancestor != nil {
					payload.NotifyWithData(ancestor, BranchOpened, &BranchDescendantSelectData{
						Branch: child,
						Op:     models.BranchOpChildAdded,
					})
				}
				s.selected = child
				payload.Notify(previous, BranchUnselectControl)
				payload.Notify(s.selected, BranchSelectControl)
				payload.Notify(s.selected, BranchSelected)
			}
			if parent != nil {
				payload.Notify(parent, BranchChildAdded)
			}
		}
	case *actions.Reorder:
		payload.Wait(s.app.Nodes)
		parent, err := mutateReorderBranch(s, action.Model.Node)
		if err != nil {
			s.app.Fail <- kerr.Wrap("NUQOPWWXHA", err)
			break
		}
		if parent != nil {
			payload.Notify(parent, BranchChildrenReordered)
		}
	case *actions.BranchClose:
		if !action.Branch.CanOpen() {
			// branch can't open - ignore
			break
		}
		action.Branch.RecursiveClose()
		payload.Notify(action.Branch, BranchClose)
	case *actions.BranchOpening:
		if !action.Branch.CanOpen() {
			// branch can't open - ignore
			break
		}
		// The branch may not be loaded, so we don't open the branch until the BranchOpenPostLoad
		// action is received. This will happen immediately if the branch is loaded or not async.
		payload.Notify(action.Branch, BranchOpening)
	case *actions.BranchOpened:
		if !action.Branch.CanOpen() {
			// branch can't open - ignore
			break
		}
		action.Branch.Open = true
		payload.Notify(action.Branch, BranchOpened)

	case *actions.BranchSelecting:

		if ancestor := action.Branch.EnsureVisible(); ancestor != nil {
			payload.NotifyWithData(ancestor, BranchOpened, &BranchDescendantSelectData{
				Branch: action.Branch,
				Op:     action.Op,
			})
			break
		}

		s.selected = action.Branch

		payload.Notify(previous, BranchUnselectControl)
		payload.Notify(s.selected, BranchSelectControl)

		if action.Op == models.BranchOpKeyboard {
			go func() {
				<-time.After(common.EditorKeyboardDebounceShort)
				if s.selected == action.Branch {
					payload.NotifyWithData(
						s.selected,
						BranchSelecting,
						&BranchSelectOperationData{Op: action.Op},
					)
				}
			}()
		} else {
			payload.NotifyWithData(
				s.selected,
				BranchSelecting,
				&BranchSelectOperationData{Op: action.Op},
			)
		}

	case *actions.BranchSelected:
		payload.Wait(s.app.Nodes)
		payload.Notify(s.selected, BranchSelected)
	case *actions.InitialState:
		payload.Wait(s.app.Package, s.app.Types, s.app.Data, s.app.Env)

		s.pkg = s.NewFileBranchModel(s.ctx, s.app.Package.Node(), "package", s.app.Package.Filename())
		s.pkg.Root = true
		s.pkg.Open = true

		s.types = models.NewBranchModel(s.ctx, &models.TypesContents{})
		s.types.Root = true
		s.types.Open = true
		for _, name := range s.app.Types.Names() {
			t := s.app.Types.Get(name)
			typeBranch := s.NewFileBranchModel(s.ctx, t.Node, name, t.File)
			s.types.Append(typeBranch)
		}

		s.data = models.NewBranchModel(s.ctx, &models.DataContents{})
		s.data.Root = true
		s.data.Open = true

		for _, name := range s.app.Data.Names() {
			s.data.Append(models.NewBranchModel(s.ctx, &models.AsyncContents{
				FileContents: models.FileContents{
					NodeContents: models.NodeContents{
						Name: name,
					},
					Filename: s.app.Data.Get(name).File,
				},
			}))
		}
		s.selected = s.data
		payload.Notify(nil, BranchInitialStateLoaded)
	case *actions.LoadFileSuccess:
		ni, ok := action.Branch.Contents.(models.NodeContentsInterface)
		if !ok {
			break
		}
		n := ni.GetNode()
		s.AppendNodeBranchModelChildren(action.Branch, n)
		s.nodeBranches[n] = action.Branch
		payload.Notify(action.Branch, BranchLoaded)
	}
	return true
}