etsy 0.1.0 → 0.2.0

data/lib/etsy/model.rb

@@ -1,64 +1,27 @@
 module Etsy
   module Model # :nodoc:all
-    
+
     module ClassMethods
-      
-      def attribute(name, options = {})
-        from = options.fetch(:from, name)
 
-        class_eval <<-CODE
-          def #{name}
-            @result['#{from}']
-          end
-        CODE
+      def attribute(name, options = {})
+        define_method name do
+          @result[options.fetch(:from, name).to_s]
+        end
       end
-      
+
       def attributes(*names)
         names.each {|name| attribute(name) }
       end
 
-      def finder(type, endpoint)
-        parameter = endpoint.scan(/:\w+/).first
-        parameter.sub!(/^:/, '')
-
-        endpoint.sub!(":#{parameter}", '#{' + parameter + '}')
-
-        send("find_#{type}", parameter, endpoint)
-      end
-      
-      def find_all(parameter, endpoint)
-        class_eval <<-CODE
-          def self.find_all_by_#{parameter}(#{parameter})
-            response = Request.get("#{endpoint}")
-            response.result.map {|listing| new(listing) }
-          end
-        CODE
-      end
-      
-      def find_one(parameter, endpoint)
-        class_eval <<-CODE
-          def self.find_by_#{parameter}(#{parameter})
-            response = Request.get("#{endpoint}")
-            new response.result
-          end
-        CODE
-      end
-      
     end
-    
-    module InstanceMethods
-      
-      def initialize(result = nil)
-        @result = result
-      end
-      
+
+    def initialize(result = nil)
+      @result = result
     end
-    
+
     def self.included(other)
-      other.send(:extend, Etsy::Model::ClassMethods)
-      other.send(:include, Etsy::Model::InstanceMethods)
+      other.extend ClassMethods
     end
-    
-    
+
   end
 end

data/lib/etsy/request.rb

@@ -1,48 +1,71 @@
 module Etsy
-  
+
   # = Request
-  # 
+  #
   # A basic wrapper around GET requests to the Etsy JSON API
   #
   class Request
-    
-    # The base URL for API requests
-    def self.base_url
-      "http://beta-api.etsy.com/v1"
+
+    def self.host # :nodoc:
+      'openapi.etsy.com'
     end
-    
+
     # Perform a GET request for the resource with optional parameters - returns
     # A Response object with the payload data
     def self.get(resource_path, parameters = {})
       request = Request.new(resource_path, parameters)
       Response.new(request.get)
     end
-    
+
     # Create a new request for the resource with optional parameters
     def initialize(resource_path, parameters = {})
       @resource_path = resource_path
       @parameters    = parameters
     end
 
+    def base_path # :nodoc:
+      parts = ['v2']
+      parts << 'sandbox' if Etsy.environment == :sandbox
+      parts << (secure? ? 'private' : 'public')
+
+      "/#{parts.join('/')}"
+    end
+
     # Perform a GET request against the API endpoint and return the raw
     # response data
     def get
-      Net::HTTP.get(endpoint_uri)
+      client.get(endpoint_url)
     end
-    
+
+    def client # :nodoc:
+      @client ||= secure? ? secure_client : basic_client
+    end
+
     def parameters # :nodoc:
       @parameters.merge(:api_key => Etsy.api_key, :detail_level => 'high')
     end
-    
+
     def query # :nodoc:
       parameters.map {|k,v| "#{k}=#{v}"}.join('&')
     end
-    
-    def endpoint_uri # :nodoc:
-      uri = URI.parse("#{self.class.base_url}#{@resource_path}")
-      uri.query = query
-      uri
+
+    def endpoint_url # :nodoc:
+      "#{base_path}#{@resource_path}?#{query}"
+    end
+
+    private
+
+    def secure_client
+      SecureClient.new(:access_token => @parameters[:access_token], :access_secret => @parameters[:access_secret])
+    end
+
+    def basic_client
+      BasicClient.new(self.class.host)
     end
-    
+
+    def secure?
+      Etsy.access_mode == :read_write && !@parameters[:access_token].nil? && !@parameters[:access_secret].nil?
+    end
+
   end
-end
+end

data/lib/etsy/response.rb

@@ -1,30 +1,36 @@
 module Etsy
