cauterize 0.0.1.pre8 → 0.0.1.pre9

data/bin/cauterize

@@ -30,7 +30,7 @@ class CauterizeCmdline < Thor
     end
 
     language = language.downcase
-    if %w(c cs doc).include? language
+    if %w(c cs ruby doc).include? language
       Cauterize.generate language, target_dir, desc_file
     else
       raise CmdLineException.new("Language '#{language}' is not supported.")

data/lib/cauterize/builders/c/group.rb

@@ -37,7 +37,7 @@ module Cauterize
               format_no_data_stubs(formatter)
 
               formatter.backdent "default:"
-              formatter << "return CA_ERR_INVALUD_TYPE_TAG;"
+              formatter << "return CA_ERR_INVALID_TYPE_TAG;"
               formatter << "break;"
             end
             formatter << "return CA_OK;"
@@ -66,7 +66,7 @@ module Cauterize
               format_no_data_stubs(formatter)
 
               formatter.backdent "default:"
-              formatter << "return CA_ERR_INVALUD_TYPE_TAG;"
+              formatter << "return CA_ERR_INVALID_TYPE_TAG;"
               formatter << "break;"
             end
             formatter << "return CA_OK;"

data/lib/cauterize/builders/ruby/buildable.rb

@@ -0,0 +1,11 @@
+module Cauterize
+  module Builders
+    module Ruby
+      class Buildable
+        def initialize(blueprint)
+          @blueprint = blueprint
+        end
+      end
+    end
+  end
+end

data/lib/cauterize/builders/ruby/builtin.rb

@@ -0,0 +1,25 @@
+module Cauterize::Builders::Ruby
+  class BuiltIn < Buildable
+    @@RUBY_TYPE_MAPPING = {
+      1 => {signed: "Int8",  unsigned: "UInt8",  :float => nil,       :bool => "Bool"},
+      2 => {signed: "Int16", unsigned: "UInt16", :float => nil,       :bool => nil},
+      4 => {signed: "Int32", unsigned: "UInt32", :float => "Float32", :bool => nil},
+      8 => {signed: "Int64", unsigned: "UInt64", :float => "Float64", :bool => nil},
+    }
+
+    def render
+      render_rbtype
+    end
+
+    def class_defn(f)
+    end
+
+    private
+
+    def render_rbtype
+      @@RUBY_TYPE_MAPPING[@blueprint.byte_length][@blueprint.flavor]
+    end
+  end
+end
+
+Cauterize::Builders.register(:ruby, Cauterize::BuiltIn, Cauterize::Builders::Ruby::BuiltIn)

data/lib/cauterize/builders/ruby/composite.rb

@@ -0,0 +1,23 @@
+module Cauterize::Builders::Ruby
+  class Composite < Buildable
+    def render
+      @blueprint.name.to_s.camel
+    end
+
+    def class_defn(f)
+      f << "class #{render} < CauterizeComposite"
+      f << "  def self.fields"
+      f << "    {"
+      @blueprint.fields.values.each_with_index do |field, i|
+        t = Cauterize::Builders.get(:ruby, field.type).render
+        f << "      #{field.name}: #{t},"
+      end
+      f << "    }"
+      f << "  end"
+      f << "end"
+      f << ""
+    end
+  end
+end
+
+Cauterize::Builders.register(:ruby, Cauterize::Composite, Cauterize::Builders::Ruby::Composite)

data/lib/cauterize/builders/ruby/enumeration.rb

@@ -0,0 +1,27 @@
+module Cauterize::Builders::Ruby
+  class Enumeration < Buildable
+    def render
+      @blueprint.name.to_s.camel
+    end
+
+    def class_defn(f)
+      rep_builder = Cauterize::Builders.get(:ruby, @blueprint.representation)
+      f << "class #{render} < CauterizeEnumeration"
+      f << "  def self.repr_type() #{rep_builder.render} end"
+      f << "  def self.fields"
+      f << "    {"
+      @blueprint.values.values.each do |v|
+        f << "      #{v.name.to_s.upcase}: #{v.value},"
+      end
+      f << "    }"
+      f << "  end"
+      @blueprint.values.values.each do |v|
+        f << "  #{v.name.to_s.upcase} = #{render}.new(:#{v.name.to_s.upcase})"
+      end
+      f << "end"
+      f << ""
+    end
+  end
+end
+
+Cauterize::Builders.register(:ruby, Cauterize::Enumeration, Cauterize::Builders::Ruby::Enumeration)

