em-dextras 0.2.0 → 0.3.0

data/.gitignore

@@ -7,7 +7,6 @@ Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
-doc/
 lib/bundler/man
 pkg
 rdoc

data/doc/samples/worldbank/fetch_indicator.rb

@@ -0,0 +1,16 @@
+class FetchIndicator
+  def initialize(indicator)
+    @indicator = indicator
+  end
+
+  def todo(country)
+    id = country["id"]
+    http = EventMachine::HttpRequest.new(indicator_url(id), :connect_timeout => 2, :inactivity_timeout => 3)
+    http.get
+  end
+
+  private
+  def indicator_url(country_id)
+    "http://api.worldbank.org/countries/#{country_id}/indicators/#@indicator?format=json" 
+  end
+end

data/doc/samples/worldbank/fetch_list_of_countries.rb

@@ -0,0 +1,12 @@
+class FetchListOfCountries
+  def todo(no_input)
+    http = EventMachine::HttpRequest.new(list_of_countries_url, :connect_timeout => 2, :inactivity_timeout => 3)
+    http.get
+  end
+
+  private
+
+  def list_of_countries_url
+    'http://api.worldbank.org/countries?format=json'
+  end
+end

data/doc/samples/worldbank/for_gnuplot.rb

@@ -0,0 +1,9 @@
+class ForGnuplot
+  include EMDextras::Chains::SynchronousStage
+  def invoke(data_item)
+    country_code = data_item["country"]["id"]
+    date         = data_item["date"]
+    value        = data_item["value"]
+    "#{country_code}\t#{date}\t#{value}"
+  end
+end

data/doc/samples/worldbank/parse_worldbank_document.rb

@@ -0,0 +1,8 @@
+class ParseWorldbankDocument
+  include EMDextras::Chains::SynchronousStage
+  def invoke(http)
+    document_body = http.response
+    json = JSON.parse document_body
+    (json.size > 1 && json[1]) ? json[1].take(10) : []
+  end
+end

data/doc/samples/worldbank/spec/fetch_indicator_spec.rb

@@ -0,0 +1,52 @@
+require_relative './support/spec_helper'
+require_relative '../fetch_indicator'
+
+describe FetchIndicator do
+  let(:country) {
+    JSON.parse <<-EOS
+    {
+      "latitude": "-15.7801",
+      "longitude": "-47.9292",
+      "id": "BRA",
+      "iso2Code": "BR",
+      "name": "Brazil",
+      "region": {
+        "value": "Latin America & Caribbean (all income levels)",
+        "id": "LCN"
+      },
+      "adminregion": {
+        "value": "Latin America & Caribbean (developing only)",
+        "id": "LAC"
+      },
+      "incomeLevel": {
+        "value": "Upper middle income",
+        "id": "UMC"
+      },
+      "lendingType": {
+        "value": "IBRD",
+        "id": "IBD"
+      },
+      "capitalCity": "Brasilia"
+    }
+    EOS
+  }
+
+  subject { described_class.new 'SI.DST.10TH.10' }
+
+  it "should successfully request a data series for the given country" do
+    EM.run do
+      subject.todo(country).should succeed_according_to(lambda {|http|
+        http.response.should include 'Brazil'
+      })
+    end
+  end
+
+  it "the indicator requested should be the one provided" do
+    EM.run do
+      fetch = FetchIndicator.new('NY.GDP.MKTP.CD') 
+      fetch.todo(country).should succeed_according_to(lambda {|http|
+        http.response.should include 'GDP'
+      })
+    end
+  end
+end

data/doc/samples/worldbank/spec/fetch_list_of_countries_spec.rb

@@ -0,0 +1,13 @@
+require_relative './support/spec_helper'
+require_relative '../fetch_list_of_countries'
+
+describe FetchListOfCountries do
+  it "should successfully request a list of countries" do
+    EM.run do
+      subject.todo('ignored input').should succeed_according_to(lambda {|request|
+        request.response_header.status.should == 200
+        request.last_effective_url.to_s.should include 'worldbank.org'
+      })
+    end
+  end
+end

data/doc/samples/worldbank/spec/for_gnuplot_spec.rb

