yeah 0.2.0 → 0.2.2

data/spec/surface_spec.rb

@@ -1,141 +0,0 @@
-require 'spec_helper'
-
-describe Surface do
-  let(:klass) { described_class }
-  let(:vector) { Vector[Random.rand(48)+2, Random.rand(48)+2] }
-  let(:instance) { klass.new(vector) }
-
-  describe '::new' do
-    subject(:method) { klass.method :new }
-
-    it { method.call.size.should eq Vector[] }
-
-    it "accepts a Vector size" do
-      surface = method.call(vector)
-      surface.size.should eq vector
-    end
-  end
-
-  describe '#size' do
-    subject { instance.size }
-
-    it { should eq vector }
-  end
-
-  describe '#size=' do
-    subject(:method) { instance.method(:size=) }
-
-    it_behaves_like 'writer', Vector[20, 20]
-  end
-
-  describe '#data' do
-    subject(:method) { instance.method(:data) }
-    let(:data) { instance.data }
-
-    it "has length of #size.x * #size.y * 4" do
-      instance.size = instance.size * 2
-      expected_length = instance.size.x * instance.size.y * 4
-      data.length.should eq expected_length
-    end
-
-    it "is a series of \x00\x00\x00\x00 by default" do
-      pixels = data.unpack('H*')[0].scan(/.{8}/)
-      pixels.uniq.size.should eq 1
-      pixels.uniq.last.should eq "00000000"
-    end
-
-    it "accepts format param" do
-      instance.data = "\x00\x11\x22\x33"
-      method.call(:rgba).should eq "\x00\x11\x22\x33"
-      method.call(:bgra).should eq "\x22\x11\x00\x33"
-    end
-  end
-
-  describe '#data=' do
-    subject(:method) { instance.method(:data=) }
-
-    it "assigns hex data of length size.x * size.y * 4" do
-      data = "\xFF" * instance.size.x * instance.size.y * 4
-      method.call(data)
-      instance.data.should eq data
-    end
-  end
-
-  describe '#color_at' do
-    subject(:method) { instance.method(:color_at) }
-
-    it { expect { method.call }.to raise_error ArgumentError }
-
-    it "matches the color of the pixel at position" do
-      method.call(vector/2).should eq Color[0, 0, 0, 0]
-    end
-  end
-
-  describe '#fill' do
-    subject(:method) { instance.method(:fill) }
-    let(:color2) { Color[0, 255, 0, 255] }
-
-    it { expect { method.call }.to raise_error ArgumentError }
-
-    it "changes color of rectangular area with position args" do
-      method.call(color2, Vector[], vector/2)
-      instance.color_at(Vector[]).should eq color2
-      instance.color_at(vector/2).should eq color2
-      instance.color_at(vector/2 + Vector[1, 0]).should eq Color[0, 0, 0, 0]
-      instance.color_at(vector/2 + Vector[0, 1]).should eq Color[0, 0, 0, 0]
-      instance.data.length.should eq instance.size.x * instance.size.y * 4
-    end
-
-    it "changes color of entire surface without position args" do
-      method.call(color2)
-      instance.color_at(Vector[]).should eq color2
-      instance.color_at(vector/2).should eq color2
-      instance.color_at(vector-1).should eq color2
-      instance.data.length.should eq instance.size.x * instance.size.y * 4
-    end
-  end
-
-  describe '#draw' do
-    subject(:method) { instance.method(:draw) }
-    let(:color) { Color[0, Random.rand(255), Random.rand(255), 255] }
-
-    it { expect { method.call }.to raise_error ArgumentError }
-
-    it "draws surface at position" do
-      surface = Surface.new(Vector[1, 1])
-      surface.fill(color)
-      surface2 = Surface.new(Vector[10, 10])
-      surface2.draw(surface, Vector[1, 1])
-
-      surface2.color_at(Vector[0, 0]).should eq Color[0, 0, 0, 0]
-      surface2.color_at(Vector[1, 1]).should eq color
-      surface2.color_at(Vector[2, 2]).should eq Color[0, 0, 0, 0]
-    end
-
-    it "draws surface at (0, 0) by default" do
-      surface = Surface.new(Vector[1, 1])
-      surface.fill(color)
-      surface2 = Surface.new(Vector[10, 10])
-      surface2.draw(surface)
-
-      surface2.color_at(Vector[0, 0]).should eq color
-      surface2.color_at(Vector[1, 1]).should eq Color[0, 0, 0, 0]
-    end
-
-    it "draws a rectangular area" do
-      surface = Surface.new(Vector[3, 3])
-      surface.fill(color)
-      surface2 = Surface.new(Vector[5, 5])
-      surface2.draw(surface, Vector[1, 1])
-
-      surface2.color_at(Vector[1, 1]).should eq color
-      surface2.color_at(Vector[1, 3]).should eq color
-      surface2.color_at(Vector[3, 1]).should eq color
-      surface2.color_at(Vector[3, 3]).should eq color
-      surface2.color_at(Vector[0, 3]).should eq Color[0, 0, 0, 0]
-      surface2.color_at(Vector[3, 0]).should eq Color[0, 0, 0, 0]
-      surface2.color_at(Vector[4, 3]).should eq Color[0, 0, 0, 0]
-      surface2.color_at(Vector[3, 4]).should eq Color[0, 0, 0, 0]
-    end
-  end
-end

