rescue_groups 0.0.1

data/lib/remote_client.rb

@@ -0,0 +1,29 @@
+require 'httparty'
+require_relative './response'
+
+module RescueGroups
+  # HTTParty wrapper with defaulted values
+  #  for Content-Type, URL and apikey authentication
+  class RemoteClient
+    include HTTParty
+
+    base_uri 'https://api.rescuegroups.org/http/json'
+    headers 'Content-Type' => 'application/json'
+
+    # method: post_and_respond
+    # purpose: make a POST request to the RescueGroups API and respond
+    # param: post_body - <Hash> - attributes to be included in the post body
+    # return: response <Response> object with details of HTTP response
+    def post_and_respond(post_body)
+      if RescueGroups.config.apikey.nil? || RescueGroups.config.apikey.length == 0
+        raise 'No RescueGroups API Key set'
+      end
+
+      response = self.class.post(
+        self.class.base_uri,
+        { body: JSON(post_body.merge(apikey: RescueGroups.config.apikey)) })
+
+      Response.new(response)
+    end
+  end
+end

data/lib/remote_model.rb

@@ -0,0 +1,47 @@
+require_relative './api_client'
+require_relative '../lib/queryable'
+require_relative '../lib/relationable'
+require_relative '../models/picture'
+
+module RescueGroups
+  class RemoteModel
+    include ApiClient
+    include Queryable
+    include Relationable
+
+    # method: initialize
+    # purpose: given a hash of attributes, assign the attributes that the
+    #            included model has defined and discard the rest
+    # param: attribute_hash - <Hash> - hash of attributes to instantiate
+    #          this model with
+    # return: nil
+    def initialize(attribute_hash = {})
+      (attribute_hash || {}).each do |key, value|
+        mapped_key = self.class.object_fields::FIELDS.key(key.to_sym)
+        mapped_method = "#{ mapped_key }="
+        next unless self.respond_to?(mapped_method)
+        self.send(mapped_method, cast_attribute_to_type(mapped_key, value))
+      end
+    end
+
+    def cast_attribute_to_type(name, value)
+      return value.to_i if name.to_s == 'id' || name =~ /_id/
+
+      value
+    end
+
+    # method: attributes
+    # purpose: Distill the included class's attributes into a hash of keys and values
+    #          If an attribute is nil, the key for that attribute is still included
+    #            in the resulting hash and the value is nil
+    # param: none
+    # return: <Hash> of attributes from the included class
+    def attributes
+      {}.tap do |hash|
+        self.class.object_fields::FIELDS.keys.each do |attribute|
+          hash[attribute] = instance_variable_get(:"@#{ attribute }")
+        end
+      end
+    end
+  end
+end

data/lib/requests/find.rb

@@ -0,0 +1,29 @@
+require_relative './invalid_client'
+
+module RescueGroups
+  module Requests
+    class Find
+      def initialize(ids, model, client)
+        @ids = [*ids].flatten.uniq.map(&:to_i)
+        @model = model
+        @client = client
+      rescue NoMethodError
+        raise 'Only initialize a Requests::Find with integers or models responding to .to_i'
+      end
+
+      def request
+        raise InvalidClient, 'Invalid client given to Requests::Find' unless @client.respond_to?(:post_and_respond)
+        @client.post_and_respond(as_json)
+      end
+
+      def as_json(*)
+        {
+          objectAction: :publicView,
+          objectType:   @model.object_type,
+          fields:       @model.object_fields.all,
+          values:       @ids.map { |i| { @model.object_fields::FIELDS[:id] => i } }
+        }
+      end
+    end
+  end
+end

data/lib/requests/invalid_client.rb

@@ -0,0 +1 @@
+class InvalidClient < StandardError; end

data/lib/requests/where.rb

