cloudfuji 0.0.37

data/lib/cloudfuji/platform.rb

@@ -0,0 +1,47 @@
+module Cloudfuji
+  class Platform #:nodoc:
+    class << self
+      def name
+        ENV['CLOUDFUJI_NAME']
+      end
+
+      def key
+        ENV['CLOUDFUJI_APP_KEY']
+      end
+      
+      def publish_url
+        "#{host}/apps/#{name}/bus"
+      end
+
+      def protocol
+        ENV['CLOUDFUJI_PROTOCOL'] || "https"
+      end
+
+      def port
+        ENV['CLOUDFUJI_PORT']
+      end
+
+      def host
+        cloudfuji_port = port ? ":#{port}" : ""
+        cloudfuji_host = ENV['CLOUDFUJI_HOST'] || 'cloudfuji.com'
+        "#{protocol}://#{cloudfuji_host}#{cloudfuji_port}"
+      end
+
+      def on_cloudfuji?
+        ENV['HOSTING_PLATFORM']=="cloudfuji"
+      end
+
+      def claimed?
+        (ENV['CLOUDFUJI_CLAIMED'].nil? or ENV['CLOUDFUJI_CLAIMED'].blank?) ? false : true
+      end
+
+      def metrics_token
+        ENV['CLOUDFUJI_METRICS_TOKEN']
+      end
+
+      def cloudfuji_js_source
+        "#{Cloudfuji::Platform.host}/api/cloudfuji.js"
+      end
+    end
+  end
+end

data/lib/cloudfuji/schema.rb

@@ -0,0 +1,42 @@
+module Cloudfuji
+  # Holds devise schema information. To use it, just include its methods
+  # and overwrite the apply_schema method.
+  module Schema
+
+    # Creates reset_password_token and reset_password_sent_at.
+    #
+    # == Options
+    # * :reset_within - When true, adds a column that reset passwords within some date
+    def recoverable(options={})
+      use_within = options.fetch(:reset_within, Devise.reset_password_within.present?)
+      apply_devise_schema :reset_password_token, String
+      apply_devise_schema :reset_password_sent_at, DateTime if use_within
+    end
+
+    # Creates remember_token and remember_created_at.
+    #
+    # == Options
+    # * :use_salt - When true, does not create a remember_token and use password_salt instead.
+    def rememberable(options={})
+      use_salt = options.fetch(:use_salt, Devise.use_salt_as_remember_token)
+      apply_devise_schema :remember_token,      String unless use_salt
+      apply_devise_schema :remember_created_at, DateTime
+    end
+
+    # Creates sign_in_count, current_sign_in_at, last_sign_in_at,
+    # current_sign_in_ip, last_sign_in_ip.
+    def trackable
+      apply_devise_schema :sign_in_count,      Integer, :default => 0
+      apply_devise_schema :current_sign_in_at, DateTime
+      apply_devise_schema :last_sign_in_at,    DateTime
+      apply_devise_schema :current_sign_in_ip, String
+      apply_devise_schema :last_sign_in_ip,    String
+    end
+
+
+    # Overwrite with specific modification to create your own schema.
+    def apply_devise_schema(name, type, options={})
+      raise NotImplementedError
+    end
+  end
+end

data/lib/cloudfuji/smtp.rb

@@ -0,0 +1,24 @@
+module Cloudfuji
+  class SMTP
+    class << self
+      [:tls, :server, :port, :domain, :authentication, :user, :password].each do |method_name|
+        define_method "#{method_name}".to_sym do
+          ENV["SMTP_#{method_name.to_s.upcase}"]
+        end
+      end
+
+      def setup_action_mailer_smtp!
+        ActionMailer::Base.smtp_settings = {
+          :enable_starttls_auto => Cloudfuji::SMTP.tls,
+          :tls =>                  Cloudfuji::SMTP.tls,
+          :address =>              Cloudfuji::SMTP.server,
+          :port =>                 Cloudfuji::SMTP.port,
+          :domain =>               Cloudfuji::SMTP.domain,
+          :authentication =>       Cloudfuji::SMTP.authentication,
+          :user_name =>            Cloudfuji::SMTP.user,
+          :password =>             Cloudfuji::SMTP.password,
+        }
+      end
+    end
+  end
+end

data/lib/cloudfuji/user.rb

