sipatra 0.0.3

data/lib/sipatra/base.rb

@@ -0,0 +1,301 @@
+require 'sipatra/helpers'
+require 'sipatra/extension_modules'
+require 'benchmark'
+
+module Sipatra
+  VERSION = '1.0.0'
+  
+  class Base
+    include HelperMethods
+    attr_accessor :sip_factory, :context, :session, :msg, :params
+    
+    def initialize()
+      @params = Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+    end
+    
+    # called from Java to set SIP servlet bindings
+    def set_bindings(*args)
+      @context, @sip_factory, @session, @msg = args
+      session.extend Sipatra::SessionExtension
+      msg.extend Sipatra::MessageExtension
+    end
+    
+    def session=(session)
+      @session = session
+      class << @session
+         include SessionExtension
+       end
+    end
+    
+    # called to process a SIP request
+    def do_request
+      call! self.class.req_handlers
+    end
+    
+    # called to process a SIP response
+    def do_response
+      call! self.class.resp_handlers
+    end
+    
+    # Exit the current block, halts any further processing
+    # of the message.
+    # TODO: handle a response (as param)
+    def halt
+      throw :halt
+    end
+    
+    # Pass control to the next matching handler.
+    def pass
+      throw :pass
+    end
+    
+    def request?
+      !msg.respond_to?(:getRequest)
+    end
+    
+    def response?
+      msg.respond_to?(:getRequest)
+    end
+    
+    private
+    
+    def msg_type
+      response? ? :response : :request
+    end
+    
+    def eval_options(opts)
+      opts.each_pair { |key, condition|
+        pass unless header? key
+        header_match = condition.match header[key]
+        @params[key] = header_match.to_a if header_match
+      }
+    end
+    
+    def eval_condition(arg, keys, opts)
+      #clear (for multi usage)
+      @params.clear
+      if request?
+        match = arg.match msg.requestURI.to_s
+        if match
+          eval_options(opts)
+          if keys.any?
+            values = match.captures.to_a #Array of matched values
+            keys.zip(values).each do |(k, v)|
+              @params[k] = v
+            end
+          elsif(match.length > 1)
+            @params[:uri] = match.to_a
+          end
+          return true
+        end
+      else
+        if ((arg == 0) or (arg == msg.status))
+          eval_options(opts)
+          return true
+        end
+      end
+      return false
+    end
+    
+    def process_handler(handlers_hash, method_or_joker)
+      if handlers = handlers_hash[method_or_joker]
+        handlers.each do |pattern, keys, opts, block|
+          catch :pass do
+            throw :pass unless eval_condition(pattern, keys, opts)
+            throw :halt, instance_eval(&block)          
+          end
+        end
+      end
+    end
+    
+    # Run all filters defined on superclasses and then those on the current class.
+    def filter!(type, base = self.class)
+      filter! type, base.superclass if base.superclass.respond_to?(:filters)
+      base.filters[type].each { |block| instance_eval(&block) }
+    end
+    
+    def call!(handlers)
+      filter! :before
+      catch(:halt) do
+        process_handler(handlers, msg.method)
+        process_handler(handlers, "_")
+      end
+    ensure 
+      filter! :after
+    end
+    
+    class << self
+      attr_reader :req_handlers, :resp_handlers, :filters
+      
+      # permits configuration of the application
+      def configure(*envs, &block)
+        yield self if envs.empty? || envs.include?(environment.to_sym)
+      end
+      
+      # Methods defined in the block and/or in the module
+      # arguments available to handlers.
+      def helpers(*modules, &block)
+        include(*modules) if modules.any?
+        class_eval(&block) if block_given?
+      end
+      
+      # Extension modules registered on this class and all superclasses.
+      def extensions
+        if superclass.respond_to?(:extensions)
+          (@extensions + superclass.extensions).uniq
+        else
+          @extensions
+        end
+      end
+      
+      # Extends current class with all modules passed as arguements
+      # if a block is present, creates a module with the block and
+      # extends the current class with it.
+      def register_extension(*extensions, &block)
+        extensions << Module.new(&block) if block_given?
+        @extensions += extensions
+        extensions.each do |extension|
+          extend extension
+          extension.registered(self) if extension.respond_to?(:registered)
+        end
+      end      
+      
+      def response(*args, &block)
+        method_name = args.shift if (!args.first.kind_of? Hash) and (!args.first.kind_of? Integer)
+        code_int = args.shift if !args.first.kind_of? Hash
+        opts = *args
+        pattern = code_int || 0
+        sip_method_name = method_name ? method_name.to_s.upcase : "_"
+        handler("response_#{sip_method_name}  \"#{pattern}\"", sip_method_name, pattern, [], opts || {}, &block)
+      end
+      
+      [:ack, :bye, :cancel, :info, :invite, :message, 
+       :notify, :options, :prack, :publish, :refer, 
+       :register, :subscribe, :update, :request].each do |name|
+        define_method name do |*args, &block|
+          path = args.shift if (!args.first.kind_of? Hash)
+          opts = *args
+          uri = path || //
+          pattern, keys = compile_uri_pattern(uri)
+          sip_method_name = name == :request ? "_" : name.to_s.upcase
+          handler("request_#{sip_method_name}  \"#{uri.kind_of?(Regexp) ? uri.source : uri}\"", sip_method_name, pattern, keys , opts || {}, &block)
+        end
+      end
+      
+      def before(msg_type = nil, &block)
+        add_filter(:before, msg_type, &block)
+      end
+      
+      def after(msg_type = nil, &block)
+        add_filter(:after, msg_type, &block)
+      end
+            
+      def reset!
+        @req_handlers          = {}
+        @resp_handlers         = {}
+        @extensions            = []
+        @filters               = {:before => [], :after => []}
+      end
+
+      def inherited(subclass)
+        subclass.reset!
+        super
+      end
+      
+      def before_filters
+        filters[:before]
+      end
+
+      def after_filters
+        filters[:after]
+      end
+      
+      private
+      
+      def add_filter(type, message_type = nil, &block)
+        if message_type
+          add_filter(type) do
+            next unless msg_type == message_type
+            instance_eval(&block)
+          end
+        else
+          filters[type] << block
+        end
+      end
+            
+      # compiles a URI pattern
+      def compile_uri_pattern(uri)
+        keys = []
+        if uri.respond_to? :to_str
+          pattern =
+          uri.to_str.gsub(/\(:(\w+)\)/) do |match|
+            keys << $1.dup
+                "([^:@;=?&]+)"
+          end
+          [/^#{pattern}$/, keys]
+        elsif uri.respond_to? :match
+          [uri, keys]
+        else
+          raise TypeError, uri
+        end
+      end
+      
+      def handler(method_name, verb, pattern, keys, options={}, &block)
+        define_method method_name, &block
+        unbound_method = instance_method(method_name)
+        block =
+        if block.arity != 0
+          proc { unbound_method.bind(self).call(*@block_params) }
+        else
+          proc { unbound_method.bind(self).call }
+        end
+        handler_table(method_name, verb).push([pattern, keys, options, block]).last # TODO: conditions  
+      end         
+      
+      def handler_table(method_name, verb)
+        if method_name.start_with? "response"
+         (@resp_handlers ||= {})[verb] ||= []
+        else
+         (@req_handlers ||= {})[verb] ||= []
+        end
+      end   
+    end
+    
+    reset!
+  end
+  
+  class Application < Base    
+    def self.register_extension(*extensions, &block) #:nodoc:
+      added_methods = extensions.map {|m| m.public_instance_methods }.flatten
+      Delegator.delegate(*added_methods)
+      super(*extensions, &block)
+    end    
+  end
+  
+  module Delegator #:nodoc:
+    def self.delegate(*methods)
+      methods.each do |method_name|
+        eval <<-RUBY, binding, '(__DELEGATE__)', 1
+          def #{method_name}(*args, &b)
+            ::Sipatra::Application.send(#{method_name.inspect}, *args, &b)
+          end
+          private #{method_name.inspect}
+        RUBY
+      end
+    end
+    
+    delegate :ack, :bye, :cancel, :info, :invite, :message,
+      :notify, :options, :prack, :publish, :refer, 
+      :register, :subscribe, :update, 
+      :helpers, :configure,
+      :before, :after, :request, :response
+  end
+  
+  def self.helpers(*extensions, &block)
+    Application.helpers(*extensions, &block)
+  end  
+  
+  def self.register_extension(*extensions, &block)
+    Application.register_extension(*extensions, &block)
+  end
+end

data/lib/sipatra/extension_modules.rb

@@ -0,0 +1,21 @@
+module Sipatra
+  module MessageExtension
+    def uri
+      requestURI
+    end
+  end
+  
+  module SessionExtension
+    def [](name)
+      getAttribute(name.to_s)
+    end
+    
+    def []=(name, value)
+      if value.nil?
+        removeAttribute(name.to_s)
+      else
+        setAttribute(name.to_s, value)
+      end
+    end
+  end
+end

data/lib/sipatra/helpers.rb

@@ -0,0 +1,205 @@
+module Sipatra
+  STATUS_CODES_MAP = {
+    :accepted => 202,
+    :address_incomplete => 484,
+    :alternative_service => 380,
+    :ambiguous => 485,
+    :bad_event => 489,
+    :bad_extension => 420,
+    :bad_gateway => 502,
+    :bad_identity_info => 436,
+    :bad_request => 400,
+    :busy_everywhere => 600,
+    :busy_here => 486,
+    :call_being_forwarded => 181,
+    :call_leg_done => 481,
+    :call_queued => 182,
+    :conditional_request_failed => 412,
+    :decline => 603,
+    :does_not_exit_anywhere => 604,
+    :extension_required => 421,
+    :forbidden => 403,
+    :gone => 410,
+    :interval_too_brief => 423,
+    :invalid_identity_header => 438,
+    :loop_detected => 482,
+    :message_too_large => 513,
+    :method_not_allowed => 405,
+    :moved_permanently => 301,
+    :moved_temporarily => 302,
+    :multiple_choices => 300,
+    :not_acceptable => 406,
+    :not_acceptable_anywhere => 606,
+    :not_acceptable_here => 488, 
+    :not_found => 404,
+    :not_implemented => 501,
+    :ok => 200,
+    :payment_required => 402,
+    :precondition_failure => 580,
+    :provide_referer_identity => 429,
+    :proxy_authentication_required => 407,
+    :request_entity_too_large => 413,
+    :request_pending => 491,
+    :request_terminated => 487,
+    :request_timeout => 408,
+    :request_uri_too_long => 414,
+    :ringing => 180,
+    :security_agreement_required => 494,
+    :server_internal_error => 500,
+    :server_timeout => 504,
+    :service_unavailable => 503,
+    :session_interval_too_small => 422,
+    :session_progress => 183,
+    :temporarily_unavailable => 480,
+    :too_many_hops => 483,
+    :trying => 100,
+    :unauthorized => 401,
+    :undecipherable => 493,
+    :unsupported_certificate => 437,
+    :unsupported_media_type => 415,
+    :unsupported_uri_scheme => 416,
+    :use_identity_header => 428,
+    :use_proxy => 305,
+    :version_not_supported => 505,
+  }
+  
+  class HeadersWrapper
+    def initialize(app, plural = false, address = false)
+      @app = app
+      method_definitions = <<-RUBY
+        def [](name)
+          @app.msg.get#{address ? "Address" : ""}Header#{plural ? "s" : ""}(name.to_s)#{plural ? ".to_a" : ""}
+        end
+      RUBY
+      if plural
+        method_definitions += <<-RUBY
+          def []=(name, values)
+            name = name.to_s
+            @app.msg.removeHeader(name)
+            if !values.nil?
+              values.each do |value| 
+                @app.msg.add#{address ? "Address" : ""}Header(name, value#{address ? ", true" : ".to_s"})
+              end
+            end
+          end 
+        RUBY
+      else
+        method_definitions += <<-RUBY
+          def []=(name, value)
+            if !value.nil?
+              @app.msg.set#{address ? "Address" : ""}Header(name.to_s, value)
+            else
+              @app.msg.removeHeader(name.to_s)
+            end
+          end 
+        RUBY
+      end
+      class << self; self; end.class_eval method_definitions
+      end 
+    end
+    
+    module HelperMethods  
+      def proxy(*args)
+        uri = args.shift
+        uri, options = nil, uri if uri.kind_of? Hash
+        options ||= args.shift || {}
+        if uri.nil?
+          uri = msg.requestURI
+        else
+          uri = sip_factory.createURI(uri)
+        end
+        proxy = msg.getProxy()
+        proxy.setRecordRoute(options[:record_route]) if options.has_key? :record_route
+        proxy.proxyTo(uri)
+      end    
+      
+      def header
+        @header_wrapper ||= HeadersWrapper::new(self)
+      end
+      
+      def headers
+        @headers_wrapper ||= HeadersWrapper::new(self, true)
+      end
+      
+      def address_header
+        @address_header_wrapper ||= HeadersWrapper::new(self, false, true)
+      end
+      
+      def address_headers
+        @address_headers_wrapper ||= HeadersWrapper::new(self, true, true)
+      end
+      
+      def add_header(name, value)
+        msg.addHeader(name.to_s, value)
+      end
+      
+      def add_address_header(name, value, first = true)
+        msg.addAddressHeader(name.to_s, value, first)
+      end
+      
+      def header?(name)
+        !msg.getHeader(name.to_s).nil?
+      end
+      
+      def modify_header(header_name, pattern = nil, new_value = nil)
+        #FIXME: "JAVA" Code
+        if pattern
+          pattern = Regexp.new(/^#{pattern}$/) unless pattern.kind_of? Regexp
+          headers[header_name] = headers[header_name].map do |value|
+            value.gsub(pattern, new_value)
+          end
+        else
+          headers[header_name] = headers[header_name].map do |value|
+            yield value
+          end
+        end
+      end
+      
+      def remove_header(name)
+        msg.removeHeader(name.to_s)
+      end
+      
+      def send_response(status, *args)
+        create_args = [convert_status_code(status)]
+        create_args << args.shift unless args.empty? || args.first.kind_of?(Hash)
+        response = msg.createResponse(*create_args)
+        unless args.empty?
+          raise ArgumentError, "last argument should be a Hash" unless args.first.kind_of? Hash
+          args.first.each_pair do |name, value|
+            response.addHeader(name.to_s, value.to_s)
+          end
+        end
+        if block_given?
+          yield response
+        end
+        response.send
+      end
+      
+      def create_address(addr, options = {})
+        addr = addr.to_s # TODO: Handle URI instances
+        address = sip_factory.createAddress(addr)
+        address.setExpires(options[:expires]) if options.has_key? :expires
+        address.setDisplayName(options[:display_name]) if options.has_key? :display_name
+        
+        address      
+      end
+      
+      def push_route(route)
+        msg.pushRoute(sip_factory.createAddress(route))
+      end    
+      
+      private
+      
+      def convert_status_code(symbol_or_int)
+        case symbol_or_int
+          when Integer: return symbol_or_int
+          when Symbol: 
+          code = STATUS_CODES_MAP[symbol_or_int]
+          raise ArgumentError, "Unknown status code symbol: '#{symbol_or_int}'" unless code
+          code
+        else
+          raise ArgumentError, "Status code value should be a Symbol or Int not '#{symbol_or_int.class}'"
+        end
+      end
+    end
+  end

data/lib/sipatra-jars.rb

@@ -0,0 +1,13 @@
+module SipatraJars
+  PATH = File.expand_path(File.dirname(__FILE__))
+
+  class << self
+    def all_jar_names
+      @all_jar_names ||= all_jar_paths.map { |path| File::basename(path) }
+    end
+
+    def all_jar_paths
+      @all_jar_paths ||= Dir[PATH + "/sipatra/*.jar"]
+    end
+  end
+end

data/lib/sipatra.rb

@@ -0,0 +1,9 @@
+if  ENV['SIPATRA_PATH']
+  ENV['GEM_HOME'] = ENV['SIPATRA_PATH'] + '/../gems'
+  ENV['GEM_PATH'] = ENV['SIPATRA_PATH'] + '/../gems'
+  require 'rubygems'
+end
+
+require 'sipatra/base'
+
+include Sipatra::Delegator

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: sipatra
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Dominique Broeglin
+- Jean-Baptiste Morin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-30 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: Sipatra is a Ruby DSL for easy writting of SIP Servlet applications
+email: 
+- dominique.broeglin@gmail.com
+- jean-baptiste.morin@nexcom.fr
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/sipatra-jars.rb
+- lib/sipatra.rb
+- lib/sipatra/base.rb
+- lib/sipatra/commons-pool-1.5.5.jar
+- lib/sipatra/extension_modules.rb
+- lib/sipatra/helpers.rb
+- lib/sipatra/sipatra-0.0.3-SNAPSHOT.jar
+- lib/sipatra/slf4j-api-1.4.0.jar
+- lib/sipatra/slf4j-log4j12-1.4.0.jar
+has_rdoc: true
+homepage: http://confluence.cipango.org/display/DOC/Sipatra
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: DSL for easy writting of SIP Servlet applications
+test_files: []
+