bushido 0.0.35 → 0.0.36

data/lib/bushido/data_helper.rb

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

data/lib/bushido/engine.rb

@@ -0,0 +1,21 @@
+require 'bushido'
+
+if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  require 'rails'
+  require 'rails/routes'
+
+  module Bushido
+    class Engine < Rails::Engine
+        
+      initializer "bushido.add_middleware" do |app|
+        # Only include our middleware if its on our platform
+        unless ENV['BUSHIDO_APP'].nil?
+          app.middleware.use Bushido::Middleware
+        end
+      end
+    end
+  end
+else
+  # Rails 2 handling
+  Rails.configuration.middleware.use 'Bushido::Middleware'
+end

data/lib/bushido/envs_helper.rb

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

data/lib/bushido/event.rb

@@ -15,6 +15,10 @@ module Bushido
     attr_reader :category, :name, :data
 
     class << self
+      def events_url
+        "#{Bushido::Platform.host}/apps/#{Bushido::Platform.name}/events.json"
+      end
+      
       # Lists all events
       def all
         @@events.collect{ |e| Event.new(e) }
@@ -29,12 +33,31 @@ module Bushido
       def last
         Event.new(@@events.last)
       end
+
+      # NOOP right now
+      def refresh
+        @@events = Bushido::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("Bushido::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]
+
+        Bushido::Command.post_command(events_url, payload)
+      end
     end
 
     def initialize(options={})
       @category = options["category"]
-      @name = options["name"]
-      @data = options["data"]
+      @name     = options["name"]
+      @data     = options["data"]
     end
+
   end
 end

data/lib/bushido/event_observer.rb

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

data/lib/bushido/mail_helper.rb

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

data/lib/bushido/mail_route.rb

@@ -0,0 +1,186 @@
+module Bushido
+  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 Bushido::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/bushido/middleware.rb

@@ -2,36 +2,28 @@
 
 module Bushido
   class Middleware
-
-    BUSHIDO_JS_URL = "#{Bushido::Platform.host}/api/bushido.js"
-
     include Rack::Utils
 
     def initialize(app, opts = {})
       @app = app
-      @bushido_app_name       = ENV['BUSHIDO_APP']
-      @bushido_metrics_token  = ENV['BUSHIDO_METRICS_TOKEN']
-      @bushido_claimed        = (ENV['BUSHIDO_CLAIMED'].nil? or ENV['BUSHIDO_CLAIMED'].blank?) ? false : true
     end
 
     def call(env)
-      @bushido_claimed        = (ENV['BUSHIDO_CLAIMED'].nil? or ENV['BUSHIDO_CLAIMED'].blank?) ? false : true
+      if Bushido::Platform.on_bushido? and Bushido::Bar.in_bar_display_path?(env)
+        status, headers, response = @app.call(env)
 
-      status, headers, response = @app.call(env)
-      
-      unless @bushido_app_name.empty?
         content = ""
         response.each { |part| content += part }
 
         # "claiming" bar + stats ?
         content.gsub!(/<\/body>/i, <<-STR
             <script type="text/javascript">
-              var _bushido_app = '#{@bushido_app_name}';
-              var _bushido_claimed = #{@bushido_claimed.to_s};
-              var _bushido_metrics_token = '#{@bushido_metrics_token}';
+              var _bushido_app = '#{Bushido::Platform.name}';
+              var _bushido_claimed = #{Bushido::Platform.claimed?.to_s};
+              var _bushido_metrics_token = '#{Bushido::Platform.metrics_token}';
               (function() {
                 var bushido = document.createElement('script'); bushido.type = 'text/javascript'; bushido.async = true;
-                bushido.src = '#{BUSHIDO_JS_URL}?#{::Bushido::VERSION.gsub('.', '')}';
+                bushido.src = '#{Bushido::Platform.bushido_js_source}?t=#{::Bushido::VERSION.gsub('.', '')}';
                 var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(bushido, s);
               })();
             </script>     
@@ -40,10 +32,11 @@ module Bushido
         )
 
         headers['content-length'] = bytesize(content).to_s
+        [status, headers, [content]]
+      else
+        @app.call(env)
       end
-      [status, headers, [content]]
     end
-
   end
 end
 

data/lib/bushido/platform.rb

@@ -5,7 +5,6 @@ module Bushido
         ENV['BUSHIDO_NAME']
       end
 
-
       def key
         ENV['BUSHIDO_APP_KEY']
       end
@@ -14,9 +13,34 @@ module Bushido
         "#{host}/apps/#{name}/bus"
       end
 
+      def protocol
+        ENV['BUSHIDO_PROTOCOL'] || "https"
+      end
+
+      def port
+        ENV['BUSHIDO_PORT']
+      end
+
       def host
-        port = ENV['BUSHIDO_PORT'] ? ":#{ENV['BUSHIDO_PORT']}" : ""
-        "http://#{ENV['BUSHIDO_HOST'] || 'bushi.do'}#{port}"
+        bushido_port = port ? ":#{port}" : ""
+        bushido_host = ENV['BUSHIDO_HOST'] || 'bushi.do'
+        "#{protocol}://#{bushido_host}#{bushido_port}"
+      end
+
+      def on_bushido?
+        ENV['HOSTING_PLATFORM']=="bushido"
+      end
+
+      def claimed?
+        (ENV['BUSHIDO_CLAIMED'].nil? or ENV['BUSHIDO_CLAIMED'].blank?) ? false : true
+      end
+
+      def metrics_token
+        ENV['BUSHIDO_METRICS_TOKEN']
+      end
+
+      def bushido_js_source
+        "#{Bushido::Platform.host}/api/bushido.js"
       end
     end
   end

data/lib/bushido/smtp.rb

@@ -0,0 +1,24 @@
+module Bushido
+  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 => Bushido::SMTP.tls,
+          :tls =>                  Bushido::SMTP.tls,
+          :address =>              Bushido::SMTP.server,
+          :port =>                 Bushido::SMTP.port,
+          :domain =>               Bushido::SMTP.domain,
+          :authentication =>       Bushido::SMTP.authentication,
+          :user_name =>            Bushido::SMTP.user,
+          :password =>             Bushido::SMTP.password,
+        }
+      end
+    end
+  end
+end

