cloudfuji 0.0.37

data/lib/cloudfuji/envs_helper.rb

@@ -0,0 +1 @@
+# Automatically required by the envs_controller

data/lib/cloudfuji/event.rb

@@ -0,0 +1,63 @@
+module Cloudfuji
+  # Cloudfuji::Event lists all the events from the Cloudfuji server. All events
+  # are hashes with the following keys:
+  # * category
+  # * name
+  # * data
+  # Data will hold the arbitrary data for the type of event signalled
+  class Event
+    begin
+      @@events = JSON.parse(ENV["CLOUDFUJI_EVENTS"]) #:nodoc:
+    rescue
+      @@events = []
+    end
+
+    attr_reader :category, :name, :data
+
+    class << self
+      def events_url
+        "#{Cloudfuji::Platform.host}/apps/#{Cloudfuji::Platform.name}/events.json"
+      end
+      
+      # Lists all events
+      def all
+        @@events.collect{ |e| Event.new(e) }
+      end
+
+      # Lists the first (oldest) event
+      def first
+        Event.new(@@events.first)
+      end
+
+      # Lists the last (newest) event
+      def last
+        Event.new(@@events.last)
+      end
+
+      # NOOP right now
+      def refresh
+        @@events = Cloudfuji::Command.get_command(events_url)
+      end
+
+      def publish(options={})
+        # Enforce standard format on client side so that any errors
+        # can be more quickly caught for the developer
+        return StandardError("Cloudfuji::Event format incorrect, please make sure you're using the correct structure for sending events") unless !options[:name].nil? && !options[:category].nil? && !options[:data].nil?
+
+        payload            = {}
+        payload[:category] = options[:category]
+        payload[:name]     = options[:name]
+        payload[:data]     = options[:data]
+
+        Cloudfuji::Command.post_command(events_url, payload)
+      end
+    end
+
+    def initialize(options={})
+      @category = options["category"]
+      @name     = options["name"]
+      @data     = options["data"]
+    end
+
+  end
+end

data/lib/cloudfuji/event_observer.rb

@@ -0,0 +1,20 @@
+module Cloudfuji
+  class EventObserver
+    attr_accessor :params
+
+    def self.inherited(klass)
+      if Cloudfuji::Platform.on_cloudfuji?
+        Cloudfuji::Data.add_observer(klass.new)
+      else
+      end
+    end
+
+    def initialize
+      @params ||= {}
+    end
+
+    def params
+      @params
+    end
+  end
+end

data/lib/cloudfuji/mail_helper.rb

@@ -0,0 +1 @@
+# Automatically required by the mail_controller

data/lib/cloudfuji/mail_route.rb

