ballast 1.9.3 → 2.0.0

data/spec/ballast/concerns/view_spec.rb

@@ -8,11 +8,6 @@ require "spec_helper"
 describe Ballast::Concerns::View do
   class ViewMockClass < OpenStruct
     include Ballast::Concerns::View
-
-    def initialize(attrs)
-      @operation = OpenStruct.new(attrs.delete(:operation))
-      super(attrs)
-    end
   end
 
   subject{ ViewMockClass.new(response: OpenStruct.new(headers: {}), headers: {}, params: {}, performed?: false) }
@@ -27,42 +22,36 @@ describe Ballast::Concerns::View do
 
   describe "#browser" do
     it "should return a browser object" do
-      expect(subject).to receive(:request).and_return(OpenStruct.new(user_agent: "AGENT"))
-      expect(Brauser::Browser).to receive(:new).with("AGENT").and_return("BROWSER")
+      expect(subject).to receive(:request).exactly(2).and_return(OpenStruct.new(user_agent: "AGENT", headers: {"Accept-Language" => "FOO"}))
+      expect(Brauser::Browser).to receive(:new).with("AGENT", "FOO").and_return("BROWSER")
       expect(subject.browser).to eq("BROWSER")
     end
   end
 
   describe "#browser_supported?" do
-    before(:each) do
-      expect(subject).to receive(:request).and_return(OpenStruct.new(user_agent: "AGENT"))
+    before(:example) do
+      expect(subject).to receive(:request).exactly(2).and_return(OpenStruct.new(user_agent: "AGENT", headers: {"Accept-Language" => "FOO"}))
     end
 
     it "should check if a browser is supported" do
-      expect(subject.browser).to receive(:supported?).with("CONF").and_return("SUPPORTED")
+      expect(subject.browser).to receive(:supported?).with(Dir.pwd + "/CONF").and_return("SUPPORTED")
       expect(subject.browser_supported?("CONF")).to eq("SUPPORTED")
     end
 
     it "should use a default file" do
-      class Rails
-        def self.root
-          Pathname.new("ROOT")
-        end
-      end
-
-      expect(subject.browser).to receive(:supported?).with("ROOT/config/supported-browsers.yml").and_return(true)
+      expect(subject.browser).to receive(:supported?).with(Dir.pwd + "/config/supported-browsers.yml").and_return(true)
       subject.browser_supported?
     end
   end
 
   describe "#layout_params" do
     it "should return a single parameter" do
-      subject.set_layout_params(a: 1)
+      subject.update_layout_params(a: 1)
       expect(subject.layout_params(:a)).to eq(1)
     end
 
     it "should return a default value for a missing parameter" do
-      subject.set_layout_params(a: 1)
+      subject.update_layout_params(a: 1)
       expect(subject.layout_params(:b, 2)).to eq(2)
     end
 
@@ -73,27 +62,27 @@ describe Ballast::Concerns::View do
 
     it "should return the entire hash if no arguments are passed" do
       expect(subject.layout_params).to eq({})
-      subject.set_layout_params(a: 1)
+      subject.update_layout_params(a: 1)
       expect(subject.layout_params).to eq({"a" => 1})
     end
   end
 
-  describe "#set_layout_params" do
+  describe "#update_layout_params" do
     it "should merge arguments into the existing parameters" do
       expect(subject.layout_params).to eq({})
-      subject.set_layout_params(a: 1, b: 2)
+      subject.update_layout_params(a: 1, b: 2)
       expect(subject.layout_params).to eq({"a" => 1, "b" => 2})
     end
   end
 
   describe "#javascript_params" do
-    before(:each) do
+    before(:example) do
       subject.instance_variable_set(:@javascript_params, {a: "1", b: 2})
     end
 
     it "should output Javascript as HTML" do
       expect(subject).to receive(:content_tag).with(:tag, '{"a":"1","b":2}', {"data-jid" => "ID"}).and_return("HTML")
-      expect(subject.javascript_params("ID", :tag)).to eq("HTML")
+      expect(subject.javascript_params("ID", tag: :tag)).to eq("HTML")
     end
 
     it "should return Javascript as Hash" do
@@ -102,9 +91,9 @@ describe Ballast::Concerns::View do
     end
   end
 
