hosties 1.1.0.alpha → 1.1.0.alpha2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b67e9ef6e1d2d98eaf6c3e5dc570e2b478e12708
-  data.tar.gz: d3fa2796ecfee0d21f0091c6ca6d1518961d281f
+  metadata.gz: c5aad13eda9a31ed69dda41c369424d5311e4d60
+  data.tar.gz: 3a37f4fed44c321a37ec488580e164e7c521fd55
 SHA512:
-  metadata.gz: c3b2df43b6b47519ad39ef1c339c60b94e0ad27f2d1b7941c4686e7cbaed8166735aa03ac4fa1c8b9a3fae126a41935e041030a669f6ab1c1410eb3d0d5ee326
-  data.tar.gz: 86b140c14683a0b37cf754158920181856cd4fb0bc85f560806e37166b13246a0da667a2db1c965a0c1bb44574a601163ab7d8c2ae3cec5aea9bce4e11879e51
+  metadata.gz: 2c27fff8d37d95deb87f6387c360e5eb7a259aced2e88fd1ea730928100b1b9990bad978261b6ed0ce20d8806a8dc1b575dd1b75d12f24142965d9e8db120c8e
+  data.tar.gz: 0e18fd57a070555657954bb4433a147e6c4a9dd10a51e9a5e59b28976cf9f892de63459219147cacb71d58a9e710008fd5123e98f6e708335415e7b8af0e8470

data/lib/hosties/definitions.rb

@@ -4,138 +4,145 @@
 # have in order to be valid.                                          #
 #######################################################################
 
-# Constrains a named attribute to a provided set of values. This is good
-# for things like describing environments that a set of hosts can be in,
-# for instance Dev, QA, etc
-class AttributeConstraint
-  attr_reader :name, :possible_vals
-
-  def initialize(name)
-    @name = name
-    @possible_vals = []
-  end
+module Hosties
+  # Constrains a named attribute to a provided set of values. This is good
+  # for things like describing environments that a set of hosts can be in,
+  # for instance Dev, QA, etc
+  class AttributeConstraint
+    attr_reader :name, :possible_vals
+
+    def initialize(name)
+      @name = name
+      @possible_vals = []
+    end
 
-  def can_be(val, *more)
-    @possible_vals += (more << val)
+    def can_be(val, *more)
+      @possible_vals += (more << val)
+    end
   end
-end
 
-# Superclass for the host and environment requirement types. This 
-# class handles the plumbing of tracking, constraining, and eventually
-# reifying attributes.
-class HasAttributes
-  attr_accessor :constraints
-  attr_accessor :attributes
-  def initialize
-    @constraints = {}
-    @attributes = []
-  end
+  # Superclass for the host and environment requirement types. This 
+  # class handles the plumbing of tracking, constraining, and eventually
+  # reifying attributes.
+  class HasAttributes
+    attr_accessor :constraints
+    attr_accessor :attributes
+
+    def initialize(verbotten = [])
+      @constraints = {}
+      @attributes = []
+      @verbotten = verbotten
+    end
 
-  # Specify symbols that will later be reified into attributes
-  def have_attributes(attr, *more)
-   @attributes += (more << attr)
-  end
+    # Specify symbols that will later be reified into attributes
+    def have_attributes(attr, *more)
+      sum = (more << attr)
+      sum.each do |name|
+        raise ArgumentError, "Reserved attribute name #{name}" if @verbotten.include?(name)
+      end
+      @attributes += sum
+    end
 
-  alias_method :have_attribute, :have_attributes
-  alias_method :has_attribute, :have_attribute
-  alias_method :has_attributes, :have_attributes
+    alias_method :have_attribute, :have_attributes
+    alias_method :has_attribute, :have_attribute
+    alias_method :has_attributes, :have_attributes
 
