librevox 0.9 → 1.0.0.alpha2

data/lib/librevox/response.rb

@@ -1,52 +0,0 @@
-require 'eventmachine'
-require 'em/protocols/header_and_content'
-
-class String
-  alias :each :each_line
-end
-
-module Librevox
-  class Response
-    attr_accessor :headers, :content
-
-    def initialize headers="", content=""
-      self.headers = headers
-      self.content = content
-    end
-
-    def headers= headers
-      @headers = headers_2_hash(headers)
-      @headers.each {|k,v| v.chomp! if v.is_a?(String)}
-    end
-
-    def content= content
-      @content = if content.respond_to?(:match) && content.match(/:/)
-                   headers_2_hash(content).merge(:body => content.split("\n\n", 2)[1].to_s)
-                 else
-                   content
-                 end
-      @content.each {|k,v| v.chomp! if v.is_a?(String)}
-    end
-
-    def event?
-      @content.is_a?(Hash) && @content.include?(:event_name)
-    end
-
-    def event
-      @content[:event_name] if event?
-    end
-
-    def api_response?
-      @headers[:content_type] == "api/response"
-    end
-
-    def command_reply?
-      @headers[:content_type] == "command/reply"
-    end
-
-    private
-    def headers_2_hash *args
-      EM::Protocols::HeaderAndContentProtocol.headers_2_hash *args
-    end
-  end
-end

data/librevox.gemspec

@@ -1,37 +0,0 @@
-Gem::Specification.new do |s|
-  s.name     = "librevox"
-  s.version  = "0.9"
-  s.date     = "2014-04-03"
-  s.summary  = "Ruby library for interacting with FreeSWITCH."
-  s.email    = "harry@vangberg.name"
-  s.homepage = "http://github.com/vangberg/librevox"
-  s.description = "EventMachine-based Ruby library for interacting with the
-open source telephony platform FreeSwitch."
-  s.authors  = ["Harry Vangberg"]
-  s.files    = [
-    "README.md",
-    "LICENSE",
-    "TODO",
-    "Rakefile",
-		"librevox.gemspec",
-		"lib/librevox.rb",
-    "lib/librevox/applications.rb",
-    "lib/librevox/command_socket.rb",
-    "lib/librevox/commands.rb",
-    "lib/librevox/response.rb",
-    "lib/librevox/listener/base.rb",
-    "lib/librevox/listener/inbound.rb",
-    "lib/librevox/listener/outbound.rb"
-  ]
-  s.test_files  = [
-    "spec/helper.rb",
-    "spec/librevox/listener.rb",
-    "spec/librevox/spec_applications.rb",
-    #"spec/librevox/spec_command_socket.rb",
-    "spec/librevox/spec_commands.rb",
-    "spec/librevox/spec_response.rb",
-    "spec/librevox/listener/spec_inbound.rb",
-    "spec/librevox/listener/spec_outbound.rb"
-  ]
-  s.add_dependency "eventmachine", "~> 1.0"
-end

data/spec/helper.rb

@@ -1,86 +0,0 @@
-require 'bacon'
-require 'librevox'
-
-module Librevox::Test
-  module Matchers
-    def send_command command
-      proc {|obj|
-        obj.outgoing_data.shift.should == "#{command}\n\n"
-      }
-    end
-
-    def send_nothing
-      proc {|obj| obj.outgoing_data.shift.should == nil}
-    end
-
-    def send_application app, args=nil
-      proc {|obj|
-        msg = <<-EOM
-sendmsg
-call-command: execute
-execute-app-name: #{app}
-        EOM
-        msg << "execute-app-arg: #{args}\n" if args
-        msg << "\n"
-
-        obj.outgoing_data.shift.should == msg
-      }
-    end
-
-    def update_session session_id=nil
-      if session_id
-        proc {|obj|
-          obj.outgoing_data.shift.should == "api uuid_dump #{session_id}\n\n"
-        }
-      else
-        proc {|obj|
-          obj.outgoing_data.shift.should.match /^api uuid_dump \d+/
-        }
-      end
-    end
-  end
-
-  module ListenerHelpers
-    def command_reply args={}
-      args["Content-Type"] = "command/reply"
-      response args
-    end
-
-    def api_response args={}
-      args["Content-Type"] = "api/response"
-      response args
-    end
-
-    def channel_data args={}
-      api_response :body => {
-        "Event-Name"  => "CHANNEL_DATA",
-        "Session-Var" => "Second"
-      }.merge(args)
-    end
-
-    def response args={}
-      body    = args.delete :body
-      headers = args
-
-      if body.is_a? Hash
-        body = body.map {|k,v| "#{k}: #{v}"}.join "\n"
-      end
-
-      headers["Content-Length"] = body.size if body
-      msg = headers.map {|k, v| "#{k}: #{v}"}.join "\n"
-
-      msg << "\n\n" + body if body
-
-      @listener.receive_data msg + "\n\n"
-    end
-
-    def event name
-      body    = "Event-Name: #{name}"
-      headers = "Content-Length: #{body.size}"
-
-      @listener.receive_data "#{headers}\n\n#{body}\n\n"
-    end
-  end
-end
-
-Bacon.summary_on_exit

