chione 0.0.2

data/spec/chione/aspect_spec.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'chione/aspect'
+require 'chione/component'
+
+
+describe Chione::Aspect do
+
+	let( :location ) do
+		Class.new( Chione::Component ) do
+			field :x, default: 0
+			field :y, default: 0
+		end
+	end
+
+	let( :tags ) do
+		Class.new( Chione::Component ) do
+			field :tags, default: []
+		end
+	end
+
+	let( :color ) do
+		Class.new( Chione::Component ) do
+			field :hue, default: 0
+			field :shade, default: 0
+			field :value, default: 0
+			field :opacity, default: 0
+		end
+	end
+
+
+	it "doesn't have any default criteria" do
+		aspect = described_class.new
+		expect( aspect.one_of ).to be_empty
+		expect( aspect.all_of ).to be_empty
+		expect( aspect.none_of ).to be_empty
+		expect( aspect ).to be_empty
+	end
+
+
+	it "can be created with default criteria" do
+		aspect = described_class.with_all_of( tags, location )
+		expect( aspect.one_of ).to be_empty
+		expect( aspect.all_of.size ).to eq( 2 )
+		expect( aspect.all_of ).to include( tags, location )
+		expect( aspect.none_of ).to be_empty
+	end
+
+
+	it "can make a clone of itself with additional one_of criteria" do
+		aspect = described_class.new
+		clone = aspect.with_one_of( location, tags )
+		expect( clone ).to_not be( aspect )
+		expect( clone.one_of ).to include( location, tags )
+		expect( aspect.one_of ).to be_empty
+	end
+
+
+	it "can make a clone of itself with additional none_of criteria" do
+		aspect = described_class.with_none_of( location )
+		clone = aspect.with_none_of( tags )
+		expect( clone ).to_not be( aspect )
+		expect( clone.none_of ).to include( location, tags )
+		expect( aspect.none_of.size ).to eq( 1 )
+		expect( aspect.none_of ).to include( location )
+	end
+
+
+	it "can make a clone of itself with additional all_of criteria" do
+		aspect = described_class.with_all_of( color, location )
+		clone = aspect.with_all_of( tags )
+		expect( clone ).to_not be( aspect )
+		expect( clone.all_of.size ).to eq( 3 )
+		expect( clone.all_of ).to include( location, tags, color )
+		expect( aspect.all_of.size ).to eq( 2 )
+		expect( aspect.all_of ).to include( location, color )
+	end
+
+
+	it "supports a fluent interface" do
+		aspect = described_class.with_all_of( tags, location ).and_none_of( color )
+		expect( aspect.one_of ).to be_empty
+		expect( aspect.all_of.size ).to eq( 2 )
+		expect( aspect.all_of ).to include( tags, location )
+		expect( aspect.none_of.size ).to eq( 1 )
+		expect( aspect.none_of ).to include( color )
+	end
+
+
+	it "flattens Arrays passed to ::with_all_of" do
+		aspect = described_class.with_all_of([ tags, location ])
+
+		expect( aspect.all_of.size ).to eq( 2 )
+		expect( aspect.all_of ).to include( tags, location )
+	end
+
+
+	it "flattens Arrays passed to #with_all_of" do
+		aspect = described_class.new
+		aspect = aspect.with_all_of([ tags, location ])
+
+		expect( aspect.all_of.size ).to eq( 2 )
+		expect( aspect.all_of ).to include( tags, location )
+	end
+
+
+	it "flattens Arrays passed to ::with_one_of" do
+		aspect = described_class.with_one_of([ tags, location ])
+
+		expect( aspect.one_of.size ).to eq( 2 )
+		expect( aspect.one_of ).to include( tags, location )
+	end
+
+
+	it "flattens Arrays passed to #with_one_of" do
+		aspect = described_class.new
+		aspect = aspect.with_one_of([ tags, location ])
+
+		expect( aspect.one_of.size ).to eq( 2 )
+		expect( aspect.one_of ).to include( tags, location )
+	end
+
+
+	it "flattens Arrays passed to ::with_none_of" do
+		aspect = described_class.with_none_of([ tags, location ])
+
+		expect( aspect.none_of.size ).to eq( 2 )
+		expect( aspect.none_of ).to include( tags, location )
+	end
+
+
+	it "flattens Arrays passed to #with_none_of" do
+		aspect = described_class.new
+		aspect = aspect.with_none_of([ tags, location ])
+
+		expect( aspect.none_of.size ).to eq( 2 )
+		expect( aspect.none_of ).to include( tags, location )
+	end
+
+end
+