-  describe "#add_javascript_params" do
-    before(:each) do
-      subject.add_javascript_params(:a, {b: 1})
+  describe "#update_javascript_params" do
+    before(:example) do
+      subject.update_javascript_params(:a, {b: 1})
     end
 
     it "should create an Hash" do
@@ -112,27 +101,27 @@ describe Ballast::Concerns::View do
     end
 
     it "should add new keys" do
-      subject.add_javascript_params(:c, {d: 2})
+      subject.update_javascript_params(:c, {d: 2})
       expect(subject.instance_variable_get(:@javascript_params)).to eq({a: {b: 1}, c: {d: 2}}.with_indifferent_access)
     end
 
     it "should merge values for the same key" do
-      subject.add_javascript_params(:a, {d: 2})
+      subject.update_javascript_params(:a, {d: 2})
       expect(subject.instance_variable_get(:@javascript_params)).to eq({a: {b: 1, d: 2}}.with_indifferent_access)
     end
 
     it "should replace values for same key if requested to" do
-      subject.add_javascript_params(:a, {d: 2}, true)
+      subject.update_javascript_params(:a, {d: 2}, replace: true)
       expect(subject.instance_variable_get(:@javascript_params)).to eq({a: {d: 2}}.with_indifferent_access)
     end
 
     it "should merge from the root" do
-      subject.add_javascript_params(nil, {d: 2})
+      subject.update_javascript_params(nil, {d: 2})
       expect(subject.instance_variable_get(:@javascript_params)).to eq({a: {b: 1}, d: 2}.with_indifferent_access)
     end
 
     it "should replace the entire hash" do
-      subject.add_javascript_params(nil, {d: 2}, true)
+      subject.update_javascript_params(nil, {d: 2}, replace: true)
       expect(subject.instance_variable_get(:@javascript_params)).to eq({d: 2}.with_indifferent_access)
     end
   end

data/spec/ballast/configuration_spec.rb

@@ -6,29 +6,79 @@
 require "spec_helper"
 
 describe Ballast::Configuration do
-  describe "#initialize" do
-    before(:each) do
-      expect(YAML).to receive(:load_file).with("ROOT/config/section_a.yml").and_return({"ENV" => {a: {b: 1}}, "OTHER" => {aa: 3}})
-      expect(YAML).to receive(:load_file).with("ROOT/config/section-b.yml").and_return({"ENV" => {c: {d: 2}}, "OTHER" => {cc: 4}})
+  describe ".default_root" do
+    it "should return the Rails root" do
+      stub_const("Rails", OpenStruct.new(root: "ROOT"))
+      expect(Ballast::Configuration.default_root).to eq("ROOT")
+    end
+
+    it "should fallback to the current working directory" do
+      expect(Ballast::Configuration.default_root).to eq(Dir.pwd)
+    end
+  end
+
+  describe ".default_environment" do
+    it "should return the Rails environment" do
+      stub_const("Rails", OpenStruct.new(env: "RAILS-ENV"))
+      expect(Ballast::Configuration.default_environment).to eq("RAILS-ENV")
+    end
+
+    it "should return the Rack environment" do
+      old_env = ENV["RACK_ENV"]
+      ENV["RACK_ENV"] = "RACK-ENV"
+
+      expect(Ballast::Configuration.default_environment).to eq("RACK-ENV")
+      ENV["RACK_ENV"] = old_env
     end
 
-    it "should load a list of sections" do
-      Ballast::Configuration.new(sections: ["section_a", "section-b"], root: "ROOT", environment: "ENV")
+    it "should fallback to production" do
+      old_env = ENV["RACK_ENV"]
+      ENV["RACK_ENV"] = nil
+
+      expect(Ballast::Configuration.default_environment).to eq("production")
+      ENV["RACK_ENV"] = old_env
     end
+  end
+
+  describe "#initialize" do
+    describe "when root and environment are defined" do
+      before(:example) do
+        expect(YAML).to receive(:load_file).with("ROOT/config/section_a.yml").and_return({"ENV" => {a: {b: 1}}, "OTHER" => {aa: 3}})
+        expect(YAML).to receive(:load_file).with("ROOT/config/section-b.yml").and_return({"ENV" => {c: {d: 2}}, "OTHER" => {cc: 4}})
+      end
+
+      it "should load a list of sections" do
+        Ballast::Configuration.new("section_a", "section-b", root: "ROOT", environment: "ENV")
+      end
 
