world_bank 0.0.1 → 0.9.0

data/lib/world_bank/data.rb

@@ -0,0 +1,73 @@
+module WorldBank
+
+  class Data
+
+    attr_reader :raw, :name, :id, :value, :date, :others
+
+    def self.format(arg)
+      find('all').format(arg)
+    end
+
+    def self.id(arg)
+      find('all').id(arg)
+    end
+
+    def self.raw
+      find('all').raw
+    end
+
+    def self.most_recent_values(arg)
+      find('all').most_recent_values(arg)
+    end
+
+    def self.page(arg)
+      find('all').page(arg)
+    end
+
+    def self.per_page
+      find('all').per_page(arg)
+    end
+
+    def self.language(arg)
+      find('all').language(arg)
+    end
+
+    def self.income_level(arg)
+      find('all').income_level(arg)
+    end
+
+    def self.lending_type(arg)
+      find('all').lending_type(arg)
+    end
+
+    def self.region(arg)
+      find('all').region(arg)
+    end 
+
+    def self.country(arg)
+      find('all').country(arg)
+    end
+
+    def self.fetch(arg)
+      find(arg).fetch
+    end
+
+    def self.all
+      find('all')
+    end
+
+    def self.find(id)
+      WorldBank::DataQuery.new('indicators', id, self)
+    end
+
+    def initialize(values={})
+      @raw = values
+      @name = values['indicator'].delete('value')
+      @id = values['indicator'].delete('id')
+      @value = values.delete('value')
+      @date = values.delete('date')
+      values.delete('indicator')
+      @others = values
+    end
+  end
+end

data/lib/world_bank/data_query.rb

@@ -0,0 +1,64 @@
+module WorldBank
+
+  class DataQuery < Query
+
+    def initialize(name, id, model)
+      super
+      @param_dir = []
+      @params_filled = false
+    end
+
+    def lending_type(lending_type)
+      ensure_unconflicting_qualifiers
+      parsed = indifferent_number lending_type
+      @param_dir = ['lendingTypes', parsed]
+      self
+    end
+
+    def income_level(income_level)
+      ensure_unconflicting_qualifiers
+      parsed = indifferent_number income_level
+      @param_dir = ['incomeLevels', parsed]
+      self
+    end
+
+    def region(regions)
+      ensure_unconflicting_qualifiers
+      parsed = indifferent_number regions
+      @param_dir = ['countries', parsed]
+      self
+    end
+
+    def country(country)
+      ensure_unconflicting_qualifiers
+      parsed = indifferent_type country
+      parsed = ensure_country_id parsed
+      @param_dir = ['countries', parsed]
+      self
+    end
+
+    def indicator(indicators)
+      parsed = indifferent_number indicators
+      @id = parsed
+      self
+    end
+    alias_method(:find, :indicator)
+
+    def source(sources)
+      ensure_unconflicting_qualifiers
+      parsed = indifferent_number sources
+      @param_dir = ['sources', parsed]
+      self
+    end
+
+    private
+
+    def ensure_unconflicting_qualifiers
+      if @params_filled
+        raise ArgumentError,
+          "Only one of 'income_level', 'lending_type', 'country', or 'source' can be called on the same query"
+      end
+      @params_filled = true
+    end
+  end
+end

data/lib/world_bank/income_level.rb

@@ -1,24 +1,17 @@
 module WorldBank
 
   class IncomeLevel
-  
+
     attr_reader :raw, :id, :name, :type
 
-    def self.client
-      @client ||= WorldBank::Client.new
+    def self.all
+      find('all')
     end
 
-    def self.all(client)
-      client.query[:dirs] = ['incomeLevels']
-      client.get_query
-    end
-  
     def self.find(id)
-      client.query[:dirs] = ['incomeLevels', id.to_s]
-      result = client.get_query
-      new(result[1][0])
+      WorldBank::ParamQuery.new('incomeLevels', id, self)
     end
-    
+
     def initialize(values={})
       @raw = values
       @id = values['id']

data/lib/world_bank/indicator.rb

