bigbluebutton-api-ruby 1.9.1 → 2.0.0.pre.rc.1

data/spec/bigbluebutton_api_spec.rb

@@ -302,9 +302,9 @@ describe BigBlueButton::BigBlueButtonApi do
         before {
           api.should_receive(:send_api_request).with(:getMeetings, {}).
           and_return(flattened_response)
-          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-          formatter_mock.should_receive(:flatten_objects).with(:meetings, :meeting)
-          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_mock)
+          formatter_double = double(BigBlueButton::BigBlueButtonFormatter)
+          formatter_double.should_receive(:flatten_objects).with(:meetings, :meeting)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_double)
           BigBlueButton::BigBlueButtonFormatter.should_receive(:format_meeting).with(meeting_hash1)
           BigBlueButton::BigBlueButtonFormatter.should_receive(:format_meeting).with(meeting_hash2)
         }
@@ -381,27 +381,27 @@ describe BigBlueButton::BigBlueButtonApi do
     describe "#last_http_response" do
       # we test this through a #test_connection call
 
-      let(:request_mock) { mock }
+      let(:request_double) { double }
       before {
         api.should_receive(:get_url)
         # this return value will be stored in @http_response
-        api.should_receive(:send_request).and_return(request_mock)
+        api.should_receive(:send_request).and_return(request_double)
         # to return fast from #send_api_request
-        request_mock.should_receive(:body).and_return("")
+        request_double.should_receive(:body).and_return("")
         api.test_connection
       }
-      it { api.last_http_response.should == request_mock }
+      it { api.last_http_response.should == request_double }
     end
 
     describe "#last_xml_response" do
       # we test this through a #test_connection call
 
-      let(:request_mock) { mock }
+      let(:request_double) { double }
       let(:expected_xml) { "<response><returncode>SUCCESS</returncode></response>" }
       before {
         api.should_receive(:get_url)
-        api.should_receive(:send_request).and_return(request_mock)
-        request_mock.should_receive(:body).at_least(1).and_return(expected_xml)
+        api.should_receive(:send_request).and_return(request_double)
+        request_double.should_receive(:body).at_least(1).and_return(expected_xml)
         api.test_connection
       }
       it { api.last_xml_response.should == expected_xml }
@@ -441,15 +441,6 @@ describe BigBlueButton::BigBlueButtonApi do
           end
         end
 
-        context "when method = :setConfigXML" do
-          it {
-            api.url = 'http://my-test-server.com/bigbluebutton/api'
-            response = api.get_url(:setConfigXML, { param1: 1, param2: 2 })
-            response[0].should eql('http://my-test-server.com/bigbluebutton/api/setConfigXML')
-            response[1].should match(/checksum=.*&param1=1&param2=2/)
-          }
-        end
-
         context "discards params with nil value" do
           let(:params) { { :param1 => "value1", :param2 => nil } }
           subject { api.get_url(:join, params)[0] }
@@ -512,22 +503,22 @@ describe BigBlueButton::BigBlueButtonApi do
       let(:data) { "any data" }
       let(:url) { "http://test-server:8080?param1=value1&checksum=12345" }
       let(:make_request) { api.send_api_request(method, params, data) }
-      let(:response_mock) { mock() } # mock of what send_request() would return
+      let(:response_double) { double() } # mock of what send_request() would return
 
       before { api.should_receive(:get_url).with(method, params).and_return([url, nil]) }
 
       context "returns an empty hash if the response body is empty" do
         before do
-          api.should_receive(:send_request).with(url, data).and_return(response_mock)
-          response_mock.should_receive(:body).and_return("")
+          api.should_receive(:send_request).with(url, data).and_return(response_double)
+          response_double.should_receive(:body).and_return("")
         end
         it { make_request.should == { } }
       end
 
       context "hashfies and validates the response body" do
         before do
-          api.should_receive(:send_request).with(url, data).and_return(response_mock)
-          response_mock.should_receive(:body).twice.and_return("response-body")
+          api.should_receive(:send_request).with(url, data).and_return(response_double)
+          response_double.should_receive(:body).twice.and_return("response-body")
         end
 
         context "checking if it has a :response key" do
@@ -545,15 +536,15 @@ describe BigBlueButton::BigBlueButtonApi do
         let(:response) { { :returncode => "SUCCESS" } }
         let(:formatted_response) { { :returncode => true, :messageKey => "", :message => "" } }
         before do
