const project = (value: number, index: number) => Observable.from(Promise.reject('' + value + '-' + index));

 protected handleObservableError(error: Response | any): Observable<any> {
     return Observable.throw(extractError(error));
 }

 loadData: function(){
   return Observable.of({});
 },

 get(url: string,
     options?: RequestOptionsArgs): Observable<Response> {
   return Observable.from([this.fakeResponse]);
 }

 /**
  * Make Cold observable to Hot observable
  * 
  * On caller function will not need to make ".subscribe(...)" to execute procedure
  * 
  * @param cold Observable
  */
 public static makeHot<T>(cold: Observable<T>) {
   const subject = new Subject<T>();
   cold.subscribe(subject);
   return new Observable<T>((observer: any) => subject.subscribe(observer));
 }

 private publishAll() {
   this.getAllSubject.next(
     Observable.fromPromise(this.db.getAll())
   )
 }

 .catch(() => {
     return Observable.throw(LoadError.createGeneralError());
 });

        beforeEach(() => {
            DevicesService.save.and.returnValue(Observable.of(sensorMock));
            DevicesService.update.and.returnValue(Observable.of(sensorMock));

            sut.sensor = sensorMock;
        });

 */
import * as _ from 'lodash';
import { Observable, Subscription } from 'rxjs';
import { CommandType, IAtomNavigation, IImplementationProvider, IImplementationService, Implementation, Reference, navigationHasRange } from 'atom-languageservices';
import { alias, injectable } from 'atom-languageservices/decorators';
import { readFile } from 'fs';
import { ProviderServiceBase } from './_ProviderServiceBase';
import { atomConfig } from '../decorators';
import { AtomCommands } from './AtomCommands';
import { AtomNavigation } from './AtomNavigation';
import { AtomTextEditorSource } from './AtomTextEditorSource';
import { CommandsService } from './CommandsService';
import { ReferenceView } from './views/ReferenceView';
type Location = IAtomNavigation.Location;

const readFile$ = Observable.bindNodeCallback(readFile);
@injectable
@alias(IImplementationService)
@atomConfig({
    default: true,
    description: 'Adds support for navigate to implementation or implementations'
})
export class ImplementationService
    extends ProviderServiceBase<IImplementationProvider, Implementation.IRequest, Observable<Location[]>, Observable<Location[]>>
    implements IImplementationService {
    private _navigation: AtomNavigation;
    private _commands: CommandsService;
    private _atomCommands: AtomCommands;
    private _source: AtomTextEditorSource;

    constructor(navigation: AtomNavigation, commands: CommandsService, atomCommands: AtomCommands, source: AtomTextEditorSource) {