@@ -1,21 +1,63 @@
 module WorldBank
 
   class Indicator
-  
+
     attr_reader :raw, :id, :name, :source, :note, :organization, :topics, :type
-    def self.client
-      @client ||= WorldBank::Client.new
+
+    def self.format(arg)
+      find('all').format(arg)
+    end
+
+    def self.id(arg)
+      find('all').id(arg)
+    end
+
+    def self.most_recent_values(arg)
+      find('all').most_recent_values(arg)
+    end
+
+    def self.page(arg)
+      find('all').page(arg)
+    end
+
+    def self.per_page
+      find('all').per_page(arg)
+    end
+
+    def self.language(arg)
+      find('all').language(arg)
+    end
+
+    def self.income_level(arg)
+      find('all').income_level(arg)
+    end
+
+    def self.lending_type(arg)
+      find('all').lending_type(arg)
+    end
+
+    def self.region(arg)
+      find('all').region(arg)
+    end
+
+    def self.country
+      find('all').country(arg)
     end
 
-    def self.all(client)
-      client.query[:dirs] = ['indicators']
-      client.get_query
+    def self.fetch(arg)
+      find(arg).fetch
     end
-  
+
+    def self.featured
+      find('all').featured_indicators
+    end
+
+    def self.all
+      find('all')
+    end
+
     def self.find(id)
-      client.query[:dirs] = ['indicators', id]
-      result = client.get_query
-      new(result[1][0])
+      WorldBank::ParamQuery.new('indicators', id, self)
     end
 
     def initialize(values={})
@@ -32,5 +74,4 @@ module WorldBank
       @type = 'indicators'
     end
   end
-
 end

data/lib/world_bank/lending_type.rb

@@ -1,22 +1,15 @@
 module WorldBank
 
   class LendingType
-  
+
     attr_reader :raw, :id, :name, :type
 
-    def self.client
-      @client ||= WorldBank::Client.new
-    end
-    
-    def self.all(client)
-      client.query[:dirs] = ['lendingTypes']
-      client.get_query
+    def self.all
+      find('all')
     end
 
     def self.find(id)
-      client.query[:dirs] = ['lendingTypes', id.to_s]
-      result = client.get_query
-      new(result[1][0])
+      WorldBank::ParamQuery.new('lendingTypes', id, self)
     end
 
     def initialize(values={})

data/lib/world_bank/param_query.rb

@@ -0,0 +1,51 @@
+module WorldBank
+
+  class ParamQuery < Query
+  
+    def initialize(name, id, model)
+      super
+    end
+    
+    def lending_type(lending_type)
+      parsed = indifferent_number lending_type
+      @query[:params].merge!({:lendingTypes => parsed})
+      self
+    end
+
+    def income_level(income_levels)
+      parsed = indifferent_number income_levels
+      @query[:params].merge!({:incomeLevels => parsed})
+      self
+    end
+
+    def region(regions)
+      parsed = indifferent_number regions
+      @query[:params].merge!({:countries => parsed})
+      self
+    end
+
+    def country(country)
+      parsed = indifferent_type country
+      parsed = ensure_country_id parsed
+      @query[:params].merge!({:countries => parsed})
+      self
+    end
+
+    def indicator(indicators)
+      parsed = indifferent_number indicators
+      @query[:params].merge!({:indicators => parsed})
+      self
+    end
+
+    def featured_indicators
+      @query[:params].merge!({:featured => 1})
+      self
+    end
+
+    def source(sources)
+      parsed = indifferent_number sources
+      @query[:params].merge!({:sources => parsed})
+      self
+    end
+  end
+end

data/lib/world_bank/query.rb

@@ -1,107 +1,211 @@
 module WorldBank
 
