wrong 0.3.1 → 0.3.2

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

@@ -1,39 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,83 +0,0 @@
-<?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

@@ -1,71 +0,0 @@
-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

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

data/lib/predicated/test_integration/usage_test.rb

@@ -1,252 +0,0 @@
-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