data/lib/cauterize/builders/ruby/fixed_array.rb

@@ -0,0 +1,20 @@
+module Cauterize::Builders::Ruby
+  class FixedArray < Buildable
+    def render
+      @blueprint.name.to_s.camel
+    end
+
+    def class_defn(f)
+      array_type_bldr = Cauterize::Builders.get(:ruby, @blueprint.array_type)
+      x = <<EOF
+class #{render} < CauterizeFixedArray
+  def self.length () #{@blueprint.array_size} end
+  def self.elem_type() #{array_type_bldr.render} end
+end
+EOF
+      f << x
+    end
+  end
+end
+
+Cauterize::Builders.register(:ruby, Cauterize::FixedArray, Cauterize::Builders::Ruby::FixedArray)

data/lib/cauterize/builders/ruby/group.rb

@@ -0,0 +1,35 @@
+module Cauterize::Builders::Ruby
+  class Group < Buildable
+    def render
+      @blueprint.name.to_s.camel
+    end
+    def initialize(blueprint)
+      super(blueprint)
+      @tag_enum = blueprint.tag_enum
+    end
+
+    def class_defn(f)
+      tag = Cauterize::Builders.get(:ruby, @tag_enum).render
+
+      f << "class #{render} < CauterizeGroup"
+      f << "  def self.tag_type() #{tag} end"
+      f << "  def self.tag_prefix() '#{@blueprint.tag_enum.name.upcase}_' end"
+      f << "  def self.fields"
+      f << "    {"
+      @blueprint.fields.values.each_with_index do |field, i|
+        if field.type
+          t = Cauterize::Builders.get(:ruby, field.type).render
+          f << "      #{field.name.to_s.upcase}: #{t},"
+        else
+          f << "      #{field.name.to_s.upcase}: nil,"
+        end
+      end
+      f << "    }"
+      f << "  end"
+      f << "end"
+      f << ""
+    end
+  end
+end
+
+Cauterize::Builders.register(:ruby, Cauterize::Group, Cauterize::Builders::Ruby::Group)

data/lib/cauterize/builders/ruby/scalar.rb

@@ -0,0 +1,19 @@
+module Cauterize::Builders::Ruby
+  class Scalar < Buildable
+    def render
+      @blueprint.name.to_s.camel
+    end
+
+    def class_defn(f)
+      tn_bldr = Cauterize::Builders.get(:ruby, @blueprint.type_name)
+      x = <<EOF
+class #{render} < CauterizeScalar
+  def self.builtin() #{tn_bldr.render} end
+end
+EOF
+      f << x
+    end
+  end
+end
+
+Cauterize::Builders.register(:ruby, Cauterize::Scalar, Cauterize::Builders::Ruby::Scalar)

data/lib/cauterize/builders/ruby/variable_array.rb

@@ -0,0 +1,22 @@
+module Cauterize::Builders::Ruby
+  class VariableArray < Buildable
+    def render
+      @blueprint.name.to_s.camel
+    end
+
+    def class_defn(f)
+      array_type_bldr = Cauterize::Builders.get(:ruby, @blueprint.array_type)
+      size_type_bldr = Cauterize::Builders.get(:ruby, @blueprint.size_type)
+      x = <<EOF
+class #{render} < CauterizeVariableArray
+  def self.size_type () #{size_type_bldr.render} end
+  def self.max_length () #{@blueprint.array_size} end
+  def self.elem_type() #{array_type_bldr.render} end
+end
+EOF
+      f << x
+    end
+  end
+end
+
+Cauterize::Builders.register(:ruby, Cauterize::VariableArray, Cauterize::Builders::Ruby::VariableArray)

data/lib/cauterize/cauterize.rb

@@ -29,6 +29,13 @@ module Cauterize
     Cauterize::CSBuilder.new(cs_file, output_prefix)
   end
 