-  module Query
-  
-    class Base
-    
-      def initialize(model)
-        @model = model
-        @client = WorldBank::Client.new
-        @client.query[:dirs] << @model.type
+  class Query
+
+    attr_reader :pages, :total
+
+    def initialize(name, id, model)
+      @model = model
+      @name = name
+      @id = id
+      @lang = false
+      @raw = false
+      @new = true
+      @query = {:params => {:format => :json}, :dirs => []}
+      @param_dir = []
+    end
+
+    #
+    # the date param is expressed as a range 'StartDate:EndDate'
+    # Date may be year & month, year & quarter, or just year
+    # Date will convert any Date/Time object to an apporpriate year & month
+    #
+    def dates(date_range)
+      if date_range.is_a? String
+
+        # assume the user knows what she is doing if passed a string
+        @query[:params][:date] = date_range
+      elsif date_range.is_a? Range
+        start = date_range.first
+        last = date_range.last
+        @query[:params][:date] = "#{start.strftime("%YM%m")}:#{last.strftime("%YM%m")}"
       end
+      self
+    end
 
-      #
-      # the date param is expressed as a range 'StartDate:EndDate'
-      # Date may be year & month, year & quarter, or just year
-      # Date will convert any Date/Time object to an apporpriate year & month
-      #
-      def dates(date_range)
-        if date_range.is_a? String
-          @client.query[:params][:date] = date_range
-        elsif date_range.is_a? Range
-          start = date_range.first
-          last = date_range.last
-          @client.query[:params][:date] = "#{start.strftime("%YM%m")}:#{last.strftime("%YM%m")}"
-        end
+    def format(format)
+      @query[:params][:format] = format
+      self
+    end
+
+    def raw
+      @raw = true
+      self
+    end
+
+    def id(id)
+      @query[:params][:id] = id
+      self
+    end
+
+    #
+    # Most Recent Values param has two optional params
+    # Gap fill will specify how many items to add if there isn't enough data for you query
+    # Frequency sets how frequent the data sets are...
+    # An example is best to explain this:
+    # I want the 5 most recent yearly values between 2000 and 2010,
+    #   but I need at least three data sets to continue. My query would look like this:
+    #   .dates('2000:2010').most_recent_values(:gap_fill => 3, :frequency => 'Y')
+    #
+    def most_recent_values(num, options={})
+      @query[:params][:gapFill] = options[:gap_fill] if options[:gap_fill]
+      @query[:params][:frequency] = options[:frequency] if options[:frequency]
+      @query[:params][:MRV] = num
+      self
+    end
+
+    def per_page(num=false)
+      if num
+        @query[:params][:perPage] = num
         self
+      else
+        @per_page || @query[:params][:per_page] || 50
       end
+    end
 
-      def format(format, prefix=nil)
-        @client.query[:params][:format] = format
+    def page(num=false)
+      if num
+        @query[:params][:page] = num
         self
+      else
+        @page || @query[:params][:page] || 1
       end
-      
-      def id(id)
-        @client.query[:params][:id] = id
-        self
+    end
+
+    def next
+      if @query[:params][:page].nil?
+        @query[:params][:page] = 2
+      else
+        @query[:params][:page] += 1
       end
-      
-      #
-      # Most Recent Values param hs two optional params
-      # Gap fill will specify how many items to add if there isn't enough data for you query
-      # Frequency sets how frequent the data sets are...
-      # An example is best to explain this:
-      # I want the 5 most recent yearly values between 2000 and 2010,
-      #   but I need at least three data sets to continue. My query would look like this:
-      #   .dates('2000:2010').most_recent_values(:gap_fill => 3, :frequency => 'Y')
-      #
-      def most_recent_values(num, options={})
-        @client.query[:params][:gapFill] = options[:gap_fill] if options[:gap_fill]
-        @client.query[:params][:frequency] = options[:frequency] if options[:frequency]
-        @client.query[:params][:MRV] = num
-        self
+      self
+    end
+
+    def language(lang)
+      if lang.to_s.length == 2
+        @lang = lang.to_s.downcase
+      else
+        @lang = [ ['french', 'fr'],
+          ['spanish', 'es'],
+          ['english', 'en'],
+          ['arabic', 'ar']  ].assoc(lang.to_s.downcase)[1]
       end
