cauterize 0.0.1.pre13 → 0.0.1.pre14

data/spec/enumeration_spec.rb

@@ -1,145 +1,145 @@
-module Cauterize
-  describe Cauterize::EnumerationValue do
-    describe :initialize do
-      it "creates an EnumerationValue" do
-        e = Cauterize::EnumerationValue.new(:foo, 1)
-        e.name.should == :foo
-        e.value.should == 1
-      end
-    end
-  end
-
-  describe Cauterize::Enumeration do
-    describe :initialize do
-      it "creates a new enumeration with the right name" do
-        Cauterize::Enumeration.new(:foo).name.should == :foo
-      end
-    end
-
-    it { can_be_documented(Cauterize::Enumeration) }
-
-    describe :value do
-      it "adds a new value to the enumeration" do
-        enum = Cauterize.enumeration(:foo) do |e|
-          e.value :a
-          e.value :b
-          e.value :c
-          e.value :d
-        end
-
-        values = enum.values
-        values.length.should == 4
-        values.keys.should == [:a, :b, :c, :d]
-        values.values.map(&:value).should == [0, 1, 2, 3]
-      end
-
-      it "accepts a fixed value" do
-        enum = Cauterize.enumeration(:foo) do |e|
-          e.value :a, 10
-          e.value :b, 20
-          e.value :c
-        end
-
-        values = enum.values
-        values.keys.should == [:a, :b, :c]
-        values.values.map(&:value).should == [10, 20, 21]
-      end
-
-      it "allows out-of-order values" do
-        lambda {
-          Cauterize.enumeration(:foo) do |e|
-            e.value :a, 10
-            e.value :b, 9
-          end
-        }.should_not raise_error
-      end
-
-      it "doesn't allow duplicate ids" do
-        lambda {
-          Cauterize.enumeration(:foo) do |e|
-            e.value :a, 1
-            e.value :b, 1
-          end
-        }.should raise_error /duplicate constant/
-      end
-
-      it "doesn't allow accidentally identical ids" do
-        en = Cauterize.enumeration(:foo) do |e|
-          e.value :a, 10
-          e.value :b, 9
-          e.value :c
-        end
-
-        en.values.values.map(&:value).should == [10,9,11]
-      end
-
-      it "errors on duplicate names" do
-        lambda {
-          Cauterize.enumeration(:foo) do |e|
-            e.value :a
-            e.value :a
-          end
-        }.should raise_error /duplicate name/
-      end
-    end
-
-    describe :representation do
-      it "chooses int8 when appropriate" do
-        Cauterize.enumeration(:a) do |t|
-          t.value :a, -128
-        end.representation.name.should == :int8
-        Cauterize.enumeration(:b) do |t|
-          t.value :a, 127
-        end.representation.name.should == :int8
-      end
-
-      it "chooses int16 when appropriate" do
-        Cauterize.enumeration(:a) do |t|
-          t.value :a, -32768
-        end.representation.name.should == :int16
-        Cauterize.enumeration(:b) do |t|
-          t.value :a, 32767
-        end.representation.name.should == :int16
-        Cauterize.enumeration(:c) do |t|
-          t.value :a, 300
-        end.representation.name.should == :int16
-      end
-
-      it "chooses int32 when appropriate" do
-        Cauterize.enumeration(:a) do |t|
-          t.value :a, -2147483648
-        end.representation.name.should == :int32
-        Cauterize.enumeration(:b) do |t|
-          t.value :a, 2147483647
-        end.representation.name.should == :int32
-      end
-
-      it "chooses int64 when appropriate" do
-        Cauterize.enumeration(:a) do |t|
-          t.value :a, -9223372036854775808
-        end.representation.name.should == :int64
-        Cauterize.enumeration(:b) do |t|
-          t.value :a, 9223372036854775807
-        end.representation.name.should == :int64
-      end
-    end
-  end
-
-  describe :enumeration do
-    it { creates_a_named_object(:enumeration, Enumeration) }
-    it { retrieves_obj_with_identical_name(:enumeration) }
-    it { yields_the_object(:enumeration) }
-    it { adds_object_to_hash(:enumeration, Cauterize.enumerations) }
-  end
-
-  describe :enumeration! do
-    it { creates_a_named_object(:enumeration!, Enumeration) }
-    it { raises_exception_with_identical_name(:enumeration!) }
-    it { yields_the_object(:enumeration!) }
-    it { adds_object_to_hash(:enumeration!, Cauterize.enumerations) }
-  end
-
-  describe :enumerations do
-    it { is_hash_of_created_objs(:enumeration, Cauterize.enumerations) }
-  end
-end
+module Cauterize
+  describe Cauterize::EnumerationValue do
+    describe :initialize do
+      it "creates an EnumerationValue" do
+        e = Cauterize::EnumerationValue.new(:foo, 1)
+        e.name.should == :foo
+        e.value.should == 1
+      end
+    end
+  end
+
+  describe Cauterize::Enumeration do
+    describe :initialize do
+      it "creates a new enumeration with the right name" do
+        Cauterize::Enumeration.new(:foo).name.should == :foo
+      end
+    end
+
+    it { can_be_documented(Cauterize::Enumeration) }
+
+    describe :value do
+      it "adds a new value to the enumeration" do
+        enum = Cauterize.enumeration(:foo) do |e|
+          e.value :a
+          e.value :b
+          e.value :c
+          e.value :d
+        end
+
+        values = enum.values
+        values.length.should == 4
+        values.keys.should == [:a, :b, :c, :d]
+        values.values.map(&:value).should == [0, 1, 2, 3]
+      end
+
+      it "accepts a fixed value" do
+        enum = Cauterize.enumeration(:foo) do |e|
+          e.value :a, 10
+          e.value :b, 20
+          e.value :c
+        end
+
+        values = enum.values
+        values.keys.should == [:a, :b, :c]
+        values.values.map(&:value).should == [10, 20, 21]
+      end
+
+      it "allows out-of-order values" do
+        lambda {
+          Cauterize.enumeration(:foo) do |e|
+            e.value :a, 10
+            e.value :b, 9
+          end
+        }.should_not raise_error
+      end
+
+      it "doesn't allow duplicate ids" do
+        lambda {
+          Cauterize.enumeration(:foo) do |e|
+            e.value :a, 1
+            e.value :b, 1
+          end
+        }.should raise_error /duplicate constant/
+      end
+
+      it "doesn't allow accidentally identical ids" do
+        en = Cauterize.enumeration(:foo) do |e|
+          e.value :a, 10
+          e.value :b, 9
+          e.value :c
+        end
+
+        en.values.values.map(&:value).should == [10,9,11]
+      end
+
+      it "errors on duplicate names" do
+        lambda {
+          Cauterize.enumeration(:foo) do |e|
+            e.value :a
+            e.value :a
+          end
+        }.should raise_error /duplicate name/
+      end
+    end
+
+    describe :representation do
+      it "chooses int8 when appropriate" do
+        Cauterize.enumeration(:a) do |t|
+          t.value :a, -128
+        end.representation.name.should == :int8
+        Cauterize.enumeration(:b) do |t|
+          t.value :a, 127
+        end.representation.name.should == :int8
+      end
+
+      it "chooses int16 when appropriate" do
+        Cauterize.enumeration(:a) do |t|
+          t.value :a, -32768
+        end.representation.name.should == :int16
+        Cauterize.enumeration(:b) do |t|
+          t.value :a, 32767
+        end.representation.name.should == :int16
+        Cauterize.enumeration(:c) do |t|
+          t.value :a, 300
+        end.representation.name.should == :int16
+      end
+
+      it "chooses int32 when appropriate" do
+        Cauterize.enumeration(:a) do |t|
+          t.value :a, -2147483648
+        end.representation.name.should == :int32
+        Cauterize.enumeration(:b) do |t|
+          t.value :a, 2147483647
+        end.representation.name.should == :int32
+      end
+
+      it "chooses int64 when appropriate" do
+        Cauterize.enumeration(:a) do |t|
+          t.value :a, -9223372036854775808
+        end.representation.name.should == :int64
+        Cauterize.enumeration(:b) do |t|
+          t.value :a, 9223372036854775807
+        end.representation.name.should == :int64
+      end
+    end
+  end
+
+  describe :enumeration do
+    it { creates_a_named_object(:enumeration, Enumeration) }
+    it { retrieves_obj_with_identical_name(:enumeration) }
+    it { yields_the_object(:enumeration) }
+    it { adds_object_to_hash(:enumeration, Cauterize.enumerations) }
+  end
+
+  describe :enumeration! do
+    it { creates_a_named_object(:enumeration!, Enumeration) }
+    it { raises_exception_with_identical_name(:enumeration!) }
+    it { yields_the_object(:enumeration!) }
+    it { adds_object_to_hash(:enumeration!, Cauterize.enumerations) }
+  end
+
+  describe :enumerations do
+    it { is_hash_of_created_objs(:enumeration, Cauterize.enumerations) }
+  end
+end

