hoth 0.1.2 → 0.2.1

data/README.md

@@ -0,0 +1,95 @@
+# Hoth
+
+Creating a SOA requires a centralized location to define all services within the SOA. Furthermore you want to know where those services live.
+
+# How to use
+
+## Install
+
+    gem install hoth
+
+## Define services and modules
+
+### Service-Definition
+
+This is how you define services:
+
+    Hoth::Services.define do
+  
+      service :service_name do |first_param, second_param|
+        returns :descriptive_name
+      end
+        
+    end
+
+This definition describes a service with a name, some parameters and its return value. The naming of the parameters is just for your understanding and will never be used again, so be descriptive. Same goes for the return value. The only exception is, if you want to assure that a service returns nil you can write
+  
+    returns :nothing
+    
+A service whith this return value will always return nil. You can also specify `:nil`, with the same result.
+
+### Module-Definition
+
+After defining all you services, you need to specify in which modules they live. Each module can be seen as a set of implemented services. Each module can have one or more endpoints. Here is how you define these modules with its endpoints and services:
+
+
+    Hoth::Modules.define do
+
+      service_module :module_name do
+        env :development, :test do
+          endpoint :default,
+            :host => 'localhost',
+            :port => 3000,
+            :transport_type => :http
+
+          endpoint :bert,
+            :host => 'localhost',
+            :port => 9999,
+            :transport_type => :bert
+
+        end
+
+        env :production do
+          endpoint :default,
+            :host => '192.168.1.12',
+            :port => 3000,
+            :transport_type => :http
+
+          endpoint :bert,
+            :host => '192.168.1.15',
+            :port => 9999,
+            :transport_type => :bert
+
+        end
+    
+        add_service :first_service
+        add_service :second_service, :via => :bert
+      end
+      
+    end
+
+
+As you can see, it is possible to define different endpoints for different environments. Each endpoint has a host, a port and a transport-type. After defining your endpoints you can add your previously defined services to the module and define which endpoint they should use. If you do not specify an endpoint the :default endpoint will be used.
+
+## Integrate in your project
+
+Just execute current code (in rails you can add this line to an initializer):
+    
+    Hoth.init!
+    
+By default, Hoth looks for the files service_definition and module_definition in the config-Directory (`./config`). If you need to load these files from another place, just set `Hoth.config_path` to your needs.
+    
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2009-2010 Dirk Breuer. See LICENSE for details.

data/THANKS.md

@@ -0,0 +1,9 @@
+# Hoth THANKS
+
+A number of people have contributed to Hoth by reporting problems,
+suggesting improvements or submitting changes. Some of these people are:
+
+ * Andreas Bade (<andi.bade@gmail.com>)
+ * Sebastian Cohnen (<sebastian.cohnen@gmail.com>)
+ * Björn Vollmer (<bjoern.vollmer@googlemail.com>)
+ * Andreas Riemer

data/lib/hoth.rb

@@ -3,15 +3,15 @@ require 'singleton'
 require 'active_support/inflector'
 
 require 'hoth/transport/hoth_transport'
-require 'hoth/transport/json_transport'
+require 'hoth/transport/http_transport'
 require 'hoth/transport/bert_transport'
 require 'hoth/transport/workling_transport'
 
-require 'hoth/definition'
-require 'hoth/deployment_module'
+require 'hoth/service_definition'
+require 'hoth/service_module'
 require 'hoth/endpoint'
 require 'hoth/service'
-require 'hoth/service_deployment'
+require 'hoth/modules'
 require 'hoth/service_registry'
 require 'hoth/services'
 
@@ -20,4 +20,39 @@ require 'hoth/util/logger'
 require 'hoth/extension/core/exception'
 require 'hoth/exceptions'
 
