copy-ruby 0.0.1

data/lib/copy/operations/show.rb

@@ -0,0 +1,20 @@
+module Copy
+  module Operations
+    module Show
+      module ClassMethods
+        # Shows a given object
+        #
+        # @param [Integer] id The id of the object that should be shown
+        # @return [Copy::Base] The found object
+        def show(attributes={})
+          response = Copy.request(:get, nil, api_member_url(attributes[:id], :show), {}, options_for_request(attributes))
+          self.new(response)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/copy/operations/update.rb

@@ -0,0 +1,21 @@
+module Copy
+  module Operations
+    module Update
+      module ClassMethods
+        # Updates a object
+        # @param [Integer] id The id of the object that should be updated
+        # @param [Hash] attributes The attributes that should be updated
+        def update(attributes={})
+          id = attributes.delete(:id)
+          session = attributes.delete(:session)
+          response = Copy.request(:put, nil, api_member_url(id, :updated), attributes, options_for_request(session: session))
+          self.new(response)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/copy/request/base.rb

@@ -0,0 +1,41 @@
+module Copy
+  module Request
+    class Base
+      attr_reader :info
+      attr_accessor :response
+
+      def initialize(info)
+        @info = info
+      end
+
+      def perform
+        raise Copy::AuthenticationError unless valid?
+        connection.set_request_data
+        send_request
+
+        validator.validated_data_for(response)
+      end
+
+      def valid?
+        return false unless info
+        return false unless info.session
+        return false unless info.session.valid?
+        true
+      end
+
+      protected
+
+      def send_request
+        self.response = connection.request
+      end
+
+      def connection
+        @connection ||= Connection.new(info)
+      end
+
+      def validator
+        @validator ||= Validator.new(info)
+      end
+    end
+  end
+end

data/lib/copy/request/connection.rb

@@ -0,0 +1,120 @@
+require 'net/http/post/multipart'
+
+module Copy
+  module Request
+    class Connection
+      include Helpers
+      attr_reader :access_token, :request_data
+
+      def initialize(request_info)
+        @info = request_info
+        @session = @info.session if @info
+        @access_token = @info.session.access_token if @session
+      end
+
+      def request
+        return unless access_token
+        if use_body_file?
+          ::File.open(body_file_attrs[:local_path]) do |file|
+            req = Net::HTTP::Post::Multipart.new(
+                api_url,
+               'file' => UploadIO.new(
+                  file,
+                  'application/octet-stream',
+                  body_file_attrs[:name]
+                )
+            )
+            access_token.sign! req
+            req['X-Api-Version'] = '1'
+            # Todo finish this to work over https
+            http = Net::HTTP.new("api.copy.com", Net::HTTP.https_default_port)
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            http.use_ssl = true
+            http.start do |http|
+              http.request(req)
+            end
+          end
+        else
+          access_token.send(*request_data)
+        end
+      end
+
+      def set_request_data
+        @request_data = []
+        @request_data << @info.http_method if @info
+        @request_data << api_url
+        unless use_url_params?
+          @request_data << body_json
+        end
+        @request_data << headers
+      end
+
+      protected
+
+      # Body params hash
+      #
+      # @return [Hash]
+      def body_hash
+        return {} unless @info
+        @info.data
+      end
+
+      # Json encoded body
+      #
+      # @return [String]
+      def body_json
+        return '' unless body_hash
+        JSON.generate(body_hash)
+      end
+
+      def body_file_attrs
+        body_hash[:file_attrs] || {}
+      end
+
+      # Body params url encoded
+      #
+      # @return [String]
+      def encoded_www_body
+        return '' unless body_hash
+        URI.encode_www_form(body_hash)
+      end
+
+      def use_body_file?
+        return false if use_url_params?
+        body_hash.has_key?(:file)
+      end
+
+      def use_url_params?
+        return false unless @info
+        case @info.http_method
+        when :post, :put
+          false
+        else
+          true
+        end
+      end
+
+      def headers
+        { "X-Api-Version" => API_VERSION }
+      end
+
+      # Returns the api url foir this request or default
+      def api_url
+        url = 'https://' + domain + '.' + API_BASE
+        if @info
+          url += @info.url
+          if use_url_params? && !body_hash.empty?
+            url += '?' + encoded_www_body
+          end
+        end
+        url
+      end
+
+      # Returns the domain for the current request or the default one
+      def domain
+        return @info.subdomain if @info
+        DOMAIN_BASE
+      end
+    end
+  end
+end

data/lib/copy/request/helpers.rb

@@ -0,0 +1,36 @@
+module Copy
+  module Request
+    module Helpers
+      def flatten_hash_keys(old_hash, new_hash={}, keys=nil)
+        old_hash.each do |key, value|
+          key = key.to_s
+          if value.is_a?(Hash)
+            all_keys_formatted = keys + "[#{key}]"
+            flatten_hash_keys(value, new_hash, all_keys_formatted)
+          else
+            new_hash[key] = value
+          end
+        end
+        new_hash
+      end
+
+      def normalize_params(params, key=nil)
+        params = flatten_hash_keys(params) if params.is_a?(Hash)
+        result = {}
+        params.each do |key, value|
+          case value
+          when Hash
+            result[key.to_s] = normalize_params(value)
+          when Array
+            value.each_with_index do |item_value, index|
+              result["#{key.to_s}[#{index}]"] = item_value.to_s
+            end
+          else
+            result[key.to_s] = value.to_s
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/copy/request/info.rb