@@ -0,0 +1,59 @@
+module Cloudfuji
+  # Cloudfuji User enables user validation against Cloudfuji's server
+  class User < Cloudfuji::Base
+    class << self
+      
+      # Checks whether user an email and password correspond to a valid cloudfuji
+      # user. Returns nil if false, or the Cloudfuji user's ID if true.
+      def valid?(email, pass)
+        params = {}
+        params[:email] = email
+        params[:pass] = pass
+        Cloudfuji::Command.post_command(valid_unity_url, params)
+      end
+
+      # Checks whether email corresponds to a valid Cloudfuji user.
+      # Returns true or false
+      def exists?(email)
+        params = {}
+        params[:email] = email
+        Cloudfuji::Command.post_command(exists_unity_url, params)
+      end
+
+      # send a Cloudfuji invite with a short description of the app (also a box of chocolates, if he's a Kryptonian)
+      # Cloudfuji::User.invite("clark@kent-on-krypton.com")
+      def invite(email)
+        params = {}
+        params[:email] = email
+        Cloudfuji::Command.post_command(invite_unity_url, params)
+      end
+
+      # List all pending invites
+      # Cloudfuji::User.pending_invites
+      def pending_invites
+        params = {}
+        Cloudfuji::Command.get_command(pending_invites_unity_url, params)
+      end
+
+      # To remove a user from an application
+      # Cloudfuji::User.remove("5z325f4knbm2f")
+      def remove(ido_id)
+          params = {}
+          params[:ido_id] = ido_id
+          Cloudfuji::Command.post_command(remove_unity_url, params)
+      end
+
+      # To send a notification to a user who belongs to your app
+      # Cloudfuji::User.notify('5z325f4knbm2f', 'Example title', 'Example message', 'chat')
+      def notify(ido_id, title, body, category="general")
+        params            = {}
+        params[:ido_id]   = ido_id
+        params[:title]    = title
+        params[:body]     = body
+        params[:category] = category
+
+        Cloudfuji::Command.post_command(notify_user_url, params)
+      end
+    end
+  end
+end

data/lib/cloudfuji/user_helper.rb

@@ -0,0 +1,7 @@
+module Cloudfuji
+  module UserHelper
+    def notify(title, body, category)
+      Cloudfuji::User.notify(self.ido_id, title, body, "chat")
+    end
+  end
+end

data/lib/cloudfuji/utils.rb

@@ -0,0 +1,53 @@
+module Cloudfuji
+  class Utils #:nodoc:
+    class << self
+      # TODO: Make this update all the available ENV variables 
+      def refresh_env!
+      end
+
+      def array_helper(array, proc)
+        array.collect do |value|
+          if value.kind_of?( Hash  )
+            deep_process_hash_keys(value, proc)
+          elsif value.kind_of?( Array )
+            array_helper(array)
+          else
+            value
+          end
+        end
+      end
+
+      def deep_process_hash_keys(input_hash, proc)
+        hash = {}
+        input_hash.keys.each do |key|
+          _key = proc.call(key)
+          if input_hash[key].kind_of?(Hash)
+            hash[_key] = deep_process_hash_keys(input_hash[key], proc)
+          elsif input_hash[key].kind_of?(Array)
+            hash[_key] = array_helper(input_hash[key], proc)
+          else
+            hash[_key] = input_hash[key]
+          end
+        end
+
+        hash
+      end
+
+      def deep_underscore_hash_keys(input_hash)
+        deep_process_hash_keys(input_hash, Proc.new { |key| key.to_s.underscore })
+      end
+
+      def deep_symbolize_hash_keys(input_hash)
+        deep_process_hash_keys(input_hash, Proc.new { |key| key.to_sym })
+      end
+
+      def deep_stringify_hash_keys(input_hash)
+        deep_process_hash_keys(input_hash, Proc.new { |key| key.to_s })
+      end
+
+      def normalize_keys(input_hash)
+        deep_symbolize_hash_keys(deep_underscore_hash_keys(input_hash))
+      end
+    end
+  end
+end

data/lib/cloudfuji/version.rb

@@ -0,0 +1,4 @@
+module Cloudfuji
+  # Current version of the Cloudfuji gem 
+  VERSION = "0.0.37"
+end

data/lib/generators/active_record/cloudfuji_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators/active_record'
+require 'generators/cloudfuji/orm_helpers'
+
+module ActiveRecord
+  module Generators
+    class CloudfujiGenerator < ActiveRecord::Generators::Base
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      include Cloudfuji::Generators::OrmHelpers
+      source_root File.expand_path("../templates", __FILE__)
+
+      def generate_model
+        invoke "active_record:model", [name], :migration => false unless model_exists?
+      end
+
+      def copy_cloudfuji_migration
+        migration_template "migration.rb", "db/migrate/cloudfuji_create_#{table_name}"
+      end
+
+      def inject_cloudfuji_content
+        inject_into_class model_path, class_name, model_contents + <<-CONTENT
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :cloudfuji_id, :cloudfuji_version
+CONTENT
+      end
+    end
+  end
+end

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,20 @@
+class CloudfujiCreate<%= table_name.camelize %> < ActiveRecord::Migration
+  def self.up
+    create_table(:<%= table_name %>) do |t|
+      t.string :cloudfuji_id
+      t.string :cloudfuji_version
+
+<% for attribute in attributes -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+
+      t.timestamps
+    end
+
+    add_index :<%= table_name %>, :cloudfuji_id, :unique => true
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

data/lib/generators/cloudfuji/auth_migration_generator.rb

