cauterize 0.0.1.pre13 → 0.0.1.pre14

data/spec/scalar_spec.rb

@@ -1,44 +1,44 @@
-module Cauterize
-  describe Scalar do
-    describe :initialize do
-      it "creates an scalar" do
-        Cauterize.scalar(:foo).name.should == :foo
-      end
-    end
-
-    it { can_be_documented(Cauterize::Scalar) }
-
-    describe :type_name do
-      it "specifies the builtin type to alias" do
-        s = Cauterize.scalar(:foo) do |t|
-          t.type_name(:int8)
-        end
-      end
-
-      it "raises an exception when a non-builtin is specified" do
-        dummy = Cauterize.scalar(:dummy)
-        s = Cauterize.scalar(:foo) do |t|
-          t.type_name(:int32)
-        end
-      end
-    end
-  end
-
-  describe :scalar do
-    it { creates_a_named_object(:scalar, Scalar) }
-    it { retrieves_obj_with_identical_name(:scalar) }
-    it { yields_the_object(:scalar) }
-    it { adds_object_to_hash(:scalar, Cauterize.scalars) }
-  end
-
-  describe :scalar! do
-    it { creates_a_named_object(:scalar!, Scalar) }
-    it { raises_exception_with_identical_name(:scalar!) }
-    it { yields_the_object(:scalar!) }
-    it { adds_object_to_hash(:scalar!, Cauterize.scalars) }
-  end
-
-  describe :scalars do
-    it { is_hash_of_created_objs(:scalar, Cauterize.scalars) }
-  end
-end
+module Cauterize
+  describe Scalar do
+    describe :initialize do
+      it "creates an scalar" do
+        Cauterize.scalar(:foo).name.should == :foo
+      end
+    end
+
+    it { can_be_documented(Cauterize::Scalar) }
+
+    describe :type_name do
+      it "specifies the builtin type to alias" do
+        s = Cauterize.scalar(:foo) do |t|
+          t.type_name(:int8)
+        end
+      end
+
+      it "raises an exception when a non-builtin is specified" do
+        dummy = Cauterize.scalar(:dummy)
+        s = Cauterize.scalar(:foo) do |t|
+          t.type_name(:int32)
+        end
+      end
+    end
+  end
+
+  describe :scalar do
+    it { creates_a_named_object(:scalar, Scalar) }
+    it { retrieves_obj_with_identical_name(:scalar) }
+    it { yields_the_object(:scalar) }
+    it { adds_object_to_hash(:scalar, Cauterize.scalars) }
+  end
+
+  describe :scalar! do
+    it { creates_a_named_object(:scalar!, Scalar) }
+    it { raises_exception_with_identical_name(:scalar!) }
+    it { yields_the_object(:scalar!) }
+    it { adds_object_to_hash(:scalar!, Cauterize.scalars) }
+  end
+
+  describe :scalars do
+    it { is_hash_of_created_objs(:scalar, Cauterize.scalars) }
+  end
+end

data/spec/spec_helper.rb