@@ -0,0 +1,41 @@
+module Copy
+  module Request
+    class Info
+      attr_accessor :http_method, :api_url, :data, :subdomain, :session, :base_path
+
+      def initialize(http_method, subdomain, api_url, data, options={})
+        @http_method = http_method
+        @subdomain   = subdomain || DOMAIN_BASE
+        @api_url     = api_url
+        @data        = data
+        @base_path   = API_BASE_PATH
+        @session     = options[:session]
+      end
+
+      def url
+        url = "/#{base_path}/#{api_url}"
+        if has_id?
+          url += "/#{data[:id]}"
+          data.delete(:id)
+        end
+
+        url
+      end
+
+      def path_with_params(path, params)
+        unless params.empty?
+          encoded_params = URI.encode_www_form(params)
+          [path, encoded_params].join("?")
+        else
+          path
+        end
+      end
+
+      protected
+
+      def has_id?
+        !data[:id].nil?
+      end
+    end
+  end
+end

data/lib/copy/request/validator.rb

@@ -0,0 +1,53 @@
+module Copy
+  module Request
+    class Validator
+      attr_reader :info
+      attr_accessor :response
+
+      def initialize(info)
+        @info = info
+      end
+
+      def validated_data_for(incoming_response)
+        self.response = incoming_response
+        verify_response_code
+        info.data = JSON.parse(response.body) if response.code.to_i != 204
+        info.data ||= {}
+        validate_response_data
+        info.data
+      end
+
+      protected
+
+      def verify_response_code
+        raise AuthenticationError if response.code.to_i == 401
+        raise APIError if response.code.to_i >= 500
+        raise NotFound if response.code.to_i >= 404
+      end
+
+      def validate_response_data
+        body ||= info.data
+        if body.is_a?(Hash)
+          if body['error']
+            handle_api_error(body['error'], body['message'])
+          elsif body['errors']
+            body['errors'].each do |error|
+              handle_api_error(error['code'], error['message'])
+            end
+          end
+        end
+      end
+
+      def handle_api_error(code, message)
+        error = case code
+                when 1021, 1024  then ObjectNotFound.new(message)
+                when 1300, 1303  then BadRequest.new(message)
+                else
+                  binding.pry
+                  APIError.new(message)
+                end
+        fail error
+      end
+    end
+  end
+end

data/lib/copy/revision.rb

@@ -0,0 +1,25 @@
+module Copy
+  class Revision < Base
+
+    attr_accessor :id, :revision_id, :modified_time, :size, :latest, :conflict,
+      :type, :creator
+
+    def initialize(attributes = {})
+      super(attributes)
+      parse_creator
+    end
+
+    protected
+
+    def parse_creator
+      return unless creator
+      @creator = Copy::User.new(creator)
+    end
+
+    # Parses UNIX timestamps and creates Time objects.
+    def parse_timestamps
+      super
+      @modified_time = Time.at(modified_time) if modified_time
+    end
+  end
+end

data/lib/copy/session.rb

@@ -0,0 +1,56 @@
+require 'oauth'
+
+module Copy
+  class Session
+
+    attr_accessor :token, :secret, :access_token
+    attr_accessor :consumer_key, :consumer_secret
+    attr_accessor :oauth_verifier, :oauth_token
+
+    OAUTH_URLS =  {
+        :site => 'https://api.copy.com',
+        :authorize_url => 'https://www.copy.com/applications/authorize',
+        :request_token_url => 'https://api.copy.com/oauth/request',
+        :access_token_url => 'https://api.copy.com/oauth/access',
+        :http_method => :get
+    }
+
+    def initialize(opts={})
+      @secret = opts[:secret]
+      @token = opts[:token]
+      @consumer_secret = opts[:secret]
+      @consumer_key = opts[:consumer_key] || Copy.configuration[:consumer_key]
+      @consumer_secret = opts[:consumer_secret] || Copy.configuration[:consumer_secret]
+      @oauth_verifier = opts[:oauth_verifier]
+      @oauth_token = opts[:oauth_token]
+    end
+
+    def valid?
+      return false unless token
+      return false unless secret
+      true
+    end
+
+    def consumer
+      @consumer ||= OAuth::Consumer.new(consumer_key, consumer_secret,
+        :site => OAUTH_URLS[:site]
+        # :authorize_url => OAUTH_URLS[:authorize_url],
+        # :request_token_url => OAUTH_URLS[:request_token_url],
+        # :access_token_url =>  get_access_token_url
+      )
+    end
+
+    def get_access_token_url
+      url = OAUTH_URLS[:request_token_url]
+      url += "?oauth_verifier=#{oauth_verifier}" if oauth_verifier
+      url += "&oauth_token=#{oauth_token}" if oauth_token
+    end
+
+    def access_token
+      @access_token ||= OAuth::AccessToken.new(consumer, token, secret)
+    end
+
+  end
+end
+
+

data/lib/copy/user.rb

@@ -0,0 +1,24 @@
+module Copy
+  class User < Base
+    include Copy::Operations::Show
+    include Copy::Operations::Update
+
+    attr_accessor :id, :email, :first_name, :last_name, :developer, :created_time,
+      :emails, :storage, :confirmed, :user_id
+
+    def id
+      @id || @user_id
+    end
+
+    class << self
+
+      # TODO: should be users
+      #
+      def api_resource_name(method=nil)
+        'user'
+      end
+
+    end
+
+  end
+end