Added tests and support in ExpressionToSql for Booleans e.g.

Where(x.Active == true)
Where(x.Active == false)
Where(x.Active)
Where(x.Active)

Admittedly, my Expression knowledge is limited, so this might be a naive implementation,
but hey, all tests passed!

Author: briandonahue

src/FluentNHibernate.Testing/DomainModel/Mapping/ClassMapXmlCreationTester.cs

@@ -581,6 +581,7 @@ public class ChildObject
         public virtual int Id { get; set; }
         public virtual string Name { get; set; }
         public virtual int Position { get; set; }
+        public virtual bool Active { get; set; }
     }
 
     public class MappedGenericObject<T>

src/FluentNHibernate.Testing/ExpressionToSqlTests.cs

@@ -55,6 +55,38 @@ public void ConvertEqualsPropertyAndString()
             sql.ShouldEqual("Name = '1'");
         }
 
+        [Test]
+        public void ConvertEqualsPropertyAndTrue()
+        {
+            var sql = ExpressionToSql.Convert<ChildObject>(x => x.Active == true);
+
+            sql.ShouldEqual("Active = 1");
+        }
+
+        [Test]
+        public void ConvertEqualsPropertyAndFalse()
+        {
+            var sql = ExpressionToSql.Convert<ChildObject>(x => x.Active == false);
+
+            sql.ShouldEqual("Active = 0");
+        }
+
+        [Test]
+        public void ConvertBooleanPropertyImplicitTrue()
+        {
+            var sql = ExpressionToSql.Convert<ChildObject>(x => x.Active);
+
+            sql.ShouldEqual("Active = 1");
+        }
+
+        [Test]
+        public void ConvertBooleanPropertyImplicitFalse()
+        {
+            var sql = ExpressionToSql.Convert<ChildObject>(x => !x.Active);
+
+            sql.ShouldEqual("Active = 0");
+        }
+
         [Test]
         public void ConvertGreater()
         {

src/FluentNHibernate/Utils/ExpressionToSql.cs

@@ -32,6 +32,14 @@ public static string Convert<T>(Expression<Func<T, bool>> expression)
         {
             if (expression.Body is BinaryExpression)
                 return Convert<T>((BinaryExpression)expression.Body);
+            var memberExpression = expression.Body as MemberExpression;
+            if (memberExpression != null && memberExpression.Type == typeof(bool))
+                    return Convert(CreateExpression<T>(memberExpression)) + " = " + Convert(true);
+            var unaryExpression = expression.Body as UnaryExpression;
+            if (unaryExpression != null && unaryExpression.Type == typeof(bool) && unaryExpression.NodeType == ExpressionType.Not)
+                    return Convert(CreateExpression<T>(unaryExpression.Operand)) + " = " + Convert(false);
+                
+
 
             throw new NotImplementedException();
         }
@@ -135,6 +143,10 @@ private static string Convert(object value)
         {
             if (value is string)
                 return "'" + value + "'";
+            if (value is bool)
+            {
+                return (bool)value ? "1" : "0";
+            }
 
             return value.ToString();
         }