data/spec/fixed_array_spec.rb

@@ -1,61 +1,61 @@
-module Cauterize
-  describe :fixed_array  do
-    it { creates_a_named_object(:fixed_array, FixedArray) }
-    it { retrieves_obj_with_identical_name(:fixed_array) }
-    it { yields_the_object(:fixed_array) }
-    it { adds_object_to_hash(:fixed_array, Cauterize.fixed_arrays) }
-  end
-
-  describe :fixed_array! do
-    it { creates_a_named_object(:fixed_array!, FixedArray) }
-    it { raises_exception_with_identical_name(:variable_array!) }
-    it { yields_the_object(:fixed_array!) }
-    it { adds_object_to_hash(:fixed_array!, Cauterize.fixed_arrays) }
-  end
-
-  describe FixedArray do
-    before { @a = Cauterize.fixed_array(:foo) }
-
-    describe :initialize do
-      it "Creates a fixed array." do
-        @a.name.should == :foo
-      end
-    end
-
-    it { can_be_documented(Cauterize::FixedArray) }
-
-    describe :array_type do
-      it "Defines the type of the FixedArray." do
-        Cauterize.scalar(:uint32_t)
-        @a.array_type :uint32_t
-        @a.instance_variable_get(:@array_type).name.should == :uint32_t
-      end
-
-      it "raises an error if type doesn't exist" do
-        lambda {
-          Cauterize.fixed_array(:fa) do |f|
-            f.array_type :lol
-          end
-        }.should raise_error /lol does not correspond/
-      end
-
-      it "is the defined type if no argument is passed" do
-        s = Cauterize.scalar(:uint32_t)
-        @a.array_type :uint32_t
-        @a.array_type.should be s
-      end
-    end
-
-    describe :array_size do
-      it "Defines the size of the FixedArray." do
-        @a.array_size 46
-        @a.instance_variable_get(:@array_size).should == 46
-      end
-
-      it "is the defined size if no argument is passed" do
-        @a.array_size 46
-        @a.array_size.should == 46
-      end
-    end
-  end
-end
+module Cauterize
+  describe :fixed_array  do
+    it { creates_a_named_object(:fixed_array, FixedArray) }
+    it { retrieves_obj_with_identical_name(:fixed_array) }
+    it { yields_the_object(:fixed_array) }
+    it { adds_object_to_hash(:fixed_array, Cauterize.fixed_arrays) }
+  end
+
+  describe :fixed_array! do
+    it { creates_a_named_object(:fixed_array!, FixedArray) }
+    it { raises_exception_with_identical_name(:variable_array!) }
+    it { yields_the_object(:fixed_array!) }
+    it { adds_object_to_hash(:fixed_array!, Cauterize.fixed_arrays) }
+  end
+
+  describe FixedArray do
+    before { @a = Cauterize.fixed_array(:foo) }
+
+    describe :initialize do
+      it "Creates a fixed array." do
+        @a.name.should == :foo
+      end
+    end
+
+    it { can_be_documented(Cauterize::FixedArray) }
+
+    describe :array_type do
+      it "Defines the type of the FixedArray." do
+        Cauterize.scalar(:uint32_t)
+        @a.array_type :uint32_t
+        @a.instance_variable_get(:@array_type).name.should == :uint32_t
+      end
+
+      it "raises an error if type doesn't exist" do
+        lambda {
+          Cauterize.fixed_array(:fa) do |f|
+            f.array_type :lol
+          end
+        }.should raise_error /lol does not correspond/
+      end
+
+      it "is the defined type if no argument is passed" do
+        s = Cauterize.scalar(:uint32_t)
+        @a.array_type :uint32_t
+        @a.array_type.should be s
+      end
+    end
+
+    describe :array_size do
+      it "Defines the size of the FixedArray." do
+        @a.array_size 46
+        @a.instance_variable_get(:@array_size).should == 46
+      end
+
+      it "is the defined size if no argument is passed" do
+        @a.array_size 46
+        @a.array_size.should == 46
+      end
+    end
+  end
+end

