saki 0.0.3 → 0.0.4

data/README.markdown

@@ -1,8 +1,8 @@
 # Saki - For times when you can't swallow Cucumber
 
-Saki lets you do acceptance testing on top of RSpec.  It is considerably more terse than cucumber, but does not sacrifice readability.
+Saki lets you do acceptance testing on top of RSpec.  It is considerably more terse than Cucumber, but does not sacrifice readability.  Saki also does not use Given/When/Then syntax because the thought is that there is little return other than familiarity for Cucumber users.
 
-Are you tired of having DRY code, but tests that seem to babble on "for the length of a bible"?  Me too.  How about RSpec code that is hard to follow, when Ruby itself is as "human" as a programming language can get?  I hate it too.
+Are you tired of having DRY code, but tests that seem to babble on "for the length of a bible"?  Me too.  How about RSpec code that is hard to follow, when Ruby itself is simple to follow?  I hate it too.
 
 Enter Saki stage left.
 
@@ -12,33 +12,70 @@ Well, here's a sample that sets up contexts that create a user and then visit an
 
 	with_existing :user do
 		on_visiting edit_path_for(:user) do
-			it { should yadda.yadda }
+			it { should let_me_edit(@user) }
 		end
 	end
 
 This code basically injects some "before blocks", so it would look like this in vanilla RSpec:
 
-	context "when a user exists" do
+	context "a user exists" do
 		before { @user = Factory :user }
-		context "when I visit the page for editing that user" do
+		context "I visit the page for editing that user" do
 			before { visit edit_user_path(:user) }
-    		it {should yadda.yadda}
+			it { should let_me_edit(@user) }
   		end
 	end
 
-I feel Saki is much more expressive.
+I believe the Saki example has the following benefits:
+
+* It saves two lines of code.
+* It standardizes the code.  Whereas a context string might accidentally get out of sync with the code (unmaintained comments, anyone), with Saki this would probably cause a test to fail.
+* It is much more expressive.  You read the test and you immediately know what it does.
+* Any exceptions to the rule (complicated setups, etc.) now stick out like sore thumbs, as they should.
+
+The only assumption is that you are using factories instead of fixtures.  You also get more out of it in a conventional RESTful application.
 
 ## What class-level methods does it use (for setting up contexts)?
 
-`with_existing` takes a factory name as a symbol and assigns it to on instance variable with the same name.
+`with_existing` takes a factory name as a symbol and assigns its created object to on instance variable with the same name.
+
+`on_visiting` takes a path as a string, or a lambda that executes within a before block to set up the path.  It also takes a symbol which is the name of a method name.  This is useful when the code is dependent on an instance variable for path creation.
+
+    path_for_user = lambda { user_path(@user) }
 
-`on_visiting` takes a path either as a string or as a lambda that executes within a before block to set up the path.  This is useful when the code is dependent on an instance variable for path creation.
+    on_visiting path_for_user do ...
+
+or you can do
+
+    def my_user_path
+        user_path(@user)
+    end
+
+    on_visiting :my_user_path do ...
 
 `on_visiting` has several helper functions for establishing a path: `create_path_for`, `index_path_for`, `edit_path_for`, `show_path_for` and `new_path_for`.  These paths all take resource names for establishing a path.  In cases where the resource is nested, it has a :parent => parent_resource option.  This lets you set up blocks like:
 
     on_visiting index_path_for(:auction)
 
-`where` is a function taking as a parameter either a lambda to execute in the before block, or a symbol which is the name of a function to execute in the before block.
+`on_following_link_to` works the same as on_visiting, but it first validates that the link exists, and then follows it.
+
+`where` is a function taking as a parameter lambda to execute in the before block.
+
+    def self.creating_a_user
+        lambda {
+            @user = Factory.build @user
+            fill_in "user[email]", :with => @user.email
+            click_button "Create"
+        }
+    end
+
+    on_following_link_to create_path_for(:user) do
+        where creating_a_user do
+            specify { page.should have_content(@user.email) }
+        end
+    end
+
+Obviously the return for this is where you have functions acting as "reusable steps" in the style of Cucumber.  In addition your "before blocks" are more expressive.
 
 Finally, to simplify setting up integration tests, anything you wrap in an `integrate` block (like `describe`) sets the test type to acceptance.
 
@@ -58,6 +95,14 @@ Then, as long as your acceptance specs require the acceptance_helper file you sh
 
 It assumes that you are using factory_girl and capybara or webrat, though it probably would work fine with other test factories.  If you need another factory in the mix, just redefine the `default_factory` method to behave how you want.
 
+## References
+
+The motivation behind my migration from Cucumber and to Saki, are described in blog posts [Encumbered by Cucumber](http://ludicast.com/articles/1), [Introducing Saki](http://ludicast.com/articles/2).
+
+## Thanks
+
+The generators are stolen directly from Steak with some minor adjustments.
+
 ## Note on Patches/Pull Requests
  
 * Fork the project.

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/saki.rb

@@ -8,6 +8,16 @@ module Saki
       Factory name
     end
 
+    def get_path(path)
+      if path.is_a? String
+        path
+      elsif path.is_a? Symbol
+        send path
+      else
+        path.call(self)
+      end
+    end
+
     def add_opts(link, opts)
       if opts[:parent]
         link = "/#{opts[:parent].class.to_s.tableize}/#{opts[:parent].id}" + link
@@ -56,6 +66,10 @@ module Saki
       end
     end    
 
+    def index_path_for(model)
+      "/#{model}"
+    end
+
 
     module ClassMethods
       def with_existing resource, &block
@@ -68,11 +82,7 @@ module Saki
       def on_following_link_to path, &block
         context "on following link" do
           before do
-            if path.is_a? String
-              path = path
-            else
-              path =  path.call(self)
-            end
+            path = get_path(path)
             has_link(path)
             visit path
           end
@@ -83,11 +93,7 @@ module Saki
       def on_visiting path, &block
         context "on visiting" do
           before do
-            if path.is_a? String
-              visit path
-            else
-              visit path.call(self)
-            end
+            visit get_path(path)
           end
           module_eval &block
         end
@@ -106,7 +112,7 @@ module Saki
           add_opts "/#{resource.to_s.pluralize}/#{(context.instance_variable_get('@' + resource.to_s)).id}/edit", opts, context
         end
       end
-
+      
       def show_path_for(resource, opts = {})
         lambda do |context|
           add_opts "/#{resource.to_s.pluralize}/#{(context.instance_variable_get('@' + resource.to_s)).id}", opts, context
@@ -125,13 +131,9 @@ module Saki
         end
       end
 
-      def where(executable, &block)
+      def where(executable, *opts, &block)
         context "anonymous closure" do
-          if executable.is_a? Symbol
-            before { send executable }
-          else
-            before { instance_eval &executable }
-          end
+          before { instance_eval &executable }
           module_eval &block
         end
       end
@@ -139,6 +141,18 @@ module Saki
   end
 end
 
+class RSpec::Core::ExampleGroup
+      def method_missing(methId)
+        str = methId.id2name
+        if str.match /(.*)_path/
+          index_path_for($1)
+        else
+          super(methId, [])
+        end
+
+      end
+end
+
 module RSpec::Core::ObjectExtensions
   def integrate(*args, &block)
     args << {} unless args.last.is_a?(Hash)

data/saki.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{saki}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nate Kidwell"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: saki
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Nate Kidwell