-          api.should_receive(:send_request).with(url, data).and_return(response_mock)
-          response_mock.should_receive(:body).twice.and_return("response-body")
+          api.should_receive(:send_request).with(url, data).and_return(response_double)
+          response_double.should_receive(:body).twice.and_return("response-body")
           BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return(response)
 
           # here starts the validation
           # doesn't test the resulting format, only that the formatter was called
-          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_mock)
-          formatter_mock.should_receive(:default_formatting).and_return(formatted_response)
+          formatter_double = double(BigBlueButton::BigBlueButtonFormatter)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_double)
+          formatter_double.should_receive(:default_formatting).and_return(formatted_response)
         end
         it { make_request }
       end
@@ -562,13 +553,13 @@ describe BigBlueButton::BigBlueButtonApi do
         let(:response) { { :returncode => true } }
         let(:formatted_response) { { } }
         before do
-          api.should_receive(:send_request).with(url, data).and_return(response_mock)
-          response_mock.should_receive(:body).twice.and_return("response-body")
+          api.should_receive(:send_request).with(url, data).and_return(response_double)
+          response_double.should_receive(:body).twice.and_return("response-body")
           BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return(response)
 
-          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_mock)
-          formatter_mock.should_receive(:default_formatting).and_return(formatted_response)
+          formatter_double = double(BigBlueButton::BigBlueButtonFormatter)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_double)
+          formatter_double.should_receive(:default_formatting).and_return(formatted_response)
         end
         it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
@@ -580,25 +571,25 @@ describe BigBlueButton::BigBlueButtonApi do
       let(:res) { Net::HTTPResponse.new(1.0, '200', 'OK') }
 
       before do
-        @http_mock = mock(Net::HTTP)
-        @http_mock.should_receive(:"open_timeout=").with(api.timeout)
-        @http_mock.should_receive(:"read_timeout=").with(api.timeout)
-        Net::HTTP.should_receive(:new).with("test-server", 8080).and_return(@http_mock)
+        @http_double = double(Net::HTTP)
+        @http_double.should_receive(:"open_timeout=").with(api.timeout)
+        @http_double.should_receive(:"read_timeout=").with(api.timeout)
+        Net::HTTP.should_receive(:new).with("test-server", 8080).and_return(@http_double)
         res.stub(:body) { "ok" }
       end
 
       context "standard case" do
-        before { @http_mock.should_receive(:get).with("/res?param1=value1&checksum=12345", {}).and_return(res) }
+        before { @http_double.should_receive(:get).with("/res?param1=value1&checksum=12345", {}).and_return(res) }
         it { api.send(:send_request, url).should == res }
       end
 
       context "handles a TimeoutError" do
