motion-firebase 2.1.5 → 3.0.0

data/lib/firebase/firebase.rb

@@ -22,8 +22,41 @@ class Firebase
     return event_type
   end
 
-  def self.new(url)
-    alloc.initWithUrl(url)
+  def self.url=(url)
+    if url.start_with?('http://')
+      raise "Invalid URL #{url.inspect} in #{__method__}: URL scheme should be 'https://', not 'http://'"
+    elsif url.start_with?('https://')
+      # all good
+    elsif url =~ '^\w+://'
+      raise "Invalid URL #{url.inspect} in #{__method__}: URL scheme should be 'https://', not '#{$~}'"
+    else
+      url = "https://#{url}"
+    end
+
+    # should we support `Firebase.url = 'myapp/path/to/child/'` ?  I'm gonna say
+    # NO for now...
+    unless url.include?('.firebaseio.com')
+      if url.include?('/')
+        raise "Invalid URL #{url.inspect} in #{__method__}: URL does not include 'firebaseio.com'"
+      end
+      url = "#{url}.firebaseio.com"
+    end
+
+    @url = url
+  end
+
+  def self.url
+    @url
+  end
+
+  def self.new(url=nil)
+    if url.nil?
+      @shared ||= alloc.initWithUrl(@url)
+    elsif url
+      alloc.initWithUrl(url)
+    else
+      super
+    end
   end
 
   # @example
@@ -36,52 +69,35 @@ class Firebase
     setDispatchQueue(queue)
   end
 
-  # @example
-  #     firebase = Firebase.new('http://..../')
-  #     firebase.auth('secretkey') do
-  #       # connected
-  #     end
-  #     firebase.auth('secretkey', disconnect: ->{}) do
-  #       # connected
-  #     end
-  #     firebase.auth('secretkey', completion: ->{}, disconnect: ->{})
-  #     # => firebase.authWithCredential(credential)
-  def auth(credential, options={}, &and_then)
-    and_then ||= options[:completion]
-    disconnect_block = options[:disconnect]
-    authWithCredential(credential, withCompletionBlock: and_then, withCancelBlock: disconnect_block)
-    return self
+  def connected_state(&block)
+    connected?
   end
 
-  alias_method :old_unauth, :unauth
-
-  def unauth(&block)
-    if block_given?
-      unauthWithCompletionBlock(block)
+  def self.connected?(&block)
+    Firebase.new.connected?(&block)
+  end
+  def connected?(&block)
+    if block
+      connected_state.on(:value) do |snapshot|
+        block.call(snapshot.value?)
+      end
     else
-      old_unauth
+      self.root['.info/connected']
     end
   end
 
-  def auth_state
-    self.root['.info/authenticated']
-  end
-
-  def connected_state
-    self.root['.info/connected']
+  def self.offline!
+    Firebase.new.offline!
   end
-
   def offline!
-    goOffline
+    self.goOffline
   end
 
-  def online!
-    goOnline
+  def self.online!
+    Firebase.new.online!
   end
-
-  def run(options={}, &transaction)
-    NSLog('The method ‘Firebase#run’ has been deprecated in favor of ‘Firebase#transaction’')
-    self.transaction(options, &transaction)
+  def online!
+    self.goOnline
   end
 
   def transaction(options={}, &transaction)
@@ -201,11 +217,6 @@ class Firebase
     return self
   end
 
-  # Calls the block when the value is true
-  def on_auth(options={}, &block)
-    auth_state.on(:value, options, &block)
-  end
-
   def on_disconnect(value, &and_then)
     if block_given?
       if value.nil?

data/lib/firebase/firebase_auth.rb

