wrong 0.1.0 → 0.2.0

data/lib/predicated/test/to/solr_test.rb

@@ -0,0 +1,39 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+require "predicated/to/solr"
+include Predicated
+
+regarding "convert a predicate to a solr query" do
+  include CanonicalTransformCases
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => "a:3",
+      "gt" => "a:[4 TO *]",
+      "lt" => "a:[* TO 2]",
+      "gte" => "a:[3 TO *]",
+      "lte" => "a:[* TO 3]"
+    },
+    "primitive types" => {
+      "false" => "a:false",
+      "true" => "a:true",
+      "string" => "a:yyy"
+    },
+    "not" => {
+      "simple" => "NOT(a:true)"
+    },
+    "simple and / or" => {
+      "and" => "(a:1 AND b:2)", #parens are necessary around AND's in solr in order to force precedence
+      "or" => "(a:1 OR b:2)",
+    },
+    "complex and / or" => {
+      "or and" => "((a:1 AND b:2) OR c:3)"
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_solr
+  end
+
+end

data/lib/predicated/test/to/xml_test.rb

@@ -0,0 +1,72 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+require "predicated/to/xml"
+include Predicated
+
+regarding "convert a predicate to an xml string" do
+  include CanonicalTransformCases
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => "<equal><left>a</left><right>3</right></equal>",
+      "gt" => "<greaterThan><left>a</left><right>3</right></greaterThan>",
+      "lt" => "<lessThan><left>a</left><right>3</right></lessThan>",
+      "gte" => "<greaterThanOrEqualTo><left>a</left><right>3</right></greaterThanOrEqualTo>",
+      "lte" => "<lessThanOrEqualTo><left>a</left><right>3</right></lessThanOrEqualTo>"
+    },
+    "primitive types" => {
+      "false" => "<equal><left>a</left><right>false</right></equal>",
+      "true" => "<equal><left>a</left><right>true</right></equal>",
+      "string" => "<equal><left>a</left><right>yyy</right></equal>"
+    },
+    "not" => {
+      "simple" => "<not><equal><left>a</left><right>true</right></equal></not>"
+    },
+    "simple and / or" => {
+      "and" => %{<and>
+                  <equal><left>a</left><right>1</right></equal>
+                  <equal><left>b</left><right>2</right></equal>
+                </and>}.gsub("\n", "").gsub(" ", ""),
+      "or" => %{<or>
+                  <equal><left>a</left><right>1</right></equal>
+                  <equal><left>b</left><right>2</right></equal>
+                </or>}.gsub("\n", "").gsub(" ", "")
+    },
+    "complex and / or" => {
+      "or and" =>  %{<or>
+                       <and>
+                         <equal><left>a</left><right>1</right></equal>
+                         <equal><left>b</left><right>2</right></equal>
+                       </and>
+                       <equal><left>c</left><right>3</right></equal>
+                     </or>}.gsub("\n", "").gsub(" ", "")
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_xml.gsub("\n", "").gsub(" ", "")
+  end
+  
+  test "pretty printing" do
+    assert{ 
+      Predicate{ Or(And(Eq("a", 1),Eq("b", 2)), Not(Eq("c",3))) }.to_xml ==
+%{<or>
+  <and>
+    <equal><left>a</left><right>1</right></equal>
+    <equal><left>b</left><right>2</right></equal>
+  </and>
+  <not>
+    <equal><left>c</left><right>3</right></equal>
+  </not>
+</or>}
+    }
+  end
+
+  test "characters that need to be encoded" do
+    assert{ 
+      Predicate{ Eq(%{'"&<>}, %{'"&<>}) }.to_xml ==
+        %{<equal><left>&apos;&quot;&amp;&lt;&gt;</left><right>&apos;&quot;&amp;&lt;&gt;</right></equal>}
+    }
+  end
+end

data/lib/predicated/test/xml_conversion_test.rb

@@ -0,0 +1,34 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/from/xml"
+require "predicated/to/xml"
+include Predicated
+
+regarding "convert xml back and forth" do
+
+  test "string to predicate to string" do
+    assert{ Predicate.from_xml("<equal><left>a</left><right>3</right></equal>").to_xml == 
+              "<equal><left>a</left><right>3</right></equal>" }
+    
+    complex_xml = %{
+       <or>
+        <and>
+          <equal><left>a</left><right>1</right></equal>
+          <equal><left>b</left><right>2</right></equal>
+        </and>
+        <equal><left>c</left><right>3</right></equal>
+      </or>
+    }
+              
+    assert{ Predicate.from_xml(complex_xml).to_xml.gsub(/\s/, "") == 
+              complex_xml.gsub(/\s/, "") }
+  end
+  
+  test "predicate to string to predicate.  note the loss of type fidelity." do
+    assert{ Predicate.from_xml(Predicate{ Eq("a",3) }.to_xml) == Predicate{ Eq("a",'3') } }
+    
+    assert{ Predicate.from_xml(Predicate{ Or(And(Eq("a",1),Eq("b",2)), Eq("c",3)) }.to_xml) ==
+              Predicate{ Or(And(Eq("a",'1'),Eq("b",'2')), Eq("c",'3')) } }
+  end
+
+end

data/lib/predicated/test_integration/arel_integration_test.rb

@@ -0,0 +1,52 @@
+require "./test/test_helper_with_wrong"
+require "./test_integration/canonical_integration_cases"
+
+require "predicated/predicate"
+require "predicated/to/arel"
+include Predicated
+
+require "sqlite3-ruby"
+require "active_record"
+
+
+def get_from_db_using_predicate(predicate)
+  Table(:widget).where(predicate.to_arel(Table(:widget))).select.
+    collect{|r|r.tuple}.
+    collect{|d|d.first}
+end
+
+regarding "predicates run against a real db" do
+  include CanonicalIntegrationCases
+  
+  
+  before do
+    unless @created
+      db_file = "/tmp/sqlite_db"
+      FileUtils.rm_f(db_file)
+      @db = SQLite3::Database.new(db_file)
+      ActiveRecord::Base.establish_connection(:adapter => "sqlite3-ruby", :database  => db_file)
+      @db.execute(%{
+        create table widget (
+          id INTEGER PRIMARY KEY, 
+          eye_color VARCHAR(25), 
+          height VARCHAR(25), 
+          age VARCHAR(25), 
+          cats NUMERIC);
+      })
+      
+      self.fixtures.each do |row|
+        @db.execute("insert into widget values (#{row[:id]}, '#{row[:eye_color]}', '#{row[:height]}', '#{row[:age]}', #{row[:cats]})")
+      end
+    end
+    @created = true    
+  end
+  
+  create_canonical_tests(
+    :id => "id", 
+    :eye_color => "eye_color", 
+    :height => "height",
+    :age => "age",
+    :cats => "cats") do |predicate|
+      get_from_db_using_predicate(predicate)
+  end
+end

data/lib/predicated/test_integration/canonical_integration_cases.rb

@@ -0,0 +1,66 @@
+module CanonicalIntegrationCases
+
+  def fixtures
+    [
+      {:id => 101, :eye_color => "red", :height => "short", :age => "old", :cats => 0},
+      {:id => 102, :eye_color => "blue", :height => "tall", :age => "old", :cats => 2},
+      {:id => 103, :eye_color => "green", :height => "short", :age => "young", :cats => 3}
+    ]
+  end
+
+  
+  module ClassMethods
+    
+    def create_canonical_tests(attrs)
+      tests = {
+        "simple eq" => { Predicate{ Eq(attrs[:id], 101) } => [101] },
+        "string eq" => { Predicate{ Eq(attrs[:eye_color],"blue") } => [102] },
+        "simple gt" => { Predicate{ Gt(attrs[:cats], 1) } => [102, 103] },
+        "simple lt" => { Predicate{ Lt(attrs[:cats], 3) } => [101, 102] },
+        "simple gte" => { Predicate{ Gte(attrs[:cats], 2) } => [102, 103] },
+        "simple lte" => { Predicate{ Lte(attrs[:cats], 2) } => [101, 102] },
+        "simple not" => { Predicate{ Not(Eq(attrs[:eye_color],"blue")) } => [101, 103] },
+        "simple and / or" => {
+          Predicate{And(Eq(attrs[:height],"tall"),Eq(attrs[:age],"old"))} => [102],
+          Predicate{And(Eq(attrs[:height],"short"),Eq(attrs[:age],"old"))} => [101],
+          Predicate{Or(Eq(attrs[:height],"short"),Eq(attrs[:age],"young")) } => [101, 103]
+        },
+        "complex and / or" => {
+          
+          Predicate{ 
+            Or(
+              And(
+                Eq(attrs[:height],"short"),
+                Eq(attrs[:age],"young")
+              ),
+              Eq(attrs[:eye_color],"red")
+            ) 
+          } => [101, 103],
+          
+          Predicate{ 
+            Or(
+              And(
+                Eq(attrs[:height],"tall"),
+                Eq(attrs[:age],"old")
+              ),
+              Eq(attrs[:eye_color],"green")
+            ) 
+          } => [102, 103]
+        }
+      }
+  
+      tests.each do |test_name, cases|
+        test test_name do
+          cases.each do |predicate, expected_ids|
+            actual_ids = yield(predicate).sort
+            assert { actual_ids == expected_ids }
+          end
+        end
+      end
+    end
+  end
+  
+  def self.included(other)
+    other.extend(ClassMethods)
+  end
+end

data/lib/predicated/test_integration/schema.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<schema name="example" version="1.2">
+  <types>
+    <fieldType name="string" class="solr.StrField" sortMissingLast="true" omitNorms="true"/>
+
+    <fieldType name="boolean" class="solr.BoolField" sortMissingLast="true" omitNorms="true"/>
+
+    <fieldtype name="binary" class="solr.BinaryField"/>
+
+    <fieldType name="int" class="solr.TrieIntField" precisionStep="0" omitNorms="true" positionIncrementGap="0"/>
+    <fieldType name="float" class="solr.TrieFloatField" precisionStep="0" omitNorms="true" positionIncrementGap="0"/>
+    <fieldType name="long" class="solr.TrieLongField" precisionStep="0" omitNorms="true" positionIncrementGap="0"/>
+    <fieldType name="double" class="solr.TrieDoubleField" precisionStep="0" omitNorms="true" positionIncrementGap="0"/>
+
+    <fieldType name="tint" class="solr.TrieIntField" precisionStep="8" omitNorms="true" positionIncrementGap="0"/>
+    <fieldType name="tfloat" class="solr.TrieFloatField" precisionStep="8" omitNorms="true" positionIncrementGap="0"/>
+    <fieldType name="tlong" class="solr.TrieLongField" precisionStep="8" omitNorms="true" positionIncrementGap="0"/>
+    <fieldType name="tdouble" class="solr.TrieDoubleField" precisionStep="8" omitNorms="true" positionIncrementGap="0"/>
+
+    <fieldType name="date" class="solr.TrieDateField" omitNorms="true" precisionStep="0" positionIncrementGap="0"/>
+
+    <fieldType name="tdate" class="solr.TrieDateField" omitNorms="true" precisionStep="6" positionIncrementGap="0"/>
+
+    <fieldType name="pint" class="solr.IntField" omitNorms="true"/>
+    <fieldType name="plong" class="solr.LongField" omitNorms="true"/>
+    <fieldType name="pfloat" class="solr.FloatField" omitNorms="true"/>
+    <fieldType name="pdouble" class="solr.DoubleField" omitNorms="true"/>
+    <fieldType name="pdate" class="solr.DateField" sortMissingLast="true" omitNorms="true"/>
+
+    <fieldType name="sint" class="solr.SortableIntField" sortMissingLast="true" omitNorms="true"/>
+    <fieldType name="slong" class="solr.SortableLongField" sortMissingLast="true" omitNorms="true"/>
+    <fieldType name="sfloat" class="solr.SortableFloatField" sortMissingLast="true" omitNorms="true"/>
+    <fieldType name="sdouble" class="solr.SortableDoubleField" sortMissingLast="true" omitNorms="true"/>
+
+    <fieldType name="random" class="solr.RandomSortField" indexed="true" />
+
+    <fieldType name="text" class="solr.TextField" positionIncrementGap="100">
+      <analyzer type="index">
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+        <filter class="solr.StopFilterFactory"
+                ignoreCase="true"
+                words="stopwords.txt"
+                enablePositionIncrements="true"
+                />
+        <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" catenateWords="1" catenateNumbers="1" catenateAll="0" splitOnCaseChange="1"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+        <filter class="solr.SnowballPorterFilterFactory" language="English" protected="protwords.txt"/>
+      </analyzer>
+      <analyzer type="query">
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+        <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/>
+        <filter class="solr.StopFilterFactory"
+                ignoreCase="true"
+                words="stopwords.txt"
+                enablePositionIncrements="true"
+                />
+        <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" catenateWords="0" catenateNumbers="0" catenateAll="0" splitOnCaseChange="1"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+        <filter class="solr.SnowballPorterFilterFactory" language="English" protected="protwords.txt"/>
+      </analyzer>
+    </fieldType>
+
+ </types>
+
+
+  <fields>
+    <field name="id" type="string" indexed="true" stored="true" required="true" />
+    <dynamicField name="*_i"  type="sint"    indexed="true"  stored="true"/>
+    <dynamicField name="*_s"  type="string"  indexed="true"  stored="true"/>
+    <dynamicField name="*_l"  type="slong"   indexed="true"  stored="true"/>
+    <dynamicField name="*_t"  type="text"    indexed="true"  stored="true"/>
+    <dynamicField name="*_b"  type="boolean" indexed="true"  stored="true"/>
+    <dynamicField name="*_f"  type="sfloat"  indexed="true"  stored="true"/>
+    <dynamicField name="*_d"  type="sdouble" indexed="true"  stored="true"/>
+    <dynamicField name="*_dt" type="date"    indexed="true"  stored="true"/>
+    <dynamicField name="*_multi" type="string" indexed="true" stored="true" multiValued="true" />
+  </fields>
+
+  <uniqueKey>id</uniqueKey>
+  <defaultSearchField>id</defaultSearchField>
+  <solrQueryParser defaultOperator="OR"/>
+
+</schema>

data/lib/predicated/test_integration/solr_integration_test.rb

@@ -0,0 +1,71 @@
+require "./test/test_helper_with_wrong"
+require "./test_integration/canonical_integration_cases"
+require "net/http"
+require "open-uri"
+
+require "predicated/predicate"
+require "predicated/to/solr"
+include Predicated
+
+#download and unpack solr
+#place (overwrite) schema.xml in the solr conf directory
+#start solr (java -jar start.jar)
+
+def get_from_solr_using_predicate(predicate)
+  eval(get_from_solr("/solr/select?q=#{URI.escape(predicate.to_solr)}&wt=ruby"))
+end
+
+def get_from_solr(path)
+  open("http://localhost:8983#{path}").read
+end
+
+def post_to_solr(body)
+  request = Net::HTTP::Post.new("/solr/update", {'Content-Type' =>'text/xml'})
+  request.body = body
+  response = Net::HTTP.new("localhost", 8983).start {|http| http.request(request) }
+  raise "Response #{response.code}\n#{response.body}" unless response.code=="200"
+end
+
+regarding "solr is running properly" do
+  test "solr schema is the one from this project" do
+    assert{ get_from_solr("/solr/admin/file/?file=schema.xml") == File.read("test_integration/schema.xml") }
+  end
+end
+
+
+regarding "predicates run against real solr" do
+  include CanonicalIntegrationCases
+  
+  before do
+    unless @posted
+      post_to_solr("<delete><query>*:*</query></delete>")
+      post_to_solr("<commit/>")
+      
+      docs_str = 
+        self.fixtures.collect do |row|
+          %{
+          <doc>
+            <field name="id">#{row[:id]}</field>
+            <field name="eye_color_s">#{row[:eye_color]}</field>
+            <field name="height_s">#{row[:height]}</field>
+            <field name="age_s">#{row[:age]}</field>
+            <field name="cats_i">#{row[:cats]}</field>
+          </doc>  
+          }
+        end.join("\n")
+      
+      post_to_solr("<add>#{docs_str}</add>")
+      post_to_solr("<commit/>")
+    end
+    @posted = true    
+  end
+  
+  create_canonical_tests(
+    :id => "id", 
+    :eye_color => "eye_color_s", 
+    :height => "height_s",
+    :age => "age_s",
+    :cats => "cats_i") do |predicate|
+      get_from_solr_using_predicate(predicate)["response"]["docs"].collect{|d|d["id"].to_i}
+  end
+end

data/lib/predicated/test_integration/suite.rb

@@ -0,0 +1,2 @@
+require "./test/test_helper"
+run_suite("test_integration/**/*_test.rb")

data/lib/predicated/test_integration/usage_test.rb

@@ -0,0 +1,252 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/to/arel"
+require "sqlite3-ruby"
+require "active_record"
+require "fileutils"
+
+regarding "prove out examples used in the README" do
+  
+  before do
+    unless @created
+      db_file = "/tmp/sqlite_db"
+      FileUtils.rm_f(db_file)
+      @db = SQLite3::Database.new(db_file)
+      ActiveRecord::Base.establish_connection(:adapter => "sqlite3-ruby", :database  => db_file)
+      @db.execute(%{
+        create table shirt (
+          id INTEGER PRIMARY KEY, 
+          color VARCHAR(25), 
+          size VARCHAR(25)
+        );
+      })      
+    end
+    @created = true    
+  end  
+  
+  
+  test "Evaluate a predicate" do
+    
+    require "predicated/evaluate"
+    extend Predicated #include Predicated
+            
+    assert{
+    Predicate { Eq(1, 2) }.evaluate == false
+    }
+    assert{
+    Predicate { Lt(1, 2) }.evaluate == true
+    }
+    assert{
+    Predicate { Or(Lt(1, 2),Eq(1, 2)) }.evaluate == true
+    }
+    
+    assert{
+    x = 1
+    Predicate { Lt(x, 2) }.evaluate == true
+    }
+  end
+
+
+  test "Parse a predicate from part of a url and then turn it into a sql where clause" do
+    
+    require "predicated/from/url_part"
+    require "predicated/to/arel"
+        
+    predicate = Predicated::Predicate.from_url_part("(color=red|color=green)&size=large")
+    
+    assert{ 
+    predicate.inspect == 
+      "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+    }
+    
+    assert{ 
+    predicate.to_arel(Table(:shirt)).to_sql == 
+      %{(("shirt"."color" = 'red' OR "shirt"."color" = 'green') AND "shirt"."size" = 'large')} 
+    }
+  end
+  
+
+  test "Parse a predicate from json and then turn it into a solr query string" do
+    
+    require "predicated/from/json"
+    require "predicated/to/solr"
+        
+    predicate = Predicated::Predicate.from_json_str(%{
+      {"and":[{"or":[["color","==","red"],["color","==","green"]]},["size","==","large"]]}
+    })
+        
+    assert{ 
+    predicate.inspect == "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+    }
+        
+    assert{ 
+    predicate.to_solr == "((color:red OR color:green) AND size:large)" 
+    }
+  end
+
+  
+  test "From json" do
+    
+    require "predicated/from/json"
+        
+    assert{ 
+    Predicated::Predicate.from_json_str(%{
+      {"and":[
+        {"or":[
+          ["color","==","red"],
+          ["color","==","green"]
+        ]},
+        ["size","==","large"]
+      ]}
+    }).inspect == "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+    }
+  end
+
+
+  test "From xml" do
+    
+    require "predicated/from/xml"
+        
+    assert{ 
+    Predicated::Predicate.from_xml(%{
+      <and>
+        <or>
+          <equal><left>color</left><right>red</right></equal>
+          <equal><left>color</left><right>green</right></equal>
+        </or>
+        <equal><left>size</left><right>large</right></equal>
+      </and>
+    }).inspect == "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+    }
+  end
+
+
+  test "From url part" do
+    
+    require "predicated/from/url_part"
+        
+    assert{ 
+    Predicated::Predicate.from_url_part("(color=red|color=green)&size=large").inspect ==
+      "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+    }
+  end
+
+
+  test "From callable object" do
+    
+    require "predicated/from/callable_object"
+        
+    assert{ 
+    Predicated::Predicate.from_callable_object{('color'=='red' || 'color'=='green') && 'size'=='large'}.inspect ==
+      "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+    }
+  end
+
+
+  test "From ruby code string" do
+      
+    require "predicated/from/ruby_code_string"
+            
+    assert{ 
+    Predicated::Predicate.from_ruby_code_string("('color'=='red' || 'color'=='green') && 'size'=='large'").inspect ==
+      "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+    }
+  end
+  
+  
+  test "To json" do
+      
+    require "predicated/to/json"
+    extend Predicated #include Predicated
+            
+    assert{ 
+    Predicate{And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))}.to_json_str.gsub(/\s/, "") ==
+    %{
+      {"and":[
+        {"or":[
+          ["color","==","red"],
+          ["color","==","green"]
+        ]},
+        ["size","==","large"]
+      ]}
+    }.gsub(/\s/, "")
+    }
+  end
+  
+  
+  test "To xml" do
+      
+    require "predicated/to/xml"
+    extend Predicated #include Predicated
+            
+    assert{ 
+    Predicate{And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))}.to_xml.gsub(/\s/, "") ==
+    %{
+      <and>
+        <or>
+          <equal><left>color</left><right>red</right></equal>
+          <equal><left>color</left><right>green</right></equal>
+        </or>
+        <equal><left>size</left><right>large</right></equal>
+      </and>      
+    }.gsub(/\s/, "")
+    }
+  end
+  
+  
+  test "To arel (sql where clause)" do
+      
+    require "predicated/to/arel"
+    extend Predicated #include Predicated
+            
+    assert{ 
+    Predicate{And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))}.to_arel(Table(:shirt)).to_sql ==
+      %{(("shirt"."color" = 'red' OR "shirt"."color" = 'green') AND "shirt"."size" = 'large')}
+    }
+  end
+  
+  
+  test "To solr query string" do
+      
+    require "predicated/to/solr"
+    extend Predicated #include Predicated
+            
+    assert{ 
+    Predicate{And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))}.to_solr ==
+      "((color:red OR color:green) AND size:large)"
+    }
+  end
+  
+  
+  test "To sentence" do
+      
+    require "predicated/to/sentence"
+    extend Predicated #include Predicated
+        
+    assert{
+    Predicate{ And(Eq("a",1),Eq("b",2)) }.to_sentence == 
+      "'a' is equal to 1 and 'b' is equal to 2"
+    }
+    
+    assert { 
+    Predicate{ Gt("a",1) }.to_negative_sentence == 
+      "'a' is not greater than 1" 
+    }    
+  end
+  
+  xtest "format and puts me" do
+    lines = File.read(__FILE__).split("\n")
+    lines =
+      lines.reject do |line|
+        line.include?("assert") || line =~ /^[ ]*\}[ ]*$/ || line =~ /^[ ]*end[ ]*$/
+      end
+    str = lines.join("\n")
+    
+    puts str.
+      gsub("  test \"", "").
+      gsub("\" do", ":").
+      gsub("extend Predicated #include Predicated", "include Predicated").
+      gsub(%{.gsub(/\\s/, "")}, "")
+  end
+  
+end