data/spec/vector_spec.rb

@@ -1,197 +0,0 @@
-require 'spec_helper'
-
-describe Vector do
-  let(:klass) { described_class }
-  let(:arguments) { (1..3).map { Random.rand(100)+1 } }
-  let(:instance) { klass.new(*arguments) }
-
-  it { klass.should be_instance_of Class }
-
-  [:new, :[]].each do |method_name|
-    describe "::#{method_name}" do
-      subject(:method) { klass.method(method_name) }
-
-      it { method.call.should be_instance_of klass }
-      it { method.call.components.should eq [0, 0, 0] }
-      it { method.call(4, 5, 6).components.should eq [4, 5, 6] }
-      it { method.call(8, 9).components.should eq [8, 9, 0] }
-      it { method.call(7).components.should eq [7, 0, 0] }
-
-      it "complains with 4 arguments" do
-        expect { method.call(7, 8, 9, 10) }.
-          to raise_error ArgumentError, /too many arguments/
-      end
-    end
-  end
-
-  describe '#components' do
-    subject(:components) { instance.components }
-
-    it { should be_instance_of Array }
-    it { should have(3).elements }
-    it { components.each { |c| c.should be_kind_of Numeric } }
-  end
-
-  describe '#components=' do
-    it "assigns array of up to 3 elements and uses 0 for missing elements" do
-      instance.components = [4, 5, 6]
-      instance.components.should eq [4, 5, 6]
-
-      instance.components = [8, 9]
-      instance.components.should eq [8, 9, 0]
-
-      instance.components = []
-      instance.components.should eq [0, 0, 0]
-    end
-
-    it "complains with 4-element array" do
-      expect { instance.components = [7, 8, 9, 10] }.
-        to raise_error ArgumentError, /too many elements/
-    end
-  end
-
-  describe '#==' do
-    it { (instance == klass[*instance.components]).should eq true }
-    it { (instance == klass[*instance.components.reverse]).should eq false }
-    it { (instance == nil).should eq false }
-  end
-
-  describe '#[]' do
-    it { instance[0].should eq arguments[0] }
-    it { instance[1].should eq arguments[1] }
-    it { instance[2].should eq arguments[2] }
-  end
-
-  describe '#[]=' do
-    it "assigns n component" do
-      3.times do |i|
-        instance[i] = instance[i] + 5
-        instance[i].should eq arguments[i] + 5
-      end
-    end
-  end
-
-  describe '#+' do
-    it "adds Vector" do
-      sum = instance + instance
-      sum.components.each_with_index do |component, i|
-        component.should eq instance.components[i] * 2
-      end
-    end
-
-    it "adds Numeric" do
-      addend = Random.rand(100)
-      sum = instance + addend
-
-      sum.components.each_with_index do |component, i|
-        component.should eq instance.components[i] + addend
-      end
-    end
-  end
-
-  describe '#-' do
-    it "subtracts Vector" do
-      difference = instance - instance
-      difference.components.each do |component|
-        component.should eq 0
-      end
-
-      difference2 = difference - instance
-      difference2.components.each_with_index do |component, i|
-        component.should eq -instance.components[i]
-      end
-    end
-
-    it "subtracts Numeric" do
-      subtrahend = Random.rand(100)
-      difference = instance - subtrahend
-
-      difference.components.each_with_index do |component, i|
-        component.should eq instance.components[i] - subtrahend
-      end
-    end
-  end
-
-  describe '#*' do
-    it "multiplies by Vector" do
-      product = instance * instance
-      product.components.each_with_index do |component, i|
-        component.should eq instance.components[i] ** 2
-      end
-    end
-
-    it "multiplies by Numeric" do
-      multiple = Random.rand(100)
-      product = instance * multiple
-
-      product.components.each_with_index do |component, i|
-        component.should eq instance.components[i] * multiple
-      end
-    end
-  end
-
-  describe '#/' do
-    it "divides by Vector" do
-      quotient = instance / instance
-      quotient.components.each do |component|
-        component.should eq 1
-      end
-
-      quotient2 = instance / quotient
-      quotient2.components.each_with_index do |component, i|
-        component.should eq instance.components[i]
-      end
-    end
-
-    it "divides by Numeric" do
-      divisor = Random.rand(100) + 1
-      quotient = instance / divisor
-
-      quotient.components.each_with_index do |component, i|
-        component.should eq instance.components[i] / divisor
-      end
-    end
-  end
-
-  [
-    [:x, :width],
-    [:y, :height],
-    [:z, :depth]
-  ].each_with_index do |method_name_set, i|
-    method_name_set.each do |method_name|
-      describe "##{method_name}" do
-        subject(:method) { instance.method(method_name) }
-
-        it { method.call.should eq instance[i] }
-      end
-
-      describe "#{method_name}=" do
-        subject(:method) { instance.method("#{method_name}=") }
-
-        it "assigns value" do
-          value = Random.rand(100)
-          method.call(value)
-          instance[i].should eq value
-        end
-      end
-    end
-  end
-
-  [:norm, :magnitude, :length, :distance, :speed].each do |method_name|
-    describe "##{method_name}" do
-      it { klass.new(3, 4).method(method_name).call.should eq 5 }
-      it { klass.new(6, 8).method(method_name).call.should eq 10 }
-    end
-  end
-
-  describe '#reset' do
-    it "sets components to 0" do
-      instance.reset
-      instance.components.should eq [0, 0, 0]
-    end
-
-    it "returns itself" do
-      instance.reset.should eq instance
-    end
-  end
-end

data/spec/yeah_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Yeah do
-  let(:modjul) { described_class }
-
-  it { modjul.should be_instance_of Module }
-
-  describe '::VERSION' do
-    subject { modjul::VERSION }
-
-    it { should be_instance_of String }
-    it { should match /[0-9]+\.[0-9]+\.[0-9]+/ }
-  end
-end

data/tmp/rspec_guard_result

@@ -1 +0,0 @@
-

data/yeah.gemspec

@@ -1,18 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
-
-require 'yeah'
-
-Gem::Specification.new do |s|
-  s.name = 'yeah'
-  s.version = Yeah::VERSION
-  s.summary = "The positive video game framework"
-  s.description = "Programming video games should have a positive impact on your health!"
-  s.authors = ["Artur Ostrega"]
-  s.email = 'skoofoo@gmail.com'
-  s.files = Dir.glob('**/*')
-  s.license = 'MIT'
-  s.homepage = 'https://github.com/skofo/yeah'
-end