-    it "should only load specific environment" do
-      subject = Ballast::Configuration.new(sections: ["section_a", "section-b"], root: "ROOT", environment: "ENV")
-      expect(subject["section_a"].keys).to eq(["a"])
-      expect(subject["section_b"].keys).to eq(["c"])
+      it "should only load specific environment" do
+        subject = Ballast::Configuration.new("section_a", "section-b", root: "ROOT", environment: "ENV")
+        expect(subject["section_a"].keys).to eq(["a"])
+        expect(subject["section_b"].keys).to eq(["c"])
+      end
     end
 
-    it "should enable dotted access" do
-      subject = Ballast::Configuration.new(sections: ["section_a", "section-b"], root: "ROOT", environment: "ENV")
+    describe "when root and environment are NOT defined, it should autodetect root and environment" do
+      around(:example) do |example|
+        old_env = ENV["RACK_ENV"]
+        ENV["RACK_ENV"] = nil
+
+        example.call
+
+        ENV["RACK_ENV"] = old_env
+      end
+
+      it "should enable dotted access" do
+        expect(YAML).to receive(:load_file).with("#{Dir.pwd}/config/section_a.yml").and_return({"production" => {a: {b: 1}}, "OTHER" => {aa: 3}})
+        expect(YAML).to receive(:load_file).with("#{Dir.pwd}/config/section-b.yml").and_return({"production" => {c: {d: 2}}, "OTHER" => {cc: 4}})
+
+        subject = Ballast::Configuration.new("section_a", "section-b")
 
-      expect(subject.section_a.a.b).to eq(1)
-      expect(subject.section_b.c).to eq({"d" => 2})
-      expect { subject.section_a.e }.to raise_error(NoMethodError)
-      expect { subject.e }.to raise_error(NoMethodError)
+        expect(subject.section_a.a.b).to eq(1)
+        expect(subject.section_b.c).to eq({"d" => 2})
+        expect { subject.section_a.e }.to raise_error(NoMethodError)
+        expect { subject.e }.to raise_error(NoMethodError)
+      end
     end
   end
 end