-Hoth::Logger.init_logging!
+module Hoth
+  
+  class <<self
+    def init!
+      load_service_definition
+      load_module_definition
+      Logger.init_logging!
+    end
+  
+    def config_path
+      @config_path || "config/"
+    end
+    
+    def config_path=(config_path)
+      @config_path = config_path
+    end
+    
+    def load_service_definition
+      require File.join(config_path, "service_definition")
+    end
+
+    def load_module_definition
+      require File.join(config_path, "module_definition")
+    end
+    
+    def env
+      @env || ENV["HOTH_ENV"] || (Object.const_defined?("Rails") ? Rails.env.to_sym : :development)
+    end
+    
+    def env=(env)
+      @env = env.to_sym
+    end
+    
+  end
+  
+end

data/lib/hoth/endpoint.rb

@@ -17,9 +17,5 @@ module Hoth
     def to_url
       "http://#{@host}:#{@port}/execute"
     end
-    
-    def is_local?
-      ENV["LOCAL"] == "true" ? true : false # make dynamic
-    end
   end
 end

data/lib/hoth/modules.rb

@@ -0,0 +1,27 @@
+module Hoth
+  class Modules
+    include Singleton
+
+    attr_reader :service_modules
+
+    def self.define(&block)
+      instance.instance_eval(&block)
+    end
+
+    def self.module(module_name)
+      instance.service_modules[module_name]
+    end
+    
+    def service_module(module_name, &block)
+      service_module = ServiceModule.new(:name => module_name)
+      service_module.instance_eval(&block)
+      @service_modules[module_name] = service_module
+    end
+    
+    private
+
+      def initialize
+        @service_modules = {}
+      end
+  end
+end

data/lib/hoth/service.rb

@@ -1,36 +1,55 @@
 module Hoth
   class Service
-    attr_accessor :name, :endpoint, :params, :return_value
+    attr_accessor :name, :params_arity, :return_value, :module
     
-    def initialize(name, args = {})
+    def initialize(name, &block)
       @name         = name
-      @endpoint     = ServiceDeployment.module(args[:endpoint])[Services.env].endpoint
-      @params       = args[:params]
-      @return_value = args[:returns]
+      @params_arity = block.arity
+      instance_eval(&block)
+    end
+    
+    def returns(return_value)
+      @return_value = return_value
     end
     
     def transport
       @transport ||= "hoth/transport/#{endpoint.transport_type}_transport".camelize.constantize.new(self)
     end
     
-    def service_impl_class
-      @service_impl_class_name ||= "#{self.name.to_s.camelize}Impl"
-      # in Rails development environment we cannot cache the class constant, because it gets unloaded, so you get 
-      # an "A copy of xxxImpl has been removed from the module tree but is still active!" error from ActiveSupport dependency mechanism
-      # TODO: Try to solve this problem
-      # TODO: get rid of these Rails dependencies
-      @service_impl_class_name.constantize
+    def impl_class
+      @impl_class_name ||= "#{self.name.to_s.camelize}Impl"
+      begin
+        @impl_class_name.constantize
+      rescue NameError => e
+        # no local implementation
+        false
+      end
+    end
+    
+    def is_local?
+      !!impl_class
     end
     
     def execute(*args)
-      if self.endpoint.is_local?
+      if self.is_local?
         decoded_params = transport.decode_params(*args)
-        Hoth::Logger.debug "decoded_params: #{decoded_params.inspect}"
-        result = service_impl_class.send(:execute, *decoded_params)
-        return return_value ? result : nil
+        result = impl_class.send(:execute, *decoded_params)
+        return return_nothing? ? nil : result
       else
         transport.call_remote_with(*args)
       end
     end
+    
+    def return_nothing?
+      return_value == :nothing || return_value == :nil || return_value == nil
+    end
+    
+    def via_endpoint(via = nil)
+      @via_endpoint = via || :default
+    end
+    
+    def endpoint
+      @endpoint ||= self.module[Hoth.env][@via_endpoint]
+    end
   end
 end

data/lib/hoth/service_definition.rb

@@ -0,0 +1,7 @@
+module Hoth
+  class ServiceDefinition
+    def service(service_name, &block)
+      ServiceRegistry.add_service(Service.new(service_name, &block))
+    end
+  end
+end

data/lib/hoth/service_module.rb