-  # Helpful method to define constraints
-  def where(name)
-    # Must define the attributes before constraining them
-    raise ArgumentError, "Unknown attribute: #{name}" unless @attributes.include? name
-    @constraints[name] = AttributeConstraint.new(name)
-  end
+    # Helpful method to define constraints
+    def where(name)
+      # Must define the attributes before constraining them
+      raise ArgumentError, "Unknown attribute: #{name}" unless @attributes.include? name
+      @constraints[name] = AttributeConstraint.new(name)
+    end
 
-  # Check if a given name-value pair is valid given the constraints
-  def valid?(name, value)
-    if @constraints.include? name then
-      constraints[name].possible_vals.include? value
-    else true end
+    # Check if a given name-value pair is valid given the constraints
+    def valid?(name, value)
+      if @constraints.include? name then
+        constraints[name].possible_vals.include? value
+      else true end
+    end
   end
-end
 
-# Defines what a host of a certain type looks like
-class HostRequirement < HasAttributes
-  attr_reader :type, :services
-  def initialize(type)
-    super()
-    @type = type
-    @services = []
-  end
+  # Defines what a host of a certain type looks like
+  class HostRequirement < HasAttributes
+    attr_reader :type, :services
+    def initialize(type)
+      super([:hostname, :type])
+      @type = type
+      @services = []
+    end
 
-  # Services will be provided with a host definition. In order for
-  # a host definition to be valid, it must provide service details 
-  # for all of the services specified by its matching 
-  # HostRequirement
-  def have_services(service, *more)
-   @services += (more << service)
-  end
+    # Services will be provided with a host definition. In order for
+    # a host definition to be valid, it must provide service details 
+    # for all of the services specified by its matching 
+    # HostRequirement
+    def have_services(service, *more)
+     @services += (more << service)
+    end
 
-  alias_method :have_service, :have_services
-  alias_method :has_service, :have_service
-  alias_method :has_services, :have_services
+    alias_method :have_service, :have_services
+    alias_method :has_service, :have_service
+    alias_method :has_services, :have_services
 
-  def finished
-    Hosties::HostDefinitions[@type] = self
+    def finished
+      Hosties::HostDefinitions[@type] = self
+    end
   end
-end
 
-# Builder method
-def host_type(symbol, &block)
-  builder = HostRequirement.new(symbol)
-  begin
-    builder.instance_eval(&block)
-    builder.finished
-  rescue ArgumentError => ex
-    # TODO: There must be a better way!
-    # I'd like to provide some feedback in this case, but I don't 
-    # like having this show up in test output. 
-    #puts "Problem defining host \"#{symbol}\": #{ex}"
-  end
-end
 
-# Used to describe an environment.
-class EnvironmentRequirement < HasAttributes
-  attr_reader :type, :hosts, :grouping
-  def initialize(type)
-    super()
-    @type = type
-    @hosts = []
-  end
+  # Used to describe an environment.
+  class EnvironmentRequirement < HasAttributes
+    attr_reader :type, :hosts, :grouping, :host_attributes
+    def initialize(type)
+      super([:type, :hosts])
+      @type = type
+      @host_attributes = []
+      @hosts = []
+    end
 
-  # Define the hosts that an environment needs to be valid,
-  # for instance, maybe you need a :logger host and a 
-  # :service host at a minimum.
-  def need(host1, *more)
-    sum = more << host1
-    # Array doesn't have an 'exists' method, so behold - map reduce wankery!
-    unless sum.map { |x| Hosties::HostDefinitions.include? x }.reduce(true) { |xs, x| x & xs }
-      raise ArgumentError, "Unrecognized host type"
+    # Define the hosts that an environment needs to be valid,
+    # for instance, maybe you need a :logger host and a 
+    # :service host at a minimum.
+    def need(host1, *more)
+      sum = more << host1
+      # Array doesn't have an 'exists' method, so behold - map reduce wankery!
+      unless sum.map { |x| Hosties::HostDefinitions.include? x }.reduce(true) { |xs, x| x & xs }
+        raise ArgumentError, "Unrecognized host type"
+      end
+      @hosts += sum
     end
