fetch 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a10520fb3d8cc9508aef80fe19c88dd4b5b72a71
-  data.tar.gz: cc19fba644b2236f5833f312bf002b495258caf7
+  metadata.gz: 538eaf280947e75a0999edfea670488a353d6c0d
+  data.tar.gz: 39ebdb1b870ef7afd28d278ada14f84bb338f859
 SHA512:
-  metadata.gz: 4b23e3bb9c6e49e85d07e37791d46343d5f36467dc279498a9da855ff8580ce3e0df3515bbf58b17222b7b013ee1be5619ec6af746fc7607c573ced140abc07b
-  data.tar.gz: 3239bdfb8eb3ce1855efcad29227fa59ff0c23893781da47b85cae867440edc1e99d35188777e482b3764ec5853b81313b0d604a61e0324d0dae52dc2b192111
+  metadata.gz: dd5d3fe051dcdf0582ac359c3865e40a048bca131e1479070491c2a93b28f23aa18be31a126fca6a4d94c340a82a2b6ea14f3596b93bb66c870d4d2151b3510e
+  data.tar.gz: e75ed279223063297541ef88f4feedd8cb805c4ec50c7c2f6fba9bc59157d5366cd73b674369299717e8833016367202a078c9d0fde6efd3238c4ffe0f6f605f

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## Version 0.0.5
+
+* The `after_fetch` callbacks are run in the reverse order of which they were
+  defined.
+
 ## Version 0.0.4
 
 * Exceptions are raised after the general `Fetch::Base` `error` callback is

data/README.md

@@ -107,6 +107,52 @@ repos.
 
 ## Good to know
 
+### Doing something before a fetch
+
+If you need to run something before a fetch is started, you can do it using the
+`before_fetch` callback.
+
+```ruby
+class UserFetcher < Fetch::Module
+  modules Facebook::UserInfoFetch,
+          Github::UserInfoFetch
+
+  before_fetch do
+    # Do something before the fetch.
+  end
+end
+
+user = User.find(123)
+UserFetcher.new(user).fetch
+# => `before_fetch` is run before fetching
+```
+
+**Note:** If you define more than one `before_fetch` callback, they are run in the order
+in which they were defined.
+
+### Doing something after a fetch
+
+If you need to run something after a fetch is completed, you can do it using
+the `after_fetch` callback.
+
+```ruby
+class UserFetcher < Fetch::Module
+  modules Facebook::UserInfoFetch,
+          Github::UserInfoFetch
+
+  after_fetch do
+    # Do something after the fetch has completed.
+  end
+end
+
+user = User.find(123)
+UserFetcher.new(user).fetch
+# => `after_fetch` is run after fetching
+```
+
+**Note:** If you define more than one `after_fetch` callback, they are run in
+the *reverse* order of which they were defined.
+
 ### Adding defaults to your requests
 
 Each fetch module has a `defaults` callback that you can use to set up defaults

data/lib/fetch/base.rb

@@ -20,10 +20,11 @@ module Fetch
                     :load,
                     :init,
                     :before_fetch,
-                    :after_fetch,
                     :progress,
                     :error
 
+    define_callback :after_fetch, reverse: true
+
     def initialize(fetchable = nil)
       @fetchable = fetchable
     end

data/lib/fetch/callbacks.rb

@@ -15,19 +15,25 @@ module Fetch
     #
     #   run_callbacks_for(:before_fetch)
     #   run_callbacks_for(:progress, 12) # 12 percent done
-    def run_callbacks_for(name, *args)
-      self.class.callbacks[name].map do |block|
-        run_callback(*args, &block)
+    def run_callbacks_for(name, args, reverse)
+      callbacks_for(name, reverse).map do |block|
+        run_callback(block, args)
       end
     end
 
-    def run_last_callback_for(name, *args)
-      if callback = self.class.callbacks[name].last
-        run_callback(*args, &callback)
+    def run_last_callback_for(name, args, reverse)
+      if block = callbacks_for(name, reverse).last
+        run_callback(block, args)
       end
     end
 
-    def run_callback(*args, &block)
+    def callbacks_for(name, reverse)
+      callbacks = self.class.callbacks[name]
+      callbacks = callbacks.reverse if reverse
+      callbacks
+    end
+
+    def run_callback(block, args)
       instance_exec(*args, &block)
     end
 
