class Product < ActiveResource::Base
  self.site = "http://www.quarkrank.com/"
end
# Now, one can query quarkrank.com's api to get all products, or complete details for a particular product by simply doing a find:
# Product.find(:all) => http://www.quarkrank.com/products.xml
# Product.find("canon-powershot-sd1000") => http://www.quarkrank.com/products/canon-powershot-sd1000.xml 

class Review < ActiveResource::Base
  # here reviews exist for a given product only.
  self.site = "http://www.quarkrank.com/products/:product_id/"
end
# Now, you can ask for reviews on canon-powershot-sd1000 by doing find:
# Review.find(:all, :params=>{:product_id=>'canon-powershot-sd1000'})

 find
  |  
  |-- find single or all items(find_single/find_every)
        |
        |-- create_url (element_path/collection_path)
        |
        |-- get_response_from_url (connection.get)
               |
               |-- make_http_request_to_url (http.get)
               |
               |-- handle_response(response) -> exceptions are raised here if we get 4xx/5xx response codes.
               |
               |-- get_body(response.body)
               |
               |-- decode_output, from xml/json to ruby hash (format.decode)
        |
        |-- convert_hash_to_active_resource_object (instantiate_record/instantiate_collection)

# code of element_path function
def element_path(id, prefix_options = {}, query_options = nil)
  prefix_options, query_options = split_options(prefix_options) if query_options.nil?
  # path to the resource, which we want to access is evaluated in this statement: 
  "#{prefix(prefix_options)}#{collection_name}/#{id}.#{format.extension}#{query_string(query_options)}"
end

prefix(prefix_options) depends on self.site variable and value(s) of nested resource variable.
   =>Evaluates the "fixed" prefix path to the resource (if any, mentioned in self.site variable) and/or
      in case you are using nested style queries, replaces variables with their values
== Examples:
1. self.site = "http://www.quarkrank.com/folders/api"
prefix(prefix_options) => "/folders/api/"
2. self.site = "http://www.quarkrank.com/folders/:folder_id"
find(1,:folder_id=>5)
prefix(prefix_options) => "/folders/5/"

collection_name => evaluates to pluralize form of classname
== Examples:
1. class Comment < ActiveResource::Base;end
collection_name => "comments"

id => id of the item we are querying, usually mentioned in find (example: User.find(5))
format_extension => what format request you are making request for (default is xml).

query_string(query_options) => generates get styled query string from remaining params.
== Examples:
1. self.site = "http://www.quarkrank.com/folders/api"
    find(1)
    query_string(query_options) => ""
2. self.site = "http://www.quarkrank.com/folders/:folder_id"
    find(1,:folder_id=>5, :filename=>"nakul")
    query_string(query_options) => "?filename=nakul"

## collection_path method is quite similar

# in case, result.message contains some characters like "%A", this leads to exception
logger.info "--> #{result.code} #{result.message} (#{result.body ? result.body : 0}b %.2fs)" % time if logger

## define a ActiveResource::Flickr  class, which raises exception if response is not OK.
  class ActiveFlickr<ActiveResource::Base
    class << self
      alias :old_find :find
      def find(*arguments)
        output = old_find(*arguments)
        if output.respond_to? :err
          case output.err.code.to_i
            when 100
              raise(ActiveResource::UnauthorizedAccess.new(output.err, output.err.msg))
            when 112
              raise(ActiveResource::MethodNotAllowed.new(output.err, output.err.msg))
            else
              raise(ConnectionError.new(output.err, "Unknown response code: #{outout.err.code}"))
          end
        end
      end
   end

# now other ActiveResource models would inherit from ActiveFlickr, rather ActiveResource::Base.

## also ActiveResource Exceptions, currently doesn't logs/prints the "message", which is passed as second argument. 
# You might want to modify the behavior to print error message also.
module ActiveResource
  class ConnectionError
    def to_s
      str = "Failed with #{response.code} #{response.message if response.respond_to?(:message)}\n"
      str += @message unless @message.nil?
      str
    end
  end
end

class ActiveResource::Base
  def self.instantiate_collection(collection, prefix_options = {})
    unless collection.kind_of? Array      [instantiate_record(collection, prefix_options)]
    else
      collection.collect! { |record| instantiate_record(record, prefix_options) }
    end
  end
end

# Type1: 
BlogPost.find('active_resouce').get(:comments)
# More examples:
Person.find(1).put(:promote, :position => 'Manager') # PUT /people/1/promote.xml
Person.find(1).delete(:deactivate) # DELETE /people/1/deactivate.xml

#Type2
Person.get(:active)  # GET /people/active.xml

  def find_custom(arg)
    object = self.new
    object.id = arg
    object
  end
# Example: For youtube videos, if we want comments for a particular video, we would do 
# Video.find_custom("ZTUVgYoeN_o").get(:comments)

  def get(method_name, options = {})
    self.class.new.load(connection.get(custom_method_element_url(method_name, options), self.class.headers))
  end

  def self.get(method_name, options = {})
    object_array = connection.get(custom_method_collection_url(method_name, options), headers)
    if object_array.class.to_s=="Array"
      object_array.collect! {|record| self.class.new.load(record)}
    else
      self.class.new.load(object_array)
    end
  end

module ActiveResource
  module Formats
    module JsonFormat
      extend self
      
      def extension
        "json"
      end
      
      def mime_type
        "application/json"
      end
      
      def encode(hash)
        hash.to_json
      end
      
      def decode(json)
        ActiveSupport::JSON.decode(json)
      end
    end
  end
end