data/spec/chione/assemblage_spec.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'chione/assemblage'
+require 'chione/component'
+require 'chione/entity'
+require 'chione/world'
+
+describe Chione::Assemblage do
+
+	let( :world ) { Chione::World.new }
+
+	let( :location_component ) do
+		Class.new( Chione::Component ) do
+			field :x, default: 0
+			field :y, default: 0
+		end
+	end
+
+	let( :tags_component ) do
+		Class.new( Chione::Component ) do
+			field :tags, default: []
+		end
+	end
+
+
+	it "acts as a factory for entities with pre-set components" do
+		assemblage = Module.new
+		assemblage.extend( described_class )
+		assemblage.add( location_component, x: 10, y: 8 )
+		assemblage.add( tags_component, tags: [:foo, :bar] )
+
+		entity = assemblage.construct_for( world )
+
+		expect( entity ).to be_a( Chione::Entity )
+		expect( entity.world ).to be( world )
+		expect( entity.components ).to include( location_component, tags_component )
+	end
+
+
+	it "can include other assemblages" do
+		general_assemblage = Module.new
+		general_assemblage.extend( described_class )
+		general_assemblage.add( location_component, x: 10, y: 8 )
+
+		specific_assemblage = Module.new
+		specific_assemblage.extend( described_class )
+		specific_assemblage.send( :include, general_assemblage )
+		specific_assemblage.add( tags_component, tags: [:foo, :bar] )
+
+		entity = specific_assemblage.construct_for( world )
+
+		expect( entity ).to be_a( Chione::Entity )
+		expect( entity.world ).to be( world )
+		expect( entity.components ).to include( location_component, tags_component )
+	end
+
+end
+

data/spec/chione/component_spec.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'chione/component'
+
+
+describe Chione::Component do
+
+	describe "concrete subclasses" do
+
+		let( :component_subclass ) do
+			Class.new( described_class )
+		end
+
+
+		it "can declare fields" do
+			component_subclass.field( :x )
+			component_subclass.field( :y )
+
+			instance = component_subclass.new
+			expect( instance ).to respond_to( :x )
+			expect( instance ).to respond_to( :y )
+
+			expect( instance.x ).to be_nil
+			expect( instance.y ).to be_nil
+		end
+
+
+		it "can declare fields with default values" do
+			component_subclass.field( :x, default: 0 )
+			component_subclass.field( :y, default: 18 )
+
+			instance = component_subclass.new
+			expect( instance.x ).to eq( 0 )
+			expect( instance.y ).to eq( 18 )
+		end
+
+
+		it "uses a dup of the default if it's not an immediate object" do
+			component_subclass.field( :things, default: [] )
+
+			instance1 = component_subclass.new
+			instance2 = component_subclass.new
+
+			instance1.things << "a thing"
+
+			expect( instance2.things ).to be_empty
+		end
+
+	end
+
+end
+

