thecity 0.0.2

data/lib/the_city/api/prayers.rb

@@ -0,0 +1,51 @@
+require 'the_city/arguments'
+require 'the_city/api/utils'
+require 'the_city/prayer'
+
+module TheCity
+  module API
+    module prayers
+      include TheCity::API::Utils
+  
+      # Posts a prayer to The City
+      #
+      # @see https://api.onthecity.org/docs
+      #
+      # @req_scope group_content
+      # @return [TheCity::Prayer]
+      # @param options [Hash] A customizable set of options.
+      # @option options [Integer] :group_id The id of the group you will be posting to.
+      # @option options [String] :title The title of the prayer.
+      # @option options [String] :body The body text of the prayer.
+      def post_prayer(options)
+        raise(Error::ArgumentError, "Must supply a options[:group_id] for the prayers's originating group") unless options[:group_id]
+        raise(Error::ArgumentError, "Title (options[:title]) required") unless options[:title]
+        raise(Error::ArgumentError, "Body (options[:body]) required") unless options[:body]
+        gid = options[:group_id] || 0
+        object_from_response(TheCity::Prayer, :post, "/groups/#{gid}/prayers/", options, {:client => self})
+      end
+
+      # Returns a prayer by id
+      #
+      # @see https://api.onthecity.org/docs
+      #
+      # @req_scope group_content
+      # @return [TheCity::Prayer]
+      # @raise [TheCity::Error::NotFound] Error raised when the prayer cannot be found.
+      # @overload prayer(id)
+      #   @param id [Integer] The id of the prayer.
+      # @overload prayer(id, options={})
+      #   @param id [Integer] The id of the prayer.
+      #   @param options [Hash] A customizable set of options.
+      #   @option options [Boolean] :force_download Forces the request to hit the server and flush the cached response
+      def prayer(*args)
+        @prayers ||= {}
+        arguments = TheCity::Arguments.new(args)
+        pid = args.shift
+        @prayers[pid] = nil if arguments.options.delete(:force_download)
+        @prayers[pid] ||= object_from_response(TheCity::Prayer, :get, "/prayers/#{pid}", arguments.options, {:client => self})
+      end
+
+    end
+  end
+end

data/lib/the_city/api/request/multipart_with_file.rb

@@ -0,0 +1,36 @@
+require 'faraday'
+
+module TheCity
+  module API
+    module Request
+      class MultipartWithFile < Faraday::Middleware
+        CONTENT_TYPE = 'Content-Type'
+
+        def call(env)
+          for key, value in env[:body]
+            if value.respond_to?(:to_io)
+              env[:body][key] = Faraday::UploadIO.new(value, mime_type(value.path), value.path)
+            end
+          end if env[:body].is_a?(::Hash)
+          @app.call(env)
+        end
+
+      private
+
+        def mime_type(path)
+          case path
+          when /\.jpe?g/i
+            'image/jpeg'
+          when /\.gif$/i
+            'image/gif'
+          when /\.png$/i
+            'image/png'
+          else
+            'application/octet-stream'
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/the_city/api/response/parse_json.rb

@@ -0,0 +1,27 @@
+require 'faraday'
+require 'json'
+
+module TheCity
+  module API
+    module Response
+      class ParseJson < Faraday::Response::Middleware
+
+        def parse(body)
+          case body
+          when /\A^\s*$\z/, nil
+            nil
+          else
+            JSON.parse(body, :symbolize_names => true)
+          end
+        end
+
+        def on_complete(env)
+          if respond_to?(:parse)
+            env[:body] = parse(env[:body]) unless [204, 301, 302, 304].include?(env[:status])
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/the_city/api/response/raise_error.rb

@@ -0,0 +1,28 @@
+require 'faraday'
+require 'the_city/error/bad_gateway'
+require 'the_city/error/bad_request'
+require 'the_city/error/forbidden'
+require 'the_city/error/gateway_timeout'
+require 'the_city/error/internal_server_error'
+require 'the_city/error/not_acceptable'
+require 'the_city/error/not_found'
+require 'the_city/error/service_unavailable'
+require 'the_city/error/too_many_requests'
+require 'the_city/error/unauthorized'
+require 'the_city/error/unprocessable_entity'
+
+module TheCity
+  module API
+    module Response
+      class RaiseError < Faraday::Response::Middleware
+
+        def on_complete(env)
+          status_code = env[:status].to_i
+          error_class = TheCity::Error.errors[status_code]
+          raise error_class.from_response(env) if error_class
+        end
+
+      end
+    end
+  end
+end