-    @hosts += sum
-  end
 
-  # Optionally specify an attribute to group by when registering 
-  # environments of this type.
-  def grouped_by(attr) 
-    raise ArgumentError, "Unknown attribute #{attr}" unless @attributes.include?(attr)
-    @grouping = attr
-  end
+    alias_method :needs, :need
+
+    def hosts_inherit(attr)
+      unless self.attributes.include? attr then
+        raise ArgumentError, "Unrecognized attribute #{attr}"
+      end
+      @host_attributes << attr
+    end
 
-  def finished
-    Hosties::EnvironmentDefinitions[@type] = self
+    # Optionally specify an attribute to group by when registering 
+    # environments of this type.
+    def grouped_by(attr) 
+      raise ArgumentError, "Unknown attribute #{attr}" unless @attributes.include?(attr)
+      @grouping = attr
+    end
+
+    def finished
+      Hosties::EnvironmentDefinitions[@type] = self
+    end
   end
 end
 
-# Builder method
+## Globally accessible builder methods
+
 def environment_type(symbol, &block)
-  builder = EnvironmentRequirement.new(symbol)
-  begin
-    builder.instance_eval(&block)
-    builder.finished
-  rescue ArgumentError => ex
-    # TODO: Same as above, find a better way to get this information out
-    #puts "Problem describing environment \"#{builder.type}\": #{ex}"
-  end
+  builder = Hosties::EnvironmentRequirement.new(symbol)
+  builder.instance_eval(&block)
+  builder.finished
+end
+
+def host_type(symbol, &block)
+  builder = Hosties::HostRequirement.new(symbol)
+  builder.instance_eval(&block)
+  builder.finished
 end

data/lib/hosties/easydata.rb

@@ -2,23 +2,33 @@
 # Provide a more convenient data structure to work with once  #
 # environment declarations have been read.                    #
 ###############################################################
-class DataWrapper
-  def metaclass
-    class << self
-      self
-    end
-  end
-end
-
 module Hosties
   module EasyData
+    class DataWrapper
+      def metaclass
+        class << self
+          self
+        end
+      end
+    end
+
     def self.fromHost(hash)
       result = DataWrapper.new
       hash.each do |k, v|
         result.metaclass.send(:define_method, k) do v end
       end
+      # Define a human-friendly to_s
+      # NOTE: Application behavior should not rely on the stability of this
+      # string representation! It is subject to change whenever I'm feeling
+      # squirrely.
+      filtered_hash = hash.reject { |k,v| k == :type or k == :hostname }
+      attr_string = filtered_hash.map{|k,v| "#{k}: #{v}"}.join(", ")
+      result.metaclass.send(:define_method, :to_s) do
+        "<#{hash[:type]} host @ #{hash[:hostname]} attrs: #{attr_string}>"
+      end
       result
     end
+
     def self.fromEnv(hash)
       result = DataWrapper.new
       hash.each do |k, v|
@@ -34,6 +44,23 @@ module Hosties
       result.metaclass.send(:define_method, :each_host) do |&block|
         yield self.hosts
       end
+      # Apply all of the host_attributes to our little host children
+      definition = Hosties::EnvironmentDefinitions[hash[:type]]
+      inheritance = definition.host_attributes
+      hash[:hosts].each do |host|
+        inheritance.each do |attr|
+          val = hash[attr]
+          host.metaclass.send(:define_method, attr) do val end
+        end
+      end
+      # Human friendly to_s
+      # NOTE: As above, this representation is subject to change whenever,
+      # don't rely on it for application behavior!
+      filtered_hash = hash.reject { |k,v| k == :type or k == :hosts }
+      attr_string = filtered_hash.map{|k,v| "#{k}: #{v}"}.join(", ")
+      result.metaclass.send(:define_method, :to_s) do
+        "<#{hash[:type]} environment, attrs: #{attr_string}, hosts: #{hash[:hosts].join(", ")}>"
+      end
       result
     end
   end