data/spec/librevox/listener/spec_inbound.rb

@@ -1,22 +0,0 @@
-require './spec/helper'
-require './spec/librevox/listener'
-
-require 'librevox/listener/inbound'
-
-class InboundTestListener < Librevox::Listener::Inbound
-end
-
-describe "Inbound listener" do
-  before do
-    @listener = InboundTestListener.new(nil)
-  end
-
-  behaves_like "events"
-  behaves_like "api commands"
-
-  should "authorize and subscribe to events" do
-    @listener.connection_completed
-    @listener.outgoing_data.shift.should == "auth ClueCon\n\n"
-    @listener.outgoing_data.shift.should == "event plain ALL\n\n"
-  end
-end

data/spec/librevox/listener/spec_outbound.rb

@@ -1,300 +0,0 @@
-require './spec/helper'
-require './spec/librevox/listener'
-
-require 'librevox/listener/outbound'
-
-module Librevox::Applications
-  def sample_app name, *args, &block
-    application name, args.join(" "), &block
-  end
-end
-
-class OutboundTestListener < Librevox::Listener::Outbound
-  def session_initiated
-    send_data "session was initiated"
-  end
-end
-
-def event_and_linger_replies
-  command_reply "Reply-Text" => "+OK Events Enabled"
-  command_reply "Reply-Text" => "+OK will linger"
-end
-
-describe "Outbound listener" do
-  extend Librevox::Test::Matchers
-
-  before do
-    @listener = OutboundTestListener.new(nil)
-    command_reply(
-      "Caller-Caller-Id-Number" => "8675309",
-      "Unique-ID"               => "1234",
-      "variable_some_var"       => "some value"
-    )
-    event_and_linger_replies
-  end
-
-  should "connect to freeswitch and subscribe to events" do
-    @listener.should send_command "connect"
-    @listener.should send_command "myevents"
-    @listener.should send_command "linger"
-  end
-
-  should "establish a session" do
-    @listener.session.class.should.equal Hash
-  end
-
-  should "call session callback after establishing new session" do
-    @listener.outgoing_data.pop.should == "session was initiated"
-  end
-
-  should "make headers available through session" do
-    @listener.session[:caller_caller_id_number].should.equal "8675309"
-  end
-
-  should "make channel variables available through #variable" do
-    @listener.variable(:some_var).should == "some value"
-  end
-
-  behaves_like "events"
-  behaves_like "api commands"
-end
-
-class OutboundListenerWithNestedApps < Librevox::Listener::Outbound
-  def session_initiated
-    sample_app "foo" do
-      sample_app "bar"
-    end
-  end
-end
-
-describe "Outbound listener with apps" do
-  extend Librevox::Test::Matchers
-
-  before do
-    @listener = OutboundListenerWithNestedApps.new(nil)
-
-    command_reply "Establish-Session" => "OK",
-                  "Unique-ID"         => "1234"
-    event_and_linger_replies
-    3.times {@listener.outgoing_data.shift}
-  end
-
-  should "only send one app at a time" do
-    @listener.should send_application "foo"
-    @listener.should send_nothing
-
-    command_reply "Reply-Text" => "+OK"
-    @listener.should update_session
-    channel_data
-
-    @listener.should send_application "bar"
-    @listener.should send_nothing
-  end
-
-  should "not be driven forward by events" do
-    @listener.should send_application "foo"
-
-    command_reply :body => {
-      "Event-Name"  => "CHANNEL_EXECUTE",
-      "Session-Var" => "Some"
-    }
-
-    @listener.should send_nothing
-  end
-
-  should "not be driven forward by api responses" do
-    @listener.should send_application "foo"
-
-    api_response :body => "Foo"
-
-    @listener.should send_nothing
-  end
-
-  should "not be driven forward by disconnect notifications" do
-    @listener.should send_application "foo"
-
-    response "Content-Type" => "text/disconnect-notice",
-             :body          => "Lingering"
-
-    @listener.should send_nothing
-  end
-end
-
-module Librevox::Applications
-  def reader_app &block
-    application 'reader_app', "", {:variable => 'app_var'}, &block
-  end
-end
-
-class OutboundListenerWithReader < Librevox::Listener::Outbound
-  def session_initiated
-    reader_app do |data|
-      application "send", data
-    end
-  end
-end
-
-describe "Outbound listener with app reading data" do
-  extend Librevox::Test::Matchers
-
-  before do
-    @listener = OutboundListenerWithReader.new(nil)
-
-    command_reply "Session-Var" => "First",
-                  "Unique-ID"   => "1234"
-    event_and_linger_replies
-    3.times {@listener.outgoing_data.shift}
-
-    @listener.should send_application "reader_app"
-  end
-
-  should "not send anything while missing response" do
-    @listener.should send_nothing
-  end
-
-  should "send uuid_dump to get channel var, after getting response" do
-    command_reply "Reply-Text" => "+OK"
-    @listener.should update_session 1234
-  end
-
-  should "update session with new data" do
-    command_reply :body => "+OK"
-
-    @listener.should update_session 1234
-    api_response :body => {
-      "Event-Name"  => "CHANNEL_DATA",
-      "Session-Var" => "Second"
-    }
-
-    @listener.session[:session_var].should == "Second"
-  end
-
-  should "return value of channel variable" do
-    command_reply :body => "+OK"
-
-    @listener.should update_session 1234
-    api_response :body => {
-      "Event-Name"       => "CHANNEL_DATA",
-      "variable_app_var" => "Second"
-    }
-
-    @listener.should send_application "send", "Second"
-  end
-end
-
-class OutboundListenerWithNonNestedApps < Librevox::Listener::Outbound
-  attr_reader :queue
-  def session_initiated
-    sample_app "foo" do
-      reader_app do |data|
-        application "send", "the end: #{data}"
-      end
-    end
-  end
-end
-
-describe "Outbound listener with non-nested apps" do
-  extend Librevox::Test::Matchers
-
-  before do
-    @listener = OutboundListenerWithNonNestedApps.new(nil)
-
-    command_reply "Session-Var" => "First",
-                  "Unique-ID"   => "1234"
-    event_and_linger_replies
-    3.times {@listener.outgoing_data.shift}
-  end
-
-  should "wait for response before calling next app" do
-    @listener.should send_application "foo"
-    command_reply :body => "+OK"
-    @listener.should update_session
-    channel_data "Unique-ID" => "1234"
-
-    @listener.should send_application "reader_app"
-    command_reply :body => "+OK"
-
-    @listener.should update_session
-    api_response :body => {
-      "Event-Name"       => "CHANNEL_DATA",
-      "variable_app_var" => "Second"
-    }
-
-    @listener.should send_application "send", "the end: Second"
-  end
-end
-
-module Librevox::Commands
-  def sample_cmd cmd, *args, &block
-    command cmd, *args, &block
-  end
-end
-
-class OutboundListenerWithAppsAndApi < Librevox::Listener::Outbound
-  def session_initiated
-    sample_app "foo" do
-      api.sample_cmd "bar" do
-        sample_app "baz"
-      end
-    end
-  end
-end
-
-describe "Outbound listener with both apps and api calls" do
-  extend Librevox::Test::Matchers
-
-  before do
-    @listener = OutboundListenerWithAppsAndApi.new(nil)
-
-    command_reply "Session-Var" => "First",
-                  "Unique-ID"   => "1234"
-    event_and_linger_replies
-    3.times {@listener.outgoing_data.shift}
-  end
-
-  should "wait for response before calling next app/cmd" do
-    @listener.should send_application "foo"
-    command_reply :body => "+OK"
-    @listener.should update_session
-    channel_data
-
-    @listener.should send_command "api bar"
-    api_response :body => "+OK"
-
-    @listener.should send_application "baz"
-  end
-end
-
-class OutboundListenerWithUpdateSessionCallback < Librevox::Listener::Outbound
-  def session_initiated
-    update_session do
-      application "send", "yay, #{session[:session_var]}"
-    end
-  end
-end
-
-describe "Outbound listener with update session callback" do
-  extend Librevox::Test::Matchers
-
-  before do
-    @listener = OutboundListenerWithUpdateSessionCallback.new(nil)
-    command_reply "Session-Var" => "First",
-                  "Unique-ID"   => "1234"
-    event_and_linger_replies
-    3.times {@listener.outgoing_data.shift}
-
-    @listener.should update_session
-    api_response :body => {
-      "Event-Name"  => "CHANNEL_DATA",
-      "Session-Var" => "Second"
-    }
-  end
-
-  should "execute callback" do
-    @listener.outgoing_data.shift.should =~ /yay,/
-  end
-
-  should "update session before calling callback" do
-    @listener.should send_application "send", "yay, Second"
-  end
-end

