carioca 0.1

data/AUTHORS

@@ -0,0 +1,8 @@
+Author : 
+  Romain GEORGES <romain@ultragreen.net>
+        - code
+	- inline documentation
+	- specs
+	- Documentation
+Ruby Gem maintener : 
+  Romain GEORGES <romain@ultragreen.net>

data/COPYRIGHT

@@ -0,0 +1,24 @@
+carioca Copyright (c) 2013 Ultragreen Software, Romain GEORGES
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ 
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+ 

data/ChangeLog

@@ -0,0 +1,4 @@
+carioca :
+- initial dev. version
+ - version 0.1 (unstable)
+	Romain GEORGES

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+gem "yard-rspec"
+gem "rspec", :require => "spec"
+gem "rake"
+gem "yard"
+gem "rdoc"
+gem "rcov"
+gem "roodi"
+gem "uuid"

data/Gemfile.lock

@@ -0,0 +1,41 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    json (1.6.5)
+    macaddr (1.0.0)
+    rake (0.9.2.2)
+    rcov (1.0.0)
+    rdoc (3.12)
+      json (~> 1.4)
+    roodi (2.2.0)
+      ruby_parser (~> 2.3.0)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    ruby_parser (2.3.1)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.2.0)
+    uuid (2.3.1)
+      macaddr (~> 1.0)
+    yard (0.7.5)
+    yard-rspec (0.1)
+      yard
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rcov
+  rdoc
+  roodi
+  rspec
+  uuid
+  yard
+  yard-rspec

data/INSTALL

@@ -0,0 +1,7 @@
+How to install carioca ?
+=========================
+
+Please install the gem version via RubyGems : 
+
+$ su -
+# gem ins carioca

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+
+require 'rspec'
+require 'rake'
+require "rake/clean"
+require "rubygems/package_task"
+require "rdoc/task"
+require 'code_statistics'
+require 'rspec/core/rake_task'
+require 'yard'
+require 'yard/rake/yardoc_task.rb'
+require "rake/tasklib"
+require "roodi"
+require "roodi_task"
+ 
+ 
+RoodiTask.new() do | t |
+t.patterns = %w(lib/**/*.rb)
+t.config = "ultragreen_roodi_coding_convention.yml"
+end
+
+
+CLEAN.include('*.tmp','*.old')
+CLOBBER.include('*.tmp', 'build/*','#*#')
+
+
+content = File::readlines(File.join(File.dirname(__FILE__), 'carioca.gemspec')).join
+spec = eval(content)
+
+RSpec::Core::RakeTask.new('spec')
+
+
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = [ 'lib/**/*.rb', '-', 'doc/**/*','spec/**/*_spec.rb']			   
+  t.options += ['--title', "Gem Documentation"]
+  t.options += ['-o', "yardoc"]
+  t.options += ['-r', "doc/manual.rdoc"]
+end
+YARD::Config.load_plugin('yard-rspec') 
+
+namespace :yardoc do
+  task :clobber do
+    rm_r "yardoc" rescue nil
+    rm_r ".yardoc" rescue nil
+  end
+end
+task :clobber => "yardoc:clobber"
+
+
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+Rake::RDocTask.new('rdoc') do |d|
+  d.rdoc_files.include('doc/**/*','bin/*')
+  d.main = 'doc/manual.rdoc'
+  d.title = 'Uglibs : Ultragreen libraries'
+  d.options << '--line-numbers' << '--diagram' << '-SHN'
+end
+
+task :default => [:gem]