data/lib/hosties/reification.rb

@@ -2,113 +2,117 @@
 # Provide some classes to turn a declarative host definition into something 
 # more useful in code, applying rules from the definition files to ensure we
 # only get valid stuff.
-class UsesAttributes
-  # Oh this old thing...
-  def metaclass 
-    class << self
-      self
+
+module Hosties
+  class UsesAttributes
+    # Oh this old thing...
+    def metaclass 
+      class << self
+        self
+      end
     end
-  end
-  def initialize(has_attributes)
-    @attributes = has_attributes.attributes
-    # Magic.
-    has_attributes.attributes.each do |attr|
-      # Add in the attribute
-      self.metaclass.send(:attr_accessor, attr)
-      # Define a constrained setter
-      self.metaclass.send(:define_method, attr) do |val|
-        raise ArgumentError, "Invalid value" unless has_attributes.valid?(attr, val)
-        instance_variable_set "@#{attr}", val
+    def initialize(has_attributes)
+      @attributes = has_attributes.attributes
+      # Magic.
+      has_attributes.attributes.each do |attr|
+        # Add in the attribute
+        self.metaclass.send(:attr_accessor, attr)
+        # Define a constrained setter
+        self.metaclass.send(:define_method, attr) do |val|
+          raise ArgumentError, "Invalid value" unless has_attributes.valid?(attr, val)
+          instance_variable_set "@#{attr}", val
+        end
       end
     end
-  end
 
-  # Return a hash after verifying everything was set correctly
-  def finish
-    retval = {}
-    # Ensure all required attributes have been set
-    @attributes.each do |attr|
-      val = instance_variable_get "@#{attr}"
-      raise ArgumentError, "Missing attribute #{attr}" if val.nil?
-      retval[attr] = val
+    # Return a hash after verifying everything was set correctly
+    def finish
+      retval = {}
+      # Ensure all required attributes have been set
+      @attributes.each do |attr|
+        val = instance_variable_get "@#{attr}"
+        raise ArgumentError, "Missing attribute #{attr}" if val.nil?
+        retval[attr] = val
+      end
+      retval
     end
-    retval
   end
-end
 
-class HostBuilder < UsesAttributes
-  def initialize(type, hostname)
-    if Hosties::HostDefinitions[type].nil? then
-      raise ArgumentError, "Unrecognized host type"
-    end
-    @type = type
-    @definition = Hosties::HostDefinitions[@type]
-    @hostname = hostname
-    @service_ports = {} # Map of service type to port
-    super(@definition) # Creates attribute code
-    # Services are really just a special kind of attribute, but for now I'll
-    # keep them separate. I'm thinking maybe I could add a new type of attribute
-    # constraint that let's a user specify that an attribute must be numeric, or
-    # a string for instance.
-    @definition.services.each do |service_type|
-      self.metaclass.send(:attr_accessor, service_type)
-      self.metaclass.send(:define_method, service_type) do |port|
-        raise ArgumentError, "Port number required" unless port.is_a? Integer
-        @service_ports[service_type] = port
+  class HostBuilder < UsesAttributes
+    def initialize(type, hostname)
+      if Hosties::HostDefinitions[type].nil? then
+        raise ArgumentError, "Unrecognized host type"
+      end
+      @type = type
+      @definition = Hosties::HostDefinitions[@type]
+      @hostname = hostname
+      @service_ports = {} # Map of service type to port
+      super(@definition) # Creates attribute code
+      # Services are really just a special kind of attribute, but for now I'll
+      # keep them separate. I'm thinking maybe I could add a new type of attribute
+      # constraint that let's a user specify that an attribute must be numeric, or
+      # a string for instance.
+      @definition.services.each do |service_type|
+        self.metaclass.send(:attr_accessor, service_type)
+        self.metaclass.send(:define_method, service_type) do |port|
+          raise ArgumentError, "Port number required" unless port.is_a? Integer
+          @service_ports[service_type] = port
+        end
       end
     end