-      
-      def per_page(num)
-        @client.query[:params][:perPage] = num
-        self
+      self
+    end
+
+    def cycle
+      @cycle_results = @pages.nil? ? fetch : []
+      (@pages - self.page).times do
+        @cycle_results += self.next.fetch
       end
-      
-      def page(num)
-        @client.query[:params][:page] = num
-        self
+      @cycle_results
+    end
+
+    def fetch
+      if @new
+        @query[:dirs].push @name
+        @query[:dirs].push @id
+        @query[:dirs].unshift @lang if @lang
+        @query[:params][:format] ||= :json
+        @new = false
       end
-    
-      def language(lang)
-        @client.query[:dirs] << lang.to_s.downcase
-        self
+      @query[:dirs] = @param_dir + @query[:dirs] unless @param_dir.empty?
+      client = WorldBank::Client.new(@query, @raw)
+      results = client.get_query
+      results = parse results unless @raw
+      results
+    end
+
+protected
+
+    def parse(results)
+      update_fetch_info(results[0])
+      if @id =~ /all/ || @model == WorldBank::Data
+        results = results[1].map { |result| @model.new result }
+      else
+        results = @model.new results[1][0]
       end
-      
-      class Countries
-        
-        def initialize(model)
-          @model = model
-          @client = WorldBank::Client.new
-          @client.query[:dirs] << 'countries'
-        end
+      results
+    end
 
-        def lending_types(lend_type)
-          parsed_array = lend_type.is_a?(Array) ? lend_type.map(&:id).join(';') : lend_type.id
-          @client.query[:params][:lendingTypes] = parsed_array
-          self
-        end
-        
-        def income_levels(income_levels)
-          parsed_array = income_levels.is_a?(Array) ? income_levels.map(&:id).join(';') : income_levels.id
-          @client.query[:params][:incomeLevels] = parsed_array
-          self
+    def update_fetch_info(meta_info)
+      @page = meta_info['page'].to_i
+      @per_page = meta_info['per_page'].to_i
+      @pages = meta_info['pages'].to_i
+      @total = meta_info['total'].to_i
+    end
+
+    def indifferent_number(possibly_multiple_args)
+      parsed = if possibly_multiple_args.is_a?(Array)
+        arr = possibly_multiple_args.map do |arg|
+          indifferent_type(arg)
         end
-        
-        def region(region)
-          parsed_array = region.map(&:id).join(';')
-          @client.query[:params][:region] = parsed_array
-          self
+        arr.join(';')
+      else
+        indifferent_type(possibly_multiple_args)
+      end
+      parsed
+    end
+
+    def indifferent_type(arg)
+      parsed = ''
+      unless arg.is_a?(String) || arg.is_a?(Numeric)
+        parsed = arg.id
+      else
+        parsed = arg
+      end
+      parsed
+    end
+
+    def ensure_country_id(id)
+      @country_id = id
+      if @country_id.length > 3
+        @matching = WorldBank::Country.country_aliases.select do |country|
+          country[2] =~ Regexp.new(@country_id)
         end
-      
-        class Indicators
-          
-          def countries(countries)
-            parsed_array = countries.map(&:id).join(';')
-            @client.query[:params][:countries] = parsed_array
-            self
-          end
+        if @matching.length > 1
+          raise ArgumentError,
+            "More than one country code matched '#{@country_id}'. Perhaps you meant one of #{@matching.join(', ')}?",
+            caller
+        elsif @matching.length == 0
+          raise ArgumentError,
+            "No countries matched '#{@country_id}', please try again.",
+            caller
+        else
+          @country_id = @matching[0][0]
         end
       end
+      @country_id
+    end
+
+    def indifferent_nums(args)
+      parsed = ''
+      if args.is_a? Array
+        parsed = args.map! do |arg|
+          arg = normalize_country_id arg
+          arg = ensure_country_id arg
+        end.join(';')
+      else
+        args = normalize_country_id args
+        parsed = ensure_country_id args
+      end
+      parsed
+    end
+
+    def normalize_country_id(id)
+        id.gsub!(/[ -]/, '_')
+        id.downcase
     end
   end
 end
+