@@ -39,17 +45,20 @@ module Fetch
 
       # Defines callback methods on the class level.
       def define_callback(*names)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+        reverse = !!options[:reverse]
+
         names.each do |name|
           define_singleton_method name do |*values, &block|
-            create_callback_for(name, *values, &block)
+            create_callback_for(name, values, block)
           end
 
           define_method name do |*args|
-            run_callbacks_for(name, *args).last
+            run_callbacks_for(name, args, reverse).last
           end
 
           define_method "#{name}!" do |*args|
-            run_last_callback_for(name, *args)
+            run_last_callback_for(name, args, reverse)
           end
         end
       end
@@ -63,12 +72,12 @@ module Fetch
 
       private
 
-      def create_callback_for(name, *values, &block)
-        add_callback(name) { values } if values.any?
-        add_callback(name, &block) if block
+      def create_callback_for(name, values, block)
+        add_callback(name, ->{ values }) if values.any?
+        add_callback(name, block) if block
       end
 
-      def add_callback(name, &block)
+      def add_callback(name, block)
         callbacks[name] << block
       end
     end

data/lib/fetch/version.rb

@@ -1,3 +1,3 @@
 module Fetch
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/test/base/after_fetch_test.rb

@@ -0,0 +1,13 @@
+require "test_helper"
+
+class AfterFetchTest < Minitest::Test
+  def test_after_fetch_runs_when_fetching
+    actions = []
+    klass = Class.new(Fetch::Base) do
+      after_fetch { actions << "first after" }
+      after_fetch { actions << "second after" }
+    end
+    klass.new.fetch
+    assert_equal ["second after", "first after"], actions
+  end
+end

data/test/base/base_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+class BaseTest < Minitest::Test
+  def test_sends_fetchable_to_modules
+    stub_request(:get, "https://api.github.com/users/lassebunk").to_return(body: "id: 1234")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "https://api.github.com/users/#{fetchable.login}"
+        req.process do |body|
+          actions << "process: #{body}"
+        end
+      end
+    end
+    user = OpenStruct.new(login: "lassebunk")
+    MockFetcher(mod).new(user).fetch
+    assert_equal ["process: id: 1234"], actions
+  end
+end

data/test/base/before_fetch_test.rb

@@ -0,0 +1,13 @@
+require "test_helper"
+
+class BeforeFetchTest < Minitest::Test
+  def test_before_fetch_runs_when_fetching
+    actions = []
+    klass = Class.new(Fetch::Base) do
+      before_fetch { actions << "first before" }
+      before_fetch { actions << "second before" }
+    end
+    klass.new.fetch
+    assert_equal ["first before", "second before"], actions
+  end
+end

data/test/base/progress_test.rb

@@ -0,0 +1,95 @@
+require "test_helper"
+
+class ProgressTest < Minitest::Test
+  def test_progress_with_single_module
+    stub_request(:get, "http://test.com/one").to_return(body: "got one")
+
+    mod = Class.new(Fetch::Module) do
+      3.times do
+        request do |req|
+          req.url = "http://test.com/one"
+        end
+      end
+    end
+
+    updates = []
+
+    klass = Class.new(MockFetcher(mod)) do
+      progress do |percent|
+        updates << percent
+      end
+    end
+
+    klass.new.fetch
+    assert_equal [0, 33, 66, 100], updates
+  end
+
+  def test_progress_with_multiple_modules
+    stub_request(:get, "http://test.com/one").to_return(body: "got one")
+
+    mods = 3.times.map do
+      Class.new(Fetch::Module) do
+        2.times do
+          request do |req|
+            req.url = "http://test.com/one"
+          end
+        end
+      end
+    end
+
+    updates = []
+
+    klass = Class.new(MockFetcher(mods)) do
+      progress do |percent|
+        updates << percent
+      end
+    end
+
+    klass.new.fetch
+    assert_equal [0, 16, 33, 50, 66, 83, 100], updates
+  end
+
+  def test_progress_with_http_failure
+    stub_request(:get, "http://test.com/one").to_return(body: "something went wrong", status: 500)
+    updates = []
+    mods = 3.times.map do
+      Class.new(Fetch::Module) do
+        request do |req|
+          req.url = "http://test.com/one"
+        end
+      end
+    end
+    klass = Class.new(MockFetcher(mods)) do
+      progress do |percent|
+        updates << percent
+      end
+    end
+
+    klass.new.fetch
+    assert_equal [0, 33, 66, 100], updates
+  end
+
+  def test_progress_with_handled_process_error
+    stub_request(:get, "http://test.com/one").to_return(body: "ok")
+    updates = []
+    mods = 3.times.map do
+      Class.new(Fetch::Module) do
+        request do |req|
+          req.url = "http://test.com/one"
+          req.process do |body|
+            wont_work
+          end
+          req.error { }
+        end
+      end
+    end
+    klass = Class.new(MockFetcher(mods)) do
+      progress do |percent|
+        updates << percent
+      end
+    end
+
+    klass.new.fetch
+    assert_equal [0, 33, 66, 100], updates
+  end
+end

