diff --git a/lib/linguist/blob_helper.rb b/lib/linguist/blob_helper.rb index 7282aef5..47fcc7ca 100644 --- a/lib/linguist/blob_helper.rb +++ b/lib/linguist/blob_helper.rb @@ -181,7 +181,7 @@ module Linguist def generated? if xcode_project_file? || visual_studio_project_file? true - elsif generated_coffeescript? || minified_javascript? + elsif generated_coffeescript? || minified_javascript? || generated_net_docfile? true else false @@ -255,6 +255,27 @@ module Linguist end end + # Internal: Is this a generated documentation file for a .NET assembly? + # + # Requires Blob#data + # + # .NET developers often check in the XML Intellisense file along with an + # assembly - however, these don't have a special extension, so we have to + # dig into the contents to determine if it's a docfile. Luckily, these files + # are extremely structured, so recognizing them is easy. + # + # Returns true or false + def generated_net_docfile? + return false unless extname == ".xml" + return false unless lines.count > 3 + + # .NET Docfiles always open with and their first tag is an + # tag + return lines[1].include?("") && + lines[2].include?("") && + lines[-2].include?("") + end + # Public: Should the blob be indexed for searching? # # Excluded: diff --git a/test/fixtures/net_docfile.xml b/test/fixtures/net_docfile.xml new file mode 100644 index 00000000..4cda7b94 --- /dev/null +++ b/test/fixtures/net_docfile.xml @@ -0,0 +1,1121 @@ + + + + ReactiveUI + + + + + IObservedChange is a generic interface that replaces the non-generic + PropertyChangedEventArgs. Note that it is used for both Changing (i.e. + 'before change') and Changed Observables. In the future, this interface + will be Covariant which will allow simpler casting between specific and + generic changes. + + + + + The object that has raised the change. + + + + + The name of the property that has changed on Sender. + + + + + The value of the property that has changed. IMPORTANT NOTE: This + property is often not set for performance reasons, unless you have + explicitly requested an Observable for a property via a method such + as ObservableForProperty. To retrieve the value for the property, + use the Value() extension method. + + + + + IReactiveNotifyPropertyChanged represents an extended version of + INotifyPropertyChanged that also exposes Observables. + + + + + IEnableLogger is a dummy interface - attaching it to any class will give + you access to the Log() method. + + + + + When this method is called, an object will not fire change + notifications (neither traditional nor Observable notifications) + until the return value is disposed. + + An object that, when disposed, reenables change + notifications. + + + + Represents an Observable that fires *before* a property is about to + be changed. Note that this should not fire duplicate change notifications if a + property is set to the same value multiple times. + + + + + Represents an Observable that fires *after* a property has changed. + Note that this should not fire duplicate change notifications if a + property is set to the same value multiple times. + + + + + IReactiveNotifyPropertyChanged of TSender is a helper interface that adds + typed versions of Changing and Changed. + + + + + IReactiveCollection represents a collection that can notify when its + contents are changed (either items are added/removed, or the object + itself changes). + + It is important to implement the Changing/Changed from + IReactiveNotifyPropertyChanged semantically as "Fire when *anything* in + the collection or any of its items have changed, in any way". + + + + + Fires when items are added to the collection, once per item added. + Functions that add multiple items such AddRange should fire this + multiple times. The object provided is the item that was added. + + + + + Fires before an item is going to be added to the collection. + + + + + Fires once an item has been removed from a collection, providing the + item that was removed. + + + + + Fires before an item will be removed from a collection, providing + the item that will be removed. + + + + + Fires whenever the number of items in a collection has changed, + providing the new Count. + + + + + Fires before a collection is about to change, providing the previous + Count. + + + + + Provides Item Changed notifications for any item in collection that + implements IReactiveNotifyPropertyChanged. This is only enabled when + ChangeTrackingEnabled is set to True. + + + + + Provides Item Changing notifications for any item in collection that + implements IReactiveNotifyPropertyChanged. This is only enabled when + + + + + Enables the ItemChanging and ItemChanged properties; when this is + enabled, whenever a property on any object implementing + IReactiveNotifyPropertyChanged changes, the change will be + rebroadcast through ItemChanging/ItemChanged. + + + + + IReactiveCollection of T is the typed version of IReactiveCollection and + adds type-specified versions of Observables + + + + + IMessageBus represents an object that can act as a "Message Bus", a + simple way for ViewModels and other objects to communicate with each + other in a loosely coupled way. + + Specifying which messages go where is done via a combination of the Type + of the message as well as an additional "Contract" parameter; this is a + unique string used to distinguish between messages of the same Type, and + is arbitrarily set by the client. + + + + + Listen provides an Observable that will fire whenever a Message is + provided for this object via RegisterMessageSource or SendMessage. + + The type of the message to listen to. + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + + + + + Determins if a particular message Type is registered. + + The type of the message. + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + True if messages have been posted for this message Type. + + + + Registers an Observable representing the stream of messages to send. + Another part of the code can then call Listen to retrieve this + Observable. + + The type of the message to listen to. + An Observable that will be subscribed to, and a + message sent out for each value provided. + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + + + + Sends a single message using the specified Type and contract. + Consider using RegisterMessageSource instead if you will be sending + messages in response to other changes such as property changes + or events. + + The type of the message to send. + The actual message to send + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + + + + Log returns the current logger object, which allows the object to + log messages with the type name attached. + + + + + + This data structure is a representation of a memoizing cache - i.e. a + class that will evaluate a function, but keep a cache of recently + evaluated parameters. + + Since this is a memoizing cache, it is important that this function be a + "pure" function in the mathematical sense - that a key *always* maps to + a corresponding return value. + + The type of the parameter to the calculation function. + The type of the value returned by the calculation + function. + + + + Constructor + + The function whose results you want to cache, + which is provided the key value, and an Tag object that is + user-defined + The size of the cache to maintain, after which old + items will start to be thrown out. + A function to call when a result gets + evicted from the cache (i.e. because Invalidate was called or the + cache is full) + + + + Evaluates the function provided, returning the cached value if possible + + The value to pass to the calculation function. + An additional optional user-specific parameter. + + + + + Ensure that the next time this key is queried, the calculation + function will be called. + + + + + Invalidate all items in the cache + + + + + Returns all values currently in the cache + + + + + + MessageBus represents an object that can act as a "Message Bus", a + simple way for ViewModels and other objects to communicate with each + other in a loosely coupled way. + + Specifying which messages go where is done via a combination of the Type + of the message as well as an additional "Contract" parameter; this is a + unique string used to distinguish between messages of the same Type, and + is arbitrarily set by the client. + + + + + Listen provides an Observable that will fire whenever a Message is + provided for this object via RegisterMessageSource or SendMessage. + + The type of the message to listen to. + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + An Observable representing the notifications posted to the + message bus. + + + + Determins if a particular message Type is registered. + + The Type of the message to listen to. + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + True if messages have been posted for this message Type. + + + + Registers an Observable representing the stream of messages to send. + Another part of the code can then call Listen to retrieve this + Observable. + + The type of the message to listen to. + An Observable that will be subscribed to, and a + message sent out for each value provided. + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + The scheduler on which to post the + notifications, RxApp.DeferredScheduler by default. + + + + Sends a single message using the specified Type and contract. + Consider using RegisterMessageSource instead if you will be sending + messages in response to other changes such as property changes + or events. + + The type of the message to send. + The actual message to send + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + The scheduler on which to post the + notifications, RxApp.DeferredScheduler by default. + + + + Returns the Current MessageBus from the RxApp global object. + + + + + Registers a ViewModel object to send property change + messages; this allows a ViewModel to listen to another ViewModel's + changes in a loosely-typed manner. + + The ViewModel to register + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + ExceptionThe registered ViewModel + must be the only instance (i.e. not in an ItemsControl) + + + + Listens to a registered ViewModel's property change notifications. + + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + An Observable that fires when an object changes and + provides the property name that has changed. + + + + Return the current instance of the ViewModel with the specified + type. + + A unique string to distinguish messages with + identical types (i.e. "MyCoolViewModel") - if the message type is + only used for one purpose, leave this as null. + The ViewModel object registered for this type. + + + + ObservableAsPropertyHelper is a class to help ViewModels implement + "output properties", that is, a property that is backed by an + Observable. The property will be read-only, but will still fire change + notifications. This class can be created directly, but is more often created via the + ToProperty and ObservableToProperty extension methods. + + This class is also an Observable itself, so that output properties can + be chained - for example a "Path" property and a chained + "PathFileNameOnly" property. + + + + + Constructs an ObservableAsPropertyHelper object. + + The Observable to base the property on. + The action to take when the property + changes, typically this will call the ViewModel's + RaisePropertyChanged method. + The initial value of the property. + The scheduler that the notifications will be + provided on - this should normally be a Dispatcher-based scheduler + (and is by default) + + + + Constructs a "default" ObservableAsPropertyHelper object. This is + useful for when you will initialize the OAPH later, but don't want + bindings to access a null OAPH at startup. + + The initial (and only) value of the property. + The scheduler that the notifications will be + provided on - this should normally be a Dispatcher-based scheduler + (and is by default) + + + + The last provided value from the Observable. + + + + + Returns the Exception which has been provided by the Observable; normally + steps should be taken to ensure that Observables provided to OAPH should + never complete or fail. + + + + + Converts an Observable to an ObservableAsPropertyHelper and + automatically provides the onChanged method to raise the property + changed notification. The ToProperty method is semantically + equivalent to this method and is often more convenient. + + The Observable to base the property on. + An Expression representing the property (i.e. + 'x => x.SomeProperty' + The initial value of the property. + The scheduler that the notifications will be + provided on - this should normally be a Dispatcher-based scheduler + (and is by default) + An initialized ObservableAsPropertyHelper; use this as the + backing field for your property. + + + + Converts an Observable to an ObservableAsPropertyHelper and + automatically provides the onChanged method to raise the property + changed notification. + + The ReactiveObject that has the property + An Expression representing the property (i.e. + 'x => x.SomeProperty' + The initial value of the property. + The scheduler that the notifications will be + provided on - this should normally be a Dispatcher-based scheduler + (and is by default) + An initialized ObservableAsPropertyHelper; use this as the + backing field for your property. + + + + ObservableAsyncMRUCache implements memoization for asynchronous or + expensive to compute methods. This memoization is an MRU-based cache + with a fixed limit for the number of items in the cache. + + This class guarantees that only one calculation for any given key is + in-flight at a time, subsequent requests will wait for the first one and + return its results (for example, an empty web image cache that receives + two concurrent requests for "Foo.jpg" will only issue one WebRequest - + this does not mean that a request for "Bar.jpg" will wait on "Foo.jpg"). + + Concurrency is also limited by the maxConcurrent parameter - when too + many in-flight operations are in progress, further operations will be + queued until a slot is available. + + The key type. + The type of the value to return from the cache. + + + + Constructs an ObservableAsyncMRUCache object. + + The function that performs the + expensive or asyncronous calculation and returns an async result - + for CPU-based operations, Observable.Return may be used to return + the result. + + Note that this function *must* return an equivalently-same result given a + specific input - because the function is being memoized, if the + calculationFunc depends on other varables other than the input + value, the results will be unpredictable. + + The number of items to cache. When this limit + is reached, not recently used items will be discarded. + The maximum number of concurrent + asynchronous operations regardless of key - this is important for + web-based caches to limit the number of concurrent requests to a + server. The default is 5. + This optional method is called when an item + is evicted from the cache - this can be used to clean up / manage an + on-disk cache; the calculationFunc can download a file and save it + to a temporary folder, and the onRelease action will delete the + file. + The scheduler to run asynchronous operations on + - defaults to TaskpoolScheduler + + + + Issues an request to fetch the value for the specified key as an + async operation. The Observable returned will fire one time when the + async operation finishes. If the operation is cached, an Observable + that immediately fires upon subscribing will be returned. + + The key to provide to the calculation function. + Returns an Observable representing the future result. + + + + The synchronous version of AsyncGet - it will issue a request for + the value of a specific key and wait until the value can be + provided. + + The key to provide to the calculation function. + The resulting value. + + + + Works like SelectMany, but memoizes selector calls. In addition, it + guarantees that no more than 'maxConcurrent' selectors are running + concurrently and queues the rest. This is very important when using + web services to avoid potentially spamming the server with hundreds + of requests. + + A selector similar to one you would pass as a + parameter passed to SelectMany. Note that similarly to + ObservableAsyncMRUCache.AsyncGet, a selector must return semantically + identical results given the same key - i.e. it must be a 'function' in + the mathematical sense. + The number of items to cache. When this limit + is reached, not recently used items will be discarded. + The maximum number of concurrent + asynchronous operations regardless of key - this is important for + web-based caches to limit the number of concurrent requests to a + server. The default is 5. + + An Observable representing the flattened results of the + selector. + + + + Works like SelectMany, but memoizes selector calls. In addition, it + guarantees that no more than 'maxConcurrent' selectors are running + concurrently and queues the rest. This is very important when using + web services to avoid potentially spamming the server with hundreds + of requests. + + This overload is useful when making the same web service call in + several places in the code, to ensure that all of the code paths are + using the same cache. + + An already-configured ObservableAsyncMRUCache. + An Observable representing the flattened results of the + cache selector. + + + + Returns the current value of a property given a notification that it has changed. + + The current value of the property + + + + Attempts to return the current value of a property given a + notification that it has changed. If any property in the + property expression is null, false is returned. + + The value of the property expression. + True if the entire expression was able to be followed, false otherwise + + + + Given a fully filled-out IObservedChange object, SetValueToProperty + will apply it to the specified object (i.e. it will ensure that + target.property == This.GetValue() and "replay" the observed change + onto another object) + + The target object to apply the change to. + The target property to apply the change to. + + + + Given a stream of notification changes, this method will convert + the property changes to the current value of the property. + + An Observable representing the stream of current values of + the given change notification stream. + + + + ValueIfNotDefault is similar to Value(), but filters out null values + from the stream. + + An Observable representing the stream of current values of + the given change notification stream. + + + + Given a stream of notification changes, this method will convert + the property changes to the current value of the property. + + + + + BindTo takes an Observable stream and applies it to a target + property. Conceptually it is similar to "Subscribe(x => + target.property = x)", but allows you to use child properties + without the null checks. + + The target object whose property will be set. + An expression representing the target + property to set. This can be a child property (i.e. x.Foo.Bar.Baz). + An object that when disposed, disconnects the binding. + + + + + + The type of the objects in the collection. + + + + Constructs a ReactiveCollection. + + + + + Constructs a ReactiveCollection given an existing list. + + The existing list with which to populate the new + list. + + + + When this method is called, an object will not fire change + notifications (neither traditional nor Observable notifications) + until the return value is disposed. + + An object that, when disposed, reenables change + notifications. + + + + Fires when items are added to the collection, once per item added. + Functions that add multiple items such as AddRange should fire this + multiple times. The object provided is the item that was added. + + + + + Fires before an item is going to be added to the collection. + + + + + Fires once an item has been removed from a collection, providing the + item that was removed. + + + + + Fires before an item will be removed from a collection, providing + the item that will be removed. + + + + + Fires before a collection is about to change, providing the previous + Count. + + + + + Fires whenever the number of items in a collection has changed, + providing the new Count. + + + + + Provides Item Changed notifications for any item in collection that + implements IReactiveNotifyPropertyChanged. This is only enabled when + ChangeTrackingEnabled is set to True. + + + + + Provides Item Changing notifications for any item in collection that + implements IReactiveNotifyPropertyChanged. This is only enabled when + + + + + Fires when anything in the collection or any of its items (if Change + Tracking is enabled) are about to change. + + + + + Fires when anything in the collection or any of its items (if Change + Tracking is enabled) have changed. + + + + + Enables the ItemChanging and ItemChanged properties; when this is + enabled, whenever a property on any object implementing + IReactiveNotifyPropertyChanged changes, the change will be + rebroadcast through ItemChanging/ItemChanged. + + + + + Creates a collection based on an an Observable by adding items + provided until the Observable completes, optionally ensuring a + delay. Note that if the Observable never completes and withDelay is + set, this method will leak a Timer. This method also guarantees that + items are always added via the UI thread. + + The Observable whose items will be put + into the new collection. + If set, items will be populated in the + collection no faster than the delay provided. + A new collection which will be populated with the + Observable. + + + + Creates a collection based on an an Observable by adding items + provided until the Observable completes, optionally ensuring a + delay. Note that if the Observable never completes and withDelay is + set, this method will leak a Timer. This method also guarantees that + items are always added via the UI thread. + + The Observable whose items will be put + into the new collection. + A Select function that will be run on each + item. + If set, items will be populated in the + collection no faster than the delay provided. + A new collection which will be populated with the + Observable. + + + + Creates a collection whose contents will "follow" another + collection; this method is useful for creating ViewModel collections + that are automatically updated when the respective Model collection + is updated. + + A Select function that will be run on each + item. + A new collection whose items are equivalent to + Collection.Select(selector) and will mirror the initial collection. + + + + ObservableForProperty returns an Observable representing the + property change notifications for a specific property on a + ReactiveObject. This method (unlike other Observables that return + IObservedChange) guarantees that the Value property of + the IObservedChange is set. + + An Expression representing the property (i.e. + 'x => x.SomeProperty.SomeOtherProperty' + If True, the Observable will notify + immediately before a property is going to change. + An Observable representing the property change + notifications for the given property. + + + + ObservableForProperty returns an Observable representing the + property change notifications for a specific property on a + ReactiveObject, running the IObservedChange through a Selector + function. + + An Expression representing the property (i.e. + 'x => x.SomeProperty' + A Select function that will be run on each + item. + If True, the Observable will notify + immediately before a property is going to change. + An Observable representing the property change + notifications for the given property. + + + + ReactiveObject is the base object for ViewModel classes, and it + implements INotifyPropertyChanged. In addition, ReactiveObject provides + Changing and Changed Observables to monitor object changes. + + + + + When this method is called, an object will not fire change + notifications (neither traditional nor Observable notifications) + until the return value is disposed. + + An object that, when disposed, reenables change + notifications. + + + + Represents an Observable that fires *before* a property is about to + be changed. + + + + + Represents an Observable that fires *after* a property has changed. + + + + + RaiseAndSetIfChanged fully implements a Setter for a read-write + property on a ReactiveObject, making the assumption that the + property has a backing field named "_NameOfProperty". To change this + assumption, set RxApp.GetFieldNameForPropertyNameFunc. + + An Expression representing the property (i.e. + 'x => x.SomeProperty' + The new value to set the property to, almost + always the 'value' keyword. + The newly set value, normally discarded. + + + + RaiseAndSetIfChanged fully implements a Setter for a read-write + property on a ReactiveObject, making the assumption that the + property has a backing field named "_NameOfProperty". To change this + assumption, set RxApp.GetFieldNameForPropertyNameFunc. This + overload is intended for Silverlight and WP7 where reflection + cannot access the private backing field. + + An Expression representing the property (i.e. + 'x => x.SomeProperty' + A Reference to the backing field for this + property. + The new value to set the property to, almost + always the 'value' keyword. + The newly set value, normally discarded. + + + + Use this method in your ReactiveObject classes when creating custom + properties where raiseAndSetIfChanged doesn't suffice. + + An Expression representing the property (i.e. + 'x => x.SomeProperty' + + + + Use this method in your ReactiveObject classes when creating custom + properties where raiseAndSetIfChanged doesn't suffice. + + An Expression representing the property (i.e. + 'x => x.SomeProperty' + + + + RaisePropertyChanging is a helper method intended for test / mock + scenarios to manually fake a property change. + + The ReactiveObject to invoke + raisePropertyChanging on. + The property that will be faking a change. + + + + RaisePropertyChanging is a helper method intended for test / mock + scenarios to manually fake a property change. + + The ReactiveObject to invoke + raisePropertyChanging on. + The property that will be faking a change. + + + + RaisePropertyChanged is a helper method intended for test / mock + scenarios to manually fake a property change. + + The ReactiveObject to invoke + raisePropertyChanging on. + The property that will be faking a change. + + + + RaisePropertyChanged is a helper method intended for test / mock + scenarios to manually fake a property change. + + The ReactiveObject to invoke + raisePropertyChanging on. + The property that will be faking a change. + + + + This class helps you take existing objects and make them compatible with + ReactiveUI and Rx.Net. To use this, declare an instance field of this + class in your class, initialize it in your Constructor, make your class + derive from IReactiveNotifyPropertyChanged, then implement all of the + properties/methods using MakeObjectReactiveHelper. + + + + + InUnitTestRunner attempts to determine heuristically if the current + application is running in a unit test framework. + + True if we have determined that a unit test framework is + currently running. + + + + + + + + + GetFieldNameForProperty returns the corresponding backing field name + for a given property name, using the convention specified in + GetFieldNameForPropertyNameFunc. + + The name of the property whose backing + field needs to be found. + The backing field name. + + + + DeferredScheduler is the scheduler used to schedule work items that + should be run "on the UI thread". In normal mode, this will be + DispatcherScheduler, and in Unit Test mode this will be Immediate, + to simplify writing common unit tests. + + + + + TaskpoolScheduler is the scheduler used to schedule work items to + run in a background thread. In both modes, this will run on the TPL + Task Pool (or the normal Threadpool on Silverlight). + + + + + Set this property to implement a custom logger provider - the + string parameter is the 'prefix' (usually the class name of the log + entry) + + + + + Set this property to implement a custom MessageBus for + MessageBus.Current. + + + + + Set this property to override the default field naming convention + of "_PropertyName" with a custom one. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + + WhenAny allows you to observe whenever one or more properties on an + object have changed, providing an initial value when the Observable + is set up, unlike ObservableForProperty(). Use this method in + constructors to set up bindings between properties that also need an + initial setup. + + + + diff --git a/test/test_blob.rb b/test/test_blob.rb index 946e4ae0..4fd0ae12 100644 --- a/test/test_blob.rb +++ b/test/test_blob.rb @@ -136,6 +136,9 @@ class TestBlob < Test::Unit::TestCase assert blob("project.resx").generated? assert blob("project.sln").generated? + # Generated .NET Docfiles + assert blob("net_docfile.xml").generated? + # Long line assert !blob("uglify.js").generated?