login_radius 1.0.1 → 11.0.0.pre.beta

data/lib/hash.rb

@@ -1,13 +0,0 @@
-class Hash
-  def self.lr_convert_hash_keys(value) #lr_ appended so no method naming conflicts with other gems
-    case value
-      when Array
-        value.map { |v| lr_convert_hash_keys(v) }
-        # or `value.map(&method(:convert_hash_keys))`
-      when Hash
-        Hash[value.map { |k, v| [k.to_s.lr_underscore, lr_convert_hash_keys(v)] }]
-      else
-        value
-     end
-  end
-end

data/lib/login_radius/exception.rb

@@ -1,4 +0,0 @@
-module LoginRadius
-  class Exception < Exception
-  end
-end

data/lib/login_radius/messages.rb

@@ -1,41 +0,0 @@
-module LoginRadius
-  module Messages
-
-    # Sends a Status message to on facebook. Params hash takes following keys:
-    # access_token :- [Required parameter] access token 
-    # title :- [optional parameter] status message title
-    # url:- [optional parameter] any url that you want post in status message
-    # imageurl :- [optional parameter] any image url that you want post in status message
-    # status :- your status message
-    # caption : [optional parameter] caption that you want post in status message
-    # description :- [optional parameter] description  that you want post in status message
-    #
-    # @param params [Hash] 
-    # @return [Boolean] Whether or not message succeeded
-    def post_status!(params = {})
-      call_api("api/v2/status/js", params)
-    end
-    def post_status(params = {})
-      post_status!(params)
-    rescue LoginRadius::Exception => e
-      false
-    end
-    
-    # Sends a Direct message to on facebook. Params hash takes following keys:
-    # access_token :- [Required parameter] access token 
-    # to :- [Required parameter] with whom you want post you direct message
-    # subject :- [optional parameter] any subject that you want post in direct message
-    # message :- [optional parameter] any message that you want post in direct message
-    #
-    # @param params [Hash] 
-    # @return [Boolean] Whether or not message succeeded
-    def direct_message!(params = {})
-      call_api("api/v2/message/js", params)
-    end
-    def direct_message(params = {})
-      direct_message!(params)
-    rescue LoginRadius::Exception => e
-      false
-    end
-  end
-end

data/lib/login_radius/related.rb

@@ -1,34 +0,0 @@
-module LoginRadius
-  module Related
-    # fetch images with respact album id. Params hash takes following keys:
-    # access_token :- [Required parameter] access token 
-    # albumid :- [Required parameter] albumid for fetch images from album
-    #
-    # @param params [Hash] 
-    # @return [Boolean] Whether or not message succeeded
-    
-    def photo!(params = {})
-      call_api("api/v2/photo", params)
-    end
-    def photo(params = {})
-      photo!(params)
-    rescue LoginRadius::Exception => e
-      false
-    end
-    
-    # fetch page with respact PageNameOrId. Params hash takes following keys:
-    # access_token :- [Required parameter] access token 
-    # pagename :- [Required parameter] pagename for fetch page details from provider
-    #
-    # @param params [Hash] 
-    # @return [Boolean] Whether or not message succeeded
-    def page!(params = {})
-      call_api("api/v2/page", params)
-    end
-    def page(params = {})
-      page!(params)
-    rescue LoginRadius::Exception => e
-      false
-    end
-  end
-end

data/lib/login_radius/user_profile.rb

