wrapture 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 67db9aad9a4383dca21f730d07b2af31642334204a66377167154a4849975005
+  data.tar.gz: de35dd304d427fe35f768567e58684a9217714ec01447c73a5961db1760b6ed1
+SHA512:
+  metadata.gz: 7afe9e387587d8efa3524566e9d9d4d2d9a87bc82fdcdb4995757c6d86a04eca17c452fee716c63681b84be536398beee5a4b429ec9f8fb34723e6650d72d219
+  data.tar.gz: 62d4696980ec04a870f32cdfc987340f840ba269601996b824db8f4e11f564fe5836943ee1e66cebb1c4e9776b052f7adb5b2eef0f7f92514b9622f1e900200b

data/bin/wrapture

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'wrapture'
+
+spec = YAML.load_file ARGV[0]
+
+normalized_spec = Wrapture.normalize_spec spec
+
+normalized_spec['classes'].each do |class_spec|
+  Wrapture.wrap_class class_spec
+end

data/lib/wrapture.rb

@@ -0,0 +1,8 @@
+module Wrapture
+
+  require 'wrapture/class_spec'
+  require 'wrapture/wrapper'
+  require 'wrapture/validator'
+  require 'wrapture/version'
+
+end

data/lib/wrapture/class_spec.rb

@@ -0,0 +1,128 @@
+module Wrapture
+  class ClassSpec
+    def initialize(spec)
+      @spec = ClassSpec.normalize_spec_hash(spec)
+    end
+
+    def generate_wrappers
+      generate_declaration_file
+      generate_definition_file
+    end
+
+    def self.normalize_spec_hash(spec)
+      normalized_spec = spec.dup
+
+      if normalized_spec['constructors'].nil?
+        normalized_spec['constructors'] = []
+      end
+
+      if normalized_spec['equivalent-struct']['members'].nil?
+        normalized_spec['equivalent-struct']['members'] = []
+      end
+
+      if normalized_spec['functions'].nil?
+        normalized_spec['functions'] = []
+      else
+        normalized_spec['functions'].each do |function_spec|
+          if function_spec['params'].nil?
+            function_spec['params'] = []
+          end
+
+          if function_spec['wrapped-function']['params'].nil?
+            function_spec['wrapped-function']['params'] = []
+          end
+
+          if function_spec['return'].nil?
+            function_spec['return'] = {}
+            function_spec['return']['type'] = 'void'
+          end
+
+          if function_spec['return']['includes'].nil?
+            function_spec['return']['includes'] = []
+          end
+        end
+      end
+
+      if normalized_spec['constants'].nil?
+        normalized_spec['constants'] = []
+
+      else
+        normalized_spec['constants'].each do |constant_spec|
+          if constant_spec['includes'].nil?
+            constant_spec['includes'] = []
+          end
+        end
+      end
+
+      return normalized_spec
+    end
+
+    private
+
+    def header_guard
+      "__#{@spec['name'].upcase}_HPP"
+    end
+
+    def declaration_includes
+      includes = []
+
+      includes.concat @spec['equivalent-struct']['includes']
+
+      @spec['functions'].each do |function_spec|
+        includes.concat function_spec['return']['includes']
+      end
+
+      includes.uniq
+    end
+
+    def pointer_wrapper?
+      @spec['constructors'].each do |constructor_spec|
+        if constructor_spec['wrapped-function']['return']['type'] == 'equivalent-struct-pointer'
+          return true
+        end
+      end
+
+      return false
+    end
+
+    def equivalent_name
+      if pointer_wrapper?
+        '*equivalent'
+      else
+        'equivalent'
+      end
+    end
+
+    def generate_declaration_file
+      file = File.open("#{@spec['name']}.hpp", 'w')
+
+      file.puts "#ifndef #{header_guard}"
+      file.puts "#define #{header_guard}"
+
+      file.puts unless declaration_includes.empty?
+      declaration_includes.each do |include_file|
+        file.puts "#include <#{include_file}"
+      end
+
+      file.puts "namespace #{@spec['namespace']} {"
+      file.puts "  class #{@spec['name']} {"
+      file.puts '  public:'
+
+      file.puts unless @spec['constants'].empty?
+      @spec['constants'].each do |constant_spec|
+        file.puts "    static const #{constant_spec['type']} #{constant_spec['name']}"
+      end
+
+      file.puts
+      file.puts "    struct #{@spec['equivalent-struct']['name']} #{equivalent_name}"
+
+      file.puts '  };' # end of class
+      file.puts '}' # end of namespace
+
+      file.close
+    end
+
+    def generate_definition_file
+    end
+  end
+end

data/lib/wrapture/validator.rb

@@ -0,0 +1,16 @@
+module Wrapture
+
+  def self.normalize_spec(spec)
+
+    normalized_spec = Hash.new
+    normalized_spec['classes'] = Array.new
+
+    spec['classes'].each do |class_spec|
+      normalized_spec['classes'] << ClassSpec.normalize_spec_hash(class_spec)
+    end
+
+    return normalized_spec
+
+  end
+
+end