-  end
 
-  def finish
-    # Ensure all services have been set
-    @definition.services.each do |svc|
-      raise ArgumentError, "Missing service #{svc}" if @service_ports[svc].nil?
+    def finish
+      # Ensure all services have been set
+      @definition.services.each do |svc|
+        raise ArgumentError, "Missing service #{svc}" if @service_ports[svc].nil?
+      end
+      # TODO: Declare these reserved names
+      super.merge({ :hostname => @hostname, :type => @type }).merge(@service_ports)
     end
-    # TODO: Declare these reserved names
-    super.merge({ :hostname => @hostname, :type => @type }).merge(@service_ports)
   end
-end
 
-# Turn a description into a useful data structure - and it's validated!
-class EnvironmentBuilder < UsesAttributes
-  def initialize(type)
-    if Hosties::EnvironmentDefinitions[type].nil? then
-      raise ArgumentError, "Unrecognized environment type"
-    end
-    @hosts = [] 
-    @type = type
-    @definition = Hosties::EnvironmentDefinitions[@type]
-    super(@definition) # Creates attribute code
-    # More magic, this time create a parameterized host builder based 
-    # on the type of hosts this environment wants. Poor man's currying
-    @definition.hosts.each do |host_type|
-      self.metaclass.send(:define_method, host_type) do |hostname, &block|
-        begin
-          builder = HostBuilder.new(host_type, hostname)
-          builder.instance_eval(&block)
-          @hosts << Hosties::EasyData.fromHost(builder.finish)
-        rescue ArgumentError => ex
-          #puts "Problem declaring host: #{ex}"
-          raise ex
+  # Turn a description into a useful data structure - and it's validated!
+  class EnvironmentBuilder < UsesAttributes
+    def initialize(type)
+      if Hosties::EnvironmentDefinitions[type].nil? then
+        raise ArgumentError, "Unrecognized environment type"
+      end
+      @hosts = [] 
+      @type = type
+      @definition = Hosties::EnvironmentDefinitions[@type]
+      super(@definition) # Creates attribute code
+      # More magic, this time create a parameterized host builder based 
+      # on the type of hosts this environment wants. Poor man's currying
+      @definition.hosts.each do |host_type|
+        self.metaclass.send(:define_method, host_type) do |hostname, &block|
+          begin
+            builder = HostBuilder.new(host_type, hostname)
+            builder.instance_eval(&block)
+            @hosts << Hosties::EasyData.fromHost(builder.finish)
+          rescue ArgumentError => ex
+            #puts "Problem declaring host: #{ex}"
+            raise ex
+          end
         end
       end
     end
-  end
 
-  def finish
-    # Verify all of the required hosts were set
-    @definition.hosts.each do |host_type| 
-      unless @hosts.detect { |host| host.type == host_type } then
-        raise ArgumentError, "Missing #{host_type} host" 
+    def finish
+      # Verify all of the required hosts were set
+      @definition.hosts.each do |host_type| 
+        unless @hosts.detect { |host| host.type == host_type } then
+          raise ArgumentError, "Missing #{host_type} host" 
+        end
       end
+      super.merge({ :type => @type, :hosts => @hosts })
     end
-    super.merge({ :hosts => @hosts })
   end
 end
 
+## Globally accessible builder methods
 def environment_for(type, &block)
   begin
-    builder = EnvironmentBuilder.new(type)
+    builder = Hosties::EnvironmentBuilder.new(type)
     builder.instance_eval(&block)
     data = builder.finish
     nice_version = Hosties::EasyData.fromEnv(data)