-  
+
   # = Response
-  # 
+  #
   # Basic wrapper around the Etsy JSON response data
   #
   class Response
-    
-    # Create a new response based on the raw JSON
-    def initialize(data)
-      @data = data
+
+    # Create a new response based on the raw HTTP response
+    def initialize(raw_response)
+      @raw_response = raw_response
     end
-    
+
     # Convert the raw JSON data to a hash
     def to_hash
-      @hash ||= JSON.parse(@data)
+      @hash ||= JSON.parse(data)
     end
-    
+
     # Number of records in the response results
     def count
       to_hash['count']
     end
-    
+
     # Results of the API request
     def result
       count == 1 ? to_hash['results'].first : to_hash['results']
     end
-    
+
+    private
+
+    def data
+      @raw_response.body
+    end
+
   end
 end

data/lib/etsy/secure_client.rb

@@ -0,0 +1,79 @@
+module Etsy
+
+  # = SecureClient
+  #
+  # Used for generating tokens and calling API methods that require authentication.
+  #
+  class SecureClient
+
+    # Create a new client with the necessary parameters.  Accepts the following
+    # key/value pairs:
+    #
+    #   :request_token
+    #   :request_secret
+    #   :access_token
+    #   :access_secret
+    #
+    # The request token / secret is useful for generating the access token.  Pass
+    # the access token / secret when initializing from stored credentials.
+    #
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
+
+    def consumer # :nodoc:
+      @consumer ||= OAuth::Consumer.new(Etsy.api_key, Etsy.api_secret, {
+        :site               => 'http://openapi.etsy.com',
+        :request_token_path => '/v2/sandbox/oauth/request_token',
+        :access_token_path  => '/v2/sandbox/oauth/access_token',
+        :authorize_url      => 'https://www.etsy.com/oauth/signin'
+      })
+    end
+
+    # Generate a request token.
+    #
+    def request_token
+      consumer.get_request_token(:oauth_callback => Etsy.callback_url)
+    end
+
+    # Access token for this request, either generated from the request token or taken
+    # from the :access_token parameter.
+    #
+    def access_token
+      @attributes[:access_token] || client.token
+    end
+
+    # Access secret for this request, either generated from the request token or taken
+    # from the :access_secret parameter.
+    #
+    def access_secret
+      @attributes[:access_secret] || client.secret
+    end
+
+    def client_from_request_data # :nodoc:
+      request_token = OAuth::RequestToken.new(consumer, @attributes[:request_token], @attributes[:request_secret])
+      request_token.get_access_token(:oauth_verifier => @attributes[:verifier])
+    end
+
+    def client_from_access_data # :nodoc:
+      OAuth::AccessToken.new(consumer, @attributes[:access_token], @attributes[:access_secret])
+    end
+
+    def client # :nodoc:
+      @client ||= has_access_data? ? client_from_access_data : client_from_request_data
+    end
+
+    # Fetch a raw response from the specified endpoint.
+    #
+    def get(endpoint)
+      client.get(endpoint)
+    end
+
+    private
+
+    def has_access_data?
+      !@attributes[:access_token].nil? && !@attributes[:access_secret].nil?
+    end
+
+  end
+end

data/lib/etsy/shop.rb

@@ -1,9 +1,8 @@
 module Etsy
-  
+
   # = Shop
   #
-  # Represents a single Etsy shop.  Users may or may not have an associated shop - 
-  # check the result of User#seller? to find out.
+  # Represents a single Etsy shop.  Users may or may not have an associated shop.
   #
   # A shop has the following attributes:
   #
@@ -11,40 +10,65 @@ module Etsy
   # [title] A brief heading for the shop's main page
   # [announcement] An announcement to buyers (displays on the shop's home page)
   # [message] The message sent to users who buy from this shop
-  # [banner_image_url] The full URL to the shops's banner image
-  # [listing_count] The total number of active listings contained in this shop
+  # [image_url] The full URL to the shops's banner image
+  # [active_listings_count] The number of active listings present in this shop
   #
   class Shop
-    
+
     include Etsy::Model
 
