messagebus_ruby_api 0.4.0 → 0.4.4

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/log_subscriber.rb

@@ -0,0 +1,122 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveSupport
+  # ActiveSupport::LogSubscriber is an object set to consume ActiveSupport::Notifications
+  # with solely purpose of logging. The log subscriber dispatches notifications to a
+  # regirested object based on its given namespace.
+  #
+  # An example would be Active Record log subscriber responsible for logging queries:
+  #
+  #   module ActiveRecord
+  #     class LogSubscriber < ActiveSupport::LogSubscriber
+  #       def sql(event)
+  #         "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
+  #       end
+  #     end
+  #   end
+  #
+  # And it's finally registed as:
+  #
+  #   ActiveRecord::LogSubscriber.attach_to :active_record
+  #
+  # Since we need to know all instance methods before attaching the log subscriber,
+  # the line above should be called after your ActiveRecord::LogSubscriber definition.
+  #
+  # After configured, whenever a "sql.active_record" notification is published,
+  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
+  # the sql method.
+  #
+  # Log subscriber also has some helpers to deal with logging and automatically flushes
+  # all logs when the request finishes (via action_dispatch.callback notification) in
+  # a Rails environment.
+  class LogSubscriber
+    # Embed in a String to clear all previous ANSI sequences.
+    CLEAR   = "\e[0m"
+    BOLD    = "\e[1m"
+
+    # Colors
+    BLACK   = "\e[30m"
+    RED     = "\e[31m"
+    GREEN   = "\e[32m"
+    YELLOW  = "\e[33m"
+    BLUE    = "\e[34m"
+    MAGENTA = "\e[35m"
+    CYAN    = "\e[36m"
+    WHITE   = "\e[37m"
+
+    mattr_accessor :colorize_logging
+    self.colorize_logging = true
+
+    class_attribute :logger
+
+    class << self
+      remove_method :logger
+      def logger
+        @logger ||= Rails.logger if defined?(Rails)
+      end
+
+      def attach_to(namespace, log_subscriber=new, notifier=ActiveSupport::Notifications)
+        log_subscribers << log_subscriber
+        @@flushable_loggers = nil
+
+        log_subscriber.public_methods(false).each do |event|
+          next if 'call' == event.to_s
+
+          notifier.subscribe("#{event}.#{namespace}", log_subscriber)
+        end
+      end
+
+      def log_subscribers
+        @@log_subscribers ||= []
+      end
+
+      def flushable_loggers
+        @@flushable_loggers ||= begin
+          loggers = log_subscribers.map(&:logger)
+          loggers.uniq!
+          loggers.select { |l| l.respond_to?(:flush) }
+        end
+      end
+
+      # Flush all log_subscribers' logger.
+      def flush_all!
+        flushable_loggers.each { |log| log.flush }
+      end
+    end
+
+    def call(message, *args)
+      return unless logger
+
+      method = message.split('.').first
+      begin
+        send(method, ActiveSupport::Notifications::Event.new(message, *args))
+      rescue Exception => e
+        logger.error "Could not log #{message.inspect} event. #{e.class}: #{e.message}"
+      end
+    end
+
+  protected
+
+    %w(info debug warn error fatal unknown).each do |level|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{level}(*args, &block)
+          return unless logger
+          logger.#{level}(*args, &block)
+        end
+      METHOD
+    end
+
+    # Set color by using a string or one of the defined constants. If a third
+    # option is set to true, it also adds bold to the string. This is based
+    # on Highline implementation and it automatically appends CLEAR to the end
+    # of the returned String.
+    #
+    def color(text, color, bold=false)
+      return text unless colorize_logging
+      color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+      bold  = bold ? BOLD : ""
+      "#{bold}#{color}#{text}#{CLEAR}"
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/memoizable.rb