data/lib/the_city/api/topics.rb

@@ -0,0 +1,51 @@
+require 'the_city/arguments'
+require 'the_city/api/utils'
+require 'the_city/topic'
+
+module TheCity
+  module API
+    module Topics
+      include TheCity::API::Utils
+  
+      # Posts a topic to The City
+      #
+      # @see https://api.onthecity.org/docs
+      #
+      # @req_scope group_content
+      # @return [TheCity::Topic]
+      # @param options [Hash] A customizable set of options.
+      # @option options [Integer] :group_id The id of the group you will be posting to.
+      # @option options [String] :title The title of the topic.
+      # @option options [String] :body The body text of the topic.
+      def post_topic(options)
+        raise(Error::ArgumentError, "Must supply a options[:group_id] for the topic's originating group") unless options[:group_id]
+        raise(Error::ArgumentError, "Title (options[:title]) required") unless options[:title]
+        raise(Error::ArgumentError, "Body (options[:body]) required") unless options[:body]
+        gid = options[:group_id] || 0
+        object_from_response(TheCity::Topic, :post, "/groups/#{gid}/topics/", options, {:client => self})
+      end
+
+      # Returns a topic by id
+      #
+      # @see https://api.onthecity.org/docs
+      #
+      # @req_scope group_content
+      # @return [TheCity::Topic]
+      # @raise [TheCity::Error::NotFound] Error raised when the topic cannot be found.
+      # @overload topic(id)
+      #   @param id [Integer] The id of the topic.
+      # @overload topic(id, options={})
+      #   @param id [Integer] The id of the topic.
+      #   @param options [Hash] A customizable set of options.
+      #   @option options [Boolean] :force_download Forces the request to hit the server and flush the cached response
+      def topic(*args)
+        @topics ||= {}
+        arguments = TheCity::Arguments.new(args)
+        tid = args.shift
+        @topics[tid] = nil if arguments.options.delete(:force_download)
+        @topics[tid] ||= object_from_response(TheCity::Topic, :get, "/topics/#{tid}", arguments.options, {:client => self})
+      end
+
+    end
+  end
+end

data/lib/the_city/api/users.rb

@@ -0,0 +1,78 @@
+require 'the_city/api/utils'
+
+module TheCity
+  module API
+    module Users
+      include TheCity::API::Utils
+
+      # @see https://api.onthecity.org/docs
+      #
+      # @return [TheCity::User] The requested user.
+      # @raise [TheCity::Error::NotFound] Error raised when the user cannot be found.
+      # @req_scope user_trusted
+      # @overload user(id)
+      #   @param id [Integer] The id of the user.
+      # @overload user(id, options={})
+      #   @param id [Integer] The id of the user.
+      #   @param options [Hash] A customizable set of options.
+      #   @option options [Boolean] :force_download Forces the request to hit the server and flush the cached response
+      def user(*args)
+        @users ||= {}
+        arguments = TheCity::Arguments.new(args)
+        uid = args.shift
+        @users[uid] = nil if arguments.options.delete(:force_download)
+        @users[uid] ||= object_from_response(TheCity::User, :get, "/users/#{uid}", arguments.options, {:client => self})
+      end
+
+      # Returns the user associated with the current access token
+      #
+      # @see https://api.onthecity.org/docs
+      #
+      # @req_scope user_basic
+      # @opt_scope user_extended
+      # @return [TheCity::User] The authenticated user.
+      # @param options [Hash] A customizable set of options.
+      # @option options [Boolean] :force_download Forces the request to hit the server and flush the cached response
+      def me(options={})
+        @me = nil if options.delete(:force_download)
+        @me ||= object_from_response(TheCity::User, :get, "/me", options, {:current_user => true, :client => self})
+      end
+      alias current_user me
+
+      # Returns the permissions for the current user
+      #
+      # @see https://api.onthecity.org/docs
+      #
+      # @req_scope user_permissions
+      # @opt_scope group_content
+      # @return [TheCity::Permissions] The permission object for the current user.
+      # @overload permissions(options={})
+      #   @param options [Hash] A customizable set of options.
+      def permissions(*args)
+        arguments = TheCity::Arguments.new(args)
+        object_from_response(TheCity::Permissions, :get, "/me/permissions", arguments.options)
+      end
+
+      # Returns true if the specified user exists
+      #
+      # @req_scope user_trusted
+      # @return [Boolean] true if the user exists, otherwise false.
+      # @param user [Integer, String, TheCity::User] A City user id, or object.
+      def user?(user)
+        user_id = case user
+        when ::Integer
+          user
+        when ::String
+          user.to_i
+        when TheCity::User
+          user.id
+        end
+        get("/users/#{user_id}")
+        true
+      rescue TheCity::Error::NotFound
+        false
+      end
+
+    end
+  end
+end