-    finder :one, '/shops/:user_id'
-    
+    attributes :title, :announcement, :user_id
+
+    attribute :id, :from => :shop_id
+    attribute :image_url, :from => 'image_url_760x100'
+    attribute :active_listings_count, :from => 'listing_active_count'
+    attribute :updated, :from => :last_updated_tsz
+    attribute :created, :from => :creation_tsz
     attribute :name, :from => :shop_name
-    attribute :updated, :from => :last_updated_epoch
-    attribute :created, :from => :creation_epoch
     attribute :message, :from => :sale_message
 
-    attributes :banner_image_url, :listing_count, :title, :announcement, :user_id
-   
+    # Retrieve one or more shops by name or ID:
+    #
+    #   Etsy::Shop.find('reagent')
+    #
+    # You can find multiple shops by passing an array of identifiers:
+    #
+    #   Etsy::Shop.find(['reagent', 'littletjane'])
+    #
+    def self.find(*identifiers)
+      response = Request.get("/shops/#{identifiers.join(',')}")
+      shops = [response.result].flatten.map {|data| new(data) }
+
+      (identifiers.length == 1) ? shops[0] : shops
+    end
+
+    # Retrieve a list of all shops.  By default it fetches 25 at a time, but that can
+    # be configured by passing the :limit and :offset parameters:
+    #
+    #   Etsy::Shop.all(:limit => 100, :offset => 100)
+    #
+    def self.all(options = {})
+      response = Request.get("/shops", options)
+      response.result.map {|data| new(data) }
+    end
+
     # Time that this shop was created
     #
     def created_at
       Time.at(created)
     end
-    
+
     # Time that this shop was last updated
     #
     def updated_at
       Time.at(updated)
     end
-    
-    # A collection of listings in this user's shop. See Etsy::Listing for
-    # more information
+
+    # The collection of active listings associated with this shop
     #
     def listings
-      Listing.find_all_by_user_id(user_id)
+      @listings ||= Listing.find_all_by_shop_id(id)
     end
-    
+
   end
 end

data/lib/etsy/user.rb

@@ -1,54 +1,59 @@
 module Etsy
-  
+
   # = User
   #
   # Represents a single Etsy user - has the following attributes:
   #
   # [id] The unique identifier for this user
   # [username] This user's username
-  # [url] The full URL to this user's profile page / shop (if seller)
-  # [city] The user's city / state (optional)
-  # [gender] The user's gender
-  # [bio] User's biography
+  # [email] This user's email address (authenticated calls only)
   #
   class User
-    
+
     include Etsy::Model
-    
-    finder :one, '/users/:username'
-    
-    attribute :username, :from => :user_name
+
     attribute :id, :from => :user_id
-    attribute :joined, :from => :join_epoch
-    attribute :seller, :from => :is_seller
-    attribute :last_login, :from => :last_login_epoch
-
-    attributes :url, :city, :gender, :bio
-    
-    # This user's shop, returns nil if user is not a seller. See Etsy::Shop
-    # for more information.
+    attribute :username, :from => :login_name
+    attribute :email, :from => :primary_email
+    attribute :created, :from => :creation_tsz
+
+    # Retrieve one or more users by name or ID:
     #
-    def shop
-      Shop.find_by_user_id(id) if seller?
+    #   Etsy::User.find('reagent')
+    #
+    # You can find multiple users by passing an array of identifiers:
+    #
+    #   Etsy::User.find(['reagent', 'littletjane'])
+    #
+    def self.find(*identifiers)
+      self.get("/users/#{identifiers.join(',')}")
     end
-    
-    # Is this user a seller?
+
+    # Retrieve the currently authenticated user.
     #
-    def seller?
-      seller
+    def self.myself(token, secret)
+      self.get("/users/__SELF__", :access_token => token, :access_secret => secret)
     end
-    
-    # Time that this user joined the site
+
+    # The shop associated with this user.
     #
-    def joined_at
-      Time.at(joined)
+    def shop
+      @shop ||= Shop.find(username)
     end
-    
-    # Time that this user last logged in
+
+    # Time that this user was created
     #
-    def last_login_at
-      Time.at(last_login)
+    def created_at
+      Time.at(created)
+    end
+
+    private
+
+    def self.get(query, options={})
+      response = Request.get(query, options)
+      users = [response.result].flatten.map {|data| new(data) }
+
+      (users.length == 1) ? users[0] : users
     end
-    
   end
-end
+end