@@ -0,0 +1,186 @@
+module Cloudfuji
+  class Mailroute
+    def self.map(&block)
+      raise StandardError.new("Mailroute only supported in Ruby >= 1.9.1") if RUBY_VERSION < "1.9.1"
+      
+      @@routes ||= self.new
+      yield @@routes
+    end
+
+    def self.routes
+      @@routes
+    end
+
+    def self.clear_routes!
+      @@routes = self.new
+    end
+
+    def self.pretty_print_routes
+      @@routes.routes.each_pair do |route_name, definition|
+        puts "#{route_name} => "
+        definition[:rules].each do |rule|
+          pretty_print_rule(rule, "\t\t")
+        end
+        definition[:constraints].each do |constraint|
+          pretty_print_contraint(constraint, "\t\t")
+        end
+      end
+    end
+
+    def self.pretty_print_rule(rule, prefix="")
+      output = "#{prefix}#{rule.first} => #{string_to_regex(rule[1]).inspect}, required? #{rule.last == true}"
+      puts output
+    end
+
+    def self.pretty_print_contraint(constraint, prefix="")
+      output = "#{prefix}Constraint: #{constraint.inspect}"
+      puts output
+    end
+
+    # Taken from somewhere on stackoverflow, props to the author!
+    def self.string_to_regex(string)
+      return nil unless string.strip.match(/\A\/(.*)\/(.*)\Z/mx)
+      regexp , flags = $1 , $2
+      return nil if !regexp || flags =~ /[^xim]/m
+
+      x = /x/.match(flags) && Regexp::EXTENDED
+      i = /i/.match(flags) && Regexp::IGNORECASE
+      m = /m/.match(flags) && Regexp::MULTILINE
+
+      Regexp.new regexp , [x,i,m].inject(0){|a,f| f ? a+f : a }
+    end
+
+    def self.field_matcher(*field_names)
+      self.class_eval do
+        field_names.each do |field_name|
+          define_method field_name do |line, *args|
+            constraints = args.first || {}
+            required    = args[1]
+
+            add_route_rule(field_name.to_s, build_matcher(line, constraints), required)
+          end
+        end
+      end
+    end
+
+    attr_accessor :params, :constraints, :routes, :current_target, :reply
+    field_matcher :from, :sender, :subject, :body
+
+    # Regex shortcuts
+    def ampm
+      /\d+[apmAPM]{2}/
+    end
+
+    def word
+      /\w+/
+    end
+
+    def number
+      /\d+/
+    end
+
+    def words_and_spaces
+      /[\w|\s]+/
+    end
+
+    def month
+      /((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Sept|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?))/
+    end
+
+    def year
+      /((?:(?:[1]{1}\\d{1}\\d{1}\\d{1})|(?:[2]{1}\\d{3})))(?![\\d])/
+    end
+
+    def initialize
+      @routes ||= ActiveSupport::OrderedHash.new
+    end
+
+    def route(target, &block)
+      @routes[@current_target = target] = {:rules => [], :constraints => []}
+      yield self
+    end
+
+    # Maybe add_requirement is better?
+    # Constraint procs must return true if the mail should be allowed
+    def add_constraint(params_field_name, requirement_type)
+      checkers = {
+        :not_allowed => Proc.new { |params| params[params_field_name.to_s].nil? },
+        :required    => Proc.new { |params| not params[params_field_name.to_s].nil? },
+        :custom      => Proc.new { |params| requirement_type.call(params[params_field_name.to_s]) }
+      }
+
+      checker = requirement_type.is_a?(Proc) ? checkers[:custom] : checkers[requirement_type]
+
+      raise StandardError if checker.nil?
+
+      @routes[@current_target][:constraints] << checker
+      @routes[@current_target][:constraints].flatten! # In case we've added a nil
+    end
+
+    def process(mail)
+      @params = preprocess_mail(mail)
+
+      # Iterate through the routes and test each rule for each route against current mail
+      @routes.each_pair do |route_name, definition|
+        _matches = true
+
+        # route: {'name-of-route' => {:rules => [[:field, matcher]], :constraints => []}}
+        definition[:rules].each do |matcher|
+          result = self.class.string_to_regex(matcher[1]).match(mail[matcher.first])
+          if result.nil?
+            _matches = false
+            break
+          end
+          
+          # Only Ruby 1.9 support named capture groups
+          result.names.each { |key| @params[key] = result[key] }
+        end
+        
+        # Run param-based constraints
+        if _matches and constraints_pass?(definition[:constraints], params)
+          @params['mail'] = mail
+          puts "Firing: #{@params.inspect}, #{route_name}"
+          return Cloudfuji::Data.fire(params, "mail_#{route_name.gsub('.', '_')}")
+          break
+        end
+
+      end
+    end
+
+    private
+
+    def preprocess_mail(mail)
+      params = {}
+      # Remove Re:'s from the subject and set reply => true if present
+      if mail["subject"].match(/^(Re: ){1,}/i)
+        params['reply'] = true
+        until !mail["subject"].match(/^(Re: ){1,}/i)
+          mail["subject"] = mail["subject"][4..-1]
+        end
+      end
+
+      if from_details = mail['from'].try(:match, /^([\w|\s]*) <(.*)>/)
+        params['from_name']  = from_details[1]
+        params['from_email'] = from_details[2]
+      end
+
+      return params
+    end
+
+    def add_route_rule(field, matcher, required=true)
+      route = @routes[@current_target]
+      route[route.keys.first] << [field, matcher, required]
+    end
+
+    def build_matcher(line, constraints)
+      temp = "/#{line}/"
+      constraints.keys.each { |key| temp.gsub!("{:#{key}}", "(?<#{key}>#{constraints[key].inspect[1..-2]})")  }
+      temp
+    end
+
+    def constraints_pass?(constraints, params)
+      constraints.nil? or constraints.select{ |proc| proc.call(params) != true }.empty?
+    end
+  end
+end
+

data/lib/cloudfuji/middleware.rb

@@ -0,0 +1,42 @@
+#require 'rack/utils'
+
+module Cloudfuji
+  class Middleware
+    include Rack::Utils
+
+    def initialize(app, opts = {})
+      @app = app
+    end
+
+    def call(env)
+      if Cloudfuji::Platform.on_cloudfuji? and Cloudfuji::Bar.in_bar_display_path?(env)
+        status, headers, response = @app.call(env)
+
+        content = ""
+        response.each { |part| content += part }
+
+        # "claiming" bar + stats ?
+        content.gsub!(/<\/body>/i, <<-STR
+            <script type="text/javascript">
+              var _cloudfuji_app = '#{Cloudfuji::Platform.name}';
+              var _cloudfuji_claimed = #{Cloudfuji::Platform.claimed?.to_s};
+              var _cloudfuji_metrics_token = '#{Cloudfuji::Platform.metrics_token}';
+              (function() {
+                var cloudfuji = document.createElement('script'); cloudfuji.type = 'text/javascript'; cloudfuji.async = true;
+                cloudfuji.src = '#{Cloudfuji::Platform.cloudfuji_js_source}?t=#{::Cloudfuji::VERSION.gsub('.', '')}';
+                var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(cloudfuji, s);
+              })();
+            </script>     
+          </body>
+        STR
+        )
+
+        headers['content-length'] = bytesize(content).to_s
+        [status, headers, [content]]
+      else
+        @app.call(env)
+      end
+    end
+  end
+end
+

