punchblock 1.9.4 → 2.0.0.beta1

data/lib/punchblock/command/unjoin.rb

@@ -5,48 +5,16 @@ module Punchblock
     class Unjoin < CommandNode
       register :unjoin, :core
 
-      ##
-      # Create an ujoin command
-      #
-      # @param [Hash] options
-      # @option options [String, Optional] :call_id the call ID to unjoin
-      # @option options [String, Optional] :mixer_name the mixer name to unjoin
-      #
-      # @return [Command::Unjoin] a formatted Rayo unjoin command
-      #
-      def self.new(options = {})
-        super().tap do |new_node|
-          options.each_pair { |k,v| new_node.send :"#{k}=", v }
-        end
-      end
-
-      ##
       # @return [String] the call ID to unjoin
-      def call_id
-        read_attr :'call-id'
-      end
-
-      ##
-      # @param [String] other the call ID to unjoin
-      def call_id=(other)
-        write_attr :'call-id', other
-      end
+      attribute :call_uri
+      alias :call_id= :call_uri=
 
-      ##
       # @return [String] the mixer name to unjoin
-      def mixer_name
-        read_attr :'mixer-name'
-      end
-
-      ##
-      # @param [String] other the mixer name to unjoin
-      def mixer_name=(other)
-        write_attr :'mixer-name', other
-      end
+      attribute :mixer_name
 
-      def inspect_attributes # :nodoc:
-        [:call_id, :mixer_name] + super
+      def rayo_attributes
+        {'call-uri' => call_uri, 'mixer-name' => mixer_name}
       end
-    end # Unjoin
-  end # Command
-end # Punchblock
+    end
+  end
+end

data/lib/punchblock/command/unmute.rb

@@ -4,6 +4,6 @@ module Punchblock
   module Command
     class Unmute < CommandNode
       register :unmute, :core
-    end # Mute
-  end # Command
-end # Punchblock
+    end
+  end
+end

data/lib/punchblock/command_node.rb

@@ -1,16 +1,8 @@
 # encoding: utf-8
-
 require 'state_machine'
 
 module Punchblock
   class CommandNode < RayoNode
-    def self.new(options = {})
-      super().tap do |new_node|
-        new_node.target_call_id = options[:target_call_id]
-        new_node.target_mixer_name = options[:target_mixer_name]
-        new_node.component_id = options[:component_id]
-      end
-    end
 
     def initialize(*args)
       super
@@ -31,11 +23,6 @@ module Punchblock
       end
     end
 
-    def write_attr(*args)
-      raise StandardError, "Cannot alter attributes of a requested command" unless new?
-      super
-    end
-
     def response(timeout = nil)
       @response.resource timeout
     end
@@ -45,9 +32,5 @@ module Punchblock
       @response.resource = other
       execute!
     end
-
-    def inspect_attributes
-      super + [:state_name]
-    end
   end # CommandNode
 end # Punchblock

data/lib/punchblock/component/asterisk/agi/command.rb

@@ -7,142 +7,35 @@ module Punchblock
         class Command < ComponentNode
           register :command, :agi
 
-          def self.new(options = {})
-            super().tap do |new_node|
-              options.each_pair { |k,v| new_node.send :"#{k}=", v }
-            end
-          end
-
-          def name
-            read_attr :name
-          end
-
-          def name=(other)
-            write_attr :name, other
-          end
-
-          ##
-          # @return [Array[String]] array of values of params
-          #
-          def params_array
-            params.map(&:value)
-          end
-
-          ##
-          # @return [Array[Param]] params
-          #
-          def params
-            find('//ns:param', :ns => self.class.registered_ns).map do |i|
-              Param.new i
-            end
-          end
-
-          ##
-          # @param [Hash, Array] params A hash of key-value param pairs, or an array of Param objects
-          #
-          def params=(params)
-            find('//ns:param', :ns => self.class.registered_ns).each(&:remove)
-            [params].flatten.each { |i| self << Param.new(i) } if params.is_a? Array
-          end
-
-          def inspect_attributes # :nodoc:
-            [:name, :params_array] + super
-          end
-
-          class Param < RayoNode
-            ##
-            # @param [String] name
-            # @param [String] value
-            #
-            def self.new(value)
-              super(:param).tap do |new_node|
-                case value
-                when Nokogiri::XML::Node
-                  new_node.inherit value
-                else
-                  new_node.value = value
-                end
-              end
-            end
-
-            # The Header's value
-            # @return [String]
-            def value
-              read_attr :value
-            end
-
-            # Set the Header's value
-            # @param [String] value the new value for the param
-            def value=(value)
-              write_attr :value, value
-            end
+          attribute :name
+          attribute :params, Array, default: []
 
-            def inspect_attributes # :nodoc:
-              [:value] + super
+          def inherit(xml_node)
+            xml_node.xpath('//ns:param', ns: self.class.registered_ns).to_a.each do |param|
+              params << param[:value]
             end
+            super
           end
 
           class Complete
             class Success < Event::Complete::Reason
               register :success, :agi_complete
 
-              def node_with_name(name)
-                n = if self.class.registered_ns
-                  find_first "ns:#{name}", :ns => self.class.registered_ns
-                else
-                  find_first name
-                end
+              attribute :code, Integer
+              attribute :result, Integer
+              attribute :data
 
-                unless n
-                  self << (n = RayoNode.new(name, self.document))
-                  n.namespace = self.class.registered_ns
+              def inherit(xml_node)
+                [:code, :result, :data].each do |attr|
+                  node = xml_node.at_xpath "ns:#{attr}", ns: self.class.registered_ns
+                  self.send "#{attr}=", node.text if node
                 end