-        before { @http_mock.should_receive(:get) { raise TimeoutError } }
+        before { @http_double.should_receive(:get) { raise TimeoutError } }
         it { expect { api.send(:send_request, url) }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
 
       context "handles general Exceptions" do
-        before { @http_mock.should_receive(:get) { raise Exception } }
+        before { @http_double.should_receive(:get) { raise Exception } }
         it { expect { api.send(:send_request, url) }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
 
@@ -607,7 +598,7 @@ describe BigBlueButton::BigBlueButtonApi do
         before {
           path = "/res?param1=value1&checksum=12345"
           opts = { 'Content-Type' => 'application/xml' }
-          @http_mock.should_receive(:post).with(path, data, opts).and_return(res)
+          @http_double.should_receive(:post).with(path, data, opts).and_return(res)
         }
         it {
           api.send(:send_request, url, data).should == res
@@ -616,7 +607,7 @@ describe BigBlueButton::BigBlueButtonApi do
 
       context "get with headers" do
         let(:headers_hash) { { :anything => "anything" } }
-        before { @http_mock.should_receive(:get).with("/res?param1=value1&checksum=12345", headers_hash).and_return(res) }
+        before { @http_double.should_receive(:get).with("/res?param1=value1&checksum=12345", headers_hash).and_return(res) }
         it {
           api.request_headers = headers_hash
           api.send(:send_request, url).should == res
@@ -629,7 +620,7 @@ describe BigBlueButton::BigBlueButtonApi do
         before {
           path = "/res?param1=value1&checksum=12345"
           opts = { 'Content-Type' => 'application/xml', :anything => "anything" }
-          @http_mock.should_receive(:post).with(path, data, opts).and_return(res)
+          @http_double.should_receive(:post).with(path, data, opts).and_return(res)
         }
         it {
           api.request_headers = headers_hash
@@ -694,11 +685,11 @@ describe BigBlueButton::BigBlueButtonApi do
       context "formats the response" do
         before {
           api.should_receive(:send_api_request).with(:getRecordings, anything).and_return(flattened_response)
-          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-          formatter_mock.should_receive(:flatten_objects).with(:recordings, :recording)
+          formatter_double = double(BigBlueButton::BigBlueButtonFormatter)
+          formatter_double.should_receive(:flatten_objects).with(:recordings, :recording)
           BigBlueButton::BigBlueButtonFormatter.should_receive(:format_recording).with(recording1)
           BigBlueButton::BigBlueButtonFormatter.should_receive(:format_recording).with(recording2)
-          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_mock)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_double)
         }
         it { api.get_recordings }
       end

data/spec/bigbluebutton_formatter_spec.rb

@@ -53,10 +53,10 @@ describe BigBlueButton::BigBlueButtonFormatter do
       formatter.to_boolean(:false1)
       formatter.to_boolean(:false2)
     }
-    it { hash[:true1].should be_true }
-    it { hash[:true2].should be_true }
-    it { hash[:false1].should be_false }
-    it { hash[:false2].should be_false }
+    it { hash[:true1].should be true }
+    it { hash[:true2].should be true }
+    it { hash[:false1].should be false }
+    it { hash[:false2].should be false }
 
     context "returns false if the param doesn't exists" do
       subject { BigBlueButton::BigBlueButtonFormatter.new({ :param => 1}) }
@@ -207,7 +207,7 @@ describe BigBlueButton::BigBlueButtonFormatter do
     context "when :returncode should be false" do
       before { input[:returncode] = "ERROR" }
       subject { formatter.default_formatting }
-      it { subject[:returncode].should be_false }
+      it { subject[:returncode].should be false }
     end
 
     context "when :messageKey is empty" do

metadata

@@ -1,114 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: bigbluebutton-api-ruby
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 2.0.0.pre.rc.1
 platform: ruby
 authors:
 - Mconf
 - Leonardo Crauss Daronco
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-31 00:00:00.000000000 Z
+date: 2025-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: childprocess
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.1
-- !ruby/object:Gem::Dependency
-  name: ffi
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.9.24
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.9.24
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.8.6
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.8.6
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.10.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.10.4
-- !ruby/object:Gem::Dependency
-  name: rack
+  name: xml-simple
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.11
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.11
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: rubyzip
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.0
-- !ruby/object:Gem::Dependency
-  name: xml-simple
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 0.1.0
 description: Provides methods to access BigBlueButton in a ruby application through
   its API
 email:
@@ -137,7 +67,6 @@ files:
 - Rakefile
 - bigbluebutton-api-ruby.gemspec
 - docker-compose.yml
-- examples/config_xml.rb
 - examples/create.rb
 - examples/get_version_example.rb
 - examples/join_example.rb
@@ -162,17 +91,12 @@ files:
 - features/support/features_helpers.rb
 - features/support/hooks.rb
 - lib/bigbluebutton_api.rb
-- lib/bigbluebutton_config_layout.rb
-- lib/bigbluebutton_config_xml.rb
 - lib/bigbluebutton_exception.rb
 - lib/bigbluebutton_formatter.rb
 - lib/bigbluebutton_hash_to_xml.rb
 - lib/bigbluebutton_modules.rb
-- spec/bigbluebutton_api_0.81_spec.rb
 - spec/bigbluebutton_api_0.9_spec.rb
 - spec/bigbluebutton_api_spec.rb
-- spec/bigbluebutton_config_layout_spec.rb
-- spec/bigbluebutton_config_xml_spec.rb
 - spec/bigbluebutton_exception_spec.rb
 - spec/bigbluebutton_formatter_spec.rb
 - spec/bigbluebutton_hash_to_xml_spec.rb
@@ -185,7 +109,7 @@ homepage: https://github.com/mconf/bigbluebutton-api-ruby/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -193,15 +117,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: BigBlueButton integration for ruby
 test_files: []

data/examples/config_xml.rb

@@ -1,74 +0,0 @@
-$:.unshift File.expand_path(File.dirname(__FILE__))
-$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
-
-require 'bigbluebutton_api'
-require 'prepare'
-
-begin
-  prepare
-
-  puts "---------------------------------------------------"
-  config_xml = @api.get_default_config_xml
-  config_xml = BigBlueButton::BigBlueButtonConfigXml.new(config_xml)
-  puts "The default config.xml was taken from the server"
-
-  puts "---------------------------------------------------"
-  layouts = @api.get_available_layouts
-  puts "The available layouts are"
-  puts layouts.inspect
-  puts "The default layouts are"
-  puts @api.get_default_layouts.inspect
-
-  puts "---------------------------------------------------"
-  num = rand(1000)
-  meeting_name = "Test Meeting #{num}"
-  meeting_id = "test-meeting-#{num}"
-  username = "House #{rand(1000)}"
-  username2 = "Cameron #{rand(1000)}"
-  options = { :moderatorPW => "54321",
-    :attendeePW => "12345",
-    :welcome => 'Welcome to my meeting',
-    :dialNumber => '1-800-000-0000x00000#',
-    :logoutURL => 'https://github.com/mconf/bigbluebutton-api-ruby',
-    :maxParticipants => 25 }
-  response = @api.create_meeting(meeting_name, meeting_id, options)
-  puts "A meeting has been created: #{meeting_id}"
-
-  puts "---------------------------------------------------"
-  url = @api.join_meeting_url(meeting_id, username, options[:moderatorPW])
-  puts "Please join the meeting as moderator using the link: #{url}"
-  puts "*** You will be using the DEFAULT config.xml ***"
-  puts "Waiting 30 seconds for you to join..."
-  puts
-  sleep(30)
-
-  puts "---------------------------------------------------"
-  puts "Creating a new config.xml"
-  # config_xml.set_attribute("layout", "showToolbar", "false", false)
-  config_xml.set_attribute("skinning", "enabled", "false", false)
-  config_xml.set_attribute("layout", "defaultLayout", "Webinar", false)
-  config_xml.set_attribute("layout", "showLayoutTools", "false", false)
-  config_xml.set_attribute("ChatModule", "privateEnabled", "false")
-  config_xml.set_attribute("VideoconfModule", "resolutions", "320x240")
-  config_xml.set_attribute("VideoconfModule", "presenterShareOnly", "true")
-
-  puts "---------------------------------------------------"
-  token = @api.set_config_xml(meeting_id, config_xml)
-  puts "Setting the new config.xml returned the token: #{token}"
-
-  puts "---------------------------------------------------"
-  url = @api.join_meeting_url(meeting_id, username2, options[:moderatorPW], { :configToken => token })
-  puts "Please join the meeting again using the link: #{url}"
-  puts "*** You will be using the MODIFIED config.xml, with the following modifications: ***"
-  puts "***  - Disabled layout (will show the default layout, as was used in BBB < 0.8)"
-  puts "***  - Default layout to Webinar"
-  puts "***  - Hidden layout tools"
-  puts "***  - Disabled private chat"
-  puts "***  - Restricted video resolutions to 320x240 only"
-  puts "***  - Disabled video sharing except for the presenter"
-  puts
-
-rescue Exception => ex
-  puts "Failed with error #{ex.message}"
-  puts ex.backtrace
-end

data/lib/bigbluebutton_config_layout.rb

@@ -1,58 +0,0 @@
-require "xmlsimple"
-
-module BigBlueButton
-
-  # A helper class to work with layout definition files.
-  # You set an xml file on it (usually obtained from a property of in the XML obtained from
-  # BigBlueButtonApi#get_default_config_xml), use it to work with the layouts, and then get
-  # the new xml from this class.
-  #
-  # === Usage example:
-  #
-  #   xml = api.get_default_config_xml
-  #   config_xml = BigBlueButton::BigBlueButtonConfigXml.new(xml)
-  #   url = config_xml.get_attribute("LayoutModule", "layoutConfig", true)
-  #   # send a request to 'url' to fetch the xml file into 'response'
-  #
-  #   layout_config = BigBlueButton::BigBlueButtonConfigLayout.new(response)
-  #   layout_config.get_available_layouts
-  #
-  class BigBlueButtonConfigLayout
-
-    attr_accessor :xml
-
-    # xml (string)::  The XML that has the definition of all layouts, usually fetched from
-    #                 the web conference server.
-    def initialize(xml)
-      @xml = nil
-      opts = { 'ForceArray' => false, 'KeepRoot' => true }
-      begin
-        @xml = XmlSimple.xml_in(xml, opts)
-      rescue Exception => e
-        exception = BigBlueButton::BigBlueButtonException.new("Error parsing the layouts XML. Error: #{e.message}")
-        exception.key = 'XMLParsingError'
-        raise exception
-      end
-    end
-
-    # Returns an array with the name of each layout available in the XML.
-    # Will return only unique names, ordered the way they are ordered in the XML.
-    # Returns nil if the XML is not properly formatted and an empty
-    # array if there are no layouts in the file.
-    def get_available_layouts
-      if xml_has_layouts
-        xml["layouts"]["layout"].map{ |l| l["name"] }.uniq
-      else
-        nil
-      end
-    end
-
-    protected
-
-    def xml_has_layouts
-      @xml and @xml["layouts"] and @xml["layouts"]["layout"]
-    end
-
-  end
-
-end

data/lib/bigbluebutton_config_xml.rb

@@ -1,125 +0,0 @@
-require "xmlsimple"
-
-module BigBlueButton
-
-  # A helper class to work with config.xml files.
-  # You set an xml file on it (usually obtained via BigBlueButtonApi#get_default_config_xml),
-  # use it to modify this xml, and then get the new xml from this class (usually to set in the
-  # server using BigBlueButtonApi#set_config_xml).
-  #
-  # === Usage example:
-  #
-  #   xml = api.get_default_config_xml
-  #   config_xml = BigBlueButton::BigBlueButtonConfigXml.new(xml)
-  #
-  #   # change the xml a bit
-  #   config_xml.set_attribute("skinning", "enabled", "false", false)
-  #   config_xml.set_attribute("layout", "defaultLayout", "Webinar", false)
-  #   config_xml.set_attribute("layout", "showLayoutTools", "false", false)
-  #
-  #   # set the new xml in the server
-  #   api.set_config_xml("meeting-id", config_xml)
-  #
-  class BigBlueButtonConfigXml
-
-    attr_accessor :xml
-
-    def initialize(xml)
-      @original_string = nil
-      @xml = nil
-      unless xml.nil?
-        opts = { 'ForceArray' => false, 'KeepRoot' => true }
-        begin
-          @xml = XmlSimple.xml_in(xml, opts)
-          @original_string = self.as_string.clone
-        rescue Exception => e
-          exception = BigBlueButton::BigBlueButtonException.new("Error parsing the config XML. Error: #{e.message}")
-          exception.key = 'XMLParsingError'
-          raise exception
-        end
-      end
-    end
-
-    def get_attribute(finder, attr_name, is_module=true)
-      if is_module
-        tag = find_module(finder)
-      else
-        tag = find_tag(finder)
-      end
-      if tag
-        find_attribute(tag, attr_name)
-      else
-        nil
-      end
-    end
-
-    def set_attribute(finder, attr_name, value, is_module=true)
-      if is_module
-        tag = find_module(finder)
-      else
-        tag = find_tag(finder)
-      end
-      if tag
-        attr = find_attribute(tag, attr_name)
-        if attr
-          # saves always as string
-          tag[attr_name] = value.is_a?(String) ? value : value.to_s
-        else
-          nil
-        end
-      else
-        nil
-      end
-    end
-
-    def as_string
-      XmlSimple.xml_out(@xml, { 'RootName' => nil, 'XmlDeclaration' => false, 'NoIndent' => true })
-    end
-
-    def is_modified?
-      @xml and
-        self.as_string != @original_string
-    end
-
-    protected
-
-    def find_module(module_name)
-      if xml_has_modules
-        modules = @xml["config"]["modules"]["module"]
-        modules = [modules] unless modules.is_a?(Array)
-        modules.each do |mod|
-          if mod["name"] == module_name
-            return mod
-          end
-        end
-      end
-      nil
-    end
-
-    def find_tag(name)
-      if xml_has_config
-        @xml["config"][name]
-      end
-    end
-
-    def find_attribute(mod, attr_name)
-      if mod and mod[attr_name]
-        return mod[attr_name]
-      else
-        return nil
-      end
-    end
-
-    def xml_has_modules
-      xml_has_config and
-        @xml["config"]["modules"] and
-        @xml["config"]["modules"]["module"]
-    end
-
-    def xml_has_config
-      @xml and @xml["config"]
-    end
-
-  end
-
-end