@@ -1,101 +0,0 @@
-require 'net/http'
-module LoginRadius
-  class UserProfile
-    include UserProfileGetters
-    include Messages
-    
-    attr_accessor :secret, :token, :async
-    
-    API_ROOT = "https://api.loginradius.com/"
-
-    # Takes a hash of account secret, token, and connection type(net_http or em_http)
-    # and uses it to auth against the LoginRadius API. Then it returns the Account object. The
-    # async key is optional, if set to true, will use Em::HTTP instead of Net::HTTP.
-    # 
-    # @param opts [Hash] Must have keys :token, :secret, and :async(optional)
-    # @return [LoginRadius::Account]
-    def initialize(opts = {})
-      self.token = opts[:token]
-      self.secret = opts[:secret]
-      self.async = opts[:async]
-      raise LoginRadius::Exception.new("Invalid Request") unless token
-      raise LoginRadius::Exception.new("Invalid Token") unless guid_valid?(token)
-      raise LoginRadius::Exception.new("Invalid Secret") unless guid_valid?(secret)
-    end
-
-    # Takes a guid and returns whether or not it is valid.
-    #
-    # @param guid [String]
-    # @return [Boolean]
-    def guid_valid?(guid)
-      guid.match(/^\{?[A-Z0-9]{8}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{12}\}?$/i)
-    end
-
-    # Returns whether or not this object is authed.
-    #
-    # @return [Boolean]
-    def authenticated?
-      respond_to?(:access_token)
-    end
-
-    # Generic GET call function that other submodules can use to hit the API.
-    #
-    # @param url [String] Target URL to fetch data from.
-    # @param params [Hash] Parameters to send
-    # @return data [Hash] Parsed JSON data from the call
-    def call_api(url, params = {})
-      url = API_ROOT+url unless url.match(/^#{API_ROOT}/) #in case api root is included,
-      #as would happen in a recursive redirect call.
-      
-      if async
-        #UNTESTED
-        #if async is true, we expect you to be using EM::Synchrony submodule and to be in an eventloop,
-        #like with a thin server using the Cramp framework. Otherwise, this method blows up.
-        response = EM::Synchrony.sync EventMachine::HttpRequest.new(url).aget :redirects => 2, :query => params
-        response = response.response        
-      else
-        #synchronous version of the call.
-        url_obj = URI.parse(url)
-        url_obj.query = URI.encode_www_form(params)
-        
-        http = Net::HTTP.new(url_obj.host, url_obj.port)
-        http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        response = http.get(url_obj.request_uri)
-        
-        if response.is_a?(Net::HTTPTemporaryRedirect)
-          #for some reason, we always get redirected when calling server first time.
-          #so if we do, we scan body for the redirect url, and the scan returns
-          #an array of arrays. So we grab the array we know has what we need,
-          #and grab the first element.
-          redirect_url_array = response.body.scan(/<a href=\"([^>]+)\">/i)[1]
-          redirect_url = redirect_url_array.first
-          return call_api(redirect_url, params) 
-        end
-        
-        response = response.body
-      end
-      
-      # For some reason, this API returns true/false instead of JSON responses for certain calls.
-      # We catch this here.
-      return true if response.match(/^true/i)
-      return false if response.match(/^false/i)
-      
-      #We rescue this because sometimes the API returns HTML pages(which can't be JSON parsed)
-      #This mostly happens when people use expired tokens. So we go ahead and raise an exception
-      #About it if it gets caught.
-      begin
-        converted_response = JSON.parse(response, :symbolize_names => true)
-        #it's all String keys in CamelCase above, so...
-        # IF we got a hash back, convert it directly, if its an array, convert each item which is a hash
-        # into snake case
-        #converted_response = unconverted_response.is_a?(Hash) ?
-        #                      Hash.lr_convert_hash_keys(unconverted_response).symbolize_keys! : 
-        #                      unconverted_response.map { |item| Hash.lr_convert_hash_keys(item).symbolize_keys! 
-	return converted_response
-      rescue JSON::ParserError => e
-        raise LoginRadius::Exception.new("A JSON parsing error occured because the API returned an HTML page instead of JSON. This happens mostly when you're using an expired Token. Specifics: #{e.message}")
-      end 
-    end
-  end
-end

data/lib/login_radius/user_profile_getters.rb

@@ -1,152 +0,0 @@
-#Include this module in UserProfile, and UserProfile will magically have all the methods
-#I dynamically generate below!
-module LoginRadius
-  module UserProfileGetters
-    # Below is metaprogramming. This is what Ruby is magic for.
-    # Since most API calls are similar, I define an interface for them.
-    # You add a hash with these keys below, and it makes a method for them on loadup.
-    # It creates both a ! version of the method, which throws errors if you don't have access
-    # To an API endpoint, and a safe one without a ! symbol(login! vs login) that just returns false.
-    # 
-    # @param method [Symbol] Method's name
-    # @param route [String] Route, ex. is "/users/:token/:secret" (:something is interpolated to be self.something)
-    # @param params [Hash] Hash of params you wish to send to the route. If you use symbols for values, are interpolated.
-    # @param key_success_check [Symbol] Key to check for in the response to see if it was successful. Ex, :id for login, if not set, whole response hash is returned instead of true/false
-    # @return [Boolean] Whether or not it was successful.
-    [
-      {
-        :method => :access_token,
-        :route => "api/v2/access_token",
-        :params => {:token=>:token, :secret=>:secret},
-        :key_success_check => :access_token
-      },
-      {
-        :method => :userprofile, 
-        :route => "api/v2/userprofile", 
-        :params => {:access_token => :access_token}, 
-        :key_success_check => :id
-      },
-      {
-        :method => :event,
-        :route => "api/v2/event",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :contact,
-        :route => "api/v2/contact",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :mention,
-        :route => "api/v2/mention",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :company,
-        :route => "api/v2/company",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :group,
-        :route => "api/v2/group",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :post,
-        :route => "api/v2/post",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :status,
-        :route => "api/v2/status",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :following,
-        :route => "api/v2/following",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :album,
-        :route => "api/v2/album",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :checkin,
-        :route => "api/v2/checkin",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :like,
-        :route => "api/v2/like",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :photo,
-        :route => "api/v2/photo",
-        :params => {:access_token => :access_token, :id => :id}
-      },
-      {
-        :method => :audio,
-        :route => "api/v2/audio",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :video,
-        :route => "api/v2/video",
-        :params => {:access_token => :access_token}
-      },
-      {
-        :method => :page,
-        :route => "api/v2/page",
-        :params => {:access_token => :access_token, :pagename => :PageNameOrId}
-      }
-    ].each do |method_info|
-      define_method(method_info[:method].to_s + "!") do
-        
-        #when params have symbols as values, means we actually want fields on the object,
-        #so we dynamically generate real params.
-        real_params = method_info[:params].inject(Hash.new) do |hash, entry|
-          hash[entry.first] = self.send(entry.last) 
-          hash
-        end
-
-        #allows interpolation of routes - so /blah/:token becomes /blah/2323-233d3e etc.
-        real_route = method_info[:route].gsub(/\/:(\w+)/) do |match|
-          key = match.split(":").last
-          "/"+self.send(key).to_s
-        end
-        response = call_api(real_route, real_params)
-
-        if response.is_a?(Hash)
-          #Special feature: If we get a hash back instead of an array,
-          #we create methods on the user profile object for each key.
-          #If we're just getting an array back, there is no need for this,
-          #The method itself that it's called from is all that is needed to access
-          #the data.
-
-          #define methods for each key in the hash, so they are accessible:
-          #(I dont like using method missing returns because then respond_to? doesn't work)
-          response.each do |key, value|
-            define_singleton_method(key) do 
-              return value
-            end
-          end
-        end
-
-        #raise an error if there is one, otherwise, return.
-        raise LoginRadius::Exception.new(response[:errormessage]) if (response.is_a?(Hash) and response[:errorcode])
-        return response
-      end
-      
-      #safe version of the method that doesn't throw an exception
-      define_method(method_info[:method]) do
-        begin
-          self.send(method_info[:method].to_s+"!")
-        rescue LoginRadius::Exception
-          return false
-        end
-      end
-    end
-  end
-end

data/lib/string.rb

@@ -1,8 +0,0 @@
-class String
-  def lr_underscore #lr_ appended so no method naming conflicts with other gems
-    self.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1 \2').
-    gsub(/([a-z\d])([A-Z])/,'\1 \2').
-    downcase
-  end
-end