@@ -0,0 +1,46 @@
+module Cloudfuji
+  module Generators
+    class AuthMigrationGenerator < Rails::Generators::NamedBase
+
+      def create_auth_migration_file
+        fields_to_add = []
+        new_resource = class_name.constantize.new
+
+        fields_to_add << "ido_id"     if not new_resource.respond_to?(:ido_id)
+        fields_to_add << "first_name" if not new_resource.respond_to?(:first_name)
+        fields_to_add << "last_name"  if not new_resource.respond_to?(:last_name)
+        fields_to_add << "email"      if not new_resource.respond_to?(:email)
+        fields_to_add << "locale"     if not new_resource.respond_to?(:locale)
+        fields_to_add << "timezone"   if not new_resource.respond_to?(:timezone)
+
+
+        attr_accessor_string = fields_to_add.collect { |field| ":"+field}.join(", ")
+        
+        inject_into_class "app/models/#{class_name.underscore}.rb", class_name do
+<<-EOF
+  attr_accessor #{attr_accessor_string}\n
+
+  def cloudfuji_extra_attributes(extra_attributes)
+    self.first_name = extra_attributes["first_name"].to_s
+    self.last_name  = extra_attributes["last_name"].to_s
+    self.email      = extra_attributes["email"]
+    self.locale     = extra_attributes["locale"]
+    self.timezone   = extra_attributes["timezone"]
+  end
+EOF
+        end
+
+        gem("devise_cloudfuji_authenticatable")
+
+        generate("migration", "AddCloudfujiFieldsTo#{class_name}", *fields_to_add.collect { |field| field + ":string"})
+        generate("migration", "AddIndexForIdoIdTo#{class_name}")
+        Dir["db/migrate/*add_index_for_ido_id_to*"].each do |file|
+          inject_into_file file, :after => "class AddIndexForIdoIdToUser < ActiveRecord::Migration\n  def change\n" do
+            "    add_index :#{plural_name}, :ido_id\n"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/generators/cloudfuji/cloudfuji_generator.rb

@@ -0,0 +1,14 @@
+module Cloudfuji
+  module Generators
+    class CloudfujiGenerator < Rails::Generators::NamedBase
+      namespace "cloudfuji"
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Generates a model with the given NAME (if one does not exist) with Cloudfuji " <<
+           "configuration plus a migration file and devise routes."
+
+      hook_for :orm
+
+    end
+  end
+end

data/lib/generators/cloudfuji/hooks_generator.rb

@@ -0,0 +1,43 @@
+module Cloudfuji
+  module Generators
+    class HooksGenerator < Rails::Generators::Base
+        
+      def create_hooks_file
+
+        lib("cloudfuji/hooks/user_hooks.rb") do
+<<-EOF
+class CloudfujiUserHooks < Cloudfuji::EventObserver
+  def user_added
+    user.create(:email  => params['data']['email'],
+      :ido_id => params['data']['ido_id'],
+      :active => true)
+  end
+
+  def user_removed
+    User.find_by_ido_id(params['data']['ido_id']).try(:disable!)
+  end
+end
+EOF
+        end
+        
+        lib('cloudfuji/hooks/app_hooks.rb') do
+<<-EOF
+class CloudfujiAppHooks < Cloudfuji::EventObserver
+  def app_claimed
+    User.find(1).update_attributes(:email  => params['data']['email'],
+      :ido_id => params['data']['ido_id'])
+  end
+end
+EOF
+        end
+        
+        initializer "cloudfuji_hooks.rb" do
+<<-EOF
+Dir["\#{Dir.pwd}/lib/cloudfuji/**/*.rb"].each { |file| require file }
+EOF
+        end
+      end
+
+    end
+  end
+end

data/lib/generators/cloudfuji/install_generator.rb

@@ -0,0 +1,24 @@
+# require 'active_support/secure_random'
+
+module Cloudfuji
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Creates a Devise initializer and copy locale files to your application."
+      class_option :orm
+
+      def copy_initializer
+        template "cloudfuji.rb", "config/initializers/cloudfuji.rb"
+      end
+
+      # def copy_locale
+      #   copy_file "../../../config/locales/en.yml", "config/locales/devise.en.yml"
+      # end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/cloudfuji/mail_routes_generator.rb

@@ -0,0 +1,45 @@
+module Cloudfuji
+  module Generators
+    class MailRoutesGenerator < Rails::Generators::Base
+  
+      def create_mail_routes_file
+        # Create the lib/cloudfuji directory if it doesnt exist
+        Dir.mkdir("#{Rails.root}/lib/cloudfuji") if not Dir.exists? "#{Rails.root}/lib/cloudfuji"
+        
+        lib "cloudfuji/mail_routes.rb" do
+          <<-EOF
+::Cloudfuji::Mailroute.map do |m|
+
+  m.route("simple") do
+    m.subject("hello")
+  end
+
+end
+          EOF
+        end
+
+        lib("cloudfuji/hooks/email_hooks.rb") do
+          <<-EOF
+class CloudfujiEmailHooks < Cloudfuji::EventObserver
+
+  def mail_simple
+    puts "YAY!"
+    puts params.inspect
+  end
+
+end
+          EOF
+        end
+        
+        initializer "cloudfuji_hooks.rb" do
+          <<-EOF
+Dir["\#{Dir.pwd}/lib/cloudfuji/**/*.rb"].each { |file| require file }
+          EOF
+        end
+        
+        initializer("cloudfuji_mail_routes.rb", "require './lib/cloudfuji/mail_routes.rb'")
+
+      end
+    end
+  end
+end