@@ -0,0 +1,94 @@
+require_relative './invalid_client'
+
+module RescueGroups
+  module Requests
+    class Where
+      attr_reader :search_engine, :results
+
+      def initialize(conditions, model, client, search_engine_class)
+        modifiers = %i[limit start sort order]
+
+        conditions.each do |key, value|
+          if modifiers.include?(key.to_sym)
+            instance_variable_set(:"@#{ key }", conditions.delete(key))
+          end
+        end
+
+        @conditions = conditions
+        @model = model
+        @client = client
+        @search_engine = build_search_engine(search_engine_class)
+        @results = { 'data' => {} }
+      end
+
+      def request
+        raise InvalidClient, 'Invalid client given to Requests::Where' unless @client.respond_to?(:post_and_respond)
+        response = @client.post_and_respond(as_json)
+
+        if response.success? && !response['data'].empty?
+          @results['found_rows'] = response['found_rows']
+          @results['data'].merge!(response['data'])
+        end
+
+        response
+      end
+
+      def as_json(*)
+        {
+          objectAction: :publicSearch,
+          objectType:   @model.object_type,
+          search:       @search_engine.as_json,
+        }
+      end
+
+      def update_conditions!(conditions)
+        @conditions.merge!(conditions)
+      end
+
+      def can_request_more?
+        return false if results.nil? || results['data'].nil? || results['data'].empty?
+        !results['found_rows'].nil? && results['data'].keys.length < results['found_rows']
+      end
+
+      private
+
+      def build_search_engine(search_engine_class)
+        args = {
+          limit: @limit,
+          start: @start,
+          sort: @sort,
+        }.reject { |_, v| v.nil? }
+
+        search = search_engine_class.new(**args)
+
+        add_filters_to_search_engine(search)
+
+        search
+      end
+
+      def add_filters_to_search_engine(search)
+        conditions_to_rescue_groups_key_value do |mapped_key, val|
+          equality_operator = :equal
+
+          if val.is_a?(Hash)
+            equality_operator = val.keys[0]
+            val = val.values[0]
+          end
+
+          search.add_filter(mapped_key, equality_operator, val)
+        end
+      end
+
+      def conditions_to_rescue_groups_key_value(&block)
+        fail('Block not given') unless block_given?
+        @conditions.each do |key, value|
+          mapped_key = @model.object_fields::FIELDS[key.to_sym]
+
+          next if mapped_key.nil?
+
+          yield mapped_key, value
+        end
+      end
+    end
+  end
+end

data/lib/response.rb

@@ -0,0 +1,48 @@
+module RescueGroups
+  class Response
+    attr_accessor :http_status_code, :parsed_body
+
+    # method: initialize
+    # purpose: When a Response is created, this method
+    #            extracts the code and parsed_response from
+    #            the raw HTTParty response
+    # param: raw_response - <HTTParty Response> - raw HTTParty response
+    # return: nil
+    def initialize(raw_response)
+      @http_status_code = raw_response.code
+      @parsed_body      = raw_response.parsed_response
+    end
+
+    # method: []
+    # purpose: Convenience method to access an attribute from
+    #            the parsed body
+    # param: attribute - <String> - key of desired value from response
+    # return: value at the specified key of the response
+    def [](attribute)
+      @parsed_body[attribute]
+    end
+
+    # method: success
+    # purpose: return true/false for if the response had an error (Non-HTTP error)
+    # param: none
+    # return: <Boolean> state of the response['status']
+    def success?
+      self['status'] != 'error'
+    end
+
+    # method: error
+    # purpose: traverse down response tree and extract the error
+    #            text on errorful responses
+    # param: none
+    # return: <Nil> if there is no error
+    #         <String> if an error exists and messageCriticality is expected
+    #                  value
+    def error
+      unless success?
+        self['messages']['generalMessages'].map do |m|
+          m['messageText'] if m['messageCriticality'] == 'error'
+        end.compact.join("\n")
+      end
+    end
+  end
+end

data/models/animal.rb

@@ -0,0 +1,57 @@
+require_relative '../lib/remote_model'
+require_relative '../search/animal_search'
+
+module RescueGroups
+  class Animal < RemoteModel
+    belongs_to :organization
+
+    class << self
+      # method :object_type
+      # purpose: Define this class's object_type used by the
+      #            the Queryable module when composing remote queries
+      # param: none
+      # return: <Symbol> - the value of the object_type
+      def object_type
+        :animals
+      end
+
+      # method :object_fields
+      # purpose: Define this class's object fields class used by the
+      #            the Queryable module when composing remote queries
+      # param: none
+      # return: <Constant> - the class containing the list of fields
+      #                        pertinent to this class
+      def object_fields
+        AnimalField
+      end
+
+      # method :search_engine_class
+      # purpose: Define which search engine is used by the class. The Queryable
+      #           module uses the search engine when constructing remote queries to make
+      #
+      # param: none
+      # return: <Constant> - the class that contains search data pertinent to this class
+      def search_engine_class
+        AnimalSearch
+      end
+    end
+
+    def initialize(*args)
+      super
+
+      extract_pictures if !@pictures.nil? && !@pictures.empty?
+    end
+
+    attr_accessor *object_fields::FIELDS.keys
+
+    private
+
+    def extract_pictures
+      @pictures.map! do |picture_data|
+        Picture.new(picture_data).tap do |picture|
+          picture.animal_id = self.id
+        end
+      end
+    end
+  end
+end