data/lib/the_city/api/utils.rb

@@ -0,0 +1,58 @@
+require 'the_city/arguments'
+require 'the_city/collection'
+require 'the_city/user'
+require 'the_city/group'
+require 'the_city/account'
+require 'uri'
+
+module TheCity
+  module API
+    module Utils
+
+    private
+
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param request_options [Hash]
+      # @param options [Hash]
+      # @return [Array]
+      def objects_from_response(klass, request_method, path, request_options={}, options ={})
+        response = send(request_method.to_sym, path, request_options)[:body]
+        objects_from_array(klass, response, options)
+      end
+
+      # @param klass [Class]
+      # @param array [Array]
+      # @return [Array]
+      def objects_from_array(klass, array, options={})
+        array.map do |element|
+          klass.new(element, options)
+        end
+      end
+
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param request_options [Hash]
+      # @param options [Hash]
+      # @return [Object]
+      def object_from_response(klass, request_method, path, request_options={}, options ={})
+        response = send(request_method.to_sym, path, request_options)
+        klass.from_response(response, options)
+      end
+
+      # @param collection_name [Symbol]
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param request_options [Hash]
+      # @return [TheCity::Collection]
+      def collection_from_response(collection_name, klass, request_method, path, request_options)
+        response = send(request_method.to_sym, path, request_options)
+        TheCity::Collection.from_response(response, collection_name.to_sym, klass, self, request_method, path, request_options)
+      end
+
+    end
+  end
+end

data/lib/the_city/arguments.rb

@@ -0,0 +1,11 @@
+module TheCity
+  class Arguments < Array
+    attr_reader :options
+
+    def initialize(args)
+      @options = args.last.is_a?(::Hash) ? args.pop : {}
+      super(args)
+    end
+
+  end
+end

data/lib/the_city/base.rb