data/spec/ballast/emoji_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe Ballast::Emoji do
+  before(:example) do
+    ::Emoji.instance_variable_set(:@replace_regex, nil)
+  end
+
+  shared_examples_for(:dummy_url) do
+    before(:example) do
+      ::Emoji.url_mapper = ->(url) { "URL/#{url}" }
+    end
+  end
+
+  describe ".replace_regex" do
+    it "should return the right regexp" do
+      allow(::Emoji).to receive(:unicodes_index).and_return({a: 1, b: 2})
+      expect(::Emoji.replace_regex).to eq(/(a|b)/)
+    end
+  end
+
+  describe ".replace" do
+    include_examples :dummy_url
+
+    it "should return unicode replaced using the requested method" do
+      expect(::Emoji.replace("Phone: \u{1F4F1}, Cat: \u{1F431}, #1: \u{0031}\u{20e3}, Invalid: \u{0000}.", mode: :markup)).to eq("Phone: :iphone:, Cat: :cat:, #1: 1⃣, Invalid: \u0000.")
+      expect(Emoji.replace("Phone: \u{1F4F1}, Cat: \u{1F431}, #1: \u{0031}\u{20e3}, Invalid: \u{0000}.", mode: :url)).to eq("Phone: URL/unicode/1f4f1.png, Cat: URL/unicode/1f431.png, #1: 1⃣, Invalid: \u0000.")
+      expect(Emoji.replace("Phone: \u{1F4F1}, Cat: \u{1F431}, #1: \u{0031}\u{20e3}, Invalid: \u{0000}.", mode: :image_tag, rel: :tooltip)).to eq("Phone: <img alt=\":iphone:\" class=\"emoji\" rel=\"tooltip\" src=\"URL/unicode/1f4f1.png\" title=\":iphone:\" />, Cat: <img alt=\":cat:\" class=\"emoji\" rel=\"tooltip\" src=\"URL/unicode/1f431.png\" title=\":cat:\" />, #1: 1⃣, Invalid: \u0000.")
+    end
+  
+    it "should fallback to markup when the method is not valid" do
+      expect(Emoji.replace("Phone: \u{1F4F1}, Cat: \u{1F431}, #1: \u{0031}\u{20e3}, Invalid: \u{0000}.", mode: :invalid)).to eq("Phone: :iphone:, Cat: :cat:, #1: 1⃣, Invalid: \u0000.")
+    end
+  end
+
+  describe ".enumerate" do
+    include_examples :dummy_url
+
+    it "should enumerate all the available icons" do
+      expect(Emoji.enumerate(keys_method: :raw, values_method: :url)["\u{1f604}"]).to eq("URL/unicode/1f604.png")
+      expect(Emoji.enumerate(values_method: :image_tag, rel: :tooltip)[":smile:"]).to eq("<img alt=\":smile:\" class=\"emoji\" rel=\"tooltip\" src=\"URL/unicode/1f604.png\" title=\":smile:\" />")
+    end
+  end
+
+  describe ".url_mapper=" do
+    it "should set the new mapper" do
+      ::Emoji.url_mapper = "A"
+      expect(::Emoji.url_mapper).to eq("A")
+      ::Emoji.url_mapper = nil
+    end
+  end
+
+  describe ".url_mapper" do
+    it "should return a default mapper" do
+      ::Emoji.url_mapper = nil
+      expect(::Emoji.url_mapper.call("URL")).to eq("URL")
+    end
+
+    it "should use the specified mapper" do
+      ::Emoji.url_mapper = ->(url) { url * 2 }
+      expect(::Emoji.url_mapper.call("URL")).to eq("URLURL")
+    end
+  end
+
+  describe ".url_for" do
+    it "should return an absolute URL for an image, using the URL mapper" do
+      ::Emoji.url_mapper = nil
+      expect(::Emoji.url_for("URL")).to eq("URL")
+
+      ::Emoji.url_mapper = ->(url) { url * 2 }
+      expect(::Emoji.url_for("URL")).to eq("URLURL")
+
+      ::Emoji.url_mapper = nil
+    end
+  end
+
+  describe "#markup" do
+    it "should return the markup" do
+      expect(Emoji.find_by_alias("cat").markup).to eq(":cat:")
+      expect(Emoji.find_by_alias("dog").markup).to eq(":dog:")
+      expect(Emoji.find_by_unicode("\u{1F430}").markup).to eq(":rabbit:")
+    end
+  end
+
+  describe "#url" do
+    include_examples :dummy_url
+
+    it "should return the URL/" do
+      expect(Emoji.find_by_alias("cat").url).to eq("URL/unicode/1f431.png")
+      expect(Emoji.find_by_alias("dog").url).to eq("URL/unicode/1f436.png")
+      expect(Emoji.find_by_unicode("\u{1F430}").url).to eq("URL/unicode/1f430.png")
+    end
+  end
+
+  describe "#image_tag" do
+    include_examples :dummy_url
+
+    it "should return an image" do
+      expect(Emoji.find_by_alias("cat").image_tag).to eq("<img alt=\":cat:\" class=\"emoji\" rel=\"tooltip\" src=\"URL/unicode/1f431.png\" title=\":cat:\" />")
+      expect(Emoji.find_by_alias("cat").image_tag(class: "foo")).to eq("<img alt=\":cat:\" class=\"foo emoji\" rel=\"tooltip\" src=\"URL/unicode/1f431.png\" title=\":cat:\" />")
+      expect(Emoji.find_by_alias("cat").image_tag(rel: "tooltip1", class: "abc emoji")).to eq("<img alt=\":cat:\" class=\"abc emoji\" rel=\"tooltip1\" src=\"URL/unicode/1f431.png\" title=\":cat:\" />")
+    end
+  end
+end

data/spec/ballast/errors_spec.rb

@@ -5,13 +5,13 @@
 
 require "spec_helper"
 
-describe Ballast::Errors::BaseError do
-  subject { Ballast::Errors::BaseError.new("ERROR") }
+describe Ballast::Errors::Base do
+  subject { Ballast::Errors::Base.new("ERROR") }
 
   describe ".initialize" do
-    it "should propagate the message also as a response" do
-      expect(subject.message).to eq("ERROR")
-      expect(subject.response).to eq("ERROR")
+    it "should save the details" do
+      expect(subject.message).to eq("")
+      expect(subject.details).to eq("ERROR")
     end
   end
 end