@@ -0,0 +1,55 @@
+module Hoth
+  class ServiceModule
+    attr_accessor :name, :environments
+
+    class Environment
+      attr_accessor :endpoints
+      
+      def initialize(&block)
+        @endpoints = {}
+        instance_eval(&block)
+      end
+      
+      def endpoint(endpoint_name, options)
+        @endpoints[endpoint_name.to_sym] = Endpoint.new(options)
+      end
+      
+      def [](endpoint_name)
+        @endpoints[endpoint_name.to_sym]
+      end
+    end
+    
+    def initialize(attributes = {})
+      @environments = {}
+      @name = attributes[:name]
+    end
+    
+    def env(*env_names, &block)
+      env_names.each do |env_name|
+        @environments[env_name.to_sym] = Environment.new(&block)
+      end
+    end
+    
+    def add_service(service_name, options = {})
+      unless self.environments[Hoth.env]
+        puts("no endpoint-definition for environment '#{Hoth.env}' and service '#{service_name}'")
+        exit
+      end
+
+      service = ServiceRegistry.locate_service(service_name.to_sym)
+
+      unless service
+        puts("tried to add service '#{service_name}' but was not defined by service-definition")
+        exit
+      end
+      
+      service.module = self
+      service.via_endpoint(options[:via])
+    end
+    
+    def [](env_name)
+      @environments[env_name.to_sym]
+    end
+
+  end
+end

data/lib/hoth/service_registry.rb

@@ -11,11 +11,11 @@ module Hoth
     end
     
     def add_service(service)
-      @registry[service.name] = service
+      @registry[service.name.to_sym] = service
     end
     
     def locate_service(service_name)
-      @registry[service_name]
+      @registry[service_name.to_sym]
     end
     
     private

data/lib/hoth/services.rb

@@ -1,7 +1,7 @@
 module Hoth
   class Services
     def self.define(&block)
-      (@definition || Definition.new).instance_eval(&block)
+      ServiceDefinition.new.instance_eval(&block)
     end
     
     class <<self

data/lib/hoth/transport/hoth_transport.rb

@@ -5,7 +5,7 @@ module Hoth
     class HothTransport
       extend Forwardable
       
-      def_delegators :@service_delegate, :name, :endpoint, :params, :return_value
+      def_delegators :@service_delegate, :name, :module, :endpoint, :params, :return_value
       
       def initialize(service_delegate)
         @service_delegate = service_delegate

data/lib/hoth/transport/{json_transport.rb → http_transport.rb}

@@ -1,9 +1,10 @@
 require 'json'
 require 'net/http'
 
+
 module Hoth
   module Transport