+  # Generate the Ruby code corresponding to the generated configuration
+  def make_builder_ruby(target_dir, output_prefix)
+    rb_file = File.join(target_dir, "#{output_prefix}.rb")
+
+    Cauterize::RubyBuilder.new(rb_file, output_prefix)
+  end
+
   def make_builder_doc(target_dir, output_prefix)
     doc_file = File.join(target_dir, "#{output_prefix}.txt")
 

data/lib/cauterize/ruby_builder.rb

@@ -0,0 +1,34 @@
+require 'time'
+
+module Cauterize
+  class RubyBuilder
+    attr_reader :rb
+    def initialize(rb_file, name="cauterize")
+      @rb = rb_file
+      @name = name.camel
+    end
+
+    def build
+      build_rb
+    end
+
+    def build_rb
+      f = []
+
+      f << "# WARNING: This is generated code. Do not edit this file directly."
+      f << ""
+      f << "require_relative './cauterize_ruby_builtins'"
+      f << ""
+
+      instances = BaseType.all_instances
+      builders = instances.map {|i| Builders.get(:ruby, i)}
+      builders.each { |b| b.class_defn(f) }
+      f << ""
+
+      File.open(@rb, "wb") do |fh|
+        fh.write(f.join("\n").to_s)
+      end
+    end
+
+  end
+end

data/lib/cauterize/version.rb

@@ -1,3 +1,3 @@
 module Cauterize
-  VERSION = "0.0.1.pre8"
+  VERSION = "0.0.1.pre9"
 end

data/spec/builders_spec.rb

@@ -5,6 +5,7 @@ module Cauterize
       before do
         class X; def initialize(i); end; end
         class Y; def initialize(i); end; end
+        class Z; def initialize(i); end; end
 
         # save the old list so that we can restore it later.
         old_builders = nil
@@ -34,6 +35,9 @@ module Cauterize
 
         Cauterize::Builders.register(:cs, Cauterize::Scalar, Y)
         Cauterize::Builders.get(:cs, s).class.should be Y
+
+        Cauterize::Builders.register(:ruby, Cauterize::Scalar, Z)
+        Cauterize::Builders.get(:ruby, s).class.should be Z
       end
 
       it "raises an error on duplicate registrations" do

data/spec/ruby_builder_spec.rb

@@ -0,0 +1,80 @@
+require 'tmpdir'
+require 'fileutils'
+
+module Cauterize
+  describe Cauterize::RubyBuilder do
+    before do
+      @tempdir = Dir.mktmpdir
+      @rb_path = File.join(@tempdir, "testing.rb")
+
+      @rb = RubyBuilder.new(@rb_path, "testing")
+    end
+
+    describe :build do
+      before do
+        Cauterize.set_version("1.2.3")
+
+        Cauterize.scalar(:small_uint) {|t| t.type_name(:uint8)}
+
+        Cauterize.fixed_array(:mac_address) do |fa|
+          fa.array_type :small_uint
+          fa.array_size 6
+        end
+
+        Cauterize.variable_array(:mac_table) do |t|
+          t.array_type :mac_address
+          t.array_size 64
+          t.size_type :small_uint
+        end
+
+        Cauterize.variable_array(:name) do |va|
+          va.array_type :small_uint
+          va.size_type :small_uint
+          va.array_size 32
+        end
+
+        Cauterize.enumeration(:gender) do |e|
+          e.value :male
+          e.value :female
+        end
+
+        Cauterize.composite(:place) do |c|
+          c.field :name, :name
+          c.field :elevation, :uint32
+        end
+
+        Cauterize.composite(:person) do |c|
+          c.field :first_name, :name
+          c.field :last_name, :name
+          c.field :gender, :gender
+        end
+
+        Cauterize.composite(:dog) do |c|
+          c.field :name, :name
+          c.field :gender, :gender
+          c.field :leg_count, :small_uint
+        end
+
+        Cauterize.group(:creature) do |g|
+          g.field :person, :person
+          g.field :dog, :dog
+        end
+
+        @rb.build
+        @ruby_text = File.read(@rb.rb)
+        @ruby_lines = @ruby_text.lines.to_a
+      end
+
+      describe "header generation" do
+        it "informs the user the code is generated" do
+          @ruby_text.should include("generated code. Do not edit")
+        end
+
+        it "requires 'cauterize_ruby_baseclasses'" do
+          @ruby_text.should include("require_relative './cauterize_ruby_builtins'")
+        end
+
+      end
+    end
+  end
+end

