public LoadProjectService(IProjectSerializer ProjectSerializer, ProjectViewModelFactory ProjectViewModelFactory)
        {
            _projectSerializer = ProjectSerializer;
            _projectViewModelFactory = ProjectViewModelFactory;

            OpenFileRequest = new InteractionRequest<OpenFileInteractionContext>();
        }
Example #2
0
        public RuleNode(IProjectSerializer serializer)
            : base(serializer)
        {
            Token name = serializer.ReadTextToken(this);

            if (name != null)
            {
                Name      = name.Text;
                name.Type = TokenType.Name;

                bool   found  = false;
                double num    = 1.0;
                Token  amount = serializer.ReadNumericToken(this, ref num, out found);
                if (amount != null)
                {
                    Probability = num;
                }

                Children.Add(new CommandBlockNode(serializer));
            }
            else
            {
                m_serializer.Warn("Name expected", this);
            }
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="CruiseServer" /> class.	
        /// </summary>
        /// <param name="configurationService">The configuration service.</param>
        /// <param name="projectIntegratorListFactory">The project integrator list factory.</param>
        /// <param name="projectSerializer">The project serializer.</param>
        /// <param name="stateManager">The state manager.</param>
        /// <param name="fileSystem">The file system.</param>
        /// <param name="executionEnvironment">The execution environment.</param>
        /// <param name="extensionList">The extension list.</param>
        /// <remarks></remarks>
        public CruiseServer(IConfigurationService configurationService,
                            IProjectIntegratorListFactory projectIntegratorListFactory,
                            IProjectSerializer projectSerializer,
                            IProjectStateManager stateManager,
                            IFileSystem fileSystem,
                            IExecutionEnvironment executionEnvironment,
                            List<ExtensionConfiguration> extensionList)
        {
            this.configurationService = configurationService;
            this.projectSerializer = projectSerializer;
            this.fileSystem = fileSystem;
            this.executionEnvironment = executionEnvironment;

            // Leave the manager for backwards compatability - it is marked as obsolete
#pragma warning disable 0618
            manager = new CruiseManager(this);
#pragma warning restore 0618
            serverClient = new CruiseServerClient(this);
            InitializeServerThread();

            // Initialise the configuration
            configuration = configurationService.Load();

            // Initialise the queue manager
            integrationQueueManager = IntegrationQueueManagerFactory.CreateManager(projectIntegratorListFactory, configuration, stateManager);
            integrationQueueManager.AssociateIntegrationEvents(OnIntegrationStarted, OnIntegrationCompleted);
            securityManager = configuration.SecurityManager;

            // Load the extensions
            if (extensionList != null)
            {
                InitialiseExtensions(extensionList);
            }

            this.configurationService.AddConfigurationUpdateHandler(Restart);
            programmDataFolder = this.executionEnvironment.GetDefaultProgramDataFolder(ApplicationType.Server);

            // Initialise the cache time
            var cacheTimeInConfig = ConfigurationManager.AppSettings["cacheTime"];
            if (string.IsNullOrEmpty(cacheTimeInConfig))
            {
                // Set the default cache time to five minutes
                this.cacheTime = new TimeSpan(0, 5, 0);
                Log.Info("Log cache time set to 5 minutes");
            }
            else
            {
                this.cacheTime = TimeSpan.FromSeconds(Convert.ToDouble(cacheTimeInConfig, CultureInfo.CurrentCulture));
                if (this.cacheTime.TotalSeconds < 5)
                {
                    // If the cache time is less then 5s then turn off caching
                    this.cacheTime = TimeSpan.MinValue;
                    Log.Info("Log cache has been turned off");
                }
                else
                {
                    Log.Info("Log cache time set to " + this.cacheTime.TotalSeconds.ToString(CultureInfo.CurrentCulture) + " seconds");
                }
            }
        }
    protected override byte[] SerializeWith(Project project, IProjectSerializer serializer)
    {
        var xmlSerializer = serializer as ProjectXmlSerializer;

        xmlSerializer !.BeforeSerialize += BeforeSerialize;

        return(base.SerializeWith(project, serializer));
    }
        public ProjectFactory(IProjectSerializer projectSerializer, IProjectLoader projectLoader)
        {
            Check.IfIsNull(projectSerializer).Throw<ArgumentNullException>(() => projectSerializer);
            Check.IfIsNull(projectLoader).Throw<ArgumentNullException>(() => projectLoader);

            this.projectSerializer = projectSerializer;
            this.projectLoader = projectLoader;
        }
        public ProjectFactory BuildProjectCreator(IProjectSerializer projectSerializer = null,
            IProjectLoader projectLoader = null)
        {
            projectSerializer = projectSerializer ?? new StubIProjectSerializer();
            projectLoader = projectLoader ?? new StubIProjectLoader();

            return new ProjectFactory(projectSerializer, projectLoader);
        }
Example #7
0
		public virtual void LoadCommand(IProjectSerializer serializer)
		{
            m_lineNumber = serializer.LineNumber;
			Token t = null;
			do {
				t = serializer.ReadTextToken(this);
			} while (t != null);
		}
Example #8
0
 public SilentPacker(ILaunchParameters LaunchParameters, IPackageSavingTool SavingTool, IProjectSerializer ProjectSerializer,
                     IVariablesProcessor VariablesProcessor, IRecentProjectsService RecentProjectsService)
 {
     _launchParameters = LaunchParameters;
     _savingTool = SavingTool;
     _projectSerializer = ProjectSerializer;
     _variablesProcessor = VariablesProcessor;
     _recentProjectsService = RecentProjectsService;
 }
    protected override ProjectOpenResult DeserializeWith(IProjectSerializer serializer, byte[] rawBytes)
    {
        if (serializer is IProjectXmlSerializer xmlSerializer && AfterDeserialize != null)
        {
            xmlSerializer.AfterDeserialize += AfterDeserialize;
        }

        return(base.DeserializeWith(serializer, rawBytes));
    }
Example #10
0
 public ProjectTreeLoader(
     RepositoryEntryPoint projectRepositoryPath,
     IProjectSerializer serializer,
     IFileSystemAccess fileIo)
 {
     _projectRepositoryPath = projectRepositoryPath;
     _serializer            = serializer;
     _fileIO = fileIo;
 }
Example #11
0
        public virtual void LoadCommand(IProjectSerializer serializer)
        {
            m_lineNumber = serializer.LineNumber;
            Token t = null;

            do
            {
                t = serializer.ReadTextToken(this);
            } while (t != null);
        }
 public SaveProjectCommandHandler(
     IDialogService dialogService,
     IDataContext dataContext,
     IProjectSerializer projectSerializer,
     IXmlFileService xmlFileService,
     IEventBus eventBus)
 {
     _dialogService     = dialogService;
     _dataContext       = dataContext;
     _projectSerializer = projectSerializer;
     _xmlFileService    = xmlFileService;
     _eventBus          = eventBus;
 }
Example #13
0
        public CruiseServer(IConfigurationService configurationService, IProjectIntegratorListFactory projectIntegratorListFactory, IProjectSerializer projectSerializer)
        {
            this.configurationService = configurationService;
            this.configurationService.AddConfigurationUpdateHandler(new ConfigurationUpdateHandler(Restart));
            this.projectIntegratorListFactory = projectIntegratorListFactory;

            // ToDo - get rid of manager, maybe
            manager = new CruiseManager(this);

            // By default, no integrators are running
            this.projectSerializer = projectSerializer;

            CreateIntegrators();
        }
Example #14
0
        public CruiseServer(IConfigurationService configurationService, IProjectIntegratorListFactory projectIntegratorListFactory, IProjectSerializer projectSerializer)
        {
            this.configurationService = configurationService;
            this.configurationService.AddConfigurationUpdateHandler(new ConfigurationUpdateHandler(Restart));
            this.projectIntegratorListFactory = projectIntegratorListFactory;

            // ToDo - get rid of manager, maybe
            manager = new CruiseManager(this);

            // By default, no integrators are running
            this.projectSerializer = projectSerializer;

            CreateIntegrators();
        }
        public void TestLoadCommandBlockCStyle()
        {
            Mockery            mockery        = new Mockery();
            IProjectSerializer mockSerializer = mockery.NewMock <IProjectSerializer>();

            using (mockery.Ordered)
            {
                Expect.Once.On(mockSerializer).GetProperty("Position").Will(Return.Value(0));
                Expect.Once.On(mockSerializer).Method("ReadLineBreakToken").Will(Return.Value(new Token(TokenType.LineBreak, "\r\n", 0, 2)));
                Expect.Once.On(mockSerializer).Method("ReadIndentationToken").Will(Return.Value(new Token(TokenType.Indentation, "\t", 2, 1)));
                Expect.Once.On(mockSerializer).Method("GetIndentationLevel").Will(Return.Value(1));
                Expect.Once.On(mockSerializer).Method("ReadBlockStarterToken").Will(Return.Value(new Token(TokenType.BlockStarter, "{", 3, 1)));
                Expect.Once.On(mockSerializer).Method("ReadLineBreakToken").Will(Return.Value(new Token(TokenType.LineBreak, "\r\n", 4, 2)));
                Expect.Once.On(mockSerializer).Method("ReadBlockEnderToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).GetProperty("Done").Will(Return.Value(false));
                Expect.Once.On(mockSerializer).Method("ReadIndentationToken").Will(Return.Value(new Token(TokenType.Indentation, "\t", 6, 1)));
                Expect.Once.On(mockSerializer).Method("ReadBlockEnderToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).GetProperty("Done").Will(Return.Value(false));
                Expect.Once.On(mockSerializer).Method("ReadTextToken").Will(Return.Value(new Token(TokenType.Text, "token", 7, 5)));
                Expect.Once.On(mockSerializer).GetProperty("LineNumber").Will(Return.Value(3));
                Expect.Once.On(mockSerializer).Method("ReadTextToken").Will(Return.Value(new Token(TokenType.Text, "consonants", 12, 10)));
                Expect.Once.On(mockSerializer).Method("ReadTextToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).Method("ReadLineBreakToken").Will(Return.Value(new Token(TokenType.LineBreak, "\r\n", 22, 2)));
                Expect.Once.On(mockSerializer).Method("ReadBlockEnderToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).GetProperty("Done").Will(Return.Value(false));
                Expect.Once.On(mockSerializer).Method("ReadIndentationToken").Will(Return.Value(new Token(TokenType.Indentation, "\t", 24, 1)));
                Expect.Once.On(mockSerializer).Method("ReadBlockEnderToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).GetProperty("Done").Will(Return.Value(false));
                Expect.Once.On(mockSerializer).Method("ReadTextToken").Will(Return.Value(new Token(TokenType.Command, "rule", 25, 4)));
                Expect.Once.On(mockSerializer).GetProperty("LineNumber").Will(Return.Value(4));
                Expect.Once.On(mockSerializer).Method("ReadTextToken").Will(Return.Value(new Token(TokenType.Text, "second", 29, 6)));
                Expect.Once.On(mockSerializer).Method("ReadTextToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).Method("ReadLineBreakToken").Will(Return.Value(new Token(TokenType.LineBreak, "\r\n", 35, 2)));
                Expect.Once.On(mockSerializer).Method("ReadBlockEnderToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).GetProperty("Done").Will(Return.Value(false));
                Expect.Once.On(mockSerializer).Method("ReadIndentationToken").Will(Return.Value(new Token(TokenType.Indentation, "\t", 37, 1)));
                Expect.Once.On(mockSerializer).Method("ReadBlockEnderToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).GetProperty("Done").Will(Return.Value(false));
                Expect.Once.On(mockSerializer).Method("ReadTextToken").Will(Return.Value(null));
                Expect.Once.On(mockSerializer).Method("ReadLineBreakToken").Will(Return.Value(new Token(TokenType.LineBreak, "\r\n", 38, 2)));
                Expect.Once.On(mockSerializer).Method("ReadBlockEnderToken").Will(Return.Value(new Token(TokenType.BlockEnder, "}", 40, 1)));
            }

            CommandBlockNode cbn = new CommandBlockNode(mockSerializer);

            Assert.AreEqual(2, cbn.Commands.Count);

            mockery.VerifyAllExpectationsHaveBeenMet();
        }
Example #16
0
 public OpenProjectCommandHandler(
     IDialogService dialogService,
     IEventBus eventBus,
     IApplicationStateService stateService,
     IDataContext dataContext,
     IXmlFileService xmlFileService,
     IProjectSerializer projectSerializer)
 {
     _dialogService     = dialogService;
     _xmlFileService    = xmlFileService;
     _projectSerializer = projectSerializer;
     _dataContext       = dataContext;
     _eventBus          = eventBus;
     _stateService      = stateService;
 }
        public void TestLoadCommand()
        {
            Mockery            mockery    = new Mockery();
            IProjectSerializer serializer = mockery.NewMock <IProjectSerializer>();
            RuleCommand        rc         = new RuleCommand();

            Expect.Once.On(serializer).GetProperty("LineNumber").Will(Return.Value(1));
            Expect.Once.On(serializer).Method("ReadTextToken").Will(Return.Value(new Token(TokenType.Text, "a", 0, 1)));
            Expect.Once.On(serializer).Method("ReadTextToken").Will(Return.Value(null));

            rc.LoadCommand(serializer);

            Assert.AreEqual("a", rc.Rule);

            mockery.VerifyAllExpectationsHaveBeenMet();
        }
Example #18
0
        public void SimpleTreeSetup()
        {
            _topProject = new Project
            {
                GroupId    = "a",
                ArtifactId = "a"
            };
            _secondProject =
                new Project
            {
                GroupId    = "b",
                ArtifactId = "b"
            };

            _serializer           = new ClassicProjectSerializer();
            _topProjectContent    = _serializer.Serialize(_topProject);
            _secondProjectContent = _serializer.Serialize(_secondProject);

            _topFolder         = "top";
            _secondFolderName  = "second";
            _secondFolder      = "top\\second";
            _topProjectPath    = "top\\pom.xml";
            _secondProjectPath = "top\\second\\pom.xml";

            _fileIOMock = new Mock <IFileSystemAccess>();
            _fileIOMock.Setup(io => io.GetFullPath(It.IsAny <string>())).Returns((string s) => s);
            _fileIOMock.Setup(io => io.ReadAllText(_topProjectPath)).Returns(_topProjectContent);
            _fileIOMock.Setup(io => io.ReadAllText(_secondProjectPath)).Returns(_secondProjectContent);
            _fileIOMock.Setup(io => io.IsFileExist(_topProjectPath)).Returns(true);
            _fileIOMock.Setup(io => io.IsFileExist(_secondProjectPath)).Returns(true);
            _fileIOMock.Setup(io => io.IsDirectoryExist(_topFolder)).Returns(true);
            _fileIOMock.Setup(io => io.EnumerateDirectories(_topFolder)).Returns(new[] { _secondFolderName });
            _fileIOMock.Setup(io => io.Combine(It.IsAny <string>(), It.IsAny <string>())).Returns(
                (string s1, string s2) => (s1 + '\\' + s2));
            _fileIOMock.Setup(io => io.Combine(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(
                (string s1, string s2, string s3) => (s1 + '\\' + s2 + '\\' + s3));
            _fileIOMock.Setup(io => io.GetDirectoryName(_topProjectPath)).Returns(_topFolder);
            _fileIOMock.Setup(io => io.GetDirectoryName(_secondProjectPath)).Returns(_secondFolder);
        }
Example #19
0
        public RuleNode(IProjectSerializer serializer)
            : base(serializer)
        {
            Token name = serializer.ReadTextToken(this);
            if (name != null)
            {
                Name = name.Text;
                name.Type = TokenType.Name;

                bool found = false;
                double num = 1.0;
                Token amount = serializer.ReadNumericToken(this, ref num, out found);
                if (amount != null)
                {
                    Probability = num;
                }

                Children.Add(new CommandBlockNode(serializer));
            }
            else
            {
                m_serializer.Warn("Name expected", this);
            }
        }
Example #20
0
 public ProjectNodeBase(IProjectSerializer serializer)
 {
     m_serializer = serializer;
     Index = m_serializer.Position;
 }
Example #21
0
 public TokenSetNode(IProjectSerializer serializer)
     : base(serializer)
 {
     LoadParameters();
 }
Example #22
0
 public void Setup()
 {
     _realDataFactory = new DataFactory();
     _serializer      = new ProjectSerializer(_realDataFactory);
 }
Example #23
0
 public TranslationBlockNode(IProjectSerializer serializer)
     : base(serializer)
 {
 }
Example #24
0
 public TokenSetNode(IProjectSerializer serializer) : base(serializer)
 {
     LoadParameters();
 }
Example #25
0
 public ProjectNode(IProjectSerializer serializer)
     : base(serializer)
 {
     LoadDirectives();
 }
Example #26
0
 public BlockNodeBase(IProjectSerializer serializer)
     : base(serializer)
 {
     LoadItems();
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultConfigurationFileSaver" /> class.	
        /// </summary>
        /// <param name="projectSerializer">The project serializer.</param>
        /// <remarks></remarks>
		public DefaultConfigurationFileSaver(IProjectSerializer projectSerializer)
		{
			this.projectSerializer = projectSerializer;
		}
Example #28
0
 public WeightedCommandNode(IProjectSerializer serializer)
     : base(serializer)
 {
     Successful = true;
     LoadWeightedCommand();
 }
Example #29
0
 public StartingRuleNode(IProjectSerializer serializer)
     : base(serializer)
 {
     LoadParameters();
 }
Example #30
0
    private void PostSerialize(string filename, ProjectXmlSerializer.Root xmlProjectSerializedRoot, IProjectSerializer serializer)
    {
        xmlProjectSerializedRoot.Project.ProjectFileName = filename;

        xmlProjectSerializedRoot.Project.Session = new ProjectSession(xmlProjectSerializedRoot.Project, filename);

        // at this stage, 'Data' is populated with everything EXCEPT the actual ROM bytes.
        // It would be easy to store the ROM bytes in the save file, but, for copyright reasons,
        // we leave it out.
        //
        // So now, with all our metadata loaded successfully, we now open the .smc file on disk
        // and marry the original rom's bytes with all of our metadata loaded from the project file.
        var romAddCmd = addRomDataCommandCreate();

        Debug.Assert(romAddCmd != null);

        romAddCmd.Root = xmlProjectSerializedRoot;
        romAddCmd.GetNextRomFileToTry = RomPromptFn;
        romAddCmd.MigrationRunner     = serializer.MigrationRunner;

        romAddCmd.TryReadAttachedProjectRom();
    }
Example #31
0
 public Work(string topFolder)
 {
     _fileIo            = new FileSystemAccess();
     _entryPoint        = new RepositoryEntryPoint(topFolder, _fileIo);
     _projectSerializer = new ClassicProjectSerializer();
 }
Example #32
0
 public ProjectNode(IProjectSerializer serializer) : base(serializer)
 {
     LoadDirectives();
 }
 public WeightedCommandBlockNode(IProjectSerializer serializer)
     : base(serializer)
 {
 }
 public TranslationNode(IProjectSerializer serializer)
     : base(serializer)
 {
     Successful = true;
     LoadTranslation();
 }
Example #35
0
 public void Setup()
 {
     _serializer = new UpdatingProjectSerializer();
 }
 public ProjectViewModelFactory(IProjectSerializer ProjectSerializer, ILaunchParameters LaunchParameters, IIndexHelper IndexHelper,
                                IEventAggregator EventAggregator)
 {
     _indexHelper = IndexHelper;
     _eventAggregator = EventAggregator;
 }
Example #37
0
 public TranslationNode(IProjectSerializer serializer)
     : base(serializer)
 {
     Successful = true;
     LoadTranslation();
 }
 public WeightedCommandNode(IProjectSerializer serializer) : base(serializer)
 {
     Successful = true;
     LoadWeightedCommand();
 }
Example #39
0
 public ColumnNode(IProjectSerializer serializer)
     : base(serializer)
 {
     LoadColumn();
 }
Example #40
0
 public DefaultConfigurationFileSaver(IProjectSerializer projectSerializer)
 {
     this.projectSerializer = projectSerializer;
 }
Example #41
0
 public ColumnNode(IProjectSerializer serializer)
     : base(serializer)
 {
     LoadColumn();
 }
Example #42
0
 public CommandBlockNode(IProjectSerializer serializer)
     : base(serializer)
 {
 }
Example #43
0
 public StartingRuleNode(IProjectSerializer serializer) : base(serializer)
 {
     LoadParameters();
 }
Example #44
0
 public ProjectNodeBase(IProjectSerializer serializer)
 {
     m_serializer = serializer;
     Index        = m_serializer.Position;
 }