data/spec/group_spec.rb

@@ -1,111 +1,111 @@
-module Cauterize
-  describe Cauterize do
-    describe :group do
-      it { creates_a_named_object(:group, Group) }
-      it { retrieves_obj_with_identical_name(:group) }
-      it { yields_the_object(:group) }
-      it { adds_object_to_hash(:group, Cauterize.groups) }
-    end
-
-    describe :group! do
-      it { creates_a_named_object(:group!, Group) }
-      it { raises_exception_with_identical_name(:group!) }
-      it { yields_the_object(:group!) }
-      it { adds_object_to_hash(:group!, Cauterize.groups) }
-    end
-
-    describe :groups do
-      it { is_hash_of_created_objs(:group, Cauterize.groups) }
-    end
-
-    describe GroupField do
-      describe :initialize do
-        it "creats a GroupField" do
-          t = Cauterize.scalar(:type)
-          f = GroupField.new(:name, :type)
-          f.name.should == :name
-          f.type.should be t
-        end
-      end
-    end
-
-    describe Group do
-      describe :initialize do
-        it "makes a new Group" do
-          Group.new(:foo).name == :foo
-        end
-
-        it "creates the tag enum" do
-          e = Group.new(:foo).tag_enum
-          e.name.should == :group_foo_type
-          e.values == {}
-        end
-      end
-
-      it { can_be_documented(Cauterize::Group) }
-
-      describe :field do
-        it "adds a field to the Group" do
-          a = Cauterize.scalar(:aaa)
-          b = Cauterize.scalar(:bbb)
-          grp = Cauterize.group(:foo) do |g|
-            g.field(:a, :aaa)
-            g.field(:b, :bbb)
-          end
-
-          grp.fields.values.map(&:name).should == [:a, :b]
-        end
-
-        it "errors on duplicate field names" do
-          a = Cauterize.scalar(:aaa)
-          lambda {
-            grp = Cauterize.group(:foo) do |g|
-              g.field(:a, :aaa)
-              g.field(:a, :aaa)
-            end
-          }.should raise_error /Field name a already used/
-        end
-
-        it "errors on non-existant types" do
-          lambda {
-            grp = Cauterize.group(:foo) do |g|
-              g.field(:a, :aaa)
-            end
-          }.should raise_error /name aaa does not correspond to a type/
-        end
-
-        it "adds a new value to the enum for each field" do
-          a = Cauterize.scalar(:aaa)
-          b = Cauterize.scalar(:bbb)
-          grp = Cauterize.group(:foo) do |g|
-            g.field(:a, :aaa)
-            g.field(:b, :bbb)
-          end
-
-          grp.tag_enum.values.keys.should =~ [:GROUP_FOO_TYPE_A, :GROUP_FOO_TYPE_B]
-        end
-
-        it "allows nil types" do
-          grp = Cauterize.group(:empty) do |g|
-            g.dataless(:a)
-            g.dataless(:b)
-          end
-
-          grp.tag_enum.values.keys.should =~ [:GROUP_EMPTY_TYPE_A, :GROUP_EMPTY_TYPE_B]
-        end
-      end
-
-      describe ".tag_enum" do
-        it "is the enumeration used for the type tag" do
-          Group.new(:foo).tag_enum.class.should be Cauterize::Enumeration
-        end
-      end
-
-      describe "enum_sym" do
-        it "returns the enumeration symbol for a field name" do
-          Cauterize.group(:foo).enum_sym(:a_field).should == :GROUP_FOO_TYPE_A_FIELD
-        end
-      end
-    end
-  end
-end
+module Cauterize
+  describe Cauterize do
+    describe :group do
+      it { creates_a_named_object(:group, Group) }
+      it { retrieves_obj_with_identical_name(:group) }
+      it { yields_the_object(:group) }
+      it { adds_object_to_hash(:group, Cauterize.groups) }
+    end
+
+    describe :group! do
+      it { creates_a_named_object(:group!, Group) }
+      it { raises_exception_with_identical_name(:group!) }
+      it { yields_the_object(:group!) }
+      it { adds_object_to_hash(:group!, Cauterize.groups) }
+    end
+
+    describe :groups do
+      it { is_hash_of_created_objs(:group, Cauterize.groups) }
+    end
+
+    describe GroupField do
+      describe :initialize do
+        it "creats a GroupField" do
+          t = Cauterize.scalar(:type)
+          f = GroupField.new(:name, :type)
+          f.name.should == :name
+          f.type.should be t
+        end
+      end
+    end
+
+    describe Group do
+      describe :initialize do
+        it "makes a new Group" do
+          Group.new(:foo).name == :foo
+        end
+
+        it "creates the tag enum" do
+          e = Group.new(:foo).tag_enum
+          e.name.should == :group_foo_type
+          e.values == {}
+        end
+      end
+
+      it { can_be_documented(Cauterize::Group) }
+
+      describe :field do
+        it "adds a field to the Group" do
+          a = Cauterize.scalar(:aaa)
+          b = Cauterize.scalar(:bbb)
+          grp = Cauterize.group(:foo) do |g|
+            g.field(:a, :aaa)
+            g.field(:b, :bbb)
+          end
+
+          grp.fields.values.map(&:name).should == [:a, :b]
+        end
+
+        it "errors on duplicate field names" do
+          a = Cauterize.scalar(:aaa)
+          lambda {
+            grp = Cauterize.group(:foo) do |g|
+              g.field(:a, :aaa)
+              g.field(:a, :aaa)
+            end
+          }.should raise_error /Field name a already used/
+        end
+
+        it "errors on non-existant types" do
+          lambda {
+            grp = Cauterize.group(:foo) do |g|
+              g.field(:a, :aaa)
+            end
+          }.should raise_error /name aaa does not correspond to a type/
+        end
+
+        it "adds a new value to the enum for each field" do
+          a = Cauterize.scalar(:aaa)
+          b = Cauterize.scalar(:bbb)
+          grp = Cauterize.group(:foo) do |g|
+            g.field(:a, :aaa)
+            g.field(:b, :bbb)
+          end
+
+          grp.tag_enum.values.keys.should =~ [:GROUP_FOO_TYPE_A, :GROUP_FOO_TYPE_B]
+        end
+
+        it "allows nil types" do
+          grp = Cauterize.group(:empty) do |g|
+            g.dataless(:a)
+            g.dataless(:b)
+          end
+
+          grp.tag_enum.values.keys.should =~ [:GROUP_EMPTY_TYPE_A, :GROUP_EMPTY_TYPE_B]
+        end
+      end
+
+      describe ".tag_enum" do
+        it "is the enumeration used for the type tag" do
+          Group.new(:foo).tag_enum.class.should be Cauterize::Enumeration
+        end
+      end
+
+      describe "enum_sym" do
+        it "returns the enumeration symbol for a field name" do
+          Cauterize.group(:foo).enum_sym(:a_field).should == :GROUP_FOO_TYPE_A_FIELD
+        end
+      end
+    end
+  end
+end