@@ -0,0 +1,133 @@
+require 'forwardable'
+require 'uri'
+
+module TheCity
+  class Base
+    extend Forwardable
+    attr_reader :attrs
+    alias to_h attrs
+    alias to_hash attrs
+    alias to_hsh attrs
+    def_delegators :attrs, :delete, :update
+
+    # Define methods that retrieve the value from attributes
+    #
+    # @param attrs [Array, Symbol]
+    def self.attr_reader(*attrs)
+      for attr in attrs
+        define_attribute_method(attr)
+        define_predicate_method(attr)
+      end
+    end
+
+    # Define object methods from attributes
+    #
+    # @param klass [Symbol]
+    # @param key1 [Symbol]
+    # @param key2 [Symbol]
+    def self.object_attr_reader(klass, key1, key2=nil)
+      define_attribute_method(key1, klass, key2)
+      define_predicate_method(key1)
+    end
+
+    # Define URI methods from attributes
+    #
+    # @param attrs [Array, Symbol]
+    def self.uri_attr_reader(*attrs)
+      for uri_key in attrs
+        array = uri_key.to_s.split("_")
+        index = array.index("uri")
+        array[index] = "url"
+        url_key = array.join("_").to_sym
+        define_uri_method(uri_key, url_key)
+        define_predicate_method(uri_key, url_key)
+        alias_method(url_key, uri_key)
+        alias_method("#{url_key}?", "#{uri_key}?")
+      end
+    end
+
+    # Dynamically define a method for a URI
+    #
+    # @param key1 [Symbol]
+    # @param key2 [Symbol]
+    def self.define_uri_method(key1, key2)
+      define_method(key1) do
+        memoize(key1) do
+          ::URI.parse(@attrs[key2]) if @attrs[key2]
+        end
+      end
+    end
+
+    # Dynamically define a method for an attribute
+    #
+    # @param key1 [Symbol]
+    # @param klass [Symbol]
+    # @param key2 [Symbol]
+    def self.define_attribute_method(key1, klass=nil, key2=nil)
+      define_method(key1) do
+
+        memoize(key1) do
+          if klass.nil?
+            @attrs[key1]
+          else
+            if @attrs[key1]
+              if key2.nil?
+                TheCity.const_get(klass).new(@attrs[key1])
+              else
+                attrs = @attrs.dup
+                value = attrs.delete(key1)
+                TheCity.const_get(klass).new(value.update(key2 => attrs))
+              end
+            else
+              TheCity::NullObject.instance
+            end
+          end
+        end
+      end
+    end
+
+    # Dynamically define a predicate method for an attribute
+    #
+    # @param key1 [Symbol]
+    # @option key2 [Symbol]
+    def self.define_predicate_method(key1, key2=key1)
+      define_method(:"#{key1}?") do
+        !!@attrs[key2]
+      end
+    end
+
+    # Construct an object from a response hash
+    #
+    # @param response [Hash]
+    # @return [TheCity::Base]
+    def self.from_response(response, options)
+      new(response[:body], options)
+    end
+
+    # Initializes a new object
+    #
+    # @param attrs [Hash]
+    # @return [TheCity::Base]
+    def initialize(attrs={}, options={})
+      @attrs = attrs || {}
+      @client = options.delete(:client) rescue nil
+    end
+
+    # Fetches an attribute of an object using hash notation
+    #
+    # @param method [String, Symbol] Message to send to the object
+    def [](method)
+      send(method.to_sym)
+    rescue NoMethodError
+      nil
+    end
+
+    def memoize(key, &block)
+      ivar = :"@#{key}"
+      return instance_variable_get(ivar) if instance_variable_defined?(ivar)
+      result = block.call
+      instance_variable_set(ivar, result)
+    end
+
+  end
+end

data/lib/the_city/client.rb

@@ -0,0 +1,94 @@
+require 'the_city/version'
+require 'uri'
+
+module TheCity
+  class Client
+    attr_writer :access_token, :app_id, :app_secret, :subdomain, :version
+    alias oauth_token= access_token=
+
+    # Initializes a new Client object
+    #
+    # @param options [Hash]
+    # @return [TheCity::API::Client]
+    def initialize(options={})
+      for key, value in options
+        send(:"#{key}=", value)
+      end
+      yield self if block_given?
+    end
+
+    # @return [String]
+    def subdomain
+      if instance_variable_defined?(:@subdomain)
+        @subdomain
+      else
+        ENV['THECITY_SUBDOMAIN']
+      end
+    end
+
+    # @return [String]
+    def app_id
+      if instance_variable_defined?(:@app_id)
+        @app_id
+      else
+        ENV['THECITY_APP_ID']
+      end
+    end
+
+    # @return [String]
+    def app_secret
+      if instance_variable_defined?(:@app_secret)
+        @app_secret
+      else
+        ENV['THECITY_APP_SECRET']
+      end
+    end
+
+    # @return [String]
+    def access_token
+      if instance_variable_defined?(:@access_token)
+        @access_token
+      else
+        ENV['THECITY_ACCESS_TOKEN']
+      end
+    end
+    alias oauth_token access_token
+
+    # @return [String]
+    def version
+      if instance_variable_defined?(:@version)
+        @api_version || "1"
+      elsif ENV['THECITY_API_VERSION']
+        ENV['THECITY_API_VERSION']
+      else
+        "1"
+      end
+    end
+    alias api_version version
+
+    # @return [Hash]
+    def credentials
+      {
+        :app_id     => app_id,
+        :app_secret => app_secret,
+        :token      => access_token,
+      }
+    end
+
+    # @return [Boolean]
+    def credentials?
+      credentials.values.all?
+    end
+
+  private
+
+    # Ensures that all credentials set during configuration are of a
+    # valid type. Valid types are String and Symbol.
+    def validate_credentials!
+      for credential, value in credentials
+        raise(Error::ConfigurationError, "Invalid #{credential} specified: #{value.inspect} must be a string or symbol.") unless value.is_a?(String) || value.is_a?(Symbol)
+      end
+    end
+
+  end
+end