-                n
-              end
-
-              def code_node
-                node_with_name 'code'
-              end
-
-              def result_node
-                node_with_name 'result'
-              end
-
-              def data_node
-                node_with_name 'data'
-              end
-
-              def code
-                code_node.text.to_i
-              end
-
-              def code=(other)
-                code_node.content = other
-              end
-
-              def result
-                result_node.text.to_i
-              end
-
-              def result=(other)
-                result_node.content = other
-              end
-
-              def data
-                data_node.text
-              end
-
-              def data=(other)
-                data_node.content = other
-              end
-
-              def inspect_attributes
-                [:code, :result, :data]
+                super
               end
             end
-          end # Complete
-        end # Command
-      end # AGI
-    end # Asterisk
-  end # Component
-end # Punchblock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/component/asterisk/ami/action.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require 'punchblock/key_value_pair_node'
-
 module Punchblock
   module Component
     module Asterisk
@@ -9,138 +7,53 @@ module Punchblock
         class Action < ComponentNode
           register :action, :ami
 
-          def self.new(options = {})
-            super().tap do |new_node|
-              options.each_pair { |k,v| new_node.send :"#{k}=", v }
-            end
-          end
-
-          def name
-            read_attr :name
-          end
-
-          def name=(other)
-            write_attr :name, other
-          end
+          attribute :name
+          attribute :params, Hash, default: {}
 
-          ##
-          # @return [Hash] hash of key-value pairs of params
-          #
-          def params_hash
-            params.inject({}) do |hash, param|
-              hash[param.name.downcase.gsub('-', '_').to_sym] = param.value
-              hash
+          def inherit(xml_node)
+            xml_node.xpath('//ns:param', ns: self.class.registered_ns).to_a.each do |param|
+              params[param[:name]] = param[:value]
             end
+            super
           end
 
-          ##
-          # @return [Array[Param]] params
-          #
-          def params
-            find('//ns:param', :ns => self.class.registered_ns).map do |i|
-              Param.new i
-            end
+          def rayo_attributes
+            {'name' => name}
           end
 
-          ##
-          # @param [Hash, Array] params A hash of key-value param pairs, or an array of Param objects
-          #
-          def params=(params)
-            find('//ns:param', :ns => self.class.registered_ns).each(&:remove)
-            if params.is_a? Hash
-              params.each_pair { |k,v| self << Param.new(k, v) }
-            elsif params.is_a? Array
-              [params].flatten.each { |i| self << Param.new(i) }
+          def rayo_children(root)
+            super
+            params.each do |name, value|
+              root.param name: name, value: value
             end
           end
 
-          def inspect_attributes # :nodoc:
-            [:name, :params] + super
-          end
-
-          class Param < RayoNode
-            include KeyValuePairNode
-          end
-
           class Complete
             class Success < Event::Complete::Reason
               register :success, :ami_complete
 
-              def self.new(options = {})
-                super().tap do |new_node|
-                  case options
-                  when Nokogiri::XML::Node
-                    new_node.inherit options
-                  else
-                    options.each_pair { |k,v| new_node.send :"#{k}=", v }
-                  end
-                end
-              end
+              attribute :message
+              attribute :text_body
+              attribute :headers, Hash, default: {}
 
-              def message_node
-                mn = if self.class.registered_ns
-                  find_first 'ns:message', :ns => self.class.registered_ns
-                else
-                  find_first 'message'
-                end
+              alias :attributes :headers
 
-                unless mn
-                  self << (mn = RayoNode.new('message', self.document))
-                  mn.namespace = self.class.registered_ns
-                end
-                mn
-              end
-
-              def message
-                message_node.text
-              end
-
-              def message=(other)
-                message_node.content = other
-              end
+              def inherit(xml_node)
+                message_node = xml_node.at_xpath 'ns:message', ns: self.class.registered_ns
+                self.message = message_node.text if message_node
 
-              ##
-              # @return [Hash] hash of key-value pairs of attributes
-              #
-              def attributes_hash
-                attributes.inject({}) do |hash, attribute|
-                  hash[attribute.name.downcase.gsub('-', '_').to_sym] = attribute.value
-                  hash
-                end
-              end
+                text_body_node = xml_node.at_xpath 'ns:text-body', ns: self.class.registered_ns
+                self.text_body = text_body_node.text if text_body_node
 
-              ##
-              # @return [Array[Attribute]] attributes
-              #
-              def attributes
-                find('//ns:attribute', :ns => self.class.registered_ns).map do |i|
-                  Attribute.new i
+                xml_node.xpath('//ns:attribute', ns: self.class.registered_ns).to_a.each do |attribute|
+                  headers[attribute[:name]] = attribute[:value]
                 end
-              end
-
-              ##
-              # @param [Hash, Array] attributes A hash of key-value attribute pairs, or an array of Attribute objects
-              #
-              def attributes=(attributes)
-                find('//ns:attribute', :ns => self.class.registered_ns).each(&:remove)
-                if attributes.is_a? Hash
-                  attributes.each_pair { |k,v| self << Attribute.new(k, v) }
-                elsif attributes.is_a? Array
-                  [attributes].flatten.each { |i| self << Attribute.new(i) }
-                end
-              end
-
-              def inspect_attributes
-                [:message, :attributes_hash]
+                super
               end
             end
-
-            class Attribute < RayoNode
-              include KeyValuePairNode
-            end
-          end # Complete
-        end # Action
-      end # AMI
-    end # Asterisk
-  end # Component
-end # Punchblock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/component/component_node.rb

@@ -37,7 +37,7 @@ module Punchblock
 
       def response=(other)
         if other.is_a?(Ref)
-          @component_id = other.id
+          @component_id = other.component_id
           client.register_component self if client
         end
         super