data/spec/chione/entity_spec.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'chione/entity'
+require 'chione/component'
+
+
+describe Chione::Entity do
+
+	let( :world ) { Chione::World.new }
+
+	let( :location_component ) do
+		Class.new( Chione::Component ) do
+			field :x, default: 0
+			field :y, default: 0
+		end
+	end
+
+	let( :tags_component ) do
+		Class.new( Chione::Component ) do
+			field :tags, default: []
+		end
+	end
+
+	let( :bounding_box_component ) do
+		Class.new( Chione::Component ) do
+			field :width, default: 1
+			field :height, default: 1
+			field :depth, default: 1
+		end
+	end
+
+
+	it "knows what world it was created for" do
+		expect( Chione::Entity.new(world).world ).to be( world )
+	end
+
+
+	it "uses the ID it's given in creation" do
+		entity = Chione::Entity.new( world, 'some-other-id' )
+		expect( entity.id ).to eq( 'some-other-id' )
+	end
+
+
+	it "generates an ID for itself if it isn't given one" do
+		entity = Chione::Entity.new( world )
+		expect( entity.id ).to be_a( String )
+		expect( entity.id.length ).to be >= 8
+
+		expect( Chione::Entity.new(world).id ).to_not eq( entity.id )
+	end
+
+
+	describe "concrete instance" do
+
+		let( :entity ) { Chione::Entity.new(world) }
+
+
+		it "can have components added to it" do
+			entity.add_component( location_component.new )
+			entity.add_component( tags_component.new )
+
+			expect( entity ).to have_component( location_component )
+			expect( entity ).to have_component( tags_component )
+		end
+
+
+		it "lets components be fetched from it" do
+			entity.add_component( location_component.new )
+			entity.add_component( tags_component.new )
+
+			expect(
+				entity.get_component( location_component )
+			).to eq( entity.components[location_component] )
+		end
+
+
+		it "lets one of a list of components be fetched from it" do
+			entity.add_component( location_component.new )
+			entity.add_component( tags_component.new )
+
+			expect(
+				entity.get_component( bounding_box_component, location_component )
+			).to eq( entity.components[location_component] )
+		end
+
+
+		it "raises a KeyError if it doesn't have a fetched component" do
+			entity.add_component( tags_component.new )
+
+			expect {
+				entity.get_component( location_component )
+			}.to raise_error( KeyError, /#{entity.id} doesn't have/i )
+		end
+
+
+		it "raises a KeyError if it doesn't have any of several fetched components" do
+			entity.add_component( tags_component.new )
+
+			expect {
+				entity.get_component( location_component, bounding_box_component )
+			}.to raise_error( KeyError, /#{entity.id} doesn't have any of/i )
+		end
+
+	end
+
+end
+

data/spec/chione/manager_spec.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'chione/manager'
+require 'chione/world'
+
+
+describe Chione::Manager do
+
+	let( :world ) { Chione::World.new }
+
+
+	describe "concrete derivatives" do
+
+		let( :manager_class ) do
+			Class.new( described_class )
+		end
+
+		let( :manager ) { manager_class.new(world) }
+
+
+		it "are required to implement #start" do
+			expect {
+				manager.start
+			}.to raise_error( NotImplementedError, /does not implement/i )
+		end
+
+
+		it "are required to implement #stop" do
+			expect {
+				manager.stop
+			}.to raise_error( NotImplementedError, /does not implement/i )
+		end
+
+	end
+
+end
+

data/spec/chione/mixins_spec.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'chione/mixins'
+
+
+describe Chione, "mixins" do
+
+	describe Chione::MethodUtilities, 'used to extend a class' do
+
+		let!( :extended_class ) do
+			klass = Class.new
+			klass.extend( Chione::MethodUtilities )
+			klass
+		end
+
+		it "can declare a class-level attribute reader" do
+			extended_class.singleton_attr_reader :foo
+			expect( extended_class ).to respond_to( :foo )
+			expect( extended_class ).to_not respond_to( :foo= )
+			expect( extended_class ).to_not respond_to( :foo? )
+		end
+
+		it "can declare a class-level attribute writer" do
+			extended_class.singleton_attr_writer :foo
+			expect( extended_class ).to_not respond_to( :foo )
+			expect( extended_class ).to respond_to( :foo= )
+			expect( extended_class ).to_not respond_to( :foo? )
+		end
+
+		it "can declare a class-level attribute reader and writer" do
+			extended_class.singleton_attr_accessor :foo
+			expect( extended_class ).to respond_to( :foo )
+			expect( extended_class ).to respond_to( :foo= )
+			expect( extended_class ).to_not respond_to( :foo? )
+		end
+
+		it "can declare a class-level alias" do
+			def extended_class.foo
+				return "foo"
+			end
+			extended_class.singleton_method_alias( :bar, :foo )
+
+			expect( extended_class.bar ).to eq( 'foo' )
+		end
+
+		it "can declare an instance attribute predicate method" do
+			extended_class.attr_predicate :foo
+			instance = extended_class.new
+
+			expect( instance ).to_not respond_to( :foo )
+			expect( instance ).to_not respond_to( :foo= )
+			expect( instance ).to respond_to( :foo? )
+
+			expect( instance.foo? ).to be_falsey
+
+			instance.instance_variable_set( :@foo, 1 )
+			expect( instance.foo? ).to be_truthy
+		end
+
+		it "can declare an instance attribute predicate and writer" do
+			extended_class.attr_predicate_accessor :foo
+			instance = extended_class.new
+
+			expect( instance ).to_not respond_to( :foo )
+			expect( instance ).to respond_to( :foo= )
+			expect( instance ).to respond_to( :foo? )
+
+			expect( instance.foo? ).to be_falsey
+
+			instance.foo = 1
+			expect( instance.foo? ).to be_truthy
+		end
+
+		it "can declare a class-level attribute predicate and writer" do
+			extended_class.singleton_predicate_accessor :foo
+			expect( extended_class ).to_not respond_to( :foo )
+			expect( extended_class ).to respond_to( :foo= )
+			expect( extended_class ).to respond_to( :foo? )
+		end
+
+		it "can declare a class-level predicate method" do
+			extended_class.singleton_predicate_reader :foo
+			expect( extended_class ).to_not respond_to( :foo )
+			expect( extended_class ).to_not respond_to( :foo= )
+			expect( extended_class ).to respond_to( :foo? )
+		end
+
+	end
+
+
+end
+