public AutoCompleteFacet(MethodInfo autoCompleteMethod, int pageSize, int minLength, ISpecification holder)
     : this(holder) {
     method = autoCompleteMethod;
     PageSize = pageSize == 0 ? DefaultPageSize : pageSize;
     MinLength = minLength;
     methodDelegate = DelegateUtils.CreateDelegate(method);
 }

 public AuthorizationHideForSessionFacet(string roles,
                                         string users,
                                         ISpecification holder)
     : base(holder) {
     this.roles = FacetUtils.SplitOnComma(roles);
     this.users = FacetUtils.SplitOnComma(users);
 }

 public NamedFacetInferred(string value, ISpecification holder)
     : base(value, holder) {
     ShortName = TypeNameUtils.GetShortName(value);
     CapitalizedName = NameUtils.CapitalizeName(ShortName);
     SimpleName = NameUtils.SimpleName(ShortName);
     NaturalName = NameUtils.NaturalName(ShortName);
 }

        public IList<IProduct> Filter(IList<IProduct> productList, ISpecification specification)
        {
            if (productList == null || specification == null)
                return null;

            return productList.Where(product => specification.IsMatched(product)).ToList();
        }

        /// <summary>
        /// Finds the number of neighbours of a given cell that meet the passed in specification.
        /// </summary>
        /// <param name="cell">Cell whose neighbours have to be found.</param>
        /// <param name="specification">The specification that should be met by the neighbouring cells.</param>
        /// <returns>Returns the collection of cells that meet the passed in specification.</returns>
        public ICollection<Cell> FindNeighbours(Cell cell, ISpecification<Cell> specification)
        {
            List<Cell> cells = new List<Cell>();
            if (cell == null)
            {
                throw new ArgumentNullException(paramName:"Cell");
            }

            int column = cell.ColumnNumber;
            int row = cell.RowNumber;
            int startrow;
            int startcol;
            int endcol;
            int endrow;
            GetValidStartRowAndColumn(row, column, out startrow, out startcol);
            GetValidEndRowAndColumn(row, column, out endrow, out endcol);

            for (int xcoord = startrow; xcoord <= endrow; xcoord++)
            {
                for (int ycoord = startcol; ycoord <= endcol; ycoord++)
                {
                    if (!(xcoord == row && ycoord == column))
                    {
                        if (specification == null)
                            cells.Add(grid[xcoord, ycoord]);
                        else
                            if(specification.IsSatisfiedBy(grid[xcoord, ycoord]))
                                cells.Add(grid[xcoord, ycoord]);
                    }
                }
            }
            return cells;
        }

 public IEnumerable<User> AllMatching(ISpecification<User> specification)
 {
     lock (_users)
     {
         return _users.Where(specification.SatisfiedBy());
     }
 }

 public void DecorateAllHoldersFacets(ISpecification holder) {
     if (facetDecorators.Any()) {
         foreach (Type facetType in holder.FacetTypes) {
             DecorateFacet(facetType, holder);
         }
     }
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="specification"></param>
 /// <param name="item"></param>
 /// <param name="reason"></param>
 public static void IsSatisfiedByFalse(ISpecification<string> specification, string item, string reason)
 {
     Assert.IsNotNull(specification);
     Assert.IsFalse(specification.IsSatisfiedBy(item));
     Assert.AreEqual(specification.ReasonsForDissatisfaction.Count(), 1);
     Assert.AreEqual(specification.ReasonsForDissatisfaction.Single(), reason);
 }

        /// <summary>
        /// This method will return the list of cells that meet the specification.
        /// <param name="cell"> source cell, whose neighbours need to find </param>
        /// <param name="specification">Actual specification, which need to pass by neighbours.  </param>
        /// <returns>return the cell collection which pass the specification. </returns>
        public ICollection<Cell> FindNeighbourCells(Cell cell, ISpecification<Cell> specification)
        {
            if(cell == null)
                throw new ArgumentNullException("Cell can't be empty");

            List<Cell> cells = new List<Cell>();

            int startRow;
            int startCol;
            int endRow;
            int endCol;

            int colIndex = cell.ColNumber;
            int rowIndex = cell.RowNumber;

            GetValidStartRowAndCol(rowIndex, colIndex, out startRow, out startCol);
            GetValidEndRowAndCol(rowIndex, colIndex, out endRow, out endCol);

            for (int xcoord = startRow; xcoord <= endRow; xcoord++)
            {
                for (int ycoord = startCol; ycoord <= endCol; ycoord++)
                {
                    if (!(xcoord == rowIndex && ycoord == colIndex))
                    {
                        if (specification == null)
                            cells.Add(grid[xcoord, ycoord]);
                        else
                            if (specification.IsSpecificationMeet(grid[xcoord, ycoord]))
                                cells.Add(grid[xcoord, ycoord]);
                    }
                }
            }
            return cells;
        }

 public void Setup()
 {
     spec1 = Substitute.For<ISpecification<string>>();
     spec2 = Substitute.For<ISpecification<string>>();
     spec1.ReasonsForDissatisfaction.Returns(new List<string> { Spec1Dissatisfaction });
     spec2.ReasonsForDissatisfaction.Returns(new List<string> { Spec2Dissatisfaction });
 }

        private void ProcessArray(IReflector reflector, Type type, ISpecification holder) {
            FacetUtils.AddFacet(new ArrayFacet(holder));
            FacetUtils.AddFacet(new TypeOfFacetInferredFromArray(holder));

            var elementType = type.GetElementType();
            reflector.LoadSpecification(elementType);
        }

 public void Subscribe(
     string subscriptionName,
     ISpecification filter,
     Action<IEnumerable<SubscriptionMessage>> messagesReceived)
 {
     this.InitialiseSubscription(subscriptionName, filter, messagesReceived);
 }

        private static void Process(ISpecification holder) {
            var facets = new List<IFacet>();

            var specImmutable = holder as IMemberSpecImmutable;
            if (specImmutable != null) {
                facets.Add(new NamedFacetInferred(specImmutable.Identifier.MemberName, holder));
                facets.Add(new DescribedAsFacetNone(holder));
            }

            if (holder is IAssociationSpecImmutable) {
                facets.Add(new ImmutableFacetNever(holder));
                facets.Add(new PropertyDefaultFacetNone(holder));
                facets.Add(new PropertyValidateFacetNone(holder));
            }

            var immutable = holder as IOneToOneAssociationSpecImmutable;
            if (immutable != null) {
                facets.Add(new MaxLengthFacetZero(holder));
                DefaultTypicalLength(facets, immutable.ReturnSpec, immutable);
                facets.Add(new MultiLineFacetNone(holder));
            }

            if (holder is IActionSpecImmutable) {
                facets.Add(new ExecutedFacetDefault(holder));
                facets.Add(new ActionDefaultsFacetNone(holder));
                facets.Add(new ActionChoicesFacetNone(holder));
                facets.Add(new PageSizeFacetDefault(holder));
            }

            FacetUtils.AddFacets(facets);
        }

        private SubscriptionClient CreateAndGetSubscriptionInternal(string subscriptionName, ISpecification filterSpecification)
        {
            var filter = new SqlFilter(filterSpecification.Result());
            EnsureSubscriptionNameIsValid(subscriptionName);

            log.Info($"Checking subscription for path {subscriptionName} exists");

            if (!this.namespaceManager.SubscriptionExists(this.topic, subscriptionName))
            {
                log.Info("Creating subscription as it does not currently exist");

                var subscriptionDescription = new SubscriptionDescription(this.topic, subscriptionName)
                {
                    LockDuration = TimeSpan.FromMinutes(5)
                };

                this.namespaceManager.CreateSubscription(subscriptionDescription, filter);

                log.Info("Subscription created");
            }

            log.Info("Creating subscription client");

            var client = SubscriptionClient.CreateFromConnectionString(
                connectionString, this.topic, subscriptionName);

            log.Info("Subscription client created");

            return client;
        }

 public static IInteractionBuffer IsValid(ISpecification specification, IInteractionContext ic, IInteractionBuffer buf) {
     IEnumerable<IValidatingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IValidatingInteractionAdvisor).Cast<IValidatingInteractionAdvisor>();
     foreach (IValidatingInteractionAdvisor advisor in facets) {
         buf.Append(advisor.Invalidates(ic));
     }
     return buf;
 }

 private static IInteractionBuffer IsUsable(ISpecification specification, IInteractionContext ic, IInteractionBuffer buf) {
     IEnumerable<IDisablingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IDisablingInteractionAdvisor).Cast<IDisablingInteractionAdvisor>();
     foreach (IDisablingInteractionAdvisor advisor in facets) {
         buf.Append(advisor.Disables(ic));
     }
     return buf;
 }

        private void Process(IReflector reflector, MethodInfo member, ISpecification holder) {
            var allParams = member.GetParameters();
            var paramsWithAttribute = allParams.Where(p => p.GetCustomAttribute<ContributedActionAttribute>() != null).ToArray();
            if (!paramsWithAttribute.Any()) return; //Nothing to do
            var facet = new ContributedActionFacet(holder);
            foreach (ParameterInfo p in paramsWithAttribute) {
                var attribute = p.GetCustomAttribute<ContributedActionAttribute>();
                var type = reflector.LoadSpecification<IObjectSpecImmutable>(p.ParameterType);
                if (type != null) {
                    if (type.IsParseable) {
                        Log.WarnFormat("ContributedAction attribute added to a value parameter type: {0}", member.Name);
                    }
                    else if (type.IsCollection) {
                        var parent = reflector.LoadSpecification(member.DeclaringType);

                        if (parent is IObjectSpecBuilder) {
                            AddLocalCollectionContributedAction(reflector,  p, facet);
                        }
                        else {
                            AddCollectionContributedAction(reflector, member, type, p, facet, attribute);
                        }
                    }
                    else {
                        facet.AddObjectContributee(type, attribute.SubMenu, attribute.Id);
                    }
                }
            }
            FacetUtils.AddFacet(facet);
        }

 public IEnumerable<Product> By(IList<Product> products, ISpecification specification)
 {
     foreach (var product in products)
     {
         if (specification.IsSatisfiedBy(product))
             yield return product;
     }
 }

 private string CreateSpecificationTitle(ISpecification specification)
 {
     string suffix = "Specification";
     string title = specification.Story.Name;
     if (title.EndsWith(suffix))
         title = title.Remove(title.Length - suffix.Length, suffix.Length);
     return title;
 }

 public RegExFacet(string validation, string format, bool caseSensitive, string message, ISpecification holder)
     : base(typeof (IRegExFacet), holder) {
     validationPattern = validation;
     Pattern = new Regex(validation, PatternFlags);
     formatPattern = format;
     isCaseSensitive = caseSensitive;
     failureMessage = message;
 }