data/spec/definitions_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-describe HasAttributes do
+describe Hosties::HasAttributes do
   it 'rejects definitions with constraints on nonexistent attributes' do
-    instance = HasAttributes.new
+    instance = Hosties::HasAttributes.new
     instance.have_attributes :foo, :bar
     expect { instance.where(:baz).can_be("anything") }.to raise_error(ArgumentError)
   end
 end
 
-describe HostRequirement do
+describe Hosties::HostRequirement do
   it 'defines host types' do
     # Declare a host type
     host_type :logger do
@@ -16,9 +16,17 @@ describe HostRequirement do
       have_attributes :control_mbean, :default_user
     end
   end
+
+  it 'rejects definitions with reserved attribute names' do
+    builder = Hosties::HostRequirement.new(:failsauce)
+    # hostname
+    expect { builder.have_attributes(:hostname) }.to raise_error(ArgumentError)
+    # type
+    expect { builder.have_attributes(:type) }.to raise_error(ArgumentError)
+  end
 end
 
-describe EnvironmentRequirement do
+describe Hosties::EnvironmentRequirement do
   it 'defines environments with host and attribute requirements' do
     host_type :mutant_maker do end
     host_type :turkey_blaster do end
@@ -28,13 +36,32 @@ describe EnvironmentRequirement do
     end
   end
 
+  it 'rejects definitions with reserved attribute names' do
+    builder = Hosties::EnvironmentRequirement.new(:failsauce)
+    # hosts
+    expect { builder.have_attributes(:hosts) }.to raise_error(ArgumentError)
+    # type
+    expect { builder.have_attributes(:type) }.to raise_error(ArgumentError)
+  end
+
   it 'rejects environment definitions that need undefined host types' do
-    builder = EnvironmentRequirement.new(:failure)
+    builder = Hosties::EnvironmentRequirement.new(:failure)
     expect { builder.need(:nonexistent) }.to raise_error(ArgumentError)
   end
 
   it 'rejects groupings for unknown attributes' do
-    builder = EnvironmentRequirement.new(:failure)
+    builder = Hosties::EnvironmentRequirement.new(:failure)
     expect { builder.grouped_by(:nonexistent) }.to raise_error(ArgumentError)
   end
+
+  it 'can define host-inherited attributes ' do
+    builder = Hosties::EnvironmentRequirement.new(:inherit_provider)
+    builder.has_attribute :to_inherit
+    builder.hosts_inherit :to_inherit
+  end
+
+  it 'catches faulty hosts_inherit clauses' do
+    builder = Hosties::EnvironmentRequirement.new(:inherit_failure)
+    expect { builder.hosts_inherit :to_inherit }.to raise_error(ArgumentError)
+  end
 end

data/spec/easydata_spec.rb

@@ -6,7 +6,7 @@ describe Hosties::EasyData do
       have_service :http
       have_attribute :attr_one
     end
-    builder = HostBuilder.new(:easydata_one, "localhost")
+    builder = Hosties::HostBuilder.new(:easydata_one, "localhost")
     builder.http 80
     builder.attr_one "One!"
     result = Hosties::EasyData.fromHost(builder.finish)
@@ -24,7 +24,7 @@ describe Hosties::EasyData do
       have_attribute :environment
       where(:environment).can_be :dev, :testing
     end
-    builder = EnvironmentBuilder.new :easydata_one
+    builder = Hosties::EnvironmentBuilder.new :easydata_one
     builder.easydata_two "0.0.0.0" do end
     builder.easydata_three "1.1.1.1" do end
     builder.environment :dev

data/spec/hosties_spec.rb

@@ -4,7 +4,7 @@ describe Hosties do
   it 'can declare a host' do
     host_type :special_host do
     end
-    instance = HostBuilder.new(:special_host, "0.0.0.0")
+    instance = Hosties::HostBuilder.new(:special_host, "0.0.0.0")
     expect(instance.finish).to eq({ :hostname => "0.0.0.0", :type => :special_host})
   end
 
