internal override void SetSessionStateItem(Path name, object value, bool writeItem)
 {
     PSVariable variable = null;
     if (value != null)
     {
         variable = value as PSVariable;
         if (variable == null)
         {
             variable = new PSVariable(name, value);
         }
         else if (String.Compare(name, variable.Name, true, System.Globalization.CultureInfo.CurrentCulture) != 0)
         {
             PSVariable var = new PSVariable(name, variable.Value, variable.Options, variable.Attributes);
             var.Description = variable.Description;
             variable = var;
         }
     }
     else
     {
         variable = new PSVariable(name, null);
     }
     // TODO: can be Force'ed
     PSVariable item = base.SessionState.SessionStateGlobal.SetVariable(variable) as PSVariable;
     if (writeItem && (item != null))
     {
         WriteItemObject(item, item.Name, false);
     }
 }

 internal PSModuleInfo LoadModuleByName(string name, bool loadToGlobalScope, bool importMembers = true)
 {
     // TODO: where do we handle FileNotFoundExceptions etc?
     var path = new Path(name).NormalizeSlashes();
     if (name.Contains(path.CorrectSlash) || path.HasExtension())
     {
         // check if it's already loaded
         var moduleInfo = _executionContext.SessionState.LoadedModules.Get(path);
         if (moduleInfo != null)
         {
             return moduleInfo;
         }
         // load it otherwise
         moduleInfo = LoadModuleByPath(path);
         // modules are loaded either to global or module scope, never to local scope
         var targetScope = loadToGlobalScope ? ModuleIntrinsics.ModuleImportScopes.Global
                                             : ModuleIntrinsics.ModuleImportScopes.Module;
         _executionContext.SessionState.LoadedModules.Add(moduleInfo, targetScope);
         if (importMembers)
         {
             _executionContext.SessionState.LoadedModules.ImportMembers(moduleInfo, targetScope);
         }
         return moduleInfo;
     }
     // otherwise we'd need to look in our module paths for a module
     throw new NotImplementedException("Currently you can only a specific module file, not installed modules");
 }

 internal override void SetSessionStateItem(Path path, object value, bool writeItem)
 {
     if (value == null)
     {
         Environment.SetEnvironmentVariable(path, null);
     }
     else
     {
         if (value is DictionaryEntry)
         {
             value = ((DictionaryEntry)value).Value;
         }
         string str = value as string;
         if (str == null)
         {
             str = PSObject.AsPSObject(value).ToString();
         }
         Environment.SetEnvironmentVariable(path, str);
         DictionaryEntry item = new DictionaryEntry(path, str);
         if (writeItem)
         {
             WriteItemObject(item, path, false);
         }
     }
 }

        public static string CalculateFullPath(Path curLocation, Path changeCommandStr)
        {
            // TODO: sburnicki rewrite that stuff with pathintrinsics
            var changeCommand = (changeCommandStr ?? string.Empty).NormalizeSlashes();
            var currentLocation = curLocation.NormalizeSlashes();

            bool applyParts = false;
            Path resultPath;

            // use the input 'changeCommand' path if it's 
            // 'rooted' otherwise we go from the currentLocation
            if (changeCommand.HasDrive())
            {
                // windows case where changeCommand == "/" or "\" but the currentLocation has a "C:" drive
                string currentLocationDrive = currentLocation.GetDrive();
                if (changeCommand.StartsWithSlash() && !changeCommand.GetDrive().Equals(currentLocationDrive, StringComparison.InvariantCultureIgnoreCase))
                {
                    resultPath = new Path(currentLocation.CorrectSlash, currentLocation.WrongSlash, string.Format("{0}:{1}", currentLocationDrive, changeCommand));
                }
                else
                {
                    resultPath = changeCommand;
                }
            }
            else
            {
                applyParts = true;
                resultPath = currentLocation;
            }

            var correctSeparator = Char.Parse(currentLocation.CorrectSlash);
            var changeParts = changeCommand.ToString().Split(correctSeparator).Where(s => !string.IsNullOrEmpty(s));

            foreach (var part in changeParts)
            {
                // ignore single dot as it does nothing...
                if (part == ".")
                {
                    continue;
                }

                // ignore trying to go up a dir from the root dir
                if (part == ".." && resultPath.IsRootPath())
                {
                    continue;
                }

                if (part == "..")
                {
                    resultPath = resultPath.GetParentPath(currentLocation.GetDrive());
                }
                else if (applyParts)
                {
                    resultPath = resultPath.Combine(part);
                }
            }

            return resultPath.ApplyDriveSlash();
        }

        internal override object GetSessionStateItem(Path name)
        {
            // TODO: deal with empty path
            if (string.Equals("variable:" + name.CorrectSlash, name, StringComparison.CurrentCultureIgnoreCase))
                return true;

            return SessionState.SessionStateGlobal.GetVariable(name);
        }

 internal override object GetSessionStateItem(Path name)
 {
     string environmentVariable = Environment.GetEnvironmentVariable(name);
     if (environmentVariable != null)
     {
         return new DictionaryEntry(name, environmentVariable);
     }
     return null;
 }

        public void ShouldApplyNavigation(string normalSlash, string currentLocation, string changeCommand, string expectedFullPath, string errorMessage)
        {
            var currLocation = new Path(normalSlash, normalSlash == "\\" ? "/" : "\\", currentLocation);
            var changePath = new Path(normalSlash, normalSlash == "\\" ? "/" : "\\", changeCommand);

            var result = PathNavigation.CalculateFullPath(currLocation, changePath);

            result.ShouldEqual(expectedFullPath, errorMessage);

        }

 internal override object GetSessionStateItem(Path name)
 {
     Path path = PathIntrinsics.RemoveDriveName(name);
     path = path.TrimStartSlash();
     string environmentVariable = Environment.GetEnvironmentVariable(path);
     if (environmentVariable != null)
     {
         return new DictionaryEntry(path, environmentVariable);
     }
     return null;
 }

        private PSModuleInfo LoadModuleByPath(Path path)
        {
            // ALWAYS derive from global scope: the Scope parameter only defines where stuff is imported to
            var sessionState = new SessionState(_executionContext.SessionStateGlobal.RootSessionState);
            sessionState.IsScriptScope = true;
            sessionState.PSVariable.Set("PSScriptRoot", path.GetDirectory());
            var moduleInfo = new PSModuleInfo(path, path.GetFileNameWithoutExtension(), sessionState);
            sessionState.SetModule(moduleInfo);

            LoadFileIntoModule(moduleInfo, path);
            return moduleInfo;
        }

        protected override string NormalizeRelativePath(string path, string basePath)
        {
            var normPath = new Path(path).NormalizeSlashes();
            var normBase = new Path(basePath).NormalizeSlashes();
            if (!normPath.StartsWith(normBase))
            {
                var ex = new PSArgumentException("Path is outside of base path!", "PathOutsideBasePath",
                    ErrorCategory.InvalidArgument);
                WriteError(ex.ErrorRecord);
                return null;
            }

            return new Path(path.Substring(basePath.Length)).TrimStartSlash().ToString();
        }

        private void LoadFileIntoModule(PSModuleInfo moduleInfo, Path path)
        {
            // prevents accidental loops while loading a module
            moduleInfo.NestingDepth++;
            if (moduleInfo.NestingDepth > 10)
            {
                var msg = "The module is too deeply nested. A module can be only nested 10 times. Make sure to check" +
                    " the loading order of your module";
                throw new PSInvalidOperationException(msg, "Modules_ModuleTooDeeplyNested",
                    ErrorCategory.InvalidOperation);
            }

            moduleInfo.Path = path; // update path for nested modules
            var stringComparer = StringComparer.InvariantCultureIgnoreCase;
            var ext = path.GetExtension();
            if (_scriptExtensions.Contains(ext, stringComparer))
            {
                moduleInfo.ModuleType = ModuleType.Script;
                LoadScriptModule(moduleInfo, path); // actually load the script
            }
            else if (_binaryExtensions.Contains(ext, stringComparer))
            {
                moduleInfo.ModuleType = ModuleType.Binary;
                LoadBinaryModule(moduleInfo, path);
            }
            else if (_manifestExtensions.Contains(ext, stringComparer))
            {
                moduleInfo.ModuleType = ModuleType.Manifest;
                LoadManifestModule(moduleInfo, path);
            }
            else
            {
                var msg = "The extension '" + ext + "' is currently not supported";
                throw new PSInvalidOperationException(msg, "Modules_InvalidFileExtension",
                                                      ErrorCategory.InvalidOperation, null, false);
            }
            moduleInfo.ValidateExportedMembers();
        }

 protected override void SetItem(Path name, object value)
 {
     throw new NotImplementedException();
 }

 protected override void RenameItem(Path name, Path newName)
 {
     throw new NotImplementedException();
 }

 protected override void RemoveItem(Path path, bool recurse)
 {
     throw new NotImplementedException();
 }

 protected override void NewItem(Path path, string type, object newItem)
 {
     throw new NotImplementedException();
 }

 protected override void CopyItem(Path path, Path copyPath, bool recurse)
 {
     throw new NotImplementedException();
 }

 internal abstract void SetSessionStateItem(Path name, object value, bool writeItem);

 internal abstract object GetSessionStateItem(Path name);

 public IContentWriter GetContentWriter(Path path)
 {
     throw new NotImplementedException();
 }

 public void ClearContent(Path path)
 {
     throw new NotImplementedException();
 }