@@ -0,0 +1,219 @@
+# most methods have a static version that make use of Firebase.url = 'global url'
+# to create a Firebase ref.
+class Firebase
+
+  def self.auth_data
+    Firebase.new.auth_data
+  end
+  def auth_data
+    authData
+  end
+
+  # @example
+  #     Firebase.auth('secrettoken') do |error, auth_data|
+  #       if auth_data
+  #         # authenticated
+  #       end
+  #     end
+  def self.auth(token, options={}, &block)
+    Firebase.new.auth(token, options, &block)
+  end
+  def auth(token, options={}, &and_then)
+    and_then ||= options[:completion]
+    disconnect_block = options[:disconnect]
+    if disconnect || and_then.arity < 2
+      NSLog('Warning!  The Firebase authWithCredential method is deprecated.')
+      NSLog('Instead of using a completion and cancel block, pass one block:')
+      NSLog('fb.auth(token) do |error, auth_data| .. end')
+      authWithCredential(token, withCompletionBlock:and_then, withCancelBlock: disconnect_block)
+    else
+      authWithCustomToken(token, withCompletionBlock: and_then)
+    end
+    return self
+  end
+
+  def self.logout(&block)
+    Firebase.new.logout(&block)
+  end
+  def logout(&block)
+    if block_given?
+      unauthWithCompletionBlock(block)
+    else
+      unauth
+    end
+  end
+
+  def self.authenticated?(&block)
+    Firebase.new.authenticated?(&block)
+  end
+  # checks the auth status.  If you pass a block the observeAuthEventWithBlock
+  # is used to determine the status.  If you don't pass a block, this method
+  # returns true or false.
+  def authenticated?(&block)
+    if block
+      observeAuthEventWithBlock(:value, block)
+    else
+      !!authData
+    end
+  end
+
+  # You should call this when you no longer need `authenticated?` data.
+  def self.off_auth(handler)
+    Firebase.new.off_auth(handler)
+  end
+  def off_auth(handler)
+    removeAuthEventObserverWithHandle(handler)
+  end
+
+  def self.create_user(credentials, &block)
+    Firebase.new.create_user(credentials, &block)
+  end
+  def create_user(credentials, &block)
+    raise ":email is required in #{__method__}" unless credentials.key?(:email)
+    raise ":password is required in #{__method__}" unless credentials.key?(:password)
+    email = credentials[:email]
+    password = credentials[:password]
+    begin
+      createUserWithEmail(email, password: password, withCompletionBlock: block)
+    rescue RuntimeError => e
+      block.call(e, nil)
+    end
+  end
+
+  def self.create_user_and_login(credentials, &block)
+    Firebase.new.create_user_and_login(credentials, &block)
+  end
+  def create_user_and_login(credentials, &block)
+    raise ":email is required in #{__method__}" unless credentials.key?(:email)
+    raise ":password is required in #{__method__}" unless credentials.key?(:password)
+    email = credentials[:email]
+    password = credentials[:password]
+    begin
+      createUserWithEmail(email, password: password, withCompletionBlock: -> (error) do
+        if error
+          block.call(error, nil)
+        else
+          login(credentials, &block)
+        end
+      end)
+    rescue RuntimeError => e
+      block.call(e, nil)
+    end
+  end
+
+  def self.update_user(credentials, &block)
+    Firebase.new.update_user(credentials, &block)
+  end
+  def update_user(credentials, &block)
+    raise ":email is required in #{__method__}" unless credentials.key?(:email)
+    raise ":old_password is required in #{__method__}" unless credentials.key?(:old_password)
+    raise ":new_password is required in #{__method__}" unless credentials.key?(:new_password)
+    email = credentials[:email]
+    old_password = credentials[:old_password]
+    new_password = credentials[:new_password]
+    changePasswordForUser(email, fromOld: old_password, toNew: new_password, withCompletionBlock: block)
+  end
+
+  def self.send_password_reset(credentials, &block)
+    Firebase.new.send_password_reset(credentials, &block)
+  end
+  def send_password_reset(email, &block)
+    resetPasswordForUser(email, withCompletionBlock: block)
+  end
+
+  def self.remove_user(credentials, &block)
+    Firebase.new.remove_user(credentials, &block)
+  end
+  def remove_user(credentials, &block)
+    raise ":email is required in #{__method__}" unless credentials.key?(:email)
+    raise ":password is required in #{__method__}" unless credentials.key?(:password)
+    email = credentials[:email]
+    password = credentials[:password]
+    removeUser(email, password: password, withCompletionBlock: block)
+  end
+
+  def login_anonymously(&block)
+    authAnonymouslyWithCompletionBlock(block)
+  end
+
+  def login(credentials, &block)
+    raise ":email is required in #{__method__}" unless credentials.key?(:email)
+    raise ":password is required in #{__method__}" unless credentials.key?(:password)
+    email = credentials[:email]
+    password = credentials[:password]
+    begin
+      authUser(email, password: password, withCompletionBlock: block)
+    rescue RuntimeError => e
+      block.call(e, nil)
+    end
+  end
+
+  def login_to_oauth(provider, parameters={}, &block)
+    if parameters.is_a?(NSString)
+      token = parameters
+    elsif parameters.key?(:token)
+      token = parameters[:token]
+    else
+      token = nil
+    end
+
+    if token
+      authWithOAuthProvider(provider, token: token, withCompletionBlock: block)
+    else
+      objc_params = {}
+      parameters.each do |key, value|
+        # explicitly convert :sym to 'sym'
+        objc_params[key.to_s] = value
+      end
+      authWithOAuthProvider(provider, parameters: objc_params, withCompletionBlock: block)
+    end
+  end
+
+  def login_to_facebook(credentials, &block)
+    if credentials.is_a?(NSString)
+      token = credentials
+    else
+      token = credentials[:token]
+    end
+    raise ":token is required in #{__method__}" unless token
+
+    authWithOAuthProvider('facebook', token: token, withCompletionBlock: block)
+  end
+
+  def login_to_twitter(credentials, &block)
+    oauth_token = credentials[:token] || credentials[:oauth_token]
+    oauth_token_secret = credentials[:secret] || credentials[:oauth_token_secret]
+    raise ":token is required in #{__method__}" unless oauth_token
+    raise ":secret is required in #{__method__}" unless oauth_token_secret
+
+    provider = 'twitter'
+    options = {
+      'oauth_token' => oauth_token,
+      'oauth_token_secret' => oauth_token_secret,
+    }
+    login_to_oauth(provider, options, &block)
+  end
+
+  def login_to_github(credentials, &block)
+    if credentials.is_a?(NSString)
+      token = credentials
+    else
+      token = credentials[:token]
+    end
+    raise ":token is required in #{__method__}" unless token
+
+    authWithOAuthProvider('github', token: token, withCompletionBlock: block)
+  end
+
+  def login_to_google(credentials, &block)
+    if credentials.is_a?(NSString)
+      token = credentials
+    else
+      token = credentials[:token]
+    end
+    raise ":token is required in #{__method__}" unless token
+
+    authWithOAuthProvider('google', token: token, withCompletionBlock: block)
+  end
+
+end

