private static HtmlTag Checkbox(UIComponentContext context)
 {
     var checkbox = new CheckboxTag(context.Value<bool>()).Attr("value", "true");
     var hidden = new HtmlTag("input").Attr("type", "hidden").Attr("value", "false");
     checkbox.Next = hidden;
     return checkbox;
 }

 public static void AddElementName(ElementRequest request, HtmlTag tag)
 {
     if (tag.IsInputElement())
     {
         tag.Attr("name", request.ElementId);
     }
 }

        public static MvcHtmlString AuthButtons(this HtmlHelper htmlHelper)
        {
            var authContainer =
                new HtmlTag("div")
                    .Attr("style", "overflow: hidden;")
                    .Append("input",
                            ht => ht.Id("authType").Attr("name", "authType").Attr("type", "hidden").Attr("value", "1"))
                    .Append("a",
                            ht => ht
                                      .Attr("href", "javascript:auth.signin('twitter')")
                                      .AddClasses("simpleAuthButton", "twitter")
                                      .Text("twitter"))
                    .Append("a",
                            ht => ht
                                      .Attr("href", "javascript:auth.signin('facebook')")
                                      .AddClasses("simpleAuthButton", "facebook")
                                      .Text("facebook"))
                    .Append("a",
                            ht => ht
                                      .Attr("href", "javascript:auth.signin('google')")
                                      .AddClasses("simpleAuthButton", "google")
                                      .Text("google"))
                    .ToHtmlString();

            return new MvcHtmlString(authContainer);
        }

        public TestEditorTag(FixtureLibrary library)
            : base("div")
        {
            AddClass("main");
            Add("h2").AddClass(HtmlClasses.TEST_NAME);
            Id("testEditor");

            AddClass(HtmlClasses.TEST_EDITOR);

            _container = Add("div").AddClasses("container", HtmlClasses.SECTION, "test-editor");

            FixtureGraph fixture = library.BuildTopLevelGraph();

            HtmlTag holder = new HolderTag(fixture).AddClass("top-level-holder");
            holder.Children.Last().Render(false);

            Container
                .MetaData(GrammarConstants.LEAF_NAME, GrammarConstants.TEST)
                .MetaData(GrammarConstants.FIXTURE, GrammarConstants.TEST)
                .MetaData(GrammarConstants.SELECTION_MODE, SelectionMode.OneOrMore.ToString())
                .Append(holder)
                .Append(new HtmlTag("hr"));

            Container.ActionLink(fixture.Policies.AddGrammarText, GrammarConstants.ADD_SECTION_ACTIVATOR);
            Container.Append(new GrammarSelector(fixture).Build());
        }

        public void mustache_attr()
        {
            var tag = new HtmlTag("a");
            tag.MustacheAttr("href", "url");

            tag.ToString().ShouldEqual("<a href=\"{{url}}\"></a>");
        }

 public override HtmlTag Build(ElementRequest request)
 {
     HtmlTag root = new HtmlTag("div").Attr("data-bind", "foreach: "+ CCHtmlConventions2.DeriveElementName(request));
     var child = new HtmlTag("div").Attr("data-bind", "text: $data" );
     root.Append(child);
     return root;
 }

        public virtual void Modify(HtmlTag form)
        {
            if (!_modify) return;

            form.Data("validation-mode", _value.ToLower());
            form.AddClass("validated-form");
        }

        public static MvcHtmlString RenderAuthWarnings(this HtmlHelper htmlHelper)
        {
            var appSettingsKeys =
                new[]
                    {
                        "googleAppID", "googleAppSecret",
                        "facebookAppID", "facebookAppSecret",
                        "twitterConsumerKey", "twitterConsumerSecret"
                    };

            var noValueForSetting = appSettingsKeys
                    .Any(key => string.IsNullOrEmpty(ConfigurationManager.AppSettings[key]));

            var message = "";

            if (noValueForSetting)
            {
                message = new HtmlTag("p")
                        .Attr("style", "color: Red;")
                        .Text("Not all key and secrets are filled in a configuration file.")
                        .ToHtmlString();
            }

            return new MvcHtmlString(message);
        }

        public override HtmlTag Build(ElementRequest request)
        {
            var tag = new HtmlTag("div").Text(request.StringValue()).AddClass("editable").Id(request.Accessor.Name);

            var options = new EditOptions();

            if (request.Accessor.HasAttribute<MarkdownAttribute>())
            {
                tag.UnEncoded().Text(new Markdown().Transform(request.RawValue== null ? "" : request.RawValue.ToString()));
                options.Markdown = true;
            }

            options.MultiLine = request.Accessor.Name == "Details";
            options.RequiresExplicitUserActionForSave = true;

            options.MaximumLength = request.Accessor.PropertyType.Equals(typeof(string)) ? Entity.UnboundedStringLength : 0;
            options.IsDate = request.Accessor.PropertyType.IsDateTime();
            options.IsTime = request.Accessor.Name.ToLower().Contains("time");
            options.IsNumber = request.Accessor.PropertyType.IsIntegerBased() || request.Accessor.PropertyType.IsFloatingPoint();
            options.Required = request.Accessor.HasAttribute<RequiredAttribute>();
            options.PlaceholderText = "Double-Click to edit " + request.Accessor.Name.ToLower() + ".";

            var data = options.ToJson();

            tag.Attr("data", "{editoptions:"+data+"}");
            return tag;
        }

 public override void Build(ElementRequest request, HtmlTag tag)
 {
     tag
         .AllTags()
         .Where(t => t.IsInputElement())
         .ForEach(t => t.AddClass("url"));
 }

 private static void setDisabledState(MenuItemToken item, HtmlTag link)
 {
     if (item.MenuItemState == MenuItemState.Disabled)
     {
         link.AddClass("disabled");
     }
 }

        public ScriptTag(string mode, Func<string, string> toFullUrl, Asset asset, string defaultUrl = null)
            : base("script")
        {
            // http://stackoverflow.com/a/1288319/75194 
            Attr("type", "text/javascript");

            if (asset == null)
            {
                Attr("src", toFullUrl(defaultUrl));
                return;
            }

            if (asset.CdnUrl.IsNotEmpty())
            {
                Attr("src", asset.CdnUrl);
                if (asset.FallbackTest.IsNotEmpty() && asset.File != null)
                {
                    Next = new HtmlTag("script");
                    var text = "if ({0}) document.write(unescape(\"%3Cscript src='{1}' type='text/javascript'%3E%3C/script%3E\"));".ToFormat(asset.FallbackTest, asset.Url);

                    Next.Encoded(false);
                    Next.Text(text);
                }

                return;
            }

            var url = asset.Url;
            if (mode.InDevelopment() && asset.File != null)
            {
                url += "?Etag=" + asset.File.Etag();
            }

            Attr("src", toFullUrl(url));
        }

        public ConventionsViewModel get_conventions()
        {
            var configTypes = new string[]
                   {
                       ConfigurationType.Settings,
                       ConfigurationType.Discovery,
                       ConfigurationType.Explicit,
                       ConfigurationType.Policy,
                       ConfigurationType.Attributes,
                       ConfigurationType.ModifyRoutes,
                       ConfigurationType.InjectNodes,
                       ConfigurationType.Conneg,
                       ConfigurationType.Attachment,
                       ConfigurationType.Navigation,
                       ConfigurationType.ByNavigation,
                       ConfigurationType.Reordering,
                       ConfigurationType.Instrumentation
                   };

            var tag = new HtmlTag("ul");
            configTypes.Each(configType => {
                tag.Add("li/a").Text(configType).Attr("href", "#" + configType);
            });


            return new ConventionsViewModel
            {
                Descriptions = new TagList(configTypes.Select(configType => new ConfigurationTypeTag(configType, _graph))),
                TableOfContents = tag
            };
        }

 public TableTag()
     : base("table")
 {
     _header = new HtmlTag("thead", this);
     _footer = new HtmlTag("tfoot", this).Render(false);
     _body = new HtmlTag("tbody", this);
 }

 public static void AddElementName(ElementRequest request, HtmlTag tag)
 {
     if (tag.IsInputElement())
     {
         tag.Attr(HtmlAttributeConstants.Name, request.ElementId);
     }
 }

 private void AssertOptionGroup(
     HtmlTag optgroup,
     string display)
 {
     Assert.Equal("optgroup", optgroup.TagName());
     Assert.Equal(display, optgroup.Attr("label"));
 }

        public void AddEqualToDataAttr(IEnumerable<PropertyValidatorResult> propertyValidators, HtmlTag htmlTag, RequestData request)
        {
            var result = propertyValidators.FirstOrDefault(x => x.PropertyValidator is EqualValidator);
            if (result != null)
            {
                var equal = result.PropertyValidator.As<EqualValidator>();
                MessageFormatter formatter = new MessageFormatter()
                    .AppendPropertyName(result.DisplayName)
                    .AppendArgument("ComparisonValue", equal.ValueToCompare);

                string message = formatter.BuildMessage(equal.ErrorMessageSource.GetString());

                if (_msUnobtrusive)
                {
                    htmlTag.Data("val", true);
                    htmlTag.Data("val-equalto", message);
                    if (request.Accessor.PropertyNames.Length > 1)
                        htmlTag.Data("val-equalto-other", request.Id.Replace("_" + request.Accessor.Name, "") + "_" + equal.MemberToCompare.Name);
                    else
                        htmlTag.Data("val-equalto-other", "*." + equal.MemberToCompare.Name);
                }
                else
                {
                    htmlTag.Data("msg-equalto", message);
                    if (request.Accessor.PropertyNames.Length > 1)
                        htmlTag.Data("rule-equalto", "#" + request.Id.Replace("_" + request.Accessor.Name, "") + "_" + equal.MemberToCompare.Name);
                    else
                        htmlTag.Data("rule-equalto", "#" + equal.MemberToCompare.Name);
                }
            }
        }

 public static HtmlTag AddValidationAttributes(HtmlTag tag, ModelInfo info)
 {
     var input = tag.FirstNonHiddenInput();
     if (input == null) return tag;
     input.AddValidationAttributes(info);
     return tag;
 }

        public ConfigureFubuMVC()
        {
            IncludeDiagnostics(true);

            this.ApplyConvention<ModelValidationConfiguration>();

            this.ApplyHandlerConventions<HandlersMarker>();

            HtmlConvention(x => x.Editors.Always.Modify((request, tag) =>
            {
                var fubuRequest = request.Get<IFubuRequest>();
                var validationResult = fubuRequest.Get<ValidationResult>();
                if (validationResult.IsValid) return;
                var ul = new HtmlTag("ul");
                var liTags = validationResult.Errors.Where(error => error.PropertyName == request.Accessor.InnerProperty.Name).Select(vf => new HtmlTag("li", li => li.Text(vf.ErrorMessage)));
                ul.Append(liTags);
                tag.Append(ul);
            }));

            this.UseSpark();

            Routes
                .IgnoreNamespaceText("fubu101")
                .HomeIs<GetHandler>(action => action.Execute(new MovieRequestModel()));

            Policies.EnrichCallsWith<MovieViewModelJsonBehavior>(request => request.Returns<MovieViewModel>());

            Views.TryToAttachWithDefaultConventions();
        }

        private void writeScripts(HtmlTag foot)
        {
            // Do this regardless
            foot.Append(_assets.For("FubuDiagnostics.js").ToEmbeddedScriptTag());

            var routeData = _routeWriter.WriteJavascriptRoutes("FubuDiagnostics.routes", _routes);
            foot.Append(routeData);

            var extensionFiles = _assets.JavascriptFiles().Where(x => x.AssemblyName != "FubuMVC.Core");

            if (_runtime.Mode.InDiagnostics())
            {
                var names = _scripts.Union(extensionFiles.Select(x => x.Name.Split('.').Reverse().Take(2).Reverse().Join(".")));
                var links = _tags.BuildScriptTags(names.Select(x => "fubu-diagnostics/" + x));
                links.Each(x => foot.Append(x));

            }
            else
            {
                _scripts.Each(name =>
                {
                    var file = _assets.For(name);
                    foot.Append(file.ToEmbeddedScriptTag());
                });

                extensionFiles.Each(file => foot.Append(file.ToEmbeddedScriptTag()));
            }
        }