easy_upnp 0.4.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b1b0ab93e8ae488f40f517fdb931fbe59b14178
-  data.tar.gz: eae09c694d7864593a0eb89989078a54b9231914
+  metadata.gz: c58d2d816ce224f674b5bca2393a6f25007b27b3
+  data.tar.gz: 97eca3f41437f100470a5bb8cdda6815a5fc7959
 SHA512:
-  metadata.gz: 441a2af6447b95c95ecb2d4ce840a0a9a6f9f47d02d6e53c4d7b87c1964ddc9062f36e538a9e9c1e94b57f54ed62a79f876cb73d89335b97c9bafe9a418033a5
-  data.tar.gz: 393c879cd71967dca3cab3f72d6a5b190ac533fc3e77fa6fb708d24bb27d8794a98119d4c932a8a818429ddcb58d144db0d9a2b4d3f649d274ec7afd94705872
+  metadata.gz: ac8b59b38423087c105266b9781e93f33e92a9771a851ef8c0c4beb89754117674694c5231889486fb96dcfc26d95fb40e12af39d65b7d2e6576dd19a1d18d24
+  data.tar.gz: b875881fd185faef0f4b8dc4c07aca21f04ce0d80acee5b2a96dd457681085ee186b086323215c86cbe69b550d062eab1dcbdb6494e3bb7c519c1361a752e092

data/README.md