@@ -12,7 +12,7 @@ describe Hosties do
     host_type :web_host do
       have_service :http
     end
-    instance = HostBuilder.new(:web_host, "0.0.0.0")
+    instance = Hosties::HostBuilder.new(:web_host, "0.0.0.0")
     expect { instance.finish }.to raise_error(ArgumentError)
   end
 
@@ -20,7 +20,7 @@ describe Hosties do
     host_type :mud_server do
       have_attribute :version
     end
-    instance = HostBuilder.new(:mud_server, "0.0.0.0")
+    instance = Hosties::HostBuilder.new(:mud_server, "0.0.0.0")
     expect { instance.finish }.to raise_error(ArgumentError)
   end
 
@@ -28,7 +28,7 @@ describe Hosties do
     host_type :web_host do
       have_service :http
     end
-    instance = HostBuilder.new(:web_host, "0.0.0.0")
+    instance = Hosties::HostBuilder.new(:web_host, "0.0.0.0")
     expect { instance.http 10.4 }.to raise_error(ArgumentError)
   end
 
@@ -40,7 +40,7 @@ describe Hosties do
     environment_type :needy_environment do
       need :type_a, :type_b
     end
-    builder = EnvironmentBuilder.new(:needy_environment)
+    builder = Hosties::EnvironmentBuilder.new(:needy_environment)
     builder.type_a "0.0.0.0" do end
     # No type_b specified
     expect { builder.finish }.to raise_error(ArgumentError)
@@ -85,6 +85,7 @@ describe Hosties do
     expect(data.hosts_by_type(:monitoring).size).to eq(2) # Two monitoring hosts
     expect(data.hosts_by_type(:service_host).size).to eq(1)
     service_host = data.hosts_by_type(:service_host).first
+    expect(service_host.hostname).to eq("192.168.0.3")
     expect(service_host.service_port).to eq(1234)
     expect(service_host.uuid).to eq("81E3C1D4-C040-4D59-A56F-4273384D576B")
   end
@@ -111,4 +112,21 @@ describe Hosties do
     expect(Hosties::GroupedEnvironments[:foobar][:dev].size).to eq(1)
     expect(Hosties::GroupedEnvironments[:foobar][:qa].size).to eq(1)
   end
+
+  it 'lets hosts inherit attributes' do
+    host_type :beneficiary do end# ha.
+    environment_type :benefactor do
+      need :beneficiary
+      has_attribute :monies
+      hosts_inherit :monies # Lucky!
+    end
+    amount = 1000000
+    environment_for :benefactor do
+      beneficiary "0.0.0.0" do end
+      # Prove that ordering doesn't matter here
+      monies amount
+    end
+    beneficiary = Hosties::Environments[:benefactor].first.hosts.first
+    expect(beneficiary.monies).to eq(amount)
+  end
 end

data/spec/reification_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
 
-describe UsesAttributes do
+describe Hosties::UsesAttributes do
   it 'can enforce attribute constraints' do
-    definition = HasAttributes.new
+    definition = Hosties::HasAttributes.new
     definition.have_attributes(:x)
     definition.where(:x).can_be("hello")
-    instance = UsesAttributes.new(definition)
+    instance = Hosties::UsesAttributes.new(definition)
     instance.x "hello"
     expect { instance.x 31 }.to raise_error(ArgumentError)
   end
   it 'catches missing attributes' do
-    definition = HasAttributes.new
+    definition = Hosties::HasAttributes.new
     definition.have_attributes(:x)
-    instance = UsesAttributes.new(definition)
+    instance = Hosties::UsesAttributes.new(definition)
     expect { instance.finish }.to raise_error(ArgumentError)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hosties
 version: !ruby/object:Gem::Version
-  version: 1.1.0.alpha
+  version: 1.1.0.alpha2
 platform: ruby
 authors:
 - Ron Dahlgren