data/support/c/src/cauterize.h

@@ -17,7 +17,7 @@ typedef enum cauterize_status {
   CA_ERR_NOT_ENOUGH_SPACE = 2,
   CA_ERR_NOT_ENOUGH_DATA = 3,
   CA_ERR_INVALID_LENGTH = 4,
-  CA_ERR_INVALUD_TYPE_TAG = 5,
+  CA_ERR_INVALID_TYPE_TAG = 5,
   CA_ERR_INVALID_ENUM_VAL = 6,
   CA_ERR_GENERAL = INT32_MAX,
 } CAUTERIZE_STATUS_T;

data/support/ruby/src/cauterize_ruby_baseclasses.rb

@@ -0,0 +1,196 @@
+require 'stringio'
+
+def takeBytes!(num_bytes, str)
+  byte = str.slice!(0, num_bytes)
+  raise "Unexpected end of string" if byte == ""
+  byte
+end
+
+class CauterizeData
+  def self.construct(x)
+    if x.is_a? CauterizeData
+      raise "Invalid Type: was #{x.class}, expected #{self.name}" if not x.is_a?(self)
+      x
+    else
+      self.new x
+    end
+  end
+
+  def self.unpack(x)
+    self.unpackio(StringIO.new(x))
+  end
+end
+
+class CauterizeBuiltin < CauterizeData
+  attr_reader :val
+  def initialize(val)
+    raise "Out of range value" if not in_range(val)
+    @val = val
+  end
+  def to_i
+    return @val.to_i
+  end
+  def to_f
+    return @val.to_f
+  end
+end
+
+class CauterizeScalar < CauterizeData
+  attr_reader :val
+
+  def initialize(val)
+    @val = self.class.builtin.construct val
+  end
+
+  def pack
+    @val.pack
+  end
+
+  def self.unpackio(str)
+    self.new self.builtin.unpackio(str)
+  end
+end
+
+
+class CauterizeFixedArray < CauterizeData
+  attr_reader :elems
+
+  def initialize(elems)
+    @elems = elems.map { |e| self.class.elem_type.construct(e) }
+    raise "Invalid length" if @elems.length != self.class.length
+  end
+
+  def pack
+    @elems.inject("") { |sum, n| sum + n.pack }
+  end
+
+  def self.unpackio(str)
+    self.new (1..self.length).map { self.elem_type.unpackio(str) }
+  end
+end
+
+
+class CauterizeVariableArray < CauterizeData
+  attr_reader :length
+  attr_reader :elems
+
+  def initialize(elems)
+    @elems = elems.map { |e| self.class.elem_type.construct(e) }
+    @length = self.class.size_type.new @elems.length
+    raise "Invalid length" if @elems.length > self.class.max_length
+  end
+
+  def pack
+    @length.pack + @elems.inject("") { |sum, n| sum + n.pack }
+  end
+
+  def self.unpackio(str)
+    length = self.size_type.unpackio(str)
+    self.new (1..length.val).map { self.elem_type.unpackio(str) }
+  end
+end
+
+
+class CauterizeComposite < CauterizeData
+  attr_reader :fields
+
+  def initialize(field_values)
+    missing_keys = self.class.fields.keys - field_values.keys
+    extra_keys = field_values.keys - self.class.fields.keys
+    raise "missing fields #{missing_keys}" if not missing_keys.empty?
+    raise "extra fields #{extra_keys}" if not extra_keys.empty?
+    @fields = Hash[field_values.map do |field_name, value|
+      [field_name, self.class.fields[field_name].construct(value)]
+    end]
+  end
+
+  def pack
+    @fields.values.inject("")  { |sum, v| sum + v.pack }
+  end
+
+  def self.unpackio(str)
+    self.new Hash[self.fields.keys.map do |k|
+      [k, self.fields[k].unpackio(str)]
+    end]
+  end
+
+  alias orig_method_missing method_missing
+
+  def method_missing(m, *args, &block)
+    if fields[m]
+      fields[m]
+    else
+      orig_method_missing(m, *args, &block)
+    end
+  end
+end
+
+
+class CauterizeEnumeration < CauterizeData
+  attr_reader :field_name
+
+  def initialize(field_name)
+    raise "Invalid field name #{field_name}" if not self.class.fields.keys.include?(field_name)
+    @field_name = field_name
+  end
+
+  def val() self.class.fields[@field_name] end
+
+  def pack
+    self.class.repr_type.construct(self.class.fields[@field_name]).pack
+  end
+
+  def self.from_int(i)
+    raise "Invalid enumeration value #{i.to_i}" if not self.fields.values.include? i.to_i
+    self.new(self.fields.invert[i.to_i])
+  end
+
+  def self.unpackio(str)
+    self.from_int(self.repr_type.unpackio(str))
+  end
+end
+
+
+class CauterizeGroup < CauterizeData
+  attr_reader :tag
+  attr_reader :data
+
+  def to_tag_name(field_name)
+    (self.class.tag_prefix + field_name.to_s).to_sym
+  end
+
+  def self.from_field_name(tag_name)
+    t = tag_name.to_s
+    t.slice!(self.tag_prefix)
+    t.to_sym
+  end
+  
+  def initialize(tag, data = nil)
+    @tag = self.class.tag_type.construct(to_tag_name(tag))
+    field_class = self.class.fields[self.class.from_field_name(@tag.field_name)]
+    if field_class.nil?
+      @data = data
+    else
+      @data = field_class.construct(data)
+    end
+  end
+
+  def pack
+    if @data.nil?
+      @tag.pack
+    else
+      @tag.pack + @data.pack
+    end
+  end
+
+  def self.unpackio(str)
+    tag = self.tag_type.unpackio(str)
+    field_name = self.from_field_name(tag.field_name)
+    data = self.fields[field_name]
+    if data.nil?
+      self.new(field_name)
+    else
+      self.new(field_name, data.unpackio(str))
+    end
+  end
+end