data/lib/bushido/user.rb

@@ -1,28 +1,58 @@
 module Bushido
   # Bushido User enables user validation against Bushido's server
-  class User
+  class User < Bushido::Base
     class << self
-      def unity_url #:nodoc:
-        "#{Bushido::Platform.host}/unity/v1"
-      end
-
-
+      
       # Checks whether user an email and password correspond to a valid bushido
       # user. Returns nil if false, or the Bushido user's ID if true.
       def valid?(email, pass)
         params = {}
         params[:email] = email
         params[:pass] = pass
-        Bushido::Command.post_command("#{unity_url}/valid", params)
+        Bushido::Command.post_command(valid_unity_url, params)
       end
-      
 
       # Checks whether email corresponds to a valid Bushido user.
       # Returns true or false
       def exists?(email)
         params = {}
         params[:email] = email
-        Bushido::Command.post_command("#{unity_url}/exists", params)
+        Bushido::Command.post_command(exists_unity_url, params)
+      end
+
+      # send a Bushido invite with a short description of the app (also a box of chocolates, if he's a Kryptonian)
+      # Bushido::User.invite("clark@kent-on-krypton.com")
+      def invite(email)
+        params = {}
+        params[:email] = email
+        Bushido::Command.post_command(invite_unity_url, params)
+      end
+
+      # List all pending invites
+      # Bushido::User.pending_invites
+      def pending_invites
+        params = {}
+        Bushido::Command.get_command(pending_invites_unity_url, params)
+      end
+
+      # To remove a user from an application
+      # Bushido::User.remove("5z325f4knbm2f")
+      def remove(ido_id)
+          params = {}
+          params[:ido_id] = ido_id
+          Bushido::Command.post_command(remove_unity_url, params)
+      end
+
+      # To send a notification to a user who belongs to your app
+      # Bushido::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
+
+        Bushido::Command.post_command(notify_user_url, params)
       end
     end
   end