@@ -84,3 +84,46 @@ EasyUpnp::Log.enabled = false
 # Change log level (only has an effect if logging is enabled)
 EasyUpnp::Log.level = :debug
 ```
+
+## Validation
+
+Clients can validate the arguments passed to its methods. By default, this behavior is disabled. You can enable it when initializing a client:
+
+```ruby
+client = device.service('urn:schemas-upnp-org:service:ContentDirectory:1') do |o|
+  o.validate_arguments = true
+end
+```
+
+This enables type checking in addition to whatever validation information is available in the UPnP service's definition. For example:
+
+```ruby
+client.GetVolume(InstanceID: '0', Channel: 'Master')
+#: ArgumentError: Invalid value for argument InstanceID: 0 is the wrong type. Should be one of: [Integer]
+client.GetVolume(InstanceID: 0, Channel: 'Master2')
+#: ArgumentError: Invalid value for argument Channel: Master2 is not in list of allowed values: ["Master"]
+client.GetVolume(InstanceID: 0, Channel: 'Master')
+#=> {:CurrentVolume=>"32"}
+```
+
+It's also possible to retrieve information about arguments:
+
+```ruby
+client.method_args(:SetVolume)
+#=> [:InstanceID, :Channel, :DesiredVolume]
+validator = client.arg_validator(:SetVolume, :DesiredVolume)
+validator.required_class
+#=> Integer
+validator.valid_range
+#=> #<Enumerator: 0..100:step(1)>
+validator.valid_range.max
+#=> 100
+validator.validate(32)
+#=> true
+validator.validate(101)
+#: ArgumentError: 101 is not in allowed range of values: #<Enumerator: 0..100:step(1)>
+
+validator = client.arg_validator(:SetVolume, :Channel)
+validator.allowed_values
+#=> ["Master"]
+```

data/easy_upnp.gemspec

@@ -13,11 +13,8 @@ Gem::Specification.new do |gem|
   gem.homepage = 'http://github.com/sidoh/easy_upnp'
 
   gem.add_dependency 'rake'
-  gem.add_dependency 'savon', '~> 2.11.1'
-  gem.add_dependency 'nori', '~> 2.6.0'
-  gem.add_dependency 'nokogiri', '~> 1.6.6.2'
-
-  gem.add_development_dependency('rspec', [">= 2.0.0"])
+  gem.add_dependency 'savon', '~> 2.11'
+  gem.add_dependency 'nokogiri', '~> 1.6'
 
   ignores  = File.readlines(".gitignore").grep(/\S+/).map(&:chomp)
   dotfiles = %w[.gitignore]

data/lib/easy_upnp/{argument_validator.rb → control_point/argument_validator.rb}

@@ -121,5 +121,29 @@ module EasyUpnp
     def self.build(&block)
       Builder.new(&block).build
     end
+
+    def self.no_op
+      build
+    end
+
+    def self.from_xml(xml)
+      build do |v|
+        v.type(xml.xpath('dataType').text)
+
+        if (range = xml.xpath('allowedValueRange')).any?
+          min = range.xpath('minimum').text
+          max = range.xpath('maximum').text
+          step = range.xpath('step')
+          step = step.any? ? step.text : 1
+
+          v.in_range(min.to_i, max.to_i, step.to_i)
+        end
+
+        if (list = xml.xpath('allowedValueList')).any?
+          allowed_values = list.xpath('allowedValue').map { |x| x.text }
+          v.allowed_values(*allowed_values)
+        end
+      end
+    end
   end
 end

data/lib/easy_upnp/control_point/client_wrapper.rb

@@ -0,0 +1,50 @@
+module EasyUpnp
+  class ClientWrapper
+    def initialize(endpoint,
+                   urn,
+                   call_options:,
+                   advanced_typecasting:,
+                   log_enabled:,
+                   log_level:)
+
+      # For some reason was not able to pass these options in the config block
+      # in Savon 2.11
+      options = {
+        log: log_enabled,
+        log_level: log_level
+      }
+
+      @client = Savon.client(options) do |c|
+        c.endpoint endpoint
+        c.namespace urn
+
+        # I found this was necessary on some of my UPnP devices (namely, a Sony TV).
+        c.namespaces({:'s:encodingStyle' => "http://schemas.xmlsoap.org/soap/encoding/"})
+
+        # This makes XML tags be like <ObjectID> instead of <objectID>.
+        c.convert_request_keys_to :camelcase
+
+        c.namespace_identifier :u
+        c.env_namespace :s
+      end
+
+      @urn = urn
+      @call_options = call_options
+      @advanced_typecasting = advanced_typecasting
+    end
+
+    def call(action_name, args)
+      attrs = {
+          soap_action: "#{@urn}##{action_name}",
+          attributes: {
+              :'xmlns:u' => @urn
+          },
+      }.merge(@call_options)
+
+      response = @client.call(action_name, attrs) do
+        advanced_typecasting @advanced_typecasting
+        message(args)
+      end
+    end
+  end
+end

data/lib/easy_upnp/control_point/device_control_point.rb

@@ -0,0 +1,149 @@
+require 'nokogiri'
+require 'open-uri'
+require 'nori'
+
+require_relative 'validator_provider'
+require_relative 'client_wrapper'
+require_relative 'service_method'
+
+module EasyUpnp
+  class DeviceControlPoint
+    attr_reader :service_endpoint
+
+    class Options
+      DEFAULTS = {
+        advanced_typecasting: true,
+        validate_arguments: false,
+        log_enabled: true,
+        log_level: :error,
+        call_options: {}
+      }
+
+      attr_reader :options
+
+      def initialize(o = {}, &block)
+        @options = o.merge(DEFAULTS)
+
+        DEFAULTS.map do |k, v|
+          define_singleton_method(k) do
+            @options[k]
+          end
+
+          define_singleton_method("#{k}=") do |v|
+            @options[k] = v
+          end
+        end
+
+        block.call(self) unless block.nil?
+      end
+    end
+
+    def initialize(urn, service_endpoint, definition, options, &block)
+      @urn = urn
+      @service_endpoint = service_endpoint
+      @definition = definition
+      @options = Options.new(options, &block)
+
+      @client = ClientWrapper.new(
+        service_endpoint,
+        urn,
+        call_options: @options.call_options,
+        advanced_typecasting: @options.advanced_typecasting,
+        log_enabled: @options.log_enabled,
+        log_level: @options.log_level
+      )
+
+      definition_xml = Nokogiri::XML(definition)
+      definition_xml.remove_namespaces!
+
+      @validator_provider = EasyUpnp::ValidatorProvider.from_xml(definition_xml)
+
+      @service_methods = {}
+      definition_xml.xpath('//actionList/action').map do |action|
+        method = EasyUpnp::ServiceMethod.from_xml(action)
+        @service_methods[method.name] = method
+
+        # Adds a method to the class
+        define_service_method(method, @client, @validator_provider, @options)
+      end
+    end
+
+    def to_params
+      {
+        urn: @urn,
+        service_endpoint: @service_endpoint,
+        definition: @definition,
+        options: @options.options
+      }
+    end
+
+    def self.from_params(params)
+      DeviceControlPoint.new(
+          params[:urn],
+          params[:service_endpoint],
+          params[:definition],
+          params[:options]
+      )
+    end
+
+    def self.from_service_definition(definition, options, &block)
+      urn = definition[:st]
+      root_uri = definition[:location]
+
+      xml = Nokogiri::XML(open(root_uri))
+      xml.remove_namespaces!
+
+      service = xml.xpath("//device/serviceList/service[serviceType=\"#{urn}\"]").first
+
+      if service.nil?
+        raise RuntimeError, "Couldn't find service with urn: #{urn}"
+      else
+        service = Nokogiri::XML(service.to_xml)
+        service_definition_uri = URI.join(root_uri, service.xpath('service/SCPDURL').text).to_s
+        service_definition = open(service_definition_uri) { |f| f.read }
+
+        DeviceControlPoint.new(
+            urn,
+            URI.join(root_uri, service.xpath('service/controlURL').text).to_s,
+            service_definition,
+            options,
+            &block
+        )
+      end
+    end
+
+    def arg_validator(method_ref, arg_name)
+      arg_ref = service_method(method_ref).arg_reference(arg_name)
+      raise ArgumentError, "Unknown argument: #{arg_name}" if arg_ref.nil?
+
+      @validator_provider.validator(arg_ref)
+    end
+
+    def method_args(method_ref)
+      service_method(method_ref).in_args
+    end
+
+    def service_method(method_ref)
+      method = @service_methods[method_ref]
+      raise ArgumentError, "Unknown method: #{method_ref}" if method.nil?
+
+      method
+    end
+
+    def service_methods
+      @service_methods.keys
+    end
+
+    private
+
+    def define_service_method(method, client, validator_provider, options)
+      if !options.validate_arguments
+        validator_provider = EasyUpnp::ValidatorProvider.no_op_provider
+      end
+
+      define_singleton_method(method.name) do |args_hash = {}|
+        method.call_method(client, args_hash, validator_provider)
+      end
+    end
+  end
+end

data/lib/easy_upnp/control_point/service_method.rb

@@ -0,0 +1,93 @@
+module EasyUpnp
+  class ServiceMethod
+    attr_reader :name, :in_args, :out_args
+
+    def initialize(name, in_args, out_args, arg_references)
+      @name = name
+      @in_args = in_args
+      @out_args = out_args
+      @arg_references = arg_references
+    end
+
+    def call_method(client, args_hash, validator_provider)
+      raise ArgumentError, 'Service args must be a hash' unless args_hash.is_a?(Hash)
+
+      present_args = args_hash.keys.map(&:to_sym)
+
+      if (unsupported_args = (present_args - in_args)).any?
+        raise ArgumentError, "Unsupported arguments: #{unsupported_args.join(', ')}." <<
+                             " Supported args: #{in_args.join(', ')}"
+      end
+
+      if (missing_args = (in_args - present_args)).any?
+        raise ArgumentError, "Missing required arguments: #{missing_args.join(', ')}"
+      end
+
+      args_hash.each do |arg, val|
+        begin
+          validator_provider.validator(arg_reference(arg)).validate(val)
+        rescue ArgumentError => e
+          raise ArgumentError, "Invalid value for argument #{arg}: #{e}"
+        end
+      end
+
+      raw_response = client.call(name, args_hash)
+      parse_response(raw_response)
+    end
+
+    def parse_response(response)
+      # Response is usually wrapped in <#{ActionName}Response></>. For example:
+      # <BrowseResponse>...</BrowseResponse>. Extract the body since consumers
+      # won't care about wrapper stuff.
+      if response.body.keys.count > 1
+        raise RuntimeError, "Unexpected keys in response body: #{response.body.keys}"
+      end
+
+      result = response.body.first[1]
+      output = {}
+
+      # Keys returned by savon are underscore style. Convert them to camelcase.
+      out_args.map do |arg|
+        output[arg] = result[underscore(arg.to_s).to_sym]
+      end
+
+      output
+    end
+
+    def arg_reference(arg)
+      @arg_references[arg.to_sym]
+    end
+
+    def self.from_xml(xml)
+      name = xml.xpath('name').text.to_sym
+      args = xml.xpath('argumentList')
+
+      arg_references = {}
+
+      extract_args = ->(v) do
+        arg_name = v.xpath('name').text.to_sym
+        ref = v.xpath('relatedStateVariable').text.to_sym
+
+        arg_references[arg_name] = ref
+        arg_name
+      end
+
+      in_args = args.xpath('argument[direction = "in"]').map(&extract_args)
+      out_args = args.xpath('argument[direction = "out"]').map(&extract_args)
+
+      ServiceMethod.new(name, in_args, out_args, arg_references)
+    end
+
+    private
+
+    # This is included in ActiveSupport, but don't want to pull that in for just this method...
+    def underscore(s)
+      s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+          gsub(/([a-z\d])([A-Z])/, '\1_\2').
+          tr("-", "_").
+          downcase
+    end
+
+  end
+end

data/lib/easy_upnp/control_point/validator_provider.rb

@@ -0,0 +1,39 @@
+require_relative 'argument_validator'
+
+module EasyUpnp
+  module ValidatorProvider
+    def self.no_op_provider
+      NoOpValidatorProvider.new
+    end
+
+    def self.from_xml(xml)
+      validators = {}
+
+      xml.xpath('//serviceStateTable/stateVariable').each do |var|
+        name = var.xpath('name').text.to_sym
+        validators[name] = EasyUpnp::ArgumentValidator.from_xml(var)
+      end
+
+      DefaultValidatorProvider.new(validators)
+    end
+
+    private
+      class DefaultValidatorProvider
+        def initialize(validators)
+          @validators = validators
+        end
+
+        def validator(arg_ref)
+          validator = @validators[arg_ref.to_sym]
+          raise ArgumentError, "Unknown argument reference: #{arg_ref}" if arg_ref.nil?
+          validator
+        end
+      end
+
+      class NoOpValidatorProvider
+        def validator(method, arg)
+          ArgumentValidator.no_op
+        end
+      end
+  end
+end

data/lib/easy_upnp/ssdp_searcher.rb

@@ -1,6 +1,7 @@
 require 'socket'
 require 'ipaddr'
 require 'timeout'
+
 require_relative 'upnp_device'
 
 module EasyUpnp
@@ -28,11 +29,11 @@ module EasyUpnp
       @options = DEFAULT_OPTIONS.merge options
     end
 
-    def option key
+    def option(key)
       @options[key]
     end
 
-    def search urn = 'ssdp:all'
+    def search(urn = 'ssdp:all')
       socket = build_socket
       packet = construct_msearch_packet(urn)
 
@@ -78,7 +79,7 @@ ST: #{urn}\r
       MSEARCH
     end
 
-    def parse_message message
+    def parse_message(message)
       lines = message.split "\r\n"
       headers = lines.map do |line|
         if !(match = line.match(/([^:]+):\s?(.*)/i)).nil?

data/lib/easy_upnp/upnp_device.rb

@@ -3,7 +3,7 @@ require 'nokogiri'
 require 'open-uri'
 require 'savon'
 
-require_relative 'device_control_point'
+require_relative 'control_point/device_control_point'
 
 module EasyUpnp
   class UpnpDevice
@@ -34,15 +34,7 @@ module EasyUpnp
     end
 
     def device_name
-      if all_services.empty?
-        raise RuntimeError, "Couldn't resolve device name because no endpoints are defined"
-      end
-
-      document = open(service_definition(all_services.first)[:location]) { |f| f.read }
-      xml = Nokogiri::XML(document)
-      xml.remove_namespaces!
-
-      xml.xpath("//device/friendlyName").text
+      @device_name ||= fetch_device_name
     end
 
     def all_services
@@ -66,5 +58,19 @@ module EasyUpnp
           reject { |s| s[:st] != urn }.
           first
     end
+
+    private
+
+    def fetch_device_name
+      if all_services.empty?
+        raise RuntimeError, "Couldn't resolve device name because no endpoints are defined"
+      end
+
+      document = open(service_definition(all_services.first)[:location]) { |f| f.read }
+      xml = Nokogiri::XML(document)
+      xml.remove_namespaces!
+
+      xml.xpath("//device/friendlyName").text
+    end
   end
 end

data/lib/easy_upnp/version.rb

@@ -1,3 +1,3 @@
 module EasyUpnp
-  VERSION = '0.4.4'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_upnp
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Christopher Mullins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-12 00:00:00.000000000 Z
+date: 2016-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -30,56 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.11.1
+        version: '2.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.11.1
-- !ruby/object:Gem::Dependency
-  name: nori
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.6.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: '2.11'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.6.2
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.6.2
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '1.6'
 description: 
 email: chris@sidoh.org
 executables:
@@ -94,9 +66,11 @@ files:
 - Rakefile
 - bin/upnp-list
 - easy_upnp.gemspec
-- lib/easy_upnp/argument_validator.rb
-- lib/easy_upnp/device_control_point.rb
-- lib/easy_upnp/logger.rb
+- lib/easy_upnp/control_point/argument_validator.rb
+- lib/easy_upnp/control_point/client_wrapper.rb
+- lib/easy_upnp/control_point/device_control_point.rb
+- lib/easy_upnp/control_point/service_method.rb
+- lib/easy_upnp/control_point/validator_provider.rb
 - lib/easy_upnp/ssdp_searcher.rb
 - lib/easy_upnp/upnp_device.rb
 - lib/easy_upnp/version.rb

data/lib/easy_upnp/device_control_point.rb

@@ -1,254 +0,0 @@
-require 'nokogiri'
-require 'open-uri'
-require 'nori'
-
-require_relative 'logger'
-require_relative 'argument_validator'
-
-module EasyUpnp
-  class DeviceControlPoint
-    attr_reader :service_methods, :service_endpoint
-
-    class Options
-      DEFAULTS = {
-        advanced_typecasting: true,
-        validate_arguments: false
-      }
-
-      attr_reader :options
-
-      def initialize(o = {}, &block)
-        @options = o.merge(DEFAULTS)
-
-        @options.map do |k, v|
-          define_singleton_method(k) do
-            @options[k]
-          end
-
-          define_singleton_method("#{k}=") do |v|
-            @options[k] = v
-          end
-        end
-
-        block.call(self) unless block.nil?
-      end
-    end
-
-    def initialize(urn, service_endpoint, definition, call_options, &block)
-      @urn = urn
-      @service_endpoint = service_endpoint
-      @call_options = call_options
-      @definition = definition
-      @options = Options.new(&block)
-
-      @client = Savon.client(log: EasyUpnp::Log.enabled?, log_level: EasyUpnp::Log.level) do |c|
-        c.endpoint service_endpoint
-        c.namespace urn
-
-        # I found this was necessary on some of my UPnP devices (namely, a Sony TV).
-        c.namespaces({:'s:encodingStyle' => "http://schemas.xmlsoap.org/soap/encoding/"})
-
-        # This makes XML tags be like <ObjectID> instead of <objectID>.
-        c.convert_request_keys_to :camelcase
-
-        c.namespace_identifier :u
-        c.env_namespace :s
-      end
-
-      definition_xml = Nokogiri::XML(definition)
-      definition_xml.remove_namespaces!
-
-      service_methods = []
-      service_methods_args = {}
-      definition_xml.xpath('//actionList/action').map do |action|
-        service_methods.push(define_action(action))
-
-        name = action.xpath('name').text
-        args = {}
-        action.xpath('argumentList/argument').map do |arg|
-          arg_name = arg.xpath('name').text
-          arg_ref = arg.xpath('relatedStateVariable').text
-          arg_dir = arg.xpath('direction').text
-
-          if direction == 'in'
-            args[arg_name.to_sym] = arg_ref.to_sym
-          end
-        end
-        service_methods_args[name.to_sym] = args
-      end
-
-      arg_validators = {}
-      definition_xml.xpath('//serviceStateTable/stateVariable').map do |var|
-        name = var.xpath('name').text
-        arg_validators[name.to_sym] = extract_validators(var)
-      end
-
-      @service_methods = service_methods
-      @service_methods_args = service_methods_args
-      @arg_validators = arg_validators
-    end
-
-    def to_params
-      {
-        urn: @urn,
-        service_endpoint: @service_endpoint,
-        definition: @definition,
-        call_options: @call_options,
-        options: @options.options
-      }
-    end
-
-    def self.from_params(params)
-      DeviceControlPoint.new(
-          params[:urn],
-          params[:service_endpoint],
-          params[:definition],
-          params[:call_options]
-      ) { |c|
-        params[:options].map { |k, v| c.options[k] = v }
-      }
-    end
-
-    def self.from_service_definition(definition, call_options = {}, &block)
-      urn = definition[:st]
-      root_uri = definition[:location]
-
-      xml = Nokogiri::XML(open(root_uri))
-      xml.remove_namespaces!
-
-      service = xml.xpath("//device/serviceList/service[serviceType=\"#{urn}\"]").first
-
-      if service.nil?
-        raise RuntimeError.new "Couldn't find service with urn: #{urn}"
-      else
-        service = Nokogiri::XML(service.to_xml)
-        service_definition_uri = URI.join(root_uri, service.xpath('service/SCPDURL').text).to_s
-        service_definition = open(service_definition_uri) { |f| f.read }
-
-        DeviceControlPoint.new(
-            urn,
-            URI.join(root_uri, service.xpath('service/controlURL').text).to_s,
-            service_definition,
-            call_options,
-            &block
-        )
-      end
-    end
-
-    def arg_validator(method, arg)
-      method_args = @service_methods_args[method.to_sym]
-      raise ArgumentError, "Unknown method: #{method}" if method_args.nil?
-
-      arg_ref = method_args[arg.to_sym]
-      raise ArgumentError, "Unknown argument: #{arg}" if arg_ref.nil?
-
-      @arg_validators[arg_ref]
-    end
-
-    def method_args(method)
-      method_args = @service_methods_args[method.to_sym]
-      raise ArgumentError, "Unknown method: #{method}" if method_args.nil?
-
-      method_args.keys
-    end
-
-    private
-
-    def extract_validators(var)
-      ArgumentValidator.build do |v|
-        v.type(var.xpath('dataType').text)
-
-        if (range = var.xpath('allowedValueRange')).any?
-          min = range.xpath('minimum').text
-          max = range.xpath('maximum').text
-          step = range.xpath('step')
-          step = step.any? ? step.text : 1
-
-          v.in_range(min.to_i, max.to_i, step.to_i)
-        end
-
-        if (list = var.xpath('allowedValueList')).any?
-          allowed_values = list.xpath('allowedValue').map { |x| x.text }
-          v.allowed_values(*allowed_values)
-        end
-      end
-    end
-
-    def define_action(action)
-      action = Nori.new.parse(action.to_xml)['action']
-      action_name = action['name']
-      args = action['argumentList']['argument']
-      args = [args] unless args.is_a? Array
-
-      input_args = args.
-          reject { |x| x['direction'] != 'in' }.
-          map { |x| x['name'].to_sym }
-      output_args = args.
-          reject { |x| x['direction'] != 'out' }.
-          map { |x| x['name'].to_sym }
-
-      define_singleton_method(action['name']) do |args_hash = {}|
-        if !args_hash.is_a? Hash
-          raise RuntimeError.new "Input arg must be a hash"
-        end
-
-        args_hash = args_hash.inject({}) { |m,(k,v)| m[k.to_sym] = v; m }
-
-        if (args_hash.keys - input_args).any?
-          raise RuntimeError.new "Unsupported arguments: #{(args_hash.keys - input_args)}." <<
-                                     " Supported args: #{input_args}"
-        end
-
-        if @options.validate_arguments
-          args_hash.each { |k,v|
-            begin
-              arg_validator(action['name'], k).validate(v)
-            rescue ArgumentError => e
-              raise ArgumentError, "Invalid value for argument #{k}: #{e}"
-            end
-          }
-        end
-
-        attrs = {
-            soap_action: "#{@urn}##{action_name}",
-            attributes: {
-                :'xmlns:u' => @urn
-            },
-        }.merge(@call_options)
-
-        options = @options
-        response = @client.call action['name'], attrs do
-          advanced_typecasting options.advanced_typecasting
-          message(args_hash)
-        end
-
-        # Response is usually wrapped in <#{ActionName}Response></>. For example:
-        # <BrowseResponse>...</BrowseResponse>. Extract the body since consumers
-        # won't care about wrapper stuff.
-        if response.body.keys.count > 1
-          raise RuntimeError.new "Unexpected keys in response body: #{response.body.keys}"
-        end
-        result = response.body.first[1]
-        output = {}
-
-        # Keys returned by savon are underscore style. Convert them to camelcase.
-        output_args.map do |arg|
-          output[arg] = result[underscore(arg.to_s).to_sym]
-        end
-
-        output
-      end
-
-      action['name']
-    end
-
-    # This is included in ActiveSupport, but don't want to pull that in for just this method...
-    def underscore s
-      s.gsub(/::/, '/').
-          gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
-          gsub(/([a-z\d])([A-Z])/, '\1_\2').
-          tr("-", "_").
-          downcase
-    end
-  end
-end

data/lib/easy_upnp/logger.rb

@@ -1,15 +0,0 @@
-module EasyUpnp
-  module Log
-    class <<self
-      attr_accessor :enabled, :level
-    end
-
-    def self.enabled?
-      @enabled.nil? ? @enabled = true : @enabled
-    end
-
-    def self.level
-      @level ||= :info
-    end
-  end
-end