data/carioca.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name = %q{carioca}
+  s.author = "Romain GEORGES"
+  s.version = "0.1"
+  s.date = %q{2013-02-18}
+  s.summary = %q{Carioca : Configuration Agent and Registry with Inversion Of Control for your Applications}
+  s.email = %q{romain@ultragreen.net}
+  s.homepage = %q{http://www.ultragreen.net}
+  s.description = %q{Carioca : provide a full IoC light Container for designing your applications}
+  s.has_rdoc = true
+  s.files = Dir['*/*/*/*'] + Dir['*/*/*'] + Dir['*/*'] + Dir['*']
+  s.bindir = nil
+  s.required_ruby_version = '>= 1.8.1'
+  s.add_development_dependency "rspec", ">= 2.0.0"
+  s.rdoc_options << '--title' << 'Carioca : Gem documentation' << '--main' << 'doc/manual.rdoc' << '--line-numbers' 
+  # << '--diagram'
+  s.rubyforge_project = "nowarning"
+end

data/doc/manual.rdoc

@@ -0,0 +1,36 @@
+= Carioca
+
+== Content
+
+Author:: Romain GEORGES <romain@ultragreen.net> 
+Version:: 1.2
+WWW:: http://www.ultragreen.net/projects/methodic
+
+== Description 
+
+CARIOCA is Configuration Agent and Registry with Inversion Of Control for your Applications
+Carioca provide a full IoC light Container for designing your applications
+Carioca provide :
+- a complete Configuration Agent 
+- A service Registry (base on IOC/DI pattern)
+
+
+== Installation
+
+In a valid Ruby environment :
+
+   $ sudo zsh
+   # gem ins carioca
+
+== Implementation 
+
+* [Carioca]
+
+
+== Example
+
+
+== Copyright
+
+<pre>carioca (c) 2012-2013 Romain GEORGES <romain@ultragreen.net> for Ultragreen Software </pre>
+

data/lib/carioca.rb

@@ -0,0 +1,228 @@
+require 'yaml'
+require 'rubygems'
+require 'methodic'
+require 'services'
+require 'daemons'
+
+module Carioca
+
+module Services
+  class Registry
+    
+    
+    private_class_method :new
+    @@inst = nil
+    def Registry.init(_options = {})
+      options = Methodic::get_options(_options) do |m|
+        m.specify_defaults_value :file => './services.registry', :debug => false
+        m.merge!
+      end
+        
+      @@inst = new(options) if @@inst.nil?
+      
+      
+      return @@inst
+      
+    end
+    
+    
+    attr_reader :list
+    attr_reader :loaded_services
+    attr_reader :debug
+
+    
+    def debug=(_value)
+        @log.level =(_value)? Logger::DEBUG : Logger::INFO     
+    end
+
+
+    def stop_service(_options)
+      options = Methodic.get_options(_options)
+      options.specify_class_of :name => String
+      options.specify_presence_of([:name])
+      options.validate!
+      if @loaded_services.include?(options[:name]) then
+        @loaded_engines[options[:name]].garbage if @loaded_services[options[:name]].respond_to? :garbage
+        @loaded_services.delete(options[:name])
+        @log.debug('Carioca') { "Service #{options[:name]} stopped"  } if @log
+        return true
+      else
+        @log.debug('Carioca') { "Service #{options[:name]} not loaded"  } if @log
+        return false
+      end
+
+    end
+
+    def register_service(_options)
+      options = Methodic.get_options(_options)
+      options.specify_classes_of({:name => String, :resource => String, :description => String, :type => Symbol, :init_options => Hash, :service => String  }) 
+      options.specify_presences_of([:name,:type,:resource,:service])
+      options.validate!
+      _name = _options.delete(:name)
+      @list[_name] = _options
+      return true
+    end
+    
+    def unregister_service(_options)
+      options = Methodic.get_options(_options = {})
+      options.specify_class_of :name => String
+      options.specify_presence_of :name
+      options.validate!
+      raise RegistryError::new("FONDATION : Can't unregistered the logger service" ) if options[:name] == 'logger'
+      raise RegistryError::new("Can't unregistered a loaded service" ) if @loaded_services.include?(options[:name])
+      @list.delete(options[:name])
+      return true
+    end
+    
+    def discover_builtin
+      Carioca::Services::discover_builtin
+    end
+
+    def save!
+      res = false
+      File.open(@registry_filename, "w") do |f|
+        res = true if f.write(@list.to_yaml)
+      end
+      return res
+    end
+    
+    def start_service(_options)
+      options = Methodic.get_options(_options)
+      options.specify_classes_of :name => String, :params => Hash 
+      options.specify_presences_of([:name])
+      options.validate!
+      @log.debug('Carioca') { "getting service #{options[:name]}"} if @log
+      self.restart_service(options) unless @loaded_services.include? options[:name] 
+      return @loaded_services[options[:name]]
+    end
+    
+    alias :get_service :start_service
+
+    def restart_service(_options)
+      options = Methodic.get_options(_options)
+      options.specify_classes_of :name => String, :params => Hash
+      options.specify_presences_of [:name]
+      options.validate!
+      self.stop_service :name => options[:name] if @loaded_services.include? options[:name] 
+      if options[:name] =~ /.*_.*/ then
+        (options[:instance],options[:shortname]) = options[:name].split(/_/) 
+      else
+        options[:shortname] = options[:name]
+      end
+      verify_requires_dependancies(options)
+      require_service(options)
+      return instanciate_service(options)
+    end
+
+    def close
+      @log.debug('Carioca') { "closing Registry ..." }
+      @loaded_services.keys.each do |service|
+        next if service == 'logger' 
+        @log.debug('Carioca') { "Stopping service #{service} ..."} 
+        self.stop_service :name => service
+      end
+      @log.debug('Carioca') { "Registry services closed, logger will be closed asynchronously" }
+      self.stop_service :name => 'logger'
+    end
+
+
+    private
+    # private initializer
+    # @param [String] _filename default = '/data/config/service.registry' filename of the service Registry
+    # @return [Registry] Singleton 
+    def initialize(_options)
+      @logger_not_in_reg = false
+      @debug = _options[:debug]
+      @registry_filename = _options[:file]
+      @list  = Hash::new
+      load if File::exist?(@registry_filename)
+      unless @list.include?('logger') then
+        self.register_service({:name => 'logger', 
+                                :service => 'Carioca::Services::InternalLogger',
+                                :resource => 'logger', 
+                                :description => "The standard ruby Logger internal wrapper Service", 
+                                :type => :builtin, 
+                                :init_options => { :target => "/tmp/log.file"}})
+        @logger_not_in_reg = true
+      end 
+        
+      @loaded_services = Hash::new
+      
+      @log = self.start_service :name => 'logger' 
+      @log.level =(@debug)? Logger::DEBUG : Logger::INFO     
+      @log.debug('Carioca') { "Registry started, service logger preloaded" }
+      @log.debug('Carioca') { "Logger registered, not in configured registry" } if @logger_not_in_reg
+    end
+
+    def load
+      @list = YAML.load_file(@registry_filename)
+    end
+    
+    private
+    
+    def verify_requires_dependancies(options)
+      _name = options[:shortname]
+      if @list[_name].include?(:requires) then
+        @list[_name][:requires].each do |service|
+          unless @loaded_services.include?(service) then
+            @log.debug('Carioca') { "Registry dependancy found and not loaded : #{service}" }
+            restart_service :name => service 
+          end
+        end
+      end      
+    end
+
+    def require_service(options)
+      _name = options[:shortname]
+      sym = ":#{@list[_name][:service].split('::').last}"
+      case @list[_name][:type] 
+      when :file then
+        require @list[_name][:resource]
+      when :builtin then
+        _file = Carioca::Services::search_builtins _name
+        if _file then
+          require _file
+        else
+          raise RegistryError::new("Config failed")
+        end
+      when :gem then
+        eval("require '#{@list[_name][:resource]}'") 
+      else 
+        raise RegistryError::new("Config failed")
+      end
+    end
+
+    def instanciate_service(options)
+      _name = options[:shortname]
+      @list[_name][:init_options] = options[:params] unless options[:params].nil?
+      if @list[_name][:init_options].nil? then 
+        eval("@loaded_services[options[:name]] = #{@list[_name][:service]}::new")
+      else
+        eval("@loaded_services[options[:name]] = #{@list[_name][:service]}::new(@list[_name][:init_options])")
+      end
+      @log.debug('Carioca') { "Service #{options[:name]} started" } if @log
+      return @loaded_services[options[:name]]
+    end
+
+    
+  end
+end
+
+
+
+end
+
+
+class RegistryError < Exception; end
+
+
+Module.class_eval do
+def init_registry _options={}
+    options = Methodic.get_options(_options)
+    options.specify_classes_of :with_file => String
+    options.specify_default_value_of :with_file => './services.registry'
+    options.merge
+    options.validate!
+    Carioca::Services::Registry.init options[:with_file]
+  end
+end

data/lib/services.rb

@@ -0,0 +1,26 @@
+module Carioca
+  module  Services
+    def Services::search_builtins(_name)
+      asearch = Gem.searcher
+      spec = asearch.find('carioca')
+      if spec then
+        res = asearch.lib_dirs_for(spec).split('/')
+        res.pop
+        services_path = res.join('/').concat('/lib/services')
+      else
+        services_path = "lib/services"
+      end
+      _file ="#{services_path}/#{_name}.rb"
+      if File::exist? _file then
+        return _file
+      else
+        return false
+      end
+    end
+
+    def Services::discover_builtin
+    end
+
+
+  end
+end

data/lib/services/configuration.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# Copyright Ultragreen (c) 2005
+#---
+# Author : Romain GEORGES 
+# type : class definition Ruby
+# obj : Generic config library
+#---
+# $Id$
+
+
+require 'rubygems'
+require 'methodic'
+require 'services'
+
+module Carioca
+  module Services 
+    
+    class Configuration
+      
+      private
+      # constructor type could be a section name in <get_sections> result
+      # override could be true of false and precise if the block of the application have 
+      # to override the main config hash result, default is true 
+      def initialize(_options)
+        options = Methodic.get_options(_options)
+        options.specify_classes_of :config_file => String
+        options.validate!
+        
+        
+        
+        
+        
+      end
+      
+      def test(params)
+        return 'toto'
+      end
+      
+    end
+  end
+  
+  
+  
+end
+
+
+# interactive hacks 
+if $0 == __FILE__ then
+  puts "#{File::basename(__FILE__)}:"
+  puts 'this is a RUBY library file'
+  puts "Copyright (c) Ultragreen"
+end

data/lib/services/debug.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# Copyright Ultragreen (c) 2012
+#---
+# Author : Romain GEORGES 
+# type : class definition Ruby
+# obj : Generic Debugs tools library
+#---
+
+
+require 'rubygems'
+require 'methodic'
+
+
+module Carioca
+  module Services
+    
+    # standard RAA dependency
+    
+    
+    class ProxyDebug
+      
+      def initialize(_options)
+        options = Methodic.get_options(_options)
+        options.specify_classes_of :service => String, :params => Hash
+        options.specify_presence_of([:service])
+        options.validate!
+        if options[:params] then
+          @obj = Registry.init.start_service :name  => options[:service], :params => options[:params]
+        else
+          @obj = Registry.init.start_service :name  => options[:service]
+        end
+        @log  = Registry.init.get_service :name => 'logger'
+        @mapped_service = options[:service]
+      end
+      
+      def method_missing(methodname, *args,&block)
+        @log.debug("ProxyDebug") { "BEGIN CALL for mapped service #{@mapped_service} "} 
+        @log.debug("ProxyDebug") { "called: #{methodname} " }
+        @log.debug("ProxyDebug") { "args : #{args}" }
+
+        if block_given? then
+          @log.debug("ProxyDebug") { "block given" }
+          a = @obj.send(methodname, *args,&block)
+        else
+          
+          a = @obj.send(methodname, *args)
+        end
+
+        @log.debug("ProxyDebug") { "=> returned: #{a} " }
+        @log.debug("ProxyDebug") { 'END CALL' }
+        return a
+      end
+    end
+    
+    
+  end
+end
+
+# protection for loading libs
+if $0 == __FILE__ then
+  puts "#{File::basename(__FILE__)}:"
+  puts 'this is a RUBY library file'
+  puts "Copyright (c) Ultragreen"
+  puts "Version : #{Agents::LIB_VERSION}"
+  puts "Author : #{Agents::AUTHOR}"
+  puts "Date release : #{Agents::DATE}"
+  puts "Observation : #{Agents::OBS}"
+end
+
+

data/lib/services/logger.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# Copyright Ultragreen (c) 2005
+#---
+# Author : Romain GEORGES 
+# type : class definition Ruby
+# obj : Generic config library
+#---
+# $Id$
+
+
+require 'rubygems'
+require 'logger'
+require 'methodic'
+
+module Carioca
+  module Services 
+    
+    class InternalLogger < Logger
+      
+      private
+      # constructor type could be a section name in <get_sections> result
+      # override could be true of false and precise if the block of the application have 
+      # to override the main config hash result, default is true 
+      def initialize(_options)
+        options = Methodic.get_options(_options)
+        options.specify_default_value_of :target => STDOUT
+        options.validate!
+        
+        super(options[:target])
+        
+        
+        
+      end
+      
+      def garbage
+        self.close
+      end
+      
+    end
+  end
+  
+  
+  
+end
+
+
+# interactive hacks 
+if $0 == __FILE__ then
+  puts "#{File::basename(__FILE__)}:"
+  puts 'this is a RUBY library file'
+  puts "Copyright (c) Ultragreen"
+end

data/spec/carioca_spec.rb

@@ -0,0 +1,230 @@
+require'rubygems'
+require'rspec'
+require 'carioca'
+
+$debug = true
+
+describe Carioca do
+  before :all do 
+    FileUtils.rm_rf("/tmp/log.file")
+    $carioca = Carioca::Services::Registry.init :file => 'spec/config/services.registry', :debug => $debug
+  end  
+  
+  subject { Carioca }
+  it { should be_an_instance_of Module}
+  context "Carioca::Services" do
+    subject { Carioca::Services }
+    it { should be_an_instance_of Module }
+  end
+  
+  context "Carioca::Services::Registry"  do
+    subject { $carioca }
+    context "#init" do 
+      it { should be_an_instance_of Carioca::Services::Registry }
+      it { $carioca.list.keys.should include "logger" }
+      it "should log Registry starting and logger init if debug mode", :if => $debug do
+        open('/tmp/log.file').grep(/DEBUG -- Carioca: Registry started, service logger preloaded/).size.should eq 1
+      end
+      it "should not log Registry starting and logger init if not debug mode", :unless => $debug do
+        open('/tmp/log.file').grep(/DEBUG -- Carioca: Registry started, service logger preloaded/).size.should eq 0
+      end
+
+
+      it "should be possible to log with this primary service" do
+        $logger = subject.get_service :name => 'logger'
+        $logger.info("test").should eq true 
+        open('/tmp/log.file').grep(/INFO -- : test/).size.should eq 1
+        $logger.warn("test").should eq true
+        open('/tmp/log.file').grep(/WARN -- : test/).size.should eq 1
+        $logger.error("test").should eq true
+        open('/tmp/log.file').grep(/ERROR -- : test/).size.should eq 1
+        $logger.fatal("test").should eq true
+        open('/tmp/log.file').grep(/FATAL -- : test/).size.should eq 1
+        $logger.info("Program") { "running" }
+        open('/tmp/log.file').grep(/INFO -- Program: running/).size.should eq 1
+      end
+    end
+
+    context "attributs" do
+      context "#debug (RW)" do
+        it { should respond_to :debug }
+        it { should respond_to :debug= }
+        it "should be true if debug mode", :if => $debug do 
+          subject.debug.should eq true 
+        end
+        it "should be false if not debug mode", :unless => $debug do
+          subject.debug.should eq false 
+        end
+      end
+
+
+      context "#list (RO)" do
+        it { should respond_to :list }
+        it { should_not respond_to :list= }
+        it { subject.list.should be_an_instance_of Hash }
+        it  { $carioca.list.keys.sort.should eq ["configuration", "debug", "dummy", "logger", "uuid"] }
+      end
+
+      context "#loaded_services (RO)" do
+        it { should respond_to :loaded_services }
+        it { should_not respond_to :loaded_services= }
+        it { subject.loaded_services.should be_an_instance_of Hash }
+        it { $carioca.loaded_services.keys.should eq ["logger"] }
+      end
+    end
+
+    context "#start_service" do 
+      it { should respond_to :start_service }
+      it { should respond_to :get_service }
+
+      context "Builtin services" do
+        context "Logger service" do
+          it "should be possible to get the logger service" do 
+            $logger = subject.get_service :name => 'logger'
+          end
+          it "should log if debug mode", :if => $debug do 
+            open('/tmp/log.file').grep(/DEBUG -- Carioca: getting service logger/).size.should >= 1
+          end
+          it "should not log if debug mode", :unless => $debug do 
+            open('/tmp/log.file').grep(/DEBUG -- Carioca: getting service logger/).size.should eq 0
+          end
+        end
+        
+
+        context "Debug Proxy Service" do
+          it "should start the registry with a service debug" do 
+            myservice = subject.start_service :name => 'debug' , :params => {:service => 'configuration'}
+            myservice.test 'titi'            
+          end
+          it { subject.list.keys.should include "debug" }
+          it "should log a proxy service log sequence" do 
+            open('/tmp/log.file').grep(/DEBUG -- ProxyDebug: BEGIN CALL for mapped service configuration/).size.should eq 1 
+            open('/tmp/log.file').grep(/DEBUG -- ProxyDebug: called: test/).size.should eq 1 
+            open('/tmp/log.file').grep(/DEBUG -- ProxyDebug: args : titi/).size.should eq 1
+            open('/tmp/log.file').grep(/DEBUG -- ProxyDebug: => returned: toto/).size.should eq 1 
+            open('/tmp/log.file').grep(/DEBUG -- ProxyDebug: END CALL/).size.should eq 1
+          end
+
+        end
+      end
+      context "External services" do
+        
+        it "should start a dummy service precised in registry YAML configuration" do 
+          
+          $dummy = subject.start_service :name => 'dummy'
+          $dummy.should be_an_instance_of ExternalServices::Dummy
+        end
+        it { subject.list.keys.should include "dummy" }
+        it "should be possible to use test method of the dummy service, and return 'OK'" do
+          $dummy.test.should eq 'OK'
+        end
+        it "should start a gem service precised in registry YAML configuration" do
+          $uuid = subject.start_service :name => 'uuid'
+          $uuid.should be_an_instance_of UUID
+        end
+        it { subject.list.keys.should include "uuid" }
+        it "should be possible to execute a method with the gem service" do
+          $uuid.generate.should be_a_kind_of String
+        end
+      end
+    end
+
+
+    context "#stop_service" do
+      it { should respond_to :stop_service }
+      it "should raise ArgumentError if the option hash argument passed not include :name" do
+        lambda { subject.stop_service }.should raise_error ArgumentError
+        lambda { subject.stop_service(:notname => 'debug') }.should raise_error ArgumentError
+      end
+      it "should return true if service really stop" do
+        subject.stop_service({:name => 'dummy'}).should eq true
+      end
+      it "should log if debug mode", :if => $debug do 
+        open('/tmp/log.file').grep(/DEBUG -- Carioca: Service dummy stopped/).size.should >= 1
+      end
+      it "should not log if debug mode", :unless => $debug do 
+        open('/tmp/log.file').grep(/DEBUG -- Carioca: Service dummy stopped/).size.should = 0
+      end
+      it "should return false if service not already running" do
+        subject.stop_service({:name => 'dum'}).should eq false
+      end
+      it "should log if debug mode and service not loaded", :if => $debug do 
+        open('/tmp/log.file').grep(/DEBUG -- Carioca: Service dum not loaded/).size.should >= 1
+      end
+      it "should not log if debug mode and service not loaded", :unless => $debug do 
+        open('/tmp/log.file').grep(/DEBUG -- Carioca: Service dum not loaded/).size.should = 0
+      end
+
+      
+    end
+
+    context "#restart_service" do
+      pending
+    end
+
+
+
+
+    context "#discover_builtin" do
+      pending
+    end
+    context "#register_service" do
+      pending
+    end
+    context "#unregister_service" do
+      pending
+    end
+
+    
+    
+    context "#save!" do
+      it { should respond_to :save! }
+      it "should save the config" do
+        subject.save!.should eq true
+      end  
+    end
+    
+    
+    
+    context "#close" do    
+      context "Closing the Carioca registry" do
+        it { should respond_to :close }
+        it "should close" do
+          subject.close.should eq true    
+        end
+        it "should log a registry closing notification if debug mode", :if => $debug do
+          open('/tmp/log.file').grep(/DEBUG -- Carioca: closing Registry .../).size.should eq 1
+        end
+        it "should not log a registry closing notification if not debug mode", :unless => $debug do
+          open('/tmp/log.file').grep(/DEBUG -- Carioca: closing Registry .../).size.should eq 0
+        end
+        it "should log a stopping notification for each services if debug mode", :if => $debug do
+          ['debug','uuid','configuration'].each do |service|
+            open('/tmp/log.file').grep(/DEBUG -- Carioca: Stopping service #{service} .../).size.should eq 1
+          end
+        end
+        it "should not log a stopping notification for each services if not debug mode", :unless => $debug do
+          ['debug','uuid','configuration'].each do |service|
+            open('/tmp/log.file').grep(/DEBUG -- Carioca: Stopping service #{service} .../).size.should eq 0
+          end
+        end
+        it "should log a registry closing confirmation if debug mode", :if => $debug do
+          open('/tmp/log.file').grep(/DEBUG -- Carioca: Registry services closed, logger will be closed asynchronously/).size.should eq 1
+        end
+        it "should not log a registry closing confirmation if not debug mode", :unless => $debug do
+          open('/tmp/log.file').grep(/DEBUG -- Carioca: Registry services closed, logger will be closed asynchronously/).size.should eq 0
+        end
+        it "should loaded services empty" do
+          subject.loaded_services.empty?.should eq true
+        end  
+      end
+    end
+  end
+end
+
+
+
+
+
+
+

data/spec/config/services.registry

@@ -0,0 +1,32 @@
+--- 
+uuid: 
+  :type: :gem
+  :service: UUID
+  :description: a Rubygems called uuid to build UUID ids.
+  :resource: uuid
+logger: 
+  :type: :builtin
+  :service: Carioca::Services::InternalLogger
+  :description: The standard ruby Logger internal wrapper Service
+  :resource: logger
+  :init_options: 
+    :target: /tmp/log.file
+dummy: 
+  :type: :file
+  :service: ExternalServices::Dummy
+  :description: a dummy test service
+  :resource: spec/samples/dummy.rb
+debug: 
+  :type: :builtin
+  :service: Carioca::Services::ProxyDebug
+  :description: Class Proxy debug logger Service
+  :resource: debug
+  :init_options: 
+    :service: configuration
+configuration: 
+  :type: :builtin
+  :service: Carioca::Services::Configuration
+  :description: Configuration Agent Service
+  :resource: configuration
+  :init_options: 
+    :config_file: ./.config

data/spec/init_spec.rb

@@ -0,0 +1 @@
+require "spec_helper"

data/spec/samples/dummy.rb

@@ -0,0 +1,10 @@
+module ExternalServices
+  class Dummy
+    def initialize
+    end
+
+    def test
+      return 'OK'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+#  config.filter_run :focus
+end

data/ultragreen_roodi_coding_convention.yml

@@ -0,0 +1,25 @@
+AssignmentInConditionalCheck:
+CaseMissingElseCheck:
+ClassLineCountCheck:             
+  line_count: 300
+ClassNameCheck:                  
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+#ClassVariableCheck:
+CyclomaticComplexityBlockCheck:  
+  complexity: 4
+CyclomaticComplexityMethodCheck: 
+  complexity: 10
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:            
+  line_count: 30 
+MethodNameCheck:                 
+  pattern: !ruby/regexp /^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ 
+# MissingForeignKeyIndexCheck:
+ModuleLineCountCheck:            
+  line_count: 500
+ModuleNameCheck:          
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:            
+  parameter_count: 5
+ 

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: carioca
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Romain GEORGES
+autorequire: 
+bindir: 
+cert_chain: []
+
+date: 2013-02-18 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id001
+description: "Carioca : provide a full IoC light Container for designing your applications"
+email: romain@ultragreen.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- spec/samples/dummy.rb
+- spec/config/services.registry
+- lib/services/configuration.rb
+- lib/services/debug.rb
+- lib/services/logger.rb
+- spec/init_spec.rb
+- spec/spec_helper.rb
+- spec/carioca_spec.rb
+- lib/carioca.rb
+- lib/services.rb
+- doc/manual.rdoc
+- carioca.gemspec
+- Rakefile
+- INSTALL
+- Gemfile.lock
+- Gemfile
+- ChangeLog
+- COPYRIGHT
+- ultragreen_roodi_coding_convention.yml
+- AUTHORS
+has_rdoc: true
+homepage: http://www.ultragreen.net
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- "Carioca : Gem documentation"
+- --main
+- doc/manual.rdoc
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: nowarning
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: "Carioca : Configuration Agent and Registry with Inversion Of Control for your Applications"
+test_files: []
+