data/lib/cloudfuji/models.rb

@@ -0,0 +1,59 @@
+module Cloudfuji
+  module Models
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def cloudfuji_save
+      # It's possible we're saving an item just handed to us by Cloudfuji, so we
+      # don't want to re-publish it. We can detect it using the version.
+      
+      puts "what"
+      # cloudfuji_id.nil? This is new, it's from us (otherwise cloudfuji would have given it an id), we should publish it.
+      # cloudfuji_version == self.find(self.id).cloudfuji_version The version hasn't changed, our data has, we should publish it
+      puts "new_record? #{self.new_record?}"
+      puts "self.id = #{self.id}"
+      puts "ido_id.nil? #{ido_id.nil?}"
+      puts "ido_version == self.class.find(self.id).ido_version ? #{ido_version == self.class.find(self.id).ido_version}" unless self.new_record?
+      if self.ido_id.nil? or (not self.new_record? and self.ido_version == self.class.find(self.id).ido_version)
+        puts "Local change, publishing to Cloudfuji databus"
+
+        data = self.to_cloudfuji
+
+        begin
+          response = Cloudfuji::Data.publish(self.class.class_variable_get("@@ido_model"), data)
+        rescue => e
+          puts e.inspect
+          # TODO: Catch specific exceptions and bubble up errors (e.g. 'cloudfuji is down', 'model is malformed', etc.)
+          return false
+        end
+
+        self.ido_version = response["ido_version"]
+        self.ido_id ||= response["ido_id"]
+
+        puts response.inspect
+      else
+        puts "Remote change, not publishing to Cloudfuji databus"
+      end
+
+      return true
+    end
+
+    module ClassMethods
+      def cloudfuji model
+        self.class_variable_set("@@ido_model", model)
+
+        [:create, :update, :destroy].each do |event|
+          puts "Hooking into #{model}.#{event}..."
+
+          Cloudfuji::Data.listen("#{model}.#{event}") do |data, hook|
+            puts "#{hook}.) Firing off #{model}.#{event} now with data: #{data}"
+            self.send("on_cloudfuji_#{event}".to_sym, self.from_cloudfuji(data))
+          end
+        end
+        
+        before_save :cloudfuji_save
+      end
+    end
+  end
+end

data/lib/cloudfuji/orm/active_record.rb

@@ -0,0 +1,44 @@
+require 'orm_adapter/adapters/active_record'
+
+module Cloudfuji
+  module Orm
+    # This module contains some helpers and handle schema (migrations):
+    #
+    #   create_table :accounts do |t|
+    #     t.database_authenticatable
+    #     t.confirmable
+    #     t.recoverable
+    #     t.rememberable
+    #     t.trackable
+    #     t.lockable
+    #     t.timestamps
+    #   end
+    #
+    # However this method does not add indexes. If you need them, here is the declaration:
+    #
+    #   add_index "accounts", ["email"],                :name => "email",                :unique => true
+    #   add_index "accounts", ["confirmation_token"],   :name => "confirmation_token",   :unique => true
+    #   add_index "accounts", ["reset_password_token"], :name => "reset_password_token", :unique => true
+    #
+    module ActiveRecord
+      module Schema
+        include Cloudfuji::Schema
+
+        # Tell how to apply schema methods.
+        def apply_cloudfuji_schema(name, type, options={})
+          column name, type.to_s.downcase.to_sym, options
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    include Cloudfuji::Models
+  end
+end
+
+ActiveRecord::ConnectionAdapters::Table.send :include, Cloudfuji::Orm::ActiveRecord::Schema
+ActiveRecord::ConnectionAdapters::TableDefinition.send :include, Cloudfuji::Orm::ActiveRecord::Schema
+

data/lib/cloudfuji/orm/mongoid.rb

@@ -0,0 +1,31 @@
+require 'orm_adapter/adapters/mongoid'
+
+module Cloudfuji
+  module Orm
+    module Mongoid
+      module Hook
+        def cloudfuji_modules_hook!
+          extend Schema
+          yield
+          return unless Devise.apply_schema
+          devise_modules.each { |m| send(m) if respond_to?(m, true) }
+        end
+      end
+
+      module Schema
+        include Cloudfuji::Schema
+
+        # Tell how to apply schema methods
+        def apply_cloudfuji_schema(name, type, options={})
+          type = Time if type == DateTime
+          field name, { :type => type }.merge!(options)
+        end
+      end
+    end
+  end
+end
+
+Mongoid::Document::ClassMethods.class_eval do
+  include Cloudfuji::Models
+  include Cloudfuji::Orm::Mongoid::Hook
+end