data/spec/librevox/listener.rb

@@ -1,142 +0,0 @@
-require './spec/helper'
-require 'librevox/listener/base'
-
-include Librevox::Test::ListenerHelpers
-
-class Librevox::Listener::Base
-  attr_accessor :outgoing_data
-
-  def initialize(*args)
-    @outgoing_data = []
-    super *args
-  end
-
-  def send_data(data)
-    @outgoing_data << data
-  end
-
-  def read_data
-    @outgoing_data.pop
-  end
-end
-
-# These tests are a bit fragile, as they depend on event hooks being
-# executed before on_event.
-shared "events" do
-  before do
-    @class = @listener.class
-
-    @class.event(:some_event) {send_data "something"}
-    @class.event(:other_event) {send_data "something else"}
-    @class.event(:hook_with_arg) {|e| send_data "got event arg: #{e.object_id}"}
-
-    def @listener.on_event(e)
-      send_data "from on_event: #{e.object_id}"
-    end
-
-    # Establish session
-    @listener.receive_data("Content-Length: 0\nTest: Testing\n\n")
-  end
-
-  should "add event hook" do
-    @class.hooks.size.should == 3
-    @class.hooks.each do |event, hooks|
-      hooks.size.should == 1
-    end
-  end
-
-  should "execute callback for event" do
-    event "OTHER_EVENT"
-    @listener.read_data.should == "something else"
-
-    event "SOME_EVENT"
-    @listener.read_data.should == "something"
-  end
-
-  should "pass response duplicate as arg to hook block" do
-    event "HOOK_WITH_ARG"
-
-    reply = @listener.read_data
-    reply.should =~ /^got event arg: /
-    reply.should.not =~ /^got event arg: #{@listener.response.object_id}$/
-  end
-
-  should "expose response as event" do
-    event "OTHER_EVENT"
-
-    @listener.event.class.should == Librevox::Response
-    @listener.event.content[:event_name].should == "OTHER_EVENT"
-  end
-
-  should "call on_event" do
-    event "THIRD_EVENT"
-
-    @listener.read_data.should =~ /^from on_event/
-  end
-
-  should "call on_event with response duplicate as argument" do
-    event "THIRD_EVENT"
-
-    @listener.read_data.should.not =~ /^from on_event: #{@listener.response.object_id}$/
-  end
-
-  should "call event hooks and on_event on CHANNEL_DATA" do
-    @listener.outgoing_data.clear
-
-    def @listener.on_event e
-      send_data "on_event: CHANNEL_DATA test"
-    end
-    @class.event(:channel_data) {send_data "event hook: CHANNEL_DATA test"}
-
-    event "CHANNEL_DATA"
-
-    @listener.outgoing_data.should.include "on_event: CHANNEL_DATA test"
-    @listener.outgoing_data.should.include "event hook: CHANNEL_DATA test"
-  end
-end
-
-module Librevox::Commands
-  def sample_cmd cmd, args="", &block
-    command cmd, args, &block
-  end
-end
-
-shared "api commands" do
-  before do
-    @class = @listener.class
-
-    # Establish session
-    command_reply "Test" => "Testing"
-  end
-
-  describe "multiple api commands" do
-    extend Librevox::Test::Matchers
-
-    before do
-      @listener.outgoing_data.clear
-
-      def @listener.on_event(e) end # Don't send anything, kthx.
-
-      @class.event(:api_test) {
-        api.sample_cmd "foo" do
-          api.sample_cmd "foo", "bar baz" do |r|
-            command "response #{r.content}"
-          end
-        end
-      }
-    end
-
-    should "only send one command at a time, and return response for commands" do
-      command_reply :body => {"Event-Name" => "API_TEST"}
-      @listener.should send_command "api foo"
-      @listener.should send_nothing
-
-      api_response "Reply-Text" => "+OK"
-      @listener.should send_command "api foo bar baz"
-      @listener.should send_nothing
-
-      api_response :body => "+YAY"
-      @listener.should send_command "response +YAY"
-    end
-  end
-end