data/models/event.rb

@@ -0,0 +1,41 @@
+require_relative '../lib/remote_model'
+require_relative '../search/event_search'
+
+module RescueGroups
+  class Event < RemoteModel
+    belongs_to :organization
+
+    class << self
+      # method :object_type
+      # purpose: Define this class's object_type used by the
+      #            the Queryable module when composing remote queries
+      # param: none
+      # return: <Symbol> - the value of the object_type
+      def object_type
+        :events
+      end
+
+      # method :object_fields
+      # purpose: Define this class's object fields class used by the
+      #            the Queryable module when composing remote queries
+      # param: none
+      # return: <Constant> - the class containing the list of fields
+      #                        pertinent to this class
+      def object_fields
+        EventField
+      end
+
+      # method :search_engine_class
+      # purpose: Define which search engine is used by the class. The Queryable
+      #           module uses the search engine when constructing remote queries to make
+      #
+      # param: none
+      # return: <Constant> - the class that contains search data pertinent to this class
+      def search_engine_class
+        EventSearch
+      end
+    end
+
+    attr_accessor *object_fields::FIELDS.keys
+  end
+end

data/models/organization.rb

@@ -0,0 +1,41 @@
+require_relative '../lib/remote_model'
+require_relative '../search/organization_search'
+
+module RescueGroups
+  class Organization < RemoteModel
+    has_many :animals
+
+    class << self
+      # method :object_type
+      # purpose: Define this class's object_type used by the
+      #            the Queryable module when composing remote queries
+      # param: none
+      # return: <Symbol> - the value of the object_type
+      def object_type
+        :orgs
+      end
+
+      # method :object_fields
+      # purpose: Define this class's object fields class used by the
+      #            the Queryable module when composing remote queries
+      # param: none
+      # return: <Constant> - the class containing the list of fields
+      #                        pertinent to this class
+      def object_fields
+        OrganizationField
+      end
+
+      # method :search_engine_class
+      # purpose: Define which search engine is used by the class. The Queryable
+      #           module uses the search engine when constructing remote queries to make
+      #
+      # param: none
+      # return: <Constant> - the class that contains search data pertinent to this class
+      def search_engine_class
+        OrganizationSearch
+      end
+    end
+
+    attr_accessor *object_fields::FIELDS.keys
+  end
+end

data/models/picture.rb

@@ -0,0 +1,26 @@
+require_relative '../fields/picture_field'
+
+module RescueGroups
+  class Picture
+    include Relationable
+
+    belongs_to :animal
+
+    attr_accessor *PictureField::FIELDS.values
+
+    def initialize(attribute_hash = {})
+      attribute_hash.each do |key, value|
+        mapped_key = PictureField::FIELDS[key.to_sym]
+        self.send(:"#{ mapped_key }=", value) unless mapped_key.nil?
+      end
+    end
+
+    def url(secure: false)
+      secure ? url_full : insecure_url_full
+    end
+
+    def url_thumb(secure: false)
+      secure ? url_thumbnail : insecure_url_thumb
+    end
+  end
+end

data/rescue_groups.gemspec

@@ -0,0 +1,28 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'version'
+
+Gem::Specification.new do |s|
+  s.name          = 'rescue_groups'
+  s.version       = RescueGroups::VERSION
+  s.summary       = %q{RescueGroups.org API wrapper}
+  s.description   = %q{Ruby ORM for the RescueGroups API. On demand pet data provided for free by RescueGroups.org.}
+  s.authors       = ['Jake Yesbeck']
+  s.email         = 'yesbeckjs@gmail.com'
+  s.homepage      = 'http://rubygems.org/gems/rescue_groups'
+  s.license       = 'MIT'
+
+  s.require_paths = %w(lib models search config)
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = s.files.grep(/^spec\//)
+
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_dependency 'httparty', '>= 0.13.0'
+
+  s.add_development_dependency 'bundler', '~> 1.3'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'guard-rspec'
+end