hunk.code_window: }
   // MarketplacePlugin is a state aware marketplace plugin.
   type MarketplacePlugin struct {
   	*BaseMarketplacePlugin
   	InstalledVersion string `json:"installed_version"`
  
hunk.labels: keep keep replace keep keep keep
hunk.after_edit: // MarketplaceLabel represents a label shown in the Marketplace UI.
   type MarketplaceLabel struct {
   	Name        string `json:"name"`
   	Description string `json:"description"`
   	URL         string `json:"url"`
   	Color       string `json:"color"`
   }
   // MarketplacePlugin is a state aware Marketplace plugin.
  
hunk.file_path: model/marketplace_plugin.go
hunk.type: replace
file: // Copyright © 2014 Steve Francia <spf@spf13.com>.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  package afero
  
  import (
  	"fmt"
  	"log"
  	"os"
  	"path/filepath"
  	"strings"
  	"sync"
  	"time"
  
  	"github.com/spf13/afero/mem"
  )
  
  type MemMapFs struct {
  	mu   sync.RWMutex
  	data map[string]*mem.FileData
  	init sync.Once
  }
  
  func NewMemMapFs() Fs {
  	return &MemMapFs{}
  }
  
  func (m *MemMapFs) getData() map[string]*mem.FileData {
  	m.init.Do(func() {
  		m.data = make(map[string]*mem.FileData)
  		// Root should always exist, right?
  		// TODO: what about windows?
  		m.data[FilePathSeparator] = mem.CreateDir(FilePathSeparator)
  	})
  	return m.data
  }
  
  func (*MemMapFs) Name() string { return "MemMapFS" }
  
  func (m *MemMapFs) Create(name string) (File, error) {
  	name = normalizePath(name)
  	m.mu.Lock()
  	file := mem.CreateFile(name)
  	m.getData()[name] = file
  	m.registerWithParent(file)
  	m.mu.Unlock()
  	return mem.NewFileHandle(file), nil
  }
  
  func (m *MemMapFs) unRegisterWithParent(fileName string) error {
  	f, err := m.lockfreeOpen(fileName)
  	if err != nil {
  		return err
  	}
  	parent := m.findParent(f)
  	if parent == nil {
  		log.Panic("parent of ", f.Name(), " is nil")
  	}
  
  	parent.Lock()
  	mem.RemoveFromMemDir(parent, f)
  	parent.Unlock()
  	return nil
  }
  
  func (m *MemMapFs) findParent(f *mem.FileData) *mem.FileData {
  	pdir, _ := filepath.Split(f.Name())
  	pdir = filepath.Clean(pdir)
  	pfile, err := m.lockfreeOpen(pdir)
  	if err != nil {
  		return nil
  	}
  	return pfile
  }
  
  func (m *MemMapFs) registerWithParent(f *mem.FileData) {
  	if f == nil {
  		return
  	}
  	parent := m.findParent(f)
  	if parent == nil {
  		pdir := filepath.Dir(filepath.Clean(f.Name()))
  		err := m.lockfreeMkdir(pdir, 0777)
  		if err != nil {
  			//log.Println("Mkdir error:", err)
  			return
  		}
  		parent, err = m.lockfreeOpen(pdir)
  		if err != nil {
  			//log.Println("Open after Mkdir error:", err)
  			return
  		}
  	}
  
  	parent.Lock()
  	mem.InitializeDir(parent)
  	mem.AddToMemDir(parent, f)
  	parent.Unlock()
  }
  
  func (m *MemMapFs) lockfreeMkdir(name string, perm os.FileMode) error {
  	name = normalizePath(name)
  	x, ok := m.getData()[name]
  	if ok {
  		// Only return ErrFileExists if it's a file, not a directory.
  		i := mem.FileInfo{FileData: x}
  		if !i.IsDir() {
  			return ErrFileExists
  		}
  	} else {
  		item := mem.CreateDir(name)
  		m.getData()[name] = item
  		m.registerWithParent(item)
  	}
  	return nil
  }
  
  func (m *MemMapFs) Mkdir(name string, perm os.FileMode) error {
  	name = normalizePath(name)
  
  	m.mu.RLock()
  	_, ok := m.getData()[name]
  	m.mu.RUnlock()
  	if ok {
  		return &os.PathError{Op: "mkdir", Path: name, Err: ErrFileExists}
  	}
  
  	m.mu.Lock()
  	item := mem.CreateDir(name)
  	m.getData()[name] = item
  	m.registerWithParent(item)
  	m.mu.Unlock()
  
  	m.Chmod(name, perm|os.ModeDir)
  
  	return nil
  }
  
  func (m *MemMapFs) MkdirAll(path string, perm os.FileMode) error {
  	err := m.Mkdir(path, perm)
  	if err != nil {
  		if err.(*os.PathError).Err == ErrFileExists {
  			return nil
  		}
  		return err
  	}
  	return nil
  }
  
  // Handle some relative paths
  func normalizePath(path string) string {
  	path = filepath.Clean(path)
  
  	switch path {
  	case ".":
  		return FilePathSeparator
  	case "..":
  		return FilePathSeparator
  	default:
  		return path
  	}
  }
  
  func (m *MemMapFs) Open(name string) (File, error) {
  	f, err := m.open(name)
  	if f != nil {
  		return mem.NewReadOnlyFileHandle(f), err
  	}
  	return nil, err
  }
  
  func (m *MemMapFs) openWrite(name string) (File, error) {
  	f, err := m.open(name)
  	if f != nil {
  		return mem.NewFileHandle(f), err
  	}
  	return nil, err
  }
  
  func (m *MemMapFs) open(name string) (*mem.FileData, error) {
  	name = normalizePath(name)
  
  	m.mu.RLock()
  	f, ok := m.getData()[name]
  	m.mu.RUnlock()
  	if !ok {
  		return nil, &os.PathError{Op: "open", Path: name, Err: ErrFileNotFound}
  	}
  	return f, nil
  }
  
  func (m *MemMapFs) lockfreeOpen(name string) (*mem.FileData, error) {
  	name = normalizePath(name)
  	f, ok := m.getData()[name]
  	if ok {
  		return f, nil
  	} else {
  		return nil, ErrFileNotFound
  	}
  }
  
  func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
  	chmod := false
  	file, err := m.openWrite(name)
  	if os.IsNotExist(err) && (flag&os.O_CREATE > 0) {
  		file, err = m.Create(name)
  		chmod = true
  	}
  	if err != nil {
  		return nil, err
  	}
  	if flag == os.O_RDONLY {
  		file = mem.NewReadOnlyFileHandle(file.(*mem.File).Data())
  	}
  	if flag&os.O_APPEND > 0 {
  		_, err = file.Seek(0, os.SEEK_END)
  		if err != nil {
  			file.Close()
  			return nil, err
  		}
  	}
  	if flag&os.O_TRUNC > 0 && flag&(os.O_RDWR|os.O_WRONLY) > 0 {
  		err = file.Truncate(0)
  		if err != nil {
  			file.Close()
  			return nil, err
  		}
  	}
  	if chmod {
  		m.Chmod(name, perm)
  	}
  	return file, nil
  }
  
  func (m *MemMapFs) Remove(name string) error {
  	name = normalizePath(name)
  
  	m.mu.Lock()
  	defer m.mu.Unlock()
  
  	if _, ok := m.getData()[name]; ok {
  		err := m.unRegisterWithParent(name)
  		if err != nil {
  			return &os.PathError{Op: "remove", Path: name, Err: err}
  		}
  		delete(m.getData(), name)
  	} else {
  		return &os.PathError{Op: "remove", Path: name, Err: os.ErrNotExist}
  	}
  	return nil
  }
  
  func (m *MemMapFs) RemoveAll(path string) error {
  	path = normalizePath(path)
  	m.mu.Lock()
  	m.unRegisterWithParent(path)
  	m.mu.Unlock()
  
  	m.mu.RLock()
  	defer m.mu.RUnlock()
  
  	for p, _ := range m.getData() {
  		if strings.HasPrefix(p, path) {
  			m.mu.RUnlock()
  			m.mu.Lock()
  			delete(m.getData(), p)
  			m.mu.Unlock()
  			m.mu.RLock()
  		}
  	}
  	return nil
  }
  
  func (m *MemMapFs) Rename(oldname, newname string) error {
  	oldname = normalizePath(oldname)
  	newname = normalizePath(newname)
  
  	if oldname == newname {
  		return nil
  	}
  
  	m.mu.RLock()
  	defer m.mu.RUnlock()
  	if _, ok := m.getData()[oldname]; ok {
  		m.mu.RUnlock()
  		m.mu.Lock()
  		m.unRegisterWithParent(oldname)
  		fileData := m.getData()[oldname]
  		delete(m.getData(), oldname)
  		mem.ChangeFileName(fileData, newname)
  		m.getData()[newname] = fileData
  		m.registerWithParent(fileData)
  		m.mu.Unlock()
  		m.mu.RLock()
  	} else {
  		return &os.PathError{Op: "rename", Path: oldname, Err: ErrFileNotFound}
  	}
  	return nil
  }
  
  func (m *MemMapFs) Stat(name string) (os.FileInfo, error) {
  	f, err := m.Open(name)
  	if err != nil {
  		return nil, err
  	}
  	fi := mem.GetFileInfo(f.(*mem.File).Data())
  	return fi, nil
  }
  
  func (m *MemMapFs) Chmod(name string, mode os.FileMode) error {
  	name = normalizePath(name)
  
  	m.mu.RLock()
  	f, ok := m.getData()[name]
  	m.mu.RUnlock()
  	if !ok {
  		return &os.PathError{Op: "chmod", Path: name, Err: ErrFileNotFound}
  	}
  
  	m.mu.Lock()
  	mem.SetMode(f, mode)
  	m.mu.Unlock()
  
  	return nil
  }
  
  func (m *MemMapFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
  	name = normalizePath(name)
  
  	m.mu.RLock()
  	f, ok := m.getData()[name]
  	m.mu.RUnlock()
  	if !ok {
  		return &os.PathError{Op: "chtimes", Path: name, Err: ErrFileNotFound}
  	}
  
  	m.mu.Lock()
  	mem.SetModTime(f, mtime)
  	m.mu.Unlock()
  
  	return nil
  }
  
  func (m *MemMapFs) List() {
  	for _, x := range m.data {
  		y := mem.FileInfo{FileData: x}
  		fmt.Println(x.Name(), y.Size())
  	}
  }
  
  // func debugMemMapList(fs Fs) {
  // 	if x, ok := fs.(*MemMapFs); ok {
  // 		x.List()
  // 	}
  // }
  