data/support/ruby/src/cauterize_ruby_builtins.rb

@@ -0,0 +1,122 @@
+require_relative './cauterize_ruby_baseclasses'
+
+class UInt8 < CauterizeBuiltin
+  def in_range(v) v >= 0 && v < 2**8 end
+  def pack
+    [val.to_i].pack("C")
+  end
+  def self.unpackio(str)
+    UInt8.new str.read(1).unpack("C")[0]
+  end
+end
+
+class UInt16 < CauterizeBuiltin
+  def in_range(v) v >= 0 && v < 2**16 end
+  def pack
+    [val.to_i].pack("S")
+  end
+  def self.unpackio(str)
+    UInt16.new str.read(2).unpack("S")[0]
+  end
+end
+
+class UInt32 < CauterizeBuiltin
+  def in_range(v) v >= 0 && v < 2**32 end
+  def pack
+    [val.to_i].pack("L")
+  end
+  def self.unpackio(str)
+    UInt32.new str.read(4).unpack("L")[0]
+  end
+end
+
+class UInt64 < CauterizeBuiltin
+  def in_range(v) v >= 0 && v < 2**64 end
+  def pack
+    [val.to_i].pack("Q")
+  end
+  def self.unpackio(str)
+    UInt64.new str.read(8).unpack("Q")[0]
+  end
+end
+
+class Int8 < CauterizeBuiltin
+  def in_range(v) (v >= -2**7) && (v < 2**7) end
+  def pack
+    [val.to_i].pack("c")
+  end
+  def self.unpackio(str)
+    Int8.new str.read(1).unpack("c")[0]
+  end
+end
+
+class Int16 < CauterizeBuiltin
+  def in_range(v) (v >= -2**15) && (v < 2**15) end
+  def pack
+    [val.to_i].pack("s")
+  end
+  def self.unpackio(str)
+    Int16.new str.read(2).unpack("s")[0]
+  end
+end
+
+class Int32 < CauterizeBuiltin
+  def in_range(v) (v >= -2**31) && (v < 2**31) end
+  def pack
+    [val.to_i].pack("l")
+  end
+  def self.unpackio(str)
+    Int32.new str.read(4).unpack("l")[0]
+  end
+end
+
+class Int64 < CauterizeBuiltin
+  def in_range(v) (v >= -2**63) && (v < 2**63) end
+  def pack
+    [val.to_i].pack("q")
+  end
+  def self.unpackio(str)
+    Int64.new str.read(8).unpack("q")[0]
+  end
+end
+
+class Bool < CauterizeBuiltin
+  def in_range(v) true end
+  def pack
+    if @val
+      [1].pack("C")
+    else
+      [0].pack("C")
+    end
+  end
+  def self.unpackio(str)
+    if str.read(1).unpack("C")[0] == 0
+      Bool.new false
+    else
+      Bool.new true
+    end
+  end
+end
+
+class Float32 < CauterizeBuiltin
+  def in_range(v) v > (-3.402823466e38) && v < (3.402823466e38) end
+  def pack
+    [val.to_f].pack("f")
+  end
+  def self.unpackio(str)
+    Float32.new str.read(4).unpack("f")[0]
+  end
+end
+
+class Float64 < CauterizeBuiltin
+  def in_range(v) true end
+  def pack
+    [val.to_f].pack("d")
+  end
+  def self.unpackio(str)
+    Float64.new str.read(8).unpack("d")[0]
+  end
+end
+
+
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cauterize
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre8
+  version: 0.0.1.pre9
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-16 00:00:00.000000000 Z
+date: 2013-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -155,6 +155,14 @@ files:
 - lib/cauterize/builders/doc/group.rb
 - lib/cauterize/builders/doc/scalar.rb
 - lib/cauterize/builders/doc/variable_array.rb