data/lib/the_city/collection.rb

@@ -0,0 +1,130 @@
+module TheCity
+  # Utility class for collections with paged responses
+  class Collection
+    include Enumerable
+    attr_reader :attrs
+    alias to_h attrs
+    alias to_hash attrs
+    alias to_hsh attrs
+
+    # Construct a new Collection object from a response hash
+    #
+    # @param response [Hash]
+    # @param key [String, Symbol] The key to fetch the data from the response
+    # @param klass [Class] The class to instantiate objects in the response
+    # @param client [TheCity::API::Client]
+    # @param request_method [String, Symbol]
+    # @param path [String]
+    # @param options [Hash]
+    # @return [TheCity::Collection]
+    def self.from_response(response, key, klass, client, request_method, path, options)
+      new(response[:body], key, klass, client, request_method, path, options)
+    end
+
+    # Initializes a new Collection
+    #
+    # @param attrs [Hash]
+    # @param key [String, Symbol] The key to fetch the data from the response
+    # @param klass [Class] The class to instantiate objects in the response
+    # @param client [TheCity::API::Client]
+    # @param request_method [String, Symbol]
+    # @param path [String]
+    # @param options [Hash]
+    # @return [TheCity::Collection]
+    def initialize(attrs, key, klass, client, request_method, path, options)
+      @key = key.to_sym
+      @klass = klass
+      @client = client
+      @request_method = request_method.to_sym
+      @path = path
+      @options = options
+      @collection = []
+      set_attrs(attrs)
+    end
+
+    # @return [Enumerator]
+    def each(start = 0, &block)
+      return to_enum(:each) unless block_given?
+      for element in Array(@collection[start..-1])
+        yield element
+        @current_cursor += 1
+      end
+      unless last?
+        start = [@collection.size, start].max
+        fetch_next_page unless last_page?
+        each(start, &block)
+      end
+      @current_cursor = 1
+      self
+    end
+
+    def current_cursor
+      @current_cursor
+    end
+
+    def next_cursur
+      (current_cursor + 1) || -1
+    end
+    alias next next_cursur
+
+    def previous_cursor
+      current_cursor - 1
+    end
+    alias previous previous_cursor
+
+    # @return [Boolean]
+    def first?
+      previous_cursor.zero?
+    end
+
+    # @return [Boolean]
+    def last?
+      current_cursor >= total_entries
+    end
+
+    def current_page
+      @current_page
+    end
+
+    def next_page
+      current_page + 1
+    end
+
+    def last_page?
+      current_page == @total_pages
+    end
+
+    def total_entries
+      @total_entries.is_a?(Array) ? @total_entries.first : @total_entries
+    end
+    alias total total_entries
+
+    def [](n)
+      @collection[n]
+    end
+
+    def last
+      @collection.last
+    end
+
+  private
+
+    def fetch_next_page
+      response = @client.send(@request_method, @path, @options.merge(:page => next_page, :per_page => @per_page))
+      set_attrs(response[:body])
+    end
+
+    def set_attrs(attrs)
+      @attrs = attrs
+      for element in Array(attrs[@key])
+        @collection << (@klass ? @klass.new(element) : element)
+      end
+      @total_entries = attrs[:total_entries],
+      @current_page = attrs[:current_page],
+      @total_pages = attrs[:total_pages],
+      @per_page = attrs[:per_page],
+      @current_cursor = ((@current_page - 1) * @per_page) + 1
+    end
+
+  end
+end