active_scraper.rb in active_scraper-0.0.2

- old
+ new
@@ -1,5 +1,86 @@
+# encoding: UTF-8
+
 require "active_scraper/engine"
-require "active_scraper/fetcher"
+require 'active_scraper/fake_http_party_response'
+require 'active_scraper/response_object'
 
 module ActiveScraper
+
+
+  # returns a ActiveScraper::CachedResponse
+  def self.get(uri, options={})
+    o = create_request_and_fetch_response(uri, options)
+
+    return o.response
+  end
+
+
+
+  # delegates to CachedRequest::find_or_build_from_uri
+  #   req (URI or String). If CachedRequest, is idempotent
+  #   
+  # returns a new or existing CachedRequest
+  def self.find_or_build_request(req, opts={})
+    CachedRequest.find_or_build_from_uri(req, opts)
+  end
+
+  ## cached_request (CachedRequest) => the request to find a response for
+  ##
+  ## returns a new or existing CachedResponse
+
+  def self.find_or_build_response(cached_request, opts={})
+    raise ArgumentError, "Only accepted CachedRequest, but was passed in a #{cached_request.class}" unless cached_request.is_a?(CachedRequest)
+    opts = normalize_hash(opts)
+
+    response = CachedResponse.find_cache_for_cached_request(cached_request, opts)
+
+    if response.blank?
+      fetched_obj = fetch_fresh(cached_request.uri, opts)
+      response = CachedResponse.build_from_response_object(fetched_obj)
+    end
+
+    return response
+  end
+
+
+  def self.create_request_and_fetch_response(uri, opts={})
+    opts = normalize_hash(opts)
+    # first, find or build the request
+    request = find_or_build_request(uri, opts)
+    # then find or build a matching response
+    response = find_or_build_response(request, opts)
+    # associate and save the two
+    request.responses << response
+    request.save
+     
+    obj = Hashie::Mash.new(request: request, response: response)
+    
+    return obj
+  end
+
+  # Returns an object compatible with HTTParty, i.e. an ActiveScraper::FakeHTTPartyResponse
+  # to be deprecated
+  def self.build_usable_response(request, response)
+    ActiveScraper::FakeHTTPartyResponse.new(request, response)
+  end
+
+
+
+  def self.fetch_fresh(url, opts={})
+     resp = HTTParty.get(url, opts)
+
+     return ActiveScraper::ResponseObject.factory(resp)
+  end
+
+
+
+
+  def self.normalize_hash(hsh)
+    unless hsh.is_a?(HashWithIndifferentAccess)
+      hsh = HashWithIndifferentAccess.new(hsh) 
+    end
+
+    return hsh
+  end
+
 end