data/spec/ballast/middlewares/default_host_spec.rb

@@ -17,15 +17,14 @@ describe Ballast::Middlewares::DefaultHost do
   end
 
   describe "#call" do
-    before(:each) do
-      @app = Proc.new { |env| env }
+    before(:example) do
       expect(YAML).to receive(:load_file).with("PATH").and_return({"production" => "HOST"})
-      ENV["RACK_ENV"] = "production"
     end
 
-    subject { Ballast::Middlewares::DefaultHost.new(@app, "PATH") }
+    subject { Ballast::Middlewares::DefaultHost.new(Proc.new { |env| env }, "PATH") }
 
     it "should correctly replace the IP if the environment is found" do
+      ENV["RACK_ENV"] = "production"
       expect(subject.call({"SERVER_NAME" => "10.0.0.1", "HTTP_HOST" => "10.0.0.1"})).to eq({"SERVER_NAME" => "HOST", "HTTP_HOST" => "HOST", "ORIG_SERVER_NAME" => "10.0.0.1", "ORIG_HTTP_HOST" => "10.0.0.1"})
     end
 
@@ -36,7 +35,6 @@ describe Ballast::Middlewares::DefaultHost do
 
     it "should not replace a non IP host" do
       expect(subject.call({"SERVER_NAME" => "abc", "HTTP_HOST" => "cde"})).to eq({"SERVER_NAME" => "abc", "HTTP_HOST" => "cde"})
-
     end
   end
 end

data/spec/ballast/request_domain_matcher_spec.rb

@@ -21,11 +21,11 @@ describe Ballast::RequestDomainMatcher do
     subject { Ballast::RequestDomainMatcher.new(["A", "ABB", "AC"], "B", "C") { |a| a * 2 } }
 
     it "should correctly match a request" do
-      expect(subject.matches?(OpenStruct.new(host: "A"))).to be_true
-      expect(subject.matches?(OpenStruct.new(host: "AB"))).to be_true
+      expect(subject.matches?(OpenStruct.new(host: "A"))).to be_truthy
+      expect(subject.matches?(OpenStruct.new(host: "AB"))).to be_truthy
       subject.replace_block = nil
-      expect(subject.matches?(OpenStruct.new(host: "AB"))).to be_true
-      expect(subject.matches?(OpenStruct.new(host: "DD"))).to be_false
+      expect(subject.matches?(OpenStruct.new(host: "AB"))).to be_truthy
+      expect(subject.matches?(OpenStruct.new(host: "DD"))).to be_falsey
     end
   end
 end

data/spec/ballast/service_spec.rb

