nimbu-api 0.0.1

data/lib/nimbu-api/endpoint.rb

@@ -0,0 +1,199 @@
+# -*- encoding: utf-8 -*-
+
+module Nimbu
+  # Core class for api interface operations
+  class Endpoint
+    include ::Nimbu::Utils::Constants
+    include Authentication
+    include Connection
+    include Request
+
+    attr_reader *Configuration.keys
+    attr_accessor *Request::Validations::VALID_API_KEYS
+
+    attr_accessor :current_options
+
+    # Returns all API public methods for a given class.
+    def self.inherited(klass)
+      klass.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def self.actions
+          self.new.api_methods_in(#{klass})
+        end
+        def actions
+          api_methods_in(#{klass})
+        end
+      RUBY_EVAL
+      super
+    end
+
+    def api_methods_in(klass)
+      puts "---"
+      (klass.send(:instance_methods, false) - ['actions']).sort.each do |method|
+        puts "|--> #{method}"
+      end
+      klass.included_modules.each do |mod|
+        if mod.to_s =~ /#{klass}/
+          puts "| \\ #{mod.to_s}"
+          mod.instance_methods(false).each do |met|
+            puts "|  |--> #{met}"
+          end
+          puts "| /"
+        end
+      end
+      puts "---"
+      nil
+    end
+
+    def append_arguments(method)
+      _method = self.method(method)
+      if _method.arity == 0
+        args = "()"
+      elsif _method.arity > 0
+        args = "(few)"
+      else
+        args = "(else)"
+      end
+      args
+    end
+
+    # Callback to update current configuration options
+     class_eval do
+       Configuration.keys.each do |key|
+         define_method "#{key}=" do |arg|
+           self.instance_variable_set("@#{key}", arg)
+           self.current_options.merge!({:"#{key}" => arg})
+         end
+       end
+     end
+
+    # Create new API
+    #
+    def initialize(options={}, &block)
+      setup(options)
+      client(options) if client_id? && client_secret?
+      yield_or_eval(&block) if block_given?
+    end
+
+    def yield_or_eval(&block)
+      return unless block
+      block.arity > 0 ? yield(self) : self.instance_eval(&block)
+    end
+
+    # Configure options and process basic authorization
+    #
+    def setup(options={})
+      options.each do |k,v|
+        self.set(k,v,true)
+      end
+      options = Nimbu.options.merge(options)
+      self.current_options = options
+      Configuration.keys.each do |key|
+        send("#{key}=", options[key])
+      end
+      process_basic_auth(options[:basic_auth])
+    end
+
+    # Extract login and password from basic_auth parameter
+    #
+    def process_basic_auth(auth)
+      case auth
+      when String
+        self.login, self.password = auth.split(':', 2)
+      when Hash
+        self.login    = auth[:login]
+        self.password = auth[:password]
+      end
+    end
+
+    # Responds to attribute query or attribute clear
+    def method_missing(method, *args, &block) # :nodoc:
+      case method.to_s
+      when /^(.*)\?$/
+        return !!self.send($1.to_s)
+      when /^clear_(.*)$/
+        self.send("#{$1.to_s}=", nil)
+      else
+        super
+      end
+    end
+
+    # Acts as setter and getter for api requests arguments parsing.
+    #
+    # Returns Arguments instance.
+    #
+    def arguments(args=(not_set = true), options={}, &block)
+      if not_set
+        @arguments
+      else
+        @arguments = Arguments.new(self, options).parse(*args, &block)
+      end
+    end
+
+    # Scope for passing request required arguments.
+    #
+    def with(args)
+      case args
+      when Hash
+        set args
+      else
+        ::Kernel.raise ArgumentError, 'This api does not support passed in arguments'
+      end
+    end
+
+    # Set an option to a given value
+    def set(option, value=(not_set=true), ignore_setter=false, &block)
+      raise ArgumentError, 'value not set' if block and !not_set
+      return self if !not_set and value.nil?
+
+      if not_set
+        set_options option
+        return self
+      end
+
+      if respond_to?("#{option}=") and not ignore_setter
+        return __send__("#{option}=", value)
+      end
+
+      define_accessors option, value
+      self
+    end
+
+    private
+
+    # Set multiple options
+    #
+    def set_options(options)
+      unless options.respond_to?(:each)
+        raise ArgumentError, 'cannot iterate over value'
+      end
+      options.each { |key, value| set(key, value) }
+    end
+
+    def define_accessors(option, value)
+      setter = proc { |val|  set option, val, true }
+      getter = proc { value }
+
+      define_singleton_method("#{option}=", setter) if setter
+      define_singleton_method(option, getter) if getter
+    end
+
+    # Dynamically define a method for setting request option
+    #
+    def define_singleton_method(method_name, content=Proc.new)
+      (class << self; self; end).class_eval do
+        undef_method(method_name) if method_defined?(method_name)
+        if String === content
+          class_eval("def #{method_name}() #{content}; end")
+        else
+          define_method(method_name, &content)
+        end
+      end
+    end
+
+    def _merge_mime_type(resource, params) # :nodoc:
+#       params['resource'] = resource
+#       params['mime_type'] = params['mime_type'] || :raw
+    end
+
+  end # Endpoint
+end # Nimbu

data/lib/nimbu-api/endpoints/authorizations.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+module Nimbu
+  module Endpoints
+    class Authorizations < Endpoint
+
+      VALID_AUTH_PARAM_NAMES = %w[
+        scopes
+        add_scopes
+        remove_scopes
+        note
+        note_url
+        client_id
+        client_secret
+      ].freeze
+
+      # List authorizations
+      #
+      # = Examples
+      #  nimbu = Nimbu.new :basic_auth => 'login:password'
+      #  nimbu.oauth.list
+      #  nimbu.oauth.list { |auth| ... }
+      #
+      def list(*args)
+        require_authentication
+        arguments(args)
+
+        response = get_request("/authorizations", arguments.params)
+        return response unless block_given?
+        response.each { |el| yield el }
+      end
+      alias :all :list
+
+      # Get a single authorization
+      #
+      # = Examples
+      #  nimbu = Nimbu.new :basic_auth => 'login:password'
+      #  nimbu.oauth.get 'authorization-id'
+      #
+      def get(*args)
+        require_authentication
+        arguments(args, :required => [:authorization_id])
+
+        get_request("/authorizations/#{authorization_id}", arguments.params)
+      end
+      alias :find :get
+
+      # Create a new authorization
+      #
+      # = Inputs
+      # * <tt>:scopes</tt> - Optional array - A list of scopes that this authorization is in.
+      # * <tt>:note</tt> - Optional string - A note to remind you what the OAuth token is for.
+      # * <tt>:note_url</tt> - Optional string - A URL to remind you what the OAuth token is for.
+      #
+      # = Examples
+      #  nimbu = Nimbu.new :basic_auth => 'login:password'
+      #  nimbu.oauth.create
+      #    "scopes" => ["public_repo"]
+      #
+      def create(*args)
+        require_authentication
+        arguments(args) do
+          sift VALID_AUTH_PARAM_NAMES
+        end
+
+        post_request("/authorizations", arguments.params)
+      end
+
+      # Update an existing authorization
+      #
+      # = Inputs
+      # * <tt>:scopes</tt> - Optional array - A list of scopes that this authorization is in.
+      # * <tt>:add_scopes</tt> - Optional array - A list of scopes to add to this authorization.
+      # * <tt>:remove_scopes</tt> - Optional array - A list of scopes to remove from this authorization.
+      # * <tt>:note</tt> - Optional string - A note to remind you what the OAuth token is for.
+      # * <tt>:note_url</tt> - Optional string - A URL to remind you what the OAuth token is for.
+      #
+      # = Examples
+      #  nimbu = Nimbu.new :basic_auth => 'login:password'
+      #  nimbu.oauth.update "authorization-id", "add_scopes" => ["repo"],
+      #
+      def update(*args)
+        require_authentication
+        arguments(args, :required => [:authorization_id]) do
+          sift VALID_AUTH_PARAM_NAMES
+        end
+
+        patch_request("/authorizations/#{authorization_id}", arguments.params)
+      end
+      alias :edit :update
+
+      # Delete an authorization
+      #
+      # = Examples
+      #  nimbu.oauth.delete 'authorization-id'
+      #
+      def delete(*args)
+        require_authentication
+        arguments(args, :required => [:authorization_id])
+
+        delete_request("/authorizations/#{authorization_id}", arguments.params)
+      end
+      alias :remove :delete
+
+      private
+
+      def require_authentication
+        raise ArgumentError, 'You can only access authentication tokens through Basic Authentication' unless authenticated?
+      end
+
+    end # Authorizations
+  end # Endpoints
+end # Nimbu

data/lib/nimbu-api/endpoints/channels.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+
+module Nimbu
+  module Endpoints
+    class Channels < Endpoint
+
+      def entries(options={}, &block)
+        @entries ||= Nimbu::Builder.new('Channels::Entries', current_options.merge(options), &block)
+      end
+
+      def list(*args)
+        arguments(args)
+
+        response = get_request("/channels", arguments.params)
+        return response unless block_given?
+        response.each { |el| yield el }
+      end
+      alias :all :list
+
+      def get(*args)
+        arguments(args, :required => [:channel_id])
+
+        get_request("/channels/#{channel_id}", arguments.params)
+      end
+      alias :find :get
+
+
+    end # Authorizations
+  end # Endpoints
+end # Nimbu

data/lib/nimbu-api/endpoints/channels/entries.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Nimbu
+  module Endpoints
+    class Channels::Entries < Endpoint
+
+      def list(*args)
+        arguments(args, :required => [:channel_id])
+
+        response = get_request("/channels/#{channel_id}/entries", arguments.params)
+
+        if block_given?
+          response.each { |el| yield el }
+        else
+          return response
+        end
+      end
+      alias :all :list
+
+      def get(*args)
+        arguments(args, :required => [:channel_id, :entry_id])
+
+        get_request("/channels/#{channel_id}/entries/#{entry_id}", arguments.params)
+      end
+      alias :find :get
+
+      def create(*args)
+        arguments(args, :required => [:channel_id])
+
+        post_request("/channels/#{channel_id}/entries", arguments.params, :with_attachments => true)
+      end
+
+      def update(*args)
+        arguments(args, :required => [:channel_id, :entry_id])
+
+        patch_request("/channels/#{channel_id}/entries/#{entry_id}", arguments.params, :with_attachments => true)
+      end
+      alias :edit :update
+
+      def delete(*args)
+        arguments(args, :required => [:channel_id, :entry_id])
+
+        delete_request("/channels/#{channel_id}/entries/#{entry_id}", arguments.params)
+      end
+      alias :remove :delete
+
+
+    end # Authorizations
+  end # Endpoints
+end # Nimbu

data/lib/nimbu-api/endpoints/sites.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Nimbu
+  module Endpoints
+    class Sites < Endpoint
+
+      def list(*args)
+        require_authentication
+        arguments(args)
+
+        response = get_request("/sites", arguments.params)
+        return response unless block_given?
+        response.each { |el| yield el }
+      end
+      alias :all :list
+
+      def get(*args)
+        require_authentication
+        arguments(args, :required => [:site_id])
+
+        get_request("/authorizations/#{site_id}", arguments.params)
+      end
+      alias :find :get
+
+
+      private
+
+      def require_authentication
+        raise ArgumentError, 'You need to be authentication to access the sites' unless authenticated?
+      end
+
+    end # Authorizations
+  end # Endpoints
+end # Nimbu

data/lib/nimbu-api/endpoints/videos.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Nimbu
+  module Endpoints
+    class Videos < Endpoint
+
+      def list(*args)
+        arguments(args)
+
+        response = get_request("/videos", arguments.params)
+        return response unless block_given?
+        response.each { |el| yield el }
+      end
+      alias :all :list
+
+      def get(*args)
+        arguments(args, :required => [:video_id])
+
+        get_request("/videos/#{video_id}", arguments.params)
+      end
+      alias :find :get
+
+
+    end # Authorizations
+  end # Endpoints
+end # Nimbu