@@ -1,122 +1,122 @@
-require 'set'
-require 'mocha/api'
-require 'require_all'
-
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'cauterize/cauterize'
-
-require_all Dir['spec/support/**/*.rb']
-
-RSpec.configure do |config|
-  config.mock_framework = :mocha
-  config.before(:each) do
-    reset_for_test
-  end
-end
-
-###
-
-module Cauterize
-  module CauterizeHelpers
-    def reset_for_test
-      BaseType.class_variable_set(:@@next_id, {})
-      BaseType.class_variable_set(:@@instances, {})
-
-      Cauterize.module_exec do
-        @builtins = {}
-        @scalars = {}
-        @composites = {}
-        @enumerations = {}
-        @fixed_ararys = {}
-        @variable_arrays = {}
-        @groups = {}
-      end
-
-      Cauterize.create_builtins
-    end
-
-    def can_be_documented(klass)
-      klass.new(:dokumented_klass, "precious documentation").description.should == "precious documentation"
-    end
-
-    def is_tagged_as(cls, tag)
-      cls.new(:foo).tag.should == tag
-    end
-
-    def creates_a_named_object(fn_sym, obj)
-      fn = Cauterize.method(fn_sym)
-      a = fn.call(:foo)
-      a.class.should == obj
-      a.name.should == :foo
-    end
-
-    def retrieves_obj_with_identical_name(fn_sym)
-      fn = Cauterize.method(fn_sym)
-      a = fn.call(:foo)
-      b = fn.call(:foo)
-      a.should be b
-    end
-
-    def raises_exception_with_identical_name(fn_sym)
-      fn = Cauterize.method(fn_sym)
-      fn.call(:foo)
-      lambda { fn.call(:foo) }.should raise_error
-    end
-
-    def yields_the_object(fn_sym)
-      fn = Cauterize.method(fn_sym)
-      called = false
-      yielded = nil
-      r = fn.call(:foo) { |a| yielded = a }
-      yielded.should be r
-    end
-
-    def adds_object_to_hash(fn_sym, hash_inst)
-      fn = Cauterize.method(fn_sym)
-
-      f = fn.call(:foo)
-      b = fn.call(:bar)
-
-      hash_inst.keys.should == [:foo, :bar]
-      hash_inst.values[0].should be f
-      hash_inst.values[1].should be b
-    end
-
-    def is_hash_of_created_objs(create_fn_sym, hash_inst)
-      create_fn = Cauterize.method(create_fn_sym)
-
-      f = create_fn.call(:foo)
-      b = create_fn.call(:bar)
-      z = create_fn.call(:zap)
-
-      vs = hash_inst.values
-      vs[0].should be f
-      vs[1].should be b
-      vs[2].should be z
-      hash_inst.keys.should == [:foo, :bar, :zap]
-    end
-
-
-    ###############################################################################
-
-    def gen_test_main(sym_list)
-      sym_voids = sym_list.map {|s| "(void*)#{s}"}.join(", ")
-      str = <<-EOF
-      #include "testing.h"
-
-      int main(int argc, char * argv[])
-      {
-        (void)argc;
-        (void)argv;
-
-        void * ptr[] = {#{sym_voids}};
-        (void)ptr;
-
-        return 0;
-      }
-      EOF
-    end
-  end
-end
-
-include Cauterize::CauterizeHelpers
+require 'set'
+require 'mocha/api'
+require 'require_all'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'cauterize/cauterize'
+
+require_all Dir['spec/support/**/*.rb']
+
+RSpec.configure do |config|
+  config.mock_framework = :mocha
+  config.before(:each) do
+    reset_for_test
+  end
+end
+
+###
+
+module Cauterize
+  module CauterizeHelpers
+    def reset_for_test
+      BaseType.class_variable_set(:@@next_id, {})
+      BaseType.class_variable_set(:@@instances, {})
+
+      Cauterize.module_exec do
+        @builtins = {}
+        @scalars = {}
+        @composites = {}
+        @enumerations = {}
+        @fixed_ararys = {}
+        @variable_arrays = {}
+        @groups = {}
+      end
+
+      Cauterize.create_builtins
+    end
+
+    def can_be_documented(klass)
+      klass.new(:dokumented_klass, "precious documentation").description.should == "precious documentation"
+    end
+
+    def is_tagged_as(cls, tag)
+      cls.new(:foo).tag.should == tag
+    end
+
+    def creates_a_named_object(fn_sym, obj)
+      fn = Cauterize.method(fn_sym)
+      a = fn.call(:foo)
+      a.class.should == obj
+      a.name.should == :foo
+    end
+
+    def retrieves_obj_with_identical_name(fn_sym)
+      fn = Cauterize.method(fn_sym)
+      a = fn.call(:foo)
+      b = fn.call(:foo)
+      a.should be b
+    end
+
+    def raises_exception_with_identical_name(fn_sym)
+      fn = Cauterize.method(fn_sym)
+      fn.call(:foo)
+      lambda { fn.call(:foo) }.should raise_error
+    end
+
+    def yields_the_object(fn_sym)
+      fn = Cauterize.method(fn_sym)
+      called = false
+      yielded = nil
+      r = fn.call(:foo) { |a| yielded = a }
+      yielded.should be r
+    end
+
+    def adds_object_to_hash(fn_sym, hash_inst)
+      fn = Cauterize.method(fn_sym)
+
+      f = fn.call(:foo)
+      b = fn.call(:bar)
+
+      hash_inst.keys.should == [:foo, :bar]
+      hash_inst.values[0].should be f
+      hash_inst.values[1].should be b
+    end
+
+    def is_hash_of_created_objs(create_fn_sym, hash_inst)
+      create_fn = Cauterize.method(create_fn_sym)
+
+      f = create_fn.call(:foo)
+      b = create_fn.call(:bar)
+      z = create_fn.call(:zap)
+
+      vs = hash_inst.values
+      vs[0].should be f
+      vs[1].should be b
+      vs[2].should be z
+      hash_inst.keys.should == [:foo, :bar, :zap]
+    end
+
+
+    ###############################################################################
+
+    def gen_test_main(sym_list)
+      sym_voids = sym_list.map {|s| "(void*)#{s}"}.join(", ")
+      str = <<-EOF
+      #include "testing.h"
+
+      int main(int argc, char * argv[])
+      {
+        (void)argc;
+        (void)argv;
+
+        void * ptr[] = {#{sym_voids}};
+        (void)ptr;
+
+        return 0;
+      }
+      EOF
+    end
+  end
+end
+
+include Cauterize::CauterizeHelpers

data/spec/support/shared_examples_for_array_buildables.rb

@@ -1,22 +1,22 @@
-include Cauterize::Builders::C
-
-shared_examples "an array buildable" do
-  let(:desc_instance) { type_constructor.call(:some_type_name) }
-  let(:formatter) { default_formatter }
-  subject { described_class.new(desc_instance) }
-
-  describe :render do
-    it "contains the name" do
-      t_name = subject.instance_variable_get(:@blueprint).array_type.name
-      subject.render.should match /#{t_name}/
-    end
-  end
-
-  describe :declare do
-    before { subject.declare(formatter, :some_sym) }
-
-    it "contains the name and a ;" do
-      formatter.to_s.should match /uint32_t some_sym\[16\]; \/\* some_type_name \*\//
-    end
-  end
-end
+include Cauterize::Builders::C
+
+shared_examples "an array buildable" do
+  let(:desc_instance) { type_constructor.call(:some_type_name) }
+  let(:formatter) { default_formatter }
+  subject { described_class.new(desc_instance) }
+
+  describe :render do
+    it "contains the name" do
+      t_name = subject.instance_variable_get(:@blueprint).array_type.name
+      subject.render.should match /#{t_name}/
+    end
+  end
+
+  describe :declare do
+    before { subject.declare(formatter, :some_sym) }
+
+    it "contains the name and a ;" do
+      formatter.to_s.should match /uint32_t some_sym\[16\]; \/\* some_type_name \*\//
+    end
+  end
+end

data/spec/support/shared_examples_for_c_buildables.rb

@@ -1,103 +1,103 @@
-# shared examples for c buildables
-
-module Cauterize
-  include Cauterize::Builders::C
-
-  shared_examples "a buildable" do
-    let(:desc_instance) { type_constructor.call(:some_type_name) }
-    let(:formatter) { default_formatter }
-    let(:builder) { Cauterize::Builders.get(:c, desc_instance) }
-    subject { described_class.new(desc_instance) }
-
-    it "should be registered" do
-      builder.class.should be described_class
-    end
-
-    it "errors on duplicate type names" do
-      instances = BaseType.class_variable_get(:@@instances)
-      instances[:a_common_name] = nil
-      BaseType.class_variable_set(:@@instances, instances)
-      lambda {
-        type_constructor.call(:a_common_name)
-      }.should raise_error /already exists/
-    end
-
-    describe :packer_sym do
-      it "contains the word Pack" do
-        subject.packer_sym.should match /Pack_/
-      end
-    end
-
-    describe :packer_sig do
-      it "looks like this" do
-        r = /CAUTERIZE_STATUS_T (?<sym>[^\(]+)\(struct Cauterize \* dst, (?<rend>(?:(?:struct|enum) )?[^ ]+) \* src\)/
-        subject.packer_sig.should match r
-        m = subject.packer_sig.match(r)
-        m[:sym].should == subject.packer_sym
-        m[:rend].should == subject.render
-      end
-    end
-
-    describe :packer_proto do
-      it "should format the sig + ;" do
-        subject.packer_proto(formatter)
-        formatter.to_s.should == subject.packer_sig + ";"
-      end
-    end
-
-    describe :wrapped_packer_defn do
-      before { subject.wrapped_packer_defn(formatter) }
-
-      it "contains the signature" do
-        formatter.to_s.should match Regexp.escape(subject.packer_sig)
-      end
-    end
-
-    describe :packer_defn do
-      before { subject.packer_defn(formatter) }
-
-      it "contains a return statement" do
-        formatter.to_s.should match /return.*;/
-      end
-    end
-
-    describe :unpacker_sym do
-      it "contains the word Unpack" do
-        subject.unpacker_sym.should match /Unpack_/
-      end
-    end
-
-    describe :unpacker_sig do
-      it "looks like this" do
-        r = /CAUTERIZE_STATUS_T (?<sym>[^\(]+)\(struct Cauterize \* src, (?<rend>(?:(?:struct|enum) )?[^ ]+) \* dst\)/
-        subject.unpacker_sig.should match r
-        m = subject.unpacker_sig.match(r)
-        m[:sym].should == subject.unpacker_sym
-        m[:rend].should == subject.render
-      end
-    end
-
-    describe :unpacker_proto do
-      it "should format the sig + ;" do
-        subject.unpacker_proto(formatter)
-        formatter.to_s.should == subject.unpacker_sig + ";"
-      end
-    end
-
-    describe :wrapped_unpacker_defn do
-      before { subject.wrapped_unpacker_defn(formatter) }
-
-      it "contains the signature" do
-        formatter.to_s.should match Regexp.escape(subject.unpacker_sig)
-      end
-    end
-
-    describe :unpacker_defn do
-      before { subject.unpacker_defn(formatter) }
-
-      it "contains a return statement" do
-        formatter.to_s.should match /return.*;/
-      end
-    end
-  end
-end
+# shared examples for c buildables
+
+module Cauterize
+  include Cauterize::Builders::C
+
+  shared_examples "a buildable" do
+    let(:desc_instance) { type_constructor.call(:some_type_name) }
+    let(:formatter) { default_formatter }
+    let(:builder) { Cauterize::Builders.get(:c, desc_instance) }
+    subject { described_class.new(desc_instance) }
+
+    it "should be registered" do
+      builder.class.should be described_class
+    end
+
+    it "errors on duplicate type names" do
+      instances = BaseType.class_variable_get(:@@instances)
+      instances[:a_common_name] = nil
+      BaseType.class_variable_set(:@@instances, instances)
+      lambda {
+        type_constructor.call(:a_common_name)
+      }.should raise_error /already exists/
+    end
+
+    describe :packer_sym do
+      it "contains the word Pack" do
+        subject.packer_sym.should match /Pack_/
+      end
+    end
+
+    describe :packer_sig do
+      it "looks like this" do
+        r = /CAUTERIZE_STATUS_T (?<sym>[^\(]+)\(struct Cauterize \* dst, (?<rend>(?:(?:struct|enum) )?[^ ]+) \* src\)/
+        subject.packer_sig.should match r
+        m = subject.packer_sig.match(r)
+        m[:sym].should == subject.packer_sym
+        m[:rend].should == subject.render
+      end
+    end
+
+    describe :packer_proto do
+      it "should format the sig + ;" do
+        subject.packer_proto(formatter)
+        formatter.to_s.should == subject.packer_sig + ";"
+      end
+    end
+
+    describe :wrapped_packer_defn do
+      before { subject.wrapped_packer_defn(formatter) }
+
+      it "contains the signature" do
+        formatter.to_s.should match Regexp.escape(subject.packer_sig)
+      end
+    end
+
+    describe :packer_defn do
+      before { subject.packer_defn(formatter) }
+
+      it "contains a return statement" do
+        formatter.to_s.should match /return.*;/
+      end
+    end
+
+    describe :unpacker_sym do
+      it "contains the word Unpack" do
+        subject.unpacker_sym.should match /Unpack_/
+      end
+    end
+
+    describe :unpacker_sig do
+      it "looks like this" do
+        r = /CAUTERIZE_STATUS_T (?<sym>[^\(]+)\(struct Cauterize \* src, (?<rend>(?:(?:struct|enum) )?[^ ]+) \* dst\)/
+        subject.unpacker_sig.should match r
+        m = subject.unpacker_sig.match(r)
+        m[:sym].should == subject.unpacker_sym
+        m[:rend].should == subject.render
+      end
+    end
+
+    describe :unpacker_proto do
+      it "should format the sig + ;" do
+        subject.unpacker_proto(formatter)
+        formatter.to_s.should == subject.unpacker_sig + ";"
+      end
+    end
+
+    describe :wrapped_unpacker_defn do
+      before { subject.wrapped_unpacker_defn(formatter) }
+
+      it "contains the signature" do
+        formatter.to_s.should match Regexp.escape(subject.unpacker_sig)
+      end
+    end
+
+    describe :unpacker_defn do
+      before { subject.unpacker_defn(formatter) }
+
+      it "contains a return statement" do
+        formatter.to_s.should match /return.*;/
+      end
+    end
+  end
+end