@@ -0,0 +1,137 @@
+require "spec_helper"
+
+describe Ballast::Service::Response do
+  describe "#initialize" do
+    it "should save attributes" do
+      subject = Ballast::Service::Response.new("STATUS", data: "DATA", errors: "ERRORS")
+      expect(subject.success).to be_falsey
+      expect(subject.data).to eq("DATA")
+      expect(subject.errors).to eq(["ERRORS"])
+    end
+  end
+
+  describe "#success?" do
+    it "should return if the operation succeeded" do
+      expect(Ballast::Service::Response.new(true).success?).to be_truthy
+      expect(Ballast::Service::Response.new(false).success?).to be_falsey
+    end
+  end
+
+  describe "#fail?" do
+    it "should return if the operation failed" do
+      expect(Ballast::Service::Response.new(true).fail?).to be_falsey
+      expect(Ballast::Service::Response.new(false).fail?).to be_truthy
+    end
+  end
+
+  describe "#error" do
+    it "should return the first error" do
+      expect(Ballast::Service::Response.new(true, errors: ["A", "B"]).error).to eq("A")
+      expect(Ballast::Service::Response.new(true).error).to be_nil
+    end
+  end
+
+  describe "as_ajax_response" do
+    it "should create the right response" do
+      expect(Ballast::AjaxResponse).to receive(:new).with(status: :ok, data: "DATA", error: nil)
+      Ballast::Service::Response.new(true, data: "DATA", errors: "ERRORS").as_ajax_response
+
+      expect(Ballast::AjaxResponse).to receive(:new).with(status: 403, data: "DATA", error: "ERROR")
+      Ballast::Service::Response.new(false, data: "DATA", errors: {status: 403, error: "ERROR"}).as_ajax_response
+
+      expect(Ballast::AjaxResponse).to receive(:new).with(status: :unknown, data: "DATA", error: "ERROR")
+      Ballast::Service::Response.new(false, data: "DATA", errors: "ERROR").as_ajax_response
+    end
+  end
+end
+
+describe Ballast::Service do
+  class DummyService < Ballast::Service
+    def self.class_success(owner: nil, params: nil, **kwargs)
+      "CLASS_DATA"
+    end
+
+    def self.class_failure(**_)
+      fail!("NO")
+    end
+
+    def instance_success(params: nil, **kwargs)
+      self
+    end
+
+    def instance_failure
+      fail!("NO")
+    end
+  end
+
+  describe ".call" do
+    it "should call the service and return its return value as data of a service response" do
+      expect(DummyService).to receive(:class_success).with({owner: "OWNER", params: {a: 1, b: 2}, other: 1}).and_call_original
+      response = DummyService.call(:class_success, owner: "OWNER", params: {a: 1, b: 2}, other: 1)
+      expect(response).to be_a(Ballast::Service::Response)
+      expect(response.success?).to be_truthy
+      expect(response.data).to eq("CLASS_DATA")
+    end
+
+    it "should fail when the operation is not supported" do
+      response = DummyService.call(:class_unknown)
+      expect(response).to be_a(Ballast::Service::Response)
+      expect(response.failed?).to be_truthy
+      expect(response.data).to be_nil
+      expect(response.error).to eq({status: 501, error: "Unsupported operation DummyService.class_unknown."})
+    end
+
+    it "should raise an exception when the invocation failed and it is asked to" do
+      expect { DummyService.call(:class_failure, raise_errors: true) }.to raise_error(Ballast::Errors::Failure)
+    end
+  end
+
+  describe ".fail!" do
+    it "should raise a failure" do
+      expect { DummyService.fail!("DETAILS") }.to raise_error(Ballast::Errors::Failure)
+    end
+
+    it "should raise a validation failure" do
+      expect { DummyService.fail!("DETAILS", on_validation: true) }.to raise_error(Ballast::Errors::ValidationFailure)
+    end
+  end
+
+  describe "#initialize" do
+    it "should save the onwer" do
+      expect(DummyService.new("OWNER").owner).to eq("OWNER")
+    end
+  end
+
+  describe "#call" do
+    it "should update the owner, then call the service and return its return value as data of a service response" do
+      expect_any_instance_of(DummyService).to receive(:instance_success).with({params: {a: 1, b: 2}, other: 1}).and_call_original
+      response = DummyService.new.call(:instance_success, owner: "OWNER", params: {a: 1, b: 2}, other: 1)
+      expect(response).to be_a(Ballast::Service::Response)
+      expect(response.success?).to be_truthy
+      expect(response.data).to be_a(DummyService)
+      expect(response.data.owner).to eq("OWNER")
+    end
+
+    it "should fail when the operation is not supported" do
+      response = DummyService.new.call(:class_unknown)
+      expect(response).to be_a(Ballast::Service::Response)
+      expect(response.failed?).to be_truthy
+      expect(response.data).to be_nil
+      expect(response.error).to eq({status: 501, error: "Unsupported operation DummyService#class_unknown."})
+    end
+
+    it "should raise an exception when the invocation failed and it is asked to" do
+      expect { DummyService.new.call(:class_failure, raise_errors: true) }.to raise_error(Ballast::Errors::Failure)
+    end
+  end
+
+  describe "#fail!" do
+    it "should forward to the class level implementation" do
+      allow_any_instance_of(DummyService).to receive(:perform)
+
+      expect(DummyService).to receive(:fail!).with("ERRORS", on_validation: "ON VALIDATION")
+
+      DummyService.new.fail!("ERRORS", on_validation: "ON VALIDATION")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,17 +3,5 @@
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
 #
 
-require "rubygems"
-require "spork"
-require "rspec"
 require "bundler/setup"
-require "ballast"
-
-Spork.prefork do
-end
-
-RSpec.configure do |config|
-  config.expect_with(:rspec) do |c|
-    c.syntax = :expect
-  end
-end
+require File.dirname(__FILE__) + "/../lib/ballast"