data/test/callbacks_test.rb

@@ -1,6 +1,6 @@
 require "test_helper"
 
-class CallbackTest < Minitest::Test
+class Test < Minitest::Test
   def test_callbacks
     actions = []
     klass = Class.new do
@@ -42,6 +42,38 @@ class CallbackTest < Minitest::Test
     assert_equal "second", klass.new.before
   end
 
+  def test_bang_method_only_runs_last_callback
+    klass = Class.new do
+      include Fetch::Callbacks
+      define_callback :before
+      before { this_shouldnt_be_run! }
+      before { "ok" }
+    end
+    assert_equal "ok", klass.new.before!
+  end
+
+  def test_callbacks_can_run_in_reverse_order
+    actions = []
+    klass = Class.new do
+      include Fetch::Callbacks
+      define_callback :after, reverse: true
+      after { actions << "first after" }
+      after { actions << "second after" }
+    end
+    klass.new.after
+    assert_equal ["second after", "first after"], actions
+  end
+
+  def test_reversed_bang_method_runs_only_first_callback
+    klass = Class.new do
+      include Fetch::Callbacks
+      define_callback :after, reverse: true
+      after { "first one defined" }
+      after { this_cant_run! }
+    end    
+    assert_equal "first one defined", klass.new.after!
+  end
+
   def test_callbacks_take_optional_arguments
     actions = []
     klass = Class.new do

data/test/module/after_process_test.rb

@@ -0,0 +1,104 @@
+require "test_helper"
+
+class AfterProcessTest < Minitest::Test
+  def test_after_process_callback_set_in_request
+    words = %w{one two}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    
+    stub_request(:get, "http://test.com/two").to_return(body: "got two")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      words.each do |word|
+        request do |req|
+          req.url = "http://test.com/#{word}"
+          req.after_process do
+            actions << "after process #{word}"
+          end
+          req.process do |body|
+            actions << "process #{word}"
+          end
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["process one", "after process one", "process two", "after process two"], actions
+  end
+
+  def test_after_process_callback_scope_set_in_request
+    words = %w{one two}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    
+    stub_request(:get, "http://test.com/two").to_return(body: "got two")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      words.each do |word|
+        request do |req|
+          req.url = "http://test.com/#{word}"
+          req.after_process do
+            actions << "after process #{word} (#{some_instance_method})"
+          end
+          req.process do |body|
+            actions << "process #{word}"
+          end
+        end
+      end
+      def some_instance_method
+        "ok"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["process one", "after process one (ok)", "process two", "after process two (ok)"], actions
+  end
+
+  def test_after_process_callback_set_in_module
+    words = %w{one two}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    
+    stub_request(:get, "http://test.com/two").to_return(body: "got two")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      words.each do |word|
+        request do |req|
+          req.url = "http://test.com/#{word}"
+          req.process do |body|
+            actions << "process #{word}"
+          end
+        end
+      end
+
+      after_process do
+        actions << "after process"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["process one", "after process", "process two", "after process"], actions
+  end
+
+  def test_after_process_callback_scope_set_in_module
+    words = %w{one two}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    
+    stub_request(:get, "http://test.com/two").to_return(body: "got two")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      words.each do |word|
+        request do |req|
+          req.url = "http://test.com/#{word}"
+          req.process do |body|
+            actions << "process #{word}"
+          end
+        end
+      end
+
+      after_process do
+        actions << "after process (#{some_instance_method})"
+      end
+
+      def some_instance_method
+        "ok"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["process one", "after process (ok)", "process two", "after process (ok)"], actions
+  end
+end