data/lib/wrapture/version.rb

@@ -0,0 +1,5 @@
+module Wrapture
+
+  VERSION = '0.1.0'
+
+end

data/lib/wrapture/wrapper.rb

@@ -0,0 +1,266 @@
+module Wrapture
+
+  def self.wrap_class( class_spec )
+
+    spec = ClassSpec.new class_spec
+    spec.generate_wrappers
+
+    class_name = class_spec['name']
+    struct_name = class_spec['equivalent-struct']['name']
+
+    # generating constructor signatures
+    constructor_signatures = Array.new
+    equivalent_name = 'equivalent'
+    equivalent_struct = 'this->equivalent'
+    equivalent_struct_pointer = '&this->equivalent'
+    member_operator = '.'
+
+    class_spec['constructors'].each do |constructor_spec|
+      if constructor_spec['wrapped-function']['return']['type'] == 'equivalent-struct-pointer'
+        equivalent_name = '*equivalent'
+        equivalent_struct = '*(this->equivalent)'
+        equivalent_struct_pointer = 'this->equivalent'
+        member_operator = '->'
+      end
+
+      params = Array.new
+      constructor_spec['wrapped-function']['params'].each do |param|
+        params << "#{param['type']} #{param['name']}"
+      end
+
+      constructor_signatures << "#{class_name}( #{params.join ', '} )"
+    end
+
+    members = Array.new
+    class_spec['equivalent-struct']['members'].each do |member|
+      members << "#{member['type']} #{member['name']}"
+    end
+
+    member_constructor_signature = "#{class_name}( #{members.join ', '} )"
+    struct_constructor_signature = "#{class_name}( struct #{struct_name} equivalent )"
+    pointer_constructor_signature = "#{class_name}( const struct #{struct_name} *equivalent )"
+
+    # get the list of includes for declarations
+    declaration_includes = class_spec['equivalent-struct']['includes'].dup
+    class_spec['functions'].each do |function_spec|
+      declaration_includes.concat function_spec['return']['includes']
+    end
+    declaration_includes.uniq!
+
+    # generate the header file
+    File.open("#{class_name}.hpp", 'w') do |file|
+      # header guard
+      file.puts "#ifndef __#{class_name.upcase}_HPP"
+      file.puts "#define __#{class_name.upcase}_HPP"
+
+      file.puts
+
+      declaration_includes.each do |include_file|
+        file.puts "#include <#{include_file}>"
+      end
+
+      file.puts unless declaration_includes.empty?
+
+      file.puts "namespace #{class_spec['namespace']} {"
+      file.puts "  class #{class_name} {"
+      file.puts '  public:'
+
+      class_spec['constants'].each do |constant_spec|
+        file.puts "    static const #{constant_spec['type']} #{constant_spec['name']};"
+      end
+      file.puts unless class_spec['constants'].empty?
+
+      file.puts "    struct #{struct_name} #{equivalent_name};"
+      file.puts
+
+      constructor_signatures.each do |signature|
+        file.puts "    #{signature};"
+      end
+
+      unless members.empty?
+        file.puts "    #{member_constructor_signature};"
+      end
+
+      file.puts "    #{struct_constructor_signature};"
+      file.puts "    #{pointer_constructor_signature};"
+
+      class_spec['equivalent-struct']['members'].each do |member|
+        file.puts "    #{member['type']} Get#{member['name'].capitalize}( void ) const;"
+        file.puts "    void Set#{member['name'].capitalize}( #{member['type']} #{member['name']} );"
+      end
+
+      class_spec['functions'].each do |function_spec|
+        static_modifier = if function_spec['static'] then 'static ' else '' end
+        file.write "    #{static_modifier}#{function_spec['return']['type']} #{function_spec['name']}( "
+
+        wrapped_params = Array.new
+        function_spec['params'].each do |param|
+          wrapped_params << "#{param['type']} #{param['name']}"
+        end
+        file.write(wrapped_params.join ', ')
+
+        file.puts ' );'
+      end
+
+      # destructor
+      unless class_spec['destructor'].nil?
+        file.puts "    ~#{class_name}( void );"
+      end
+
+      file.puts '  };' # end of class
+      file.puts '}' # end of namespace
+      file.puts '#endif' # end of header guard
+    end
+
+    # get the complete list of includes for definitions
+    definition_includes = Array.new
+    definition_includes << "#{class_name}.hpp"
+    class_spec['functions'].each do |function_spec|
+      definition_includes.concat function_spec['return']['includes']
+      definition_includes.concat function_spec['wrapped-function']['includes']
+    end
+
+    class_spec['constants'].each do |constant_spec|
+      definition_includes.concat constant_spec['includes']
+    end
+    definition_includes.uniq!
+
+    # generate the definition file
+    File.open("#{class_name}.cpp", 'w') do |file|
+      definition_includes.each do |include_file|
+        file.puts "#include <#{include_file}>"
+      end
+
+      file.puts
+      file.puts "namespace #{class_spec['namespace']} {"
+
+      # constants
+      class_spec['constants'].each do |constant_spec|
+        file.puts
+        file.puts "  const #{constant_spec['type']} #{class_name}::#{constant_spec['name']} = #{constant_spec['value']};"
+      end
+
+      # constructors
+      class_spec['constructors'].each_index do |i|
+        wrapped_function = class_spec['constructors'][i]['wrapped-function']
+        function_params = Array.new
+        wrapped_function['params'].each do |param|
+          function_params << param['name']
+        end
+
+        file.puts
+        file.puts "  #{class_name}::#{constructor_signatures[i]} {"
+        file.write('    ')
+        case wrapped_function['return']['type']
+        when 'equivalent-struct'
+          file.write(equivalent_struct)
+        when 'equivalent-struct-pointer'
+          file.write(equivalent_struct_pointer)
+        end
+        file.puts " = #{wrapped_function['name']}( #{function_params.join ', '} );"
+        file.puts '  }'
+      end
+
+      unless members.empty?
+        file.puts
+        file.puts "  #{class_name}::#{member_constructor_signature} {"
+        class_spec['equivalent-struct']['members'].each do |member|
+          file.puts "    this->equivalent#{member_operator}#{member['name']} = #{member['name']};"
+        end
+        file.puts '  }' # end of the member constructor
+      end
+
+      file.puts
+      file.puts "  #{class_name}::#{struct_constructor_signature} {"
+      class_spec['equivalent-struct']['members'].each do |member|
+        file.puts "    this->equivalent#{member_operator}#{member['name']} = equivalent.#{member['name']};"
+      end
+      file.puts '  }' # end of struct conversion
+
+      file.puts
+      file.puts "  #{class_name}::#{pointer_constructor_signature} {"
+      class_spec['equivalent-struct']['members'].each do |member|
+        file.puts "    this->equivalent#{member_operator}#{member['name']} = equivalent->#{member['name']};"
+      end
+      file.puts '  }' # end of pointer conversion
+
+      class_spec['equivalent-struct']['members'].each do |member|
+        file.puts # line to separate from previous functions
+        file.puts "  #{member['type']} #{class_name}::Get#{member['name'].capitalize}( void ) const {"
+        file.puts "    return this->equivalent#{member_operator}#{member['name']};"
+        file.puts '  }'
+        file.puts
+        file.puts "  void #{class_name}::Set#{member['name'].capitalize}( #{member['type']} #{member['name']} ) {"
+        file.puts "    this->equivalent#{member_operator}#{member['name']} = #{member['name']};"
+        file.puts '  }'
+      end
+
+      class_spec['functions'].each do |function_spec|
+        file.puts
+        file.write "  #{function_spec['return']['type']} #{class_name}::#{function_spec['name']}( "
+
+        wrapped_params = Array.new
+        function_spec['params'].each do |param|
+          wrapped_params << "#{param['type']} #{param['name']}"
+        end
+        file.write(wrapped_params.join ', ')
+
+        file.puts ' ) {'
+
+        # the function body
+        if function_spec['return']['type'] == 'void'
+          file.write "    #{function_spec['wrapped-function']['name']}( "
+        else
+          file.write "    return #{function_spec['return']['type']}( #{function_spec['wrapped-function']['name']}( "
+        end
+
+        # building the parameters
+        wrapped_params = Array.new
+        function_spec['wrapped-function']['params'].each do |param|
+          case param['name']
+          when 'equivalent-struct'
+            wrapped_params << equivalent_struct
+          when 'equivalent-struct-pointer'
+            wrapped_params << equivalent_struct_pointer
+          else
+            wrapped_params << param['name']
+          end
+        end
+        file.write(wrapped_params.join ', ')
+
+        if function_spec['return']['type'] == 'void'
+          file.puts ' );'
+        else
+          file.puts ' ) );'
+        end
+        file.puts '  }'
+      end
+
+      # destructor
+      unless class_spec['destructor'].nil?
+        file.puts
+        file.puts "  #{class_name}::~#{class_name}( void ) {"
+        file.write("    #{class_spec['destructor']['wrapped-function']['name']}( ")
+        wrapped_params = Array.new
+        class_spec['destructor']['wrapped-function']['params'].each do |param|
+          case param['name']
+          when 'equivalent-struct'
+            wrapped_params << equivalent_struct
+          when 'equivalent-struct-pointer'
+            wrapped_params << equivalent_struct_pointer
+          else
+            wrapped_params << param['name']
+          end
+        end
+        file.write(wrapped_params.join ', ')
+        file.puts ' );'
+        file.puts '  }'
+      end
+
+      file.puts # line after last function
+      file.puts '}' # end of namespace
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: wrapture
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joel Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-01 00:00:00.000000000 Z
+dependencies: []
+description: Wraps C code in C++.
+email: joelanderson333@gmail.com
+executables:
+- wrapture
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/wrapture
+- lib/wrapture.rb
+- lib/wrapture/class_spec.rb
+- lib/wrapture/validator.rb
+- lib/wrapture/version.rb
+- lib/wrapture/wrapper.rb
+homepage: http://rubygems.org/gems/wrapture
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: wrap C in C++
+test_files: []