@@ -0,0 +1,105 @@
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/aliasing'
+
+module ActiveSupport
+  module Memoizable
+    def self.memoized_ivar_for(symbol)
+      "@_memoized_#{symbol.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')}".to_sym
+    end
+
+    module InstanceMethods
+      def self.included(base)
+        base.class_eval do
+          unless base.method_defined?(:freeze_without_memoizable)
+            alias_method_chain :freeze, :memoizable
+          end
+        end
+      end
+
+      def freeze_with_memoizable
+        memoize_all unless frozen?
+        freeze_without_memoizable
+      end
+
+      def memoize_all
+        prime_cache ".*"
+      end
+
+      def unmemoize_all
+        flush_cache ".*"
+      end
+
+      def prime_cache(*syms)
+        syms.each do |sym|
+          methods.each do |m|
+            if m.to_s =~ /^_unmemoized_(#{sym})/
+              if method(m).arity == 0
+                __send__($1)
+              else
+                ivar = ActiveSupport::Memoizable.memoized_ivar_for($1)
+                instance_variable_set(ivar, {})
+              end
+            end
+          end
+        end
+      end
+
+      def flush_cache(*syms)
+        syms.each do |sym|
+          (methods + private_methods + protected_methods).each do |m|
+            if m.to_s =~ /^_unmemoized_(#{sym.to_s.gsub(/\?\Z/, '\?')})/
+              ivar = ActiveSupport::Memoizable.memoized_ivar_for($1)
+              instance_variable_get(ivar).clear if instance_variable_defined?(ivar)
+            end
+          end
+        end
+      end
+    end
+
+    def memoize(*symbols)
+      symbols.each do |symbol|
+        original_method = :"_unmemoized_#{symbol}"
+        memoized_ivar = ActiveSupport::Memoizable.memoized_ivar_for(symbol)
+
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
+          include InstanceMethods                                                  # include InstanceMethods
+                                                                                   #
+          if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)
+            raise "Already memoized #{symbol}"                                     #   raise "Already memoized mime_type"
+          end                                                                      # end
+          alias #{original_method} #{symbol}                                       # alias _unmemoized_mime_type mime_type
+                                                                                   #
+          if instance_method(:#{symbol}).arity == 0                                # if instance_method(:mime_type).arity == 0
+            def #{symbol}(reload = false)                                          #   def mime_type(reload = false)
+              if reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?  #     if reload || !defined?(@_memoized_mime_type) || @_memoized_mime_type.empty?
+                #{memoized_ivar} = [#{original_method}]                            #       @_memoized_mime_type = [_unmemoized_mime_type]
+              end                                                                  #     end
+              #{memoized_ivar}[0]                                                  #     @_memoized_mime_type[0]
+            end                                                                    #   end
+          else                                                                     # else
+            def #{symbol}(*args)                                                   #   def mime_type(*args)
+              #{memoized_ivar} ||= {} unless frozen?                               #     @_memoized_mime_type ||= {} unless frozen?
+              reload = args.pop if args.last == true || args.last == :reload       #     reload = args.pop if args.last == true || args.last == :reload
+                                                                                   #
+              if defined?(#{memoized_ivar}) && #{memoized_ivar}                    #     if defined?(@_memoized_mime_type) && @_memoized_mime_type
+                if !reload && #{memoized_ivar}.has_key?(args)                      #       if !reload && @_memoized_mime_type.has_key?(args)
+                  #{memoized_ivar}[args]                                           #         @_memoized_mime_type[args]
+                elsif #{memoized_ivar}                                             #       elsif @_memoized_mime_type
+                  #{memoized_ivar}[args] = #{original_method}(*args)               #         @_memoized_mime_type[args] = _unmemoized_mime_type(*args)
+                end                                                                #       end
+              else                                                                 #     else
+                #{original_method}(*args)                                          #       _unmemoized_mime_type(*args)
+              end                                                                  #     end
+            end                                                                    #   end
+          end                                                                      # end
+                                                                                   #
+          if private_method_defined?(#{original_method.inspect})                   # if private_method_defined?(:_unmemoized_mime_type)
+            private #{symbol.inspect}                                              #   private :mime_type
+          elsif protected_method_defined?(#{original_method.inspect})              # elsif protected_method_defined?(:_unmemoized_mime_type)
+            protected #{symbol.inspect}                                            #   protected :mime_type
+          end                                                                      # end
+        EOS
+      end
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/message_encryptor.rb

@@ -0,0 +1,71 @@
+require 'openssl'
+require 'active_support/base64'
+
+module ActiveSupport
+  # MessageEncryptor is a simple way to encrypt values which get stored somewhere
+  # you don't trust.
+  #
+  # The cipher text and initialization vector are base64 encoded and returned to you.
+  #
+  # This can be used in situations similar to the MessageVerifier, but where you don't
+  # want users to be able to determine the value of the payload.
+  class MessageEncryptor
+    class InvalidMessage < StandardError; end
+    OpenSSLCipherError = OpenSSL::Cipher.const_defined?(:CipherError) ? OpenSSL::Cipher::CipherError : OpenSSL::CipherError
+
+    def initialize(secret, cipher = 'aes-256-cbc')
+      @secret = secret
+      @cipher = cipher
+    end
+
+    def encrypt(value)
+      cipher = new_cipher
+      # Rely on OpenSSL for the initialization vector
+      iv = cipher.random_iv
+
+      cipher.encrypt
+      cipher.key = @secret
+      cipher.iv  = iv
+
+      encrypted_data = cipher.update(Marshal.dump(value))
+      encrypted_data << cipher.final
+
+      [encrypted_data, iv].map {|v| ActiveSupport::Base64.encode64s(v)}.join("--")
+    end
+
+    def decrypt(encrypted_message)
+      cipher = new_cipher
+      encrypted_data, iv = encrypted_message.split("--").map {|v| ActiveSupport::Base64.decode64(v)}
+
+      cipher.decrypt
+      cipher.key = @secret
+      cipher.iv  = iv
+
+      decrypted_data = cipher.update(encrypted_data)
+      decrypted_data << cipher.final
+
+      Marshal.load(decrypted_data)
+    rescue OpenSSLCipherError, TypeError
+      raise InvalidMessage
+    end
+
+    def encrypt_and_sign(value)
+      verifier.generate(encrypt(value))
+    end
+
+    def decrypt_and_verify(value)
+      decrypt(verifier.verify(value))
+    end
+
+
+
+    private
+      def new_cipher
+        OpenSSL::Cipher::Cipher.new(@cipher)
+      end
+
+      def verifier
+        MessageVerifier.new(@secret)
+      end
+  end
+end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/message_verifier.rb

@@ -0,0 +1,62 @@
+require 'active_support/base64'
+require 'active_support/core_ext/object/blank'
+
+module ActiveSupport
+  # MessageVerifier makes it easy to generate and verify messages which are signed
+  # to prevent tampering.
+  #
+  # This is useful for cases like remember-me tokens and auto-unsubscribe links where the
+  # session store isn't suitable or available.
+  #
+  # Remember Me:
+  #   cookies[:remember_me] = @verifier.generate([@user.id, 2.weeks.from_now])
+  #
+  # In the authentication filter:
+  #
+  #   id, time = @verifier.verify(cookies[:remember_me])
+  #   if time < Time.now
+  #     self.current_user = User.find(id)
+  #   end
+  #
+  class MessageVerifier
+    class InvalidSignature < StandardError; end
+
+    def initialize(secret, digest = 'SHA1')
+      @secret = secret
+      @digest = digest
+    end
+
+    def verify(signed_message)
+      raise InvalidSignature if signed_message.blank?
+
+      data, digest = signed_message.split("--")
+      if data.present? && digest.present? && secure_compare(digest, generate_digest(data))
+        Marshal.load(ActiveSupport::Base64.decode64(data))
+      else
+        raise InvalidSignature
+      end
+    end
+
+    def generate(value)
+      data = ActiveSupport::Base64.encode64s(Marshal.dump(value))
+      "#{data}--#{generate_digest(data)}"
+    end
+
+    private
+      # constant-time comparison algorithm to prevent timing attacks
+      def secure_compare(a, b)
+        return false unless a.bytesize == b.bytesize
+
+        l = a.unpack "C#{a.bytesize}"
+
+        res = 0
+        b.each_byte { |byte| res |= byte ^ l.shift }
+        res == 0
+      end
+
+      def generate_digest(data)
+        require 'openssl' unless defined?(OpenSSL)
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@digest).new, @secret, data)
+      end
+  end
+end