@@ -0,0 +1,26 @@
+require_relative './support/spec_helper'
+require_relative '../for_gnuplot'
+
+describe ForGnuplot do
+  let (:data_item) { 
+    JSON.parse <<-EOS
+      {
+        "date": "2009",
+        "decimal": "0",
+        "value": "1621661507655.08",
+        "country": {
+          "value": "Brazil",
+          "id": "BR"
+        },
+        "indicator": {
+          "value": "GDP (current US$)",
+          "id": "NY.GDP.MKTP.CD"
+        }
+      }
+    EOS
+  } 
+
+  it "prints a line with the country, date and value" do
+    subject.invoke(data_item).should == "BR\t2009\t1621661507655.08"
+  end
+end

data/doc/samples/worldbank/spec/parse_worldbank_document_spec.rb

@@ -0,0 +1,27 @@
+require_relative './support/spec_helper'
+require_relative '../parse_worldbank_document'
+
+describe ParseWorldbankDocument do
+  it "should return the second json array element" do
+    http_request = stub(:response => %Q|[{"first":"el"},["second","el"]]|)
+    subject.invoke(http_request).should == ["second","el"]
+  end
+
+  it "should only take the first 10 elements" do
+    http_request = stub(
+      :response => %Q|[{"first":"el"},[#{'"a",'*11}"a"]]|)
+    subject.invoke(http_request).should == Array.new(10, "a")
+  end
+
+  context "corner cases" do
+    it "should return an empty array if there is no second element" do
+      http_request = stub(:response => %Q|[{"first":"el"}]|)
+      subject.invoke(http_request).should == []
+    end
+
+    it "should return an empty array if the second element is empty" do
+      http_request = stub(:response => %Q|[{"first":"el"},[]]|)
+      subject.invoke(http_request).should == []
+    end
+  end
+end

data/doc/samples/worldbank/spec/support/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'em-http-request'
+require 'em-dextras'
+require 'em-dextras/spec'
+require 'json'

data/doc/samples/worldbank/worldbank.rb

@@ -0,0 +1,44 @@
+#! /usr/bin/env ruby
+
+require 'bundler/setup'
+require 'eventmachine'
+require 'em-http-request'
+require 'em-dextras'
+require 'json'
+
+require_relative './fetch_list_of_countries'
+require_relative './parse_worldbank_document'
+require_relative './fetch_indicator'
+require_relative './for_gnuplot'
+
+INCOME_SHARE_BY_TOP_10PC = 'SI.DST.10TH.10'
+
+class Monitoring
+  def end_of_chain!(value)
+    EM.stop
+  end
+
+  def inform_exception!(exception, stage)
+    STDERR.puts "Error: #{exception} #{exception.backtrace.join("\n") if exception.respond_to?(:backtrace)}"
+  end
+end
+
+class Print
+  include EMDextras::Chains::SynchronousStage
+  def invoke(input)
+    puts input
+  end
+end
+
+EM.run do
+  EMDextras::Chains.pipe('no input', Monitoring.new, [
+    FetchListOfCountries.new,
+    ParseWorldbankDocument.new,
+    :split,
+    FetchIndicator.new(INCOME_SHARE_BY_TOP_10PC),
+    ParseWorldbankDocument.new,
+    :split,
+    ForGnuplot.new,
+    Print.new
+  ], debug: true)
+end

data/em-dextras.gemspec

@@ -21,4 +21,8 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency("guard")
   gem.add_development_dependency("guard-rspec")
   gem.add_development_dependency("rb-inotify")
+
+  #for samples
+  gem.add_development_dependency("em-http-request")
+  gem.add_development_dependency("webmock")
 end

data/lib/em-dextras/chains.rb

@@ -1,11 +1,74 @@
 module EMDextras
   module Chains
+
+    class JoinedDeferrable
+      include EventMachine::Deferrable
+
+      def initialize(deferrables)
+        result_pairs = deferrables.map do |deferrable|
+          [deferrable, :unset]
+        end
+        @results = Hash[result_pairs]
+        @callback_values = []
+        @errback_values = []
+
+        initialize_deferrables!
+      end
+
+      def one_callback(*vs)
+        deferrable, *values = vs
+        @results[deferrable] = :ok
+        @callback_values.push *values
+
+        check_if_complete
+      end
+
+      def one_errback(*vs)
+        deferrable, *values = vs
+        @results[deferrable] = :error
+          @errback_values.push *values
+
+        check_if_complete
+      end
+
+      private
+
+      def check_if_complete
+        complete! unless any_was?(:unset)
+      end
+
+      def complete!
+        (self.fail(@errback_values); return) if any_was?(:error)
+        self.succeed(@callback_values)
+      end
+
+      def any_was?(state)
+        @results.any? {|k, v| v == state }
+      end
+
+      def initialize_deferrables!
+        ds = @results.keys
+
+        ds.each do |deferrable|
+          deferrable.callback do |*values|
+            self.one_callback deferrable, *values
+          end
+          deferrable.errback do |*values|
+            self.one_errback deferrable, *values
+          end
+        end
+
+        ds.each do |d|
+          d.timeout(5, "Expired timeout of #{5} for #{d.inspect}")
+        end
+      end
+    end
+
     module Deferrables
       def self.succeeded(*args)
         deferrable = EventMachine::DefaultDeferrable.new
         deferrable.succeed(*args)
-        deferrable
-      end
+        deferrable end
       def self.failed(*args)
         deferrable = EventMachine::DefaultDeferrable.new
         deferrable.fail(*args)
@@ -13,66 +76,115 @@ module EMDextras
       end
     end
 
-    PipeSetup = Struct.new(:monitoring, :options) do
+    PipeSetup = Struct.new(:monitoring, :options, :result) do
       def inform_exception!(error_value, stage)
-        self.monitoring.inform_exception! error_value, stage
+        if options[:context]
+          self.monitoring.inform_exception! error_value, stage, options[:context]
+        else
+          self.monitoring.inform_exception! error_value, stage
+        end
       end
     end
 
     def self.pipe(zero, monitoring, stages, options = {})
-      run_chain zero, stages, PipeSetup.new(monitoring, options)
+      result = create_chain_result(monitoring, options)
+      run_chain zero, stages, PipeSetup.new(monitoring, options, result)
+    end
+
+    def self.create_chain_result(monitoring, options)
+      EventMachine::DefaultDeferrable.new.
+        tap {|d| d.callback { |value| notify_end_of_chain!(value, monitoring, options) }}.
+        tap {|d| d.errback  { |value| notify_end_of_chain!(value, monitoring, options) }}
     end
 
     def self.run_chain input, stages, pipe_setup
-      return if stages.empty?
+      return pipe_setup.result.succeed(input) if stages.empty? || input.nil?
 
       stage, *rest = *stages
 
-      puts "Running #{stage}(#{input})" if pipe_setup.options[:debug]
-
       if stage == :split
         split_chain(input, rest, pipe_setup)
-        return
+        return pipe_setup.result
       end
 
-
       deferrable = call(stage, input, pipe_setup)
+      check_stage_is_well_behaved!(deferrable, stage, input, deferrable)
       deferrable.callback do |value|
         run_chain value, rest, pipe_setup
       end
       deferrable.errback do |error_value|
         pipe_setup.inform_exception! error_value, stage
+        pipe_setup.result.fail(error_value)
       end
+
+      pipe_setup.result
     end
 
     private
+
+    def self.check_stage_is_well_behaved!(deferrable, stage, input, value)
+      unless deferrable.respond_to?(:callback) && deferrable.respond_to?(:errback)
+        raise InvalidStage, "Stage '#{stage.class.name}' did not return a deferrable object when given input '#{input.to_s[0..10]}', instead it returned '#{value}'!"
+      end
+    end
+
     def self.split_chain input, rest, pipe_setup
       new_options = pipe_setup.options.clone
 
       context = new_options[:context]
       if context && context.respond_to?(:split)
-        new_options[:context] = context.split 
+        new_options[:context] = context.split
       end
 
-      new_pipe_setup =  PipeSetup.new(pipe_setup.monitoring, new_options)
+      rest_of_chain = rest
 
       unless input.respond_to? :each
         pipe_setup.inform_exception! ArgumentError.new(":split stage expects enumerable input. \"#{input}\" is not enumerable."), :split
         return
       end
-      input.each do |value|
-        run_chain value, rest, new_pipe_setup
+
+      splits_deferrables = input.map do |value|
+        split_result = EventMachine::DefaultDeferrable.new
+        new_pipe_setup = PipeSetup.new(pipe_setup.monitoring, new_options, split_result)
+        run_chain value, rest_of_chain, new_pipe_setup
+
+        split_result
+      end
+
+      join = JoinedDeferrable.new(splits_deferrables)
+      join.callback do |*values|
+        pipe_setup.result.succeed(*values)
+      end
+      join.errback do |*values|
+        pipe_setup.result.fail(*values)
       end
     end
 
     def self.call(stage, input, pipe_setup)
       todo_method = stage.method(:todo)
-      case todo_method.arity
-      when 1
+      arity = todo_method.arity
+      if arity < 0 && pipe_setup.options[:context]
+        stage.todo(input, pipe_setup.options[:context])
+      elsif arity < 0 || arity == 1
         stage.todo(input)
-      when 2
+      elsif arity == 2
         stage.todo(input, pipe_setup.options[:context])
       end
     end
+
+    def self.notify_end_of_chain!(value, monitoring, options)
+      context = options[:context]
+
+      if monitoring.respond_to? :end_of_chain!
+        if context
+          monitoring.end_of_chain!(value, context)
+        else
+          monitoring.end_of_chain!(value)
+        end
+      end
+    end
+
+    class InvalidStage < Exception
+    end
   end
 end

data/lib/em-dextras/extension/object/deferrable.rb

@@ -0,0 +1,17 @@
+module EventMachine
+  module Deferrable
+    def map
+      deferrable_result = EventMachine::DefaultDeferrable.new
+
+      self.callback do |original_value|
+        deferrable_result.succeed yield(original_value)
+      end
+
+      self.errback do |original_value|
+        deferrable_result.fail original_value
+      end
+
+      deferrable_result
+    end
+  end
+end

data/lib/em-dextras/spec/spec_matchers.rb

@@ -19,6 +19,26 @@ if defined?(RSpec)
     end
   end
 
+  RSpec::Matchers.define :succeed_according_to do |proc_expecting|
+    match_unless_raises Exception do |actual_deferred|
+      resolved_value = nil
+      actual_deferred.callback do |value|
+        resolved_value = value
+      end
+      actual_deferred.errback do |error|
+        if error.is_a? Exception
+          raise error
+        else
+          raise "Callback error: #{error.inspect}"
+        end
+      end
+
+      probe_event_machine :check => (lambda do |ignored|
+        proc_expecting.call(resolved_value)
+      end), :timeout => 5
+    end
+  end
+
   RSpec::Matchers.define :be_successful do |expected|
     match_unless_raises Exception do |actual_deferred|
       done = false

data/lib/em-dextras/spec/spy.rb

@@ -1,20 +1,38 @@
+require 'rspec/mocks/argument_list_matcher'
+
 module EMDextras::Spec
   class Spy
     def initialize(options = {})
       @calls = []
       @return_value = options[:default_return]
+      @only_respond_to = options[:only_respond_to]
     end
 
     def called?(method_name, *args)
-      @calls.include? :name => method_name, :args => args
+      count_calls(method_name, *args) > 0
     end
 
-    def received_call!(method_name, *args)
+    def received_n_calls!(number, method_name, *args)
       probe_event_machine check: (Proc.new do
-        check_if_received_call(method_name, *args)
+        received_calls_number = count_calls(method_name, *args)
+        unless (received_calls_number == number )
+          raise ExpectationFailed, "Expected #{method_name} to have been called #{number} times with parameters [#{args.join(",")}] but only received #{received_calls_number} such calls (also received the following calls: #{@calls.inspect})"
+        end
       end)
     end
 
+    def received_call!(method_name, *args)
+      received_n_calls!(1, method_name, *args)
+    end
+
+    def not_received_call!(method_name, *args)
+      received_n_calls!(0, method_name, *args)
+    end
+
+    def respond_to?(symbol)
+      @only_respond_to ? @only_respond_to.include?(symbol) : true
+    end
+
     def method_missing(method_name, *args, &block)
       @calls << { :name => method_name, :args => args }
       @return_value
@@ -28,6 +46,15 @@ module EMDextras::Spec
       end
     end
 
+    def count_calls(method_name, *args)
+      arg_list_matcher = RSpec::Mocks::ArgumentListMatcher.new(*args)
+
+      found = @calls.select do |call|
+        call[:name] ==  method_name && arg_list_matcher.args_match?(*call[:args])
+      end
+      found.size
+    end
+
   end
 
   class ExpectationFailed < Exception

data/lib/em-dextras/version.rb

@@ -1,5 +1,5 @@
 module Em
   module Dextras
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/em-dextras.rb

@@ -1,9 +1,10 @@
+require "eventmachine"
+
 require "em-dextras/version"
 
 require "em-dextras/chains"
 require "em-dextras/chains/synchronous_stage"
 
-require "eventmachine"
 
 module EMDextras
   # Your code goes here...