+- lib/cauterize/builders/ruby/buildable.rb
+- lib/cauterize/builders/ruby/builtin.rb
+- lib/cauterize/builders/ruby/composite.rb
+- lib/cauterize/builders/ruby/enumeration.rb
+- lib/cauterize/builders/ruby/fixed_array.rb
+- lib/cauterize/builders/ruby/group.rb
+- lib/cauterize/builders/ruby/scalar.rb
+- lib/cauterize/builders/ruby/variable_array.rb
 - lib/cauterize/builtin.rb
 - lib/cauterize/c_builder.rb
 - lib/cauterize/cauterize.rb
@@ -165,6 +173,7 @@ files:
 - lib/cauterize/fixed_array.rb
 - lib/cauterize/formatter.rb
 - lib/cauterize/group.rb
+- lib/cauterize/ruby_builder.rb
 - lib/cauterize/scalar.rb
 - lib/cauterize/snake_case.rb
 - lib/cauterize/variable_array.rb
@@ -196,6 +205,7 @@ files:
 - spec/enumeration_spec.rb
 - spec/fixed_array_spec.rb
 - spec/group_spec.rb
+- spec/ruby_builder_spec.rb
 - spec/scalar_spec.rb
 - spec/spec_helper.rb
 - spec/support/shared_examples_for_array_buildables.rb
@@ -236,6 +246,8 @@ files:
 - support/cs/test/CauterizeVariableArrayFormatterTest.cs
 - support/cs/test/OrderAttributeTest.cs
 - support/cs/test/SerializedRepresentationAttributeTest.cs
+- support/ruby/src/cauterize_ruby_baseclasses.rb
+- support/ruby/src/cauterize_ruby_builtins.rb
 homepage: https://github.com/sw17ch/cauterize
 licenses: []
 post_install_message: 
@@ -250,7 +262,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1539031795664628107
+      hash: -966914952996441061
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -291,6 +303,7 @@ test_files:
 - spec/enumeration_spec.rb
 - spec/fixed_array_spec.rb
 - spec/group_spec.rb
+- spec/ruby_builder_spec.rb
 - spec/scalar_spec.rb
 - spec/spec_helper.rb
 - spec/support/shared_examples_for_array_buildables.rb