data/lib/firebase/firebase_facebook_helper.rb

@@ -0,0 +1,24 @@
+# see https://www.firebase.com/docs/ios/guide/login/facebook.html for more info
+# (that's where this code came from)
+class Firebase
+  def self.open_facebook_session(options={}, &block)
+    self.new.open_facebook_session(options={}, &block)
+  end
+
+  def open_facebook_session(options={}, &block)
+    ref = self
+    permissions = options[:permissions] || ['public_profile']
+    allow_ui = options.fetch(:allow_login_ui, true)
+    FBSession.openActiveSessionWithReadPermissions(permissions, allowLoginUI: allow_ui,
+      completionHandler: -> (session, state, error) do
+        if error
+          block.call(error, nil)
+        elsif state == FBSessionStateOpen
+          token = session.accessTokenData.accessToken
+
+          ref.authWithOAuthProvider('facebook', token:token, withCompletionBlock:block)
+        end
+      end)
+    nil
+  end
+end

data/lib/firebase/firebase_github_helper.rb

@@ -0,0 +1,20 @@
+# see https://www.firebase.com/docs/ios/guide/login/github.html for more info
+# (that's where this code came from)
+class Firebase
+  def self.github_token=(value)
+    @github_token = value
+  end
+  def self.github_token
+    @github_token
+  end
+  def self.open_github_session(options={}, &block)
+    self.new.open_github_session(options={}, &block)
+  end
+
+  def open_github_session(options={}, &block)
+    ref = self
+    token = options[:token] || Firebase.github_token
+    raise "token is required in #{__method__}" unless token
+    firebase_ref.login_to_github('github', token)
+  end
+end

data/lib/firebase/firebase_twitter_helper.rb