-    class JsonTransport < HothTransport     
+    class HttpTransport < HothTransport     
       def call_remote_with(*args)
         response = Net::HTTP.post_form(
           URI.parse(self.endpoint.to_url),

data/lib/hoth/transport/workling_transport.rb

@@ -4,13 +4,17 @@ rescue LoadError
   STDERR.puts "You need the simple_publisher gem if you want to use Workling/Starling transport."
 end
 
+
+
+
+
 module Hoth
   module Transport
     
     class WorklingTransport < HothTransport
       
       def call_remote_with(*args)
-        topic      = SimplePublisher::Topic.new(:name => "#{endpoint.module_name.to_s.underscore}_subscribers__#{name.to_s.underscore}")
+        topic      = SimplePublisher::Topic.new(:name => "#{self.module.name.to_s.underscore}_subscribers__#{name.to_s.underscore}")
         connection = SimplePublisher::StarlingConnection.new(:host => endpoint.host, :port => endpoint.port)
 
         publisher = SimplePublisher::Publisher.new(:topic => topic, :connection => connection)

data/spec/spec_helper.rb

@@ -6,7 +6,7 @@ require 'hoth'
 require 'spec'
 require 'spec/autorun'
 
-Hoth::Services.env = "test"
+Hoth.env = "test"
 
 Spec::Matchers.define :string_matching do |regex|
   match do |string|

data/spec/unit/endpoint_spec.rb

@@ -39,11 +39,6 @@ describe Hoth::Endpoint do
     json_endpoint.should_not equal(bert_endpoint)
   end
   
-  it "should know if it is local or not" do
-    endpoint = Hoth::Endpoint.new({})
-    endpoint.is_local?.should_not be(nil)
-  end
-  
   it "should should know the deployment module this endpoint is associated to" do
     endpoint = Hoth::Endpoint.new(:module_name => "TestModule")
     endpoint.module_name.should == "TestModule"

data/spec/unit/hoth_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Hoth do
+  
+  before(:each) do
+    @old_hoth_env = Hoth.env
+    Hoth.instance_variable_set "@env", nil
+  end
+  
+  after(:each) do
+    Hoth.env = @old_hoth_env
+  end
+  
+  it "should set the environment explicitly" do
+    Hoth.env = :test
+    Hoth.env.should == :test
+  end
+  
+  it "should default to :development if no environment is set" do
+    Hoth.env.should equal(:development)
+  end
+  
+  it "should return the Rails env if Rails is available" do
+    module Rails; end
+    Rails.should_receive(:env).and_return(:production)
+    Hoth.env.should equal(:production)
+    Object.send :remove_const, :Rails
+  end
+  
+end

data/spec/unit/service_definition_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module Hoth
+  describe ServiceDefinition do
+  
+    it "should create a Service and add it to the registry instance" do
+      service_name = :my_service
+      
+      definition = ServiceDefinition.new
+      definition.service service_name do |some_params|
+        returns :nothing
+      end
+      
+      service = ServiceRegistry.locate_service(service_name)
+      service.should_not be(nil)
+      service.params_arity.should be(1)
+      service.return_value.should be(:nothing)
+    end
+  
+  end
+end

data/spec/unit/service_module_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module Hoth
+  
+  describe ServiceModule do
+  
+    it "should have a name" do
+      service_module = ServiceModule.new :name => :my_service_module
+      service_module.name.should equal(:my_service_module)
+    end
+  
+    it "should have an environment" do
+      service_module = ServiceModule.new(:name => "service_module_name")
+      block = Proc.new {}
+      service_module.env :test, &block
+      service_module[:test].should be_a(ServiceModule::Environment)
+    end
+  
+    it "should have multiple environments" do
+      service_module = ServiceModule.new(:name => "service_module_name")
+      block = Proc.new {}
+      service_module.env :test, :development, &block
+      service_module[:test].should be_a(ServiceModule::Environment)
+      service_module[:development].should be_a(ServiceModule::Environment)
+    end
+  
+    it "should be able to add services" do
+      service_module = ServiceModule.new(:name => "service_module_name")
+      block = Proc.new {}
+      
+      service_module.env :test, &block
+      
+      ServiceRegistry.should_receive(:locate_service).with(:service_name).and_return(service = mock("ServiceMock"))
+      service.should_receive(:module=).with(service_module)
+      service.should_receive(:via_endpoint).with(:special_endpoint)
+      
+      service_module.add_service("service_name", :via => :special_endpoint)
+    end
+  
+    describe ServiceModule::Environment do
+
+      it "should have an endpoint" do
+        endpoint_mock = mock("Endpoint", :null_object => true)
+      
+        endpoint_block = Proc.new { endpoint :development, {} }
+        env = ServiceModule::Environment.new(&endpoint_block)      
+        env[:development].should_not be(nil)
+      end
+    
+    end
+  
+  end
+  
+end

data/spec/unit/service_spec.rb

@@ -6,60 +6,56 @@ class TestServiceImpl
   end
 end
 
-describe Hoth::Service do
+module Hoth
   
-  before(:each) do
-    Hoth::ServiceDeployment.should_receive(:module).
-                            and_return({:test => stub(:endpoint => stub("Endpoint"))})
+  describe Service do
     
-    @service = Hoth::Service.new("TestService",
-      :endpoint => "test_module",
-      :params   => ["parameter", "another_parameter"],
-      :returns  => [:some_data]
-    )
-  end
-  
-  it "should have a name and an endpoint based ob the deployment definition" do
-    Hoth::ServiceDeployment.should_receive(:module).
-                            with("test_module").
-                            and_return({:test => mock("DeploymentModule", :endpoint => stub("Endpoint"))})
-    
-    service = Hoth::Service.new("TestService", :endpoint => "test_module")
-    service.name.should == "TestService"
-  end
-  
-  it "should define parameters and return values" do
-    Hoth::ServiceDeployment.should_receive(:module).
-                            and_return({:test => stub(:endpoint => stub("Endpoint"))})
-    
-    service = Hoth::Service.new("TestService",
-      :endpoint => "test_module",
-      :params   => ["parameter", "another_parameter"],
-      :returns  => [:some_data]
-    )
-    
-    service.params.should == ["parameter", "another_parameter"]
-    service.return_value.should == [:some_data]
-  end
+    it "should define parameters and return values" do
+      service_block = Proc.new { |param_1, param_2, param_3| returns :some_data }
+
+      service = Service.new("TestService", &service_block)
+
+      service.params_arity.should be(3)
+      service.return_value.should be(:some_data)
+    end
+    
+    it "should know its service-impl class" do
+      service = Service.new("TestService") {}
+      service.impl_class
+    end
+    
+    it "should know that its service-impl class is not available" do
+      service = Service.new("TestServiceWithoutImplClass") {}
+      service.impl_class
+    end
+    
+    it "should execute the service stub locally if its impl-class was found" do
+      service = Service.new("test_service") { |p1, p2| returns :nothing }
+      
+      service.should_receive(:transport).and_return(transport = mock("TransportMock"))
+      transport.should_receive(:decode_params).with(:arg1, :arg2).and_return(decoded_params = mock("DecodedParamsMock"))
+      service.impl_class.should_receive(:execute).with(decoded_params)
+      
+      service.execute(:arg1, :arg2)
+    end
   
-  it "should execute the service stub locally based on the endpoint" do
-    @service.should_receive(:endpoint).and_return(mock("Endpoint", :is_local? => true))
-    transport_mock = mock("HothTranport")
-    transport_mock.should_receive(:decode_params).
-                   with(:arg1, :arg2).
-                   and_return([:decoded_arg1, :decoded_arg2])
-                   
-    @service.should_receive(:transport).and_return(transport_mock)
-    
-    @service.execute(:arg1, :arg2)
-  end
+    it "should call the remote service if impl-class does not exist" do
+      service = Service.new("test_service_without_impl") { |p1, p2| returns :nothing }
+      
+      service.should_receive(:transport).and_return(transport = mock("TransportMock"))
+      transport.should_receive(:call_remote_with).with(:arg1, :arg2)
+      
+      service.execute(:arg1, :arg2)    
+    end
   
-  it "should execute the service stub via transport based on the endpoint" do
-    
-  end
+    it "should create transport instance based on endpoint" do
+      service = Service.new("test_service") { |p1, p2| returns :nothing }
+      service.should_receive(:endpoint).and_return(endpoint = mock("EndpointMock"))
+      endpoint.should_receive(:transport_type).and_return(:http)
+      Hoth::Transport::HttpTransport.should_receive(:new).with(service)
+      service.transport
+    end
   
-  it "should create transport instance based on endpoint" do
-    
   end
   
-end
+end

data/spec/unit/transport/workling_transport_spec.rb

@@ -7,13 +7,16 @@ module Hoth
       
       it "should send publish a message via SimplePublisher" do
         endpoint = mock("EndpointMock")
-        endpoint.should_receive(:module_name).and_return("TestServiceModule")
         endpoint.should_receive(:host).and_return("localhost")
         endpoint.should_receive(:port).and_return("22122")
         
+        service_module = mock("ServiceModule")
+        service_module.should_receive(:name).and_return("TestServiceModule")
+        
         service = mock("ServiceMock")
         service.should_receive(:name).and_return("TestService")
         service.should_receive(:endpoint).any_number_of_times.and_return(endpoint)
+        service.should_receive(:module).any_number_of_times.and_return(service_module)
         
         SimplePublisher::Topic.should_receive(:new).with(:name => "test_service_module_subscribers__test_service").and_return(topic = mock("Topic"))
         

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Dirk Breuer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-26 00:00:00 +01:00
+date: 2010-03-29 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -88,34 +88,35 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.md
 files: 
-- README.rdoc
+- README.md
+- THANKS.md
 - lib/hoth.rb
-- lib/hoth/definition.rb
-- lib/hoth/deployment_module.rb
 - lib/hoth/endpoint.rb
 - lib/hoth/exceptions.rb
 - lib/hoth/extension/core/exception.rb
+- lib/hoth/modules.rb
 - lib/hoth/providers/bertrpc_provider.rb
 - lib/hoth/providers/rack_provider.rb
 - lib/hoth/service.rb
-- lib/hoth/service_deployment.rb
+- lib/hoth/service_definition.rb
+- lib/hoth/service_module.rb
 - lib/hoth/service_registry.rb
 - lib/hoth/services.rb
 - lib/hoth/transport/amqp_transport.rb
 - lib/hoth/transport/bert_transport.rb
 - lib/hoth/transport/hoth_transport.rb
-- lib/hoth/transport/json_transport.rb
+- lib/hoth/transport/http_transport.rb
 - lib/hoth/transport/workling_transport.rb
 - lib/hoth/util/logger.rb
-- spec/hoth_spec.rb
 - spec/spec_helper.rb
-- spec/unit/definition_spec.rb
-- spec/unit/deployment_module_spec.rb
 - spec/unit/endpoint_spec.rb
 - spec/unit/extension/core/exception_spec.rb
+- spec/unit/hoth_spec.rb
 - spec/unit/providers/rack_provider_spec.rb
+- spec/unit/service_definition_spec.rb
+- spec/unit/service_module_spec.rb
 - spec/unit/service_spec.rb
 - spec/unit/transport/workling_transport_spec.rb
 - LICENSE
@@ -150,12 +151,12 @@ signing_key:
 specification_version: 3
 summary: Registry and deployment description abstraction for SOA-Services
 test_files: 
-- spec/hoth_spec.rb
 - spec/spec_helper.rb
-- spec/unit/definition_spec.rb
-- spec/unit/deployment_module_spec.rb
 - spec/unit/endpoint_spec.rb
 - spec/unit/extension/core/exception_spec.rb
+- spec/unit/hoth_spec.rb
 - spec/unit/providers/rack_provider_spec.rb
+- spec/unit/service_definition_spec.rb
+- spec/unit/service_module_spec.rb
 - spec/unit/service_spec.rb
 - spec/unit/transport/workling_transport_spec.rb

data/README.rdoc

@@ -1,18 +0,0 @@
-= hoth
-
-Description goes here.
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but
-   bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2009 Dirk Breuer. See LICENSE for details.

data/lib/hoth/definition.rb

@@ -1,7 +0,0 @@
-module Hoth
-  class Definition
-    def service(service_name, options = {})
-      service = ServiceRegistry.add_service(Service.new(service_name, options))
-    end
-  end
-end

data/lib/hoth/deployment_module.rb

@@ -1,41 +0,0 @@
-module Hoth
-  class DeploymentModule
-    attr_accessor :name, :environments
-
-    class Environment
-      attr_accessor :endpoint, :deployment_options
-      
-      def initialize(attributes = {})
-        @endpoint           = attributes[:endpoint]
-        @deployment_options = attributes[:deployment_options]
-      end
-      
-      def propagate_module_name_to_endpoint(module_name)
-        @endpoint.module_name = module_name
-      end
-    end
-    
-    def initialize(attributes = {})
-      @environments = {}
-      @name = attributes[:name]
-    end
-    
-    def env(*options)
-      attributes = Hash === options.last ? options.pop : {}
-      options.each do |env_name|
-        @environments[env_name.to_sym] = Environment.new(attributes)
-        @environments[env_name.to_sym].propagate_module_name_to_endpoint(@name)
-      end
-      self
-    end
-    
-    def [](env_name)
-      @environments[env_name.to_sym]
-    end
-    
-    def path(path = nil)
-      path.nil? ? @path : @path = path
-    end
-
-  end
-end

data/lib/hoth/service_deployment.rb

@@ -1,27 +0,0 @@
-module Hoth
-  class ServiceDeployment
-    include Singleton
-
-    attr_reader :deployment_modules
-
-    def self.define(&block)
-      instance.instance_eval(&block)
-    end
-
-    def self.module(module_name)
-      instance.deployment_modules[module_name]
-    end
-
-    def service_module(module_name, &block)
-      deployment_module = DeploymentModule.new(:name => module_name)
-      deployment_module.instance_eval(&block)
-      @deployment_modules[module_name] = deployment_module
-    end
-
-    private
-
-      def initialize
-        @deployment_modules = {}
-      end
-  end
-end

data/spec/hoth_spec.rb

@@ -1 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')

data/spec/unit/definition_spec.rb

@@ -1,21 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe Hoth::Definition do
-  
-  it "should create a Service and add it to the registry instance" do
-    service_name = :my_service
-    service_options = {
-      :params   => [:some_params],
-      :returns  => nil,
-      :endpoint => :my_service_module
-    }
-
-    service = mock("ServiceMock")
-    Hoth::Service.should_receive(:new).with(service_name, service_options).and_return(service)
-    Hoth::ServiceRegistry.should_receive(:add_service).with(service)
-    
-    definition = Hoth::Definition.new
-    definition.service service_name, service_options
-  end
-  
-end

data/spec/unit/deployment_module_spec.rb

@@ -1,58 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe Hoth::DeploymentModule do
-  
-  it "should have a name" do
-    deployment_module = Hoth::DeploymentModule.new :name => :my_service_module
-    deployment_module.name.should equal(:my_service_module)
-  end
-  
-  it "should have an environment" do
-    deployment_module = Hoth::DeploymentModule.new(:name => "deployment_module_name")
-    
-    env_specific_options = {:endpoint => endpoint = mock("EndpointMock"), :deployment_options => "deployment_options"}
-    endpoint.should_receive(:module_name=).with("deployment_module_name").exactly(3).times
-    deployment_module.env :test, env_specific_options
-    deployment_module[:test].should be_a(Hoth::DeploymentModule::Environment)
-
-    deployment_module.env :staging, :production, env_specific_options
-    deployment_module[:staging].should be_a(Hoth::DeploymentModule::Environment)
-    deployment_module[:production].should be_a(Hoth::DeploymentModule::Environment)
-    
-    [:test, :staging, :production].each do |environment|
-      deployment_module[environment].endpoint.should == endpoint
-      deployment_module[environment].deployment_options.should == "deployment_options"
-    end
-  end
-  
-  it "should have a path pointing to the service root" do
-    deployment_module = Hoth::DeploymentModule.new
-    deployment_module.path "services_dir/my_service"
-    deployment_module.path.should == "services_dir/my_service"
-  end
-
-  describe Hoth::DeploymentModule::Environment do
-    it "should have an endpoint" do
-      endpoint_mock = mock("Hoth::Endpoint", :null_object => true)
-      
-      env = Hoth::DeploymentModule::Environment.new(:endpoint => endpoint_mock)
-      env.endpoint.should equal(endpoint_mock)
-    end
-
-    it "should have deployment options" do
-      some_options = {:server_instances => 5}
-      
-      env = Hoth::DeploymentModule::Environment.new(:deployment_options => some_options)
-      env.deployment_options.should equal(some_options)
-    end
-    
-    it "should set propagate the module_name of the enclosing DeploymentModule to its endpoint" do
-      endpoint = mock("Hoth::Endpoint", :null_object => true)
-      endpoint.should_receive(:module_name=).with("deployment_module_name")
-      
-      env = Hoth::DeploymentModule::Environment.new(:endpoint => endpoint)
-      env.propagate_module_name_to_endpoint("deployment_module_name")
-    end
-  end
-  
-end