copy-ruby 0.0.1

data/lib/copy/client.rb

@@ -0,0 +1,70 @@
+module Copy
+  class Client
+    RESOURCES = [:user, :file, :email, :link]
+
+    attr_reader :session
+
+    # Creates an client object using the given Copy session.
+    # existing account.
+    #
+    # @param [String] client object to use the copy api.
+    def initialize(session)
+      raise Copy::AuthenticationError unless session.valid?
+      @session = session
+      self
+    end
+
+    # Metaprograming of every resource to execute it over the perform!
+    # method just to add session tho the resource
+    #
+    # @param [String||Symbol] action name of the action to execute over
+    # @param [Hash] options for the execution
+    # @returns the execution return or nil
+    #
+    # @example
+    #   session = Copy::Session.new(api_key: '_your_api_key_', auth_token: '_aut_token_for_the_user')
+    #   client = Copy::Client.new(session)
+    #   client.user.show # returns user profile
+    #   client.files.all
+    #
+    RESOURCES.each do |resource|
+      eval %{
+        def #{resource.to_s}(action, options={})
+          perform!(:#{resource.to_s}, action, options)
+        end
+      }
+    end
+
+
+    # Executes block with the access token
+    #
+    # @param [String||Symbol] resource_name name of the resource to execute over
+    # @param [String||Symbol] action name of the action to execute over
+    # @param [Hash] options for the execution
+    # @returns the execution return or nil
+    def perform!(resource_name, action, options={})
+      raise Copy::AuthenticationError unless session
+      resource(resource_name).send(action, options_with_session(options))
+    end
+    protected :perform!
+
+    # Merge the given options with the session for use the api
+    #
+    # @param [Hash] options options to merge with session
+    # @return [Hash]
+    def options_with_session(options={})
+      options.merge(session: @session)
+    end
+    protected :options_with_session
+
+    # Gest the api resource model class by his name
+    #
+    # @param [String||Symbol] name name of the resource
+    # @return [Copy::Base] resource to use the api
+    def resource(name)
+      eval('Copy::' + name.to_s.capitalize) rescue nil
+    end
+    protected :resource
+
+  end
+end

data/lib/copy/file.rb

@@ -0,0 +1,134 @@
+
+module Copy
+  class File < Base
+    include Copy::Operations::Show
+    include Copy::Operations::Delete
+    include Copy::Operations::Activity
+    include Copy::Operations::Create
+
+    TYPES = [ :file, :dir, :root, :copy, :inbox ]
+
+    attr_accessor :id, :path, :name, :type, :stub,
+      :children_count, :size, :recipient_confirmed, :mime_type, :link_name, :token,
+      :creator_id, :permissions, :syncing, :public, :object_available, :url,
+      :thumb, :share, :children, :children_count, :revision_id,
+      :modified_time, :date_last_synced,
+      :children, :counts, :inbox_notifications, :links, :revisions
+
+    def initialize(attributes = {})
+      super(attributes)
+      parse_children
+      parse_revisions
+      parse_links
+    end
+
+    def is_dir?
+      type != 'file'
+    end
+
+    def stubbed?
+      stub
+    end
+
+    def parse_children
+      return unless children
+      results = []
+      children.each do |obj|
+        results << self.class.new(obj)
+      end
+      @children = results
+    end
+    protected :parse_children
+
+    def parse_revisions
+      return unless revisions
+      results = []
+      revisions.each do |obj|
+        results << Copy::Revision.new(obj)
+      end
+      @revisions = results
+    end
+    protected :parse_revisions
+
+    def parse_links
+      return unless links
+      results = []
+      links.each do |obj|
+        results << Copy::Link.new(obj)
+      end
+      @links = results
+    end
+    protected :parse_revisions
+
+    class << self
+      # Create operation overwrite to parse file first
+      def create(attrs)
+        super(parse_file(attrs))
+      end
+
+      protected
+
+      # Redefining the files api endpoint
+      #
+      def api_member_url(id=nil, method=nil)
+        url = api_resource_name(method)
+        url += "#{id}" if id
+        url
+      end
+
+      # Redefining the files api resource name
+      # depending on the interaction
+      #
+      def api_resource_name(method=nil)
+        case method
+        when :show, :activity
+          'meta'
+        else
+          super(method)
+        end
+      end
+
+      # Parses the uploaded file to make the correct api request
+      #
+      # @param attributes [Hash] attributes to parse
+      # @return [Hash] parsed attributes hash
+      def parse_file(attrs)
+        return attrs unless attrs[:file]
+        attrs[:file_attrs] = {}
+        if attrs[:file].kind_of?(::File) or attrs[:file].kind_of?(::Tempfile) then
+          attrs[:file_attrs][:name] = attrs[:file].respond_to?(:original_filename) ? attrs[:file].original_filename : ::File.basename(attrs[:file].path)
+          attrs[:file_attrs][:local_path] = attrs[:file].path
+        elsif attrs[:file].kind_of?(String) then
+          attrs[:file_attrs][:local_path] = attrs[:file]
+          attrs[:file] = ::File.new(attrs[:file])
+          attrs[:file_attrs][:name] = ::File.basename(attrs[:file_attrs][:local_path])
+        elsif attrs[:file].kind_of?(StringIO) then
+          raise(ArgumentError, "Must specify the :as option when uploading from StringIO") unless attrs[:as]
+          attrs[:file_attrs][:local_path] = attrs[:as]
+
+          # hack for bug in UploadIO
+          class << file
+            attr_accessor :path
+          end
+          file.path = attrs[:file]
+        else
+          raise ArgumentError, "local_file must be a File, StringIO, or file path"
+        end
+
+        attrs[:file_attrs][:name] = ::File.basename(attrs.delete(:as)) if attrs[:as]
+
+        attrs
+      end
+
+      # Yiha! Api REST
+      #
+      def api_collection_url(attrs={})
+        path = attrs.delete(:path)
+        url = super(attrs)
+        url += '/' + path if path
+        url
+      end
+    end
+
+  end
+end

data/lib/copy/link.rb

@@ -0,0 +1,52 @@
+module Copy
+  class Link < Base
+    include Copy::Operations::All
+    include Copy::Operations::Show
+    include Copy::Operations::Delete
+    include Copy::Operations::Create
+    include Copy::Operations::Meta
+
+    attr_accessor :id, :name, :public, :url, :url_short, :creator_id,
+      :created_time, :object_count, :confirmation_required, :status,
+      :permissions, :recipients
+
+    # Metadata fields
+    attr_accessor :children, :path, :token, :creator_id, :permissions,
+      :syncing, :public, :type, :size, :stub, :date_last_synced, :counts,
+      :children_count, :share
+
+    def initialize(attributes = {})
+      super(attributes)
+      parse_recipients
+      parse_children
+    end
+
+    def download_url
+      return unless url
+      "#{url}?download=1"
+    end
+
+    protected
+
+    def parse_recipients
+      return if @recipients.nil?
+      results = []
+      @recipients.each do |object|
+        case object['contact_type']
+        when 'user'
+          results << Copy::User.new(object)
+        end
+      end
+      @recipients = results
+    end
+
+    def parse_children
+      return if @children.nil?
+      results = []
+      @children.each do |object|
+        results << Copy::File.new(object)
+      end
+      @children = results
+    end
+  end
+end

data/lib/copy/operations/activity.rb

@@ -0,0 +1,27 @@
+module Copy
+  module Operations
+    module Activity
+      module ClassMethods
+        # Retrieves all available objects from the Copy API
+        #
+        # @param [Hash] options Options to pass to the API
+        # @return [Array] The available objects
+        def activity(attributes={})
+          response = Copy.request(
+            :get,
+            nil,
+            api_member_url(attributes[:id], :activity ) + '/@activity',
+            {},
+            options_for_request(attributes)
+          )
+          self.new(response)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/copy/operations/all.rb

@@ -0,0 +1,31 @@
+module Copy
+  module Operations
+    module All
+      module ClassMethods
+        # Retrieves all available objects from the Copy API
+        #
+        # @param [Hash] options Options to pass to the API
+        # @return [Array] The available objects
+        def all(attributes = {})
+          session = attributes.delete(:session)
+          response = Copy.request(:get, nil, api_collection_url , attributes, options_for_request(session: session))
+          results_from response
+        end
+
+        def results_from(response)
+          results = []
+          response.each do |obj|
+            results << self.new(obj)
+          end
+          results
+        end
+        private :results_from
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/copy/operations/base.rb

@@ -0,0 +1,47 @@
+module Copy
+  module Operations
+    module Base
+      module ClassMethods
+        # Options for request
+        # overwrite this in the model to set security
+        #
+        # @return [Hash]
+        def options_for_request(attributes)
+          raise AuthenticationError unless attributes[:session]
+          {
+            session: attributes[:session]
+          }
+        end
+
+        protected
+
+        # URl for the member endpoints
+        # overwrite this in the model if the api is not well named
+        #
+        def api_member_url(id=nil, method=nil)
+          url = api_resource_name(method)
+          url += "/#{id}" if id
+          url
+        end
+
+        # URl for the collection endpoints
+        # overwrite this in the model if the api is not well named
+        #
+        def api_collection_url(attrs={})
+          api_resource_name
+        end
+
+        # resource name
+        # overwrite this in the model if the api is not well named
+        #
+        def api_resource_name(method=nil)
+          "#{self.name.split("::").last.downcase}s"
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/copy/operations/create.rb

@@ -0,0 +1,20 @@
+module Copy
+  module Operations
+    module Create
+      module ClassMethods
+        # Creates a new object
+        #
+        # @param [Hash] attributes The attributes of the created object
+        def create(attributes)
+          session = attributes.delete(:session)
+          response = Copy.request(:post, nil, api_collection_url(attributes), 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/operations/delete.rb

@@ -0,0 +1,25 @@
+module Copy
+  module Operations
+    module Delete
+      module ClassMethods
+        # Deletes the given object
+        #
+        # @param [Integer] id The id of the object that gets deleted
+        def delete(attributes={})
+          id = attributes.delete(:id)
+          response = Copy.request( :delete,
+            nil,
+            api_member_url(id, :delete),
+            {},
+            options_for_request(attributes)
+          )
+          true
+        end
+     end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/copy/operations/find.rb

@@ -0,0 +1,21 @@
+module Copy
+  module Operations
+    module Find
+      module ClassMethods
+        # Finds a given object
+        #
+        # @param [Integer] id The id of the object that should be found
+        # @return [Copy::Base] The found object
+        def find(attibutes)
+          id = attibutes.delete(:id)
+          response = Copy.request(:get, nil, api_member_url({id: id}), {}, options_for_request(attributes))
+          self.new(response["data"])
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/copy/operations/meta.rb

@@ -0,0 +1,20 @@
+module Copy
+  module Operations
+    module Meta
+      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 meta(attributes={})
+          response = Copy.request(:get, nil, 'meta/' + api_member_url(attributes[:id], :meta), {}, options_for_request(attributes))
+          self.new(response)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end