@@ -0,0 +1,169 @@
+# see https://www.firebase.com/docs/ios/guide/login/twitter.html for more info
+# (that's where this code came from)
+class Firebase
+  def self.twitter_api_key=(value)
+    @twitter_api_key = value
+  end
+  def self.twitter_api_key
+    @twitter_api_key
+  end
+  def self.open_twitter_session(options={}, &block)
+    self.new.open_twitter_session(options={}, &block)
+  end
+
+  def open_twitter_session(options={}, &block)
+    ref = self
+    api_key = options[:api_key] || Firebase.twitter_api_key
+    raise "api_key is required in #{__method__}" unless api_key
+
+    helper = Motion::Firebase::TwitterAuthHelper.new(ref, api_key)
+    helper.select_twitter_account(&block)
+    nil
+  end
+end
+
+
+module Motion
+module Firebase
+class TwitterAuthHelper
+
+  def initialize(ref, api_key)
+    @store = ACAccountStore.new
+    @ref = ref
+    @api_key = api_key
+    @account = nil
+    @acounts = nil
+    @firebase_callback = nil
+  end
+
+  # Step 1a -- get account
+  def select_twitter_account(&callback)
+    account_type = @store.accountTypeWithAccountTypeIdentifier(ACAccountTypeIdentifierTwitter)
+
+    @store.requestAccessToAccountsWithType(account_type, options: nil, completion: -> (granted, error) do
+      if granted
+        @accounts = @store.accountsWithAccountType(account_type)
+        if @accounts.length > 0
+          Dispatch::Queue.main.async do
+            next_step = -> (account, &firebase_handler) do
+              self.authenticate_account(account, &firebase_handler)
+            end
+            callback.call(nil, @accounts, next_step)
+          end if callback
+        else
+          error = NSError.alloc.initWithDomain('TwitterAuthHelper',
+                         code: AuthHelperErrorAccountAccessDenied,
+                     userInfo: { NSLocalizedDescriptionKey => 'No Twitter accounts detected on phone. Please add one in the settings first.' })
+          Dispatch::Queue.main.async do
+            callback.call(error, nil, nil)
+          end if callback
+        end
+      else
+        error = NSError.alloc.initWithDomain('TwitterAuthHelper',
+                       code: AuthHelperErrorAccountAccessDenied,
+                   userInfo: { NSLocalizedDescriptionKey => 'Access to twitter accounts denied.' })
+        Dispatch::Queue.main.async do
+          callback.call(error, nil, nil)
+        end if callback
+      end
+    end)
+  end
+
+  # Last public facing method
+  def authenticate_account(account, &firebase_handler)
+    if !account
+      error = NSError.alloc.initWithDomain('TwitterAuthHelper',
+                   code: AuthHelperErrorAccountAccessDenied,
+                   userInfo: { NSLocalizedDescriptionKey => 'No Twitter account to authenticate.' })
+      Dispatch::Queue.main.async do
+        firebase_handler.call(error, nil)
+      end if firebase_handler
+    else
+      @account = account
+      @firebase_callback = firebase_handler
+      make_reverse_request # kick off step 1b
+    end
+  end
+
+  def callback_if_exists_with_error(error)
+    if @firebase_callback
+      Dispatch::Queue.main.async do
+        @firebase_callback.call(error, nil)
+      end
+    end
+  end
+
+  # Step 1b -- get request token from Twitter
+  def make_reverse_request
+    @ref.makeReverseOAuthRequestTo('twitter', withCompletionBlock: -> (error, json) do
+      if error
+        callback_if_exists_with_error(error)
+      else
+        request = create_credential_request_with_reverse_auth_payload(json)
+        request_twitter_credentials(request)
+      end
+    end)
+  end
+
+  # Step 1b Helper -- creates request to Twitter
+  def create_credential_request_with_reverse_auth_payload(json)
+    params = {}
+
+    request_token = json['auth']
+    params['x_reverse_auth_parameters'] = request_token
+    params['x_reverse_auth_target'] = @api_key
+
+    url = NSURL.URLWithString('https://api.twitter.com/oauth/access_token')
+    req = SLRequest.requestForServiceType(SLServiceTypeTwitter, requestMethod: SLRequestMethodPOST, URL: url, parameters: params)
+    req.setAccount(@account)
+
+    req
+  end
+
+  # Step 2 -- request credentials from Twitter
+  def request_twitter_credentials(request)
+    request.performRequestWithHandler(-> (response_data, url_response, error) do
+      if error
+        callback_if_exists_with_error(error)
+      else
+        authenticate_with_twitter_credentials(response_data)
+      end
+    end)
+  end
+
+  # Step 3 -- authenticate with Firebase using Twitter credentials
+  def authenticate_with_twitter_credentials(response_data)
+    params = parse_twitter_credentials(response_data)
+    if params['error']
+      error = NSError.alloc.initWithDomain('TwitterAuthHelper',
+                   code: AuthHelperErrorOAuthTokenRequestDenied,
+                   userInfo: { NSLocalizedDescriptionKey => 'OAuth token request was denied.',
+                               'details' => params['error']})
+      callback_if_exists_with_error(error)
+    else
+      @ref.authWithOAuthProvider('twitter', parameters: params, withCompletionBlock: @firebase_callback)
+    end
+  end
+
+  # Step 3 Helper -- parsers credentials into dictionary
+  def parse_twitter_credentials(response_data)
+    account_data = NSString.alloc.initWithData(response_data, encoding:NSUTF8StringEncoding)
+    params = {}
+
+    account_data.split('&').each do |param|
+      key, value = param.split('=')
+      params[key] = value
+    end
+
+    # This is super fragile error handling, but basically check that the token and token secret are there.
+    # If not, return the result that Twitter returned.
+    if params['oauth_token_secret'] && params['oauth_token']
+      params
+    else
+      { 'error': account_data }
+    end
+  end
+
+end
+end
+end