nymph-generate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7abd8ce8a53ddcb5c97bd4c5d39260f6cba060b5
+  data.tar.gz: ff3eee3f6f077d44841a67695bb73c45b569ee3d
+SHA512:
+  metadata.gz: 6350922e9d49b95cf95250a3b9dea886ced627a28d07544418615409facd6167489d54d3c7c3f02047b818c8bbd3ae6b78d49d45c15482e0e8b164bf2a2c1ff8
+  data.tar.gz: fc45511132abe02b6428346339fb198e818a065783d30db464070760d7b79b33cabda83aa3fa6ee5e3982b379c8e464561d909d8cbadd36e3a68a74a5eadf104

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in nymph-generate.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    nymph-generate (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  nymph-generate!
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.1

data/README.md

@@ -0,0 +1,80 @@
+# nymph-generate
+This is a git repository containing the code for the Ruby Gem nymph-generate to be used alongside the Nymph Game Engine.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nymph-generate'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nymph-generate
+
+## Usage
+The output of `nymph-generate` will generate a C++ header file called `generated_registrations.h`. This contains all of the setup needed for adding specific c++ classes and methods to [Chaiscript](https://github.com/ChaiScript/ChaiScript).
+
+After the gem is installed, running is as simple as:
+```bash
+nymph-generate
+```
+
+By default, `nymph-generate` will look for a directory called `src`, and search every file recursively within that directory. Also by default, it will drop the generated header into `src/generated/`. You can specify a directory to search, as well as directory to put the output header.
+
+```bash
+nymph-generate /path/of/source/to/search /path/of/header/destination
+```
+
+Within this header file is all of the necessary code to register your desired classes and methods into the chaiscript runtime. The only thing from this file that needs to be called is:
+```c++
+// generated_registrations.h
+namespace generated {
+  ...
+  ...
+  void registerModules(std::shared_ptr<chaiscript::ChaiScript> chai);
+  ...
+}
+```
+
+All you have to give this function is a shared_ptr to the chaiscript object within your program. Make sure this is called before loading and running any scripts, otherwise they will not be there for your scripts to see.
+
+## Flagging Header Files For Processing
+There are flags that are used to let `nymph-generate` know which classes and methods to target. To let `nymph-generate` know that it needs to start processing, it looks for comments starting with `//=`. Right now there are 4 basic flags that one needs to know before being able to run `nymph-generate` on your project.
+```c++
+/* This marks a class as scriptable. This lets nymph-generate know that this class should
+ * be processed by nymph-generate. */
+
+//= SCRIPTABLE
+
+/* This marks the scriptable class as having base classes that are also scriptable within
+ * chaiscript. Only specify classes that are also scriptable themselves by listing their
+ * names exactly as they are defined and separated by spaces */
+
+//= SCRIPTABLE BASES ClassName1 ClassName2 ...
+
+/* This marks the beginning point of methods within a class that should be exposed within
+ * the chaiscript module. */
+
+//= BEGIN SCRIPTABLE
+
+/* This marks the ending point of methods within a class that should be exposed within
+ * the chaiscript module. */
+
+//= END SCRIPTABLE
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment. You can also run `bin/nymph-generate` to run this gem without installing it. This is good for development and testing.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). You can also run `bundle exec rake generate` to run this gem with rake without installing it.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sainteos/nymph-generate.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+task :default => :spec
+
+task :generate do
+  sh "./bin/generate #{ARGV[1]}"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nymph/generate"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/nymph-generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "nymph/generate"
+require "nymph/generate/generator"
+
+generator = Nymph::Generate::Generator.new
+
+if ARGV.count == 2
+  generator.run ARGV[0], ARGV[1]
+elsif ARGV.count == 1
+  generator.run ARGV[0], "#{ARGV[0]}/generated"
+else
+  generator.run "#{`pwd`.chomp!}/src", "#{`pwd`.chomp!}/generated"
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/nymph/generate/generator.rb

@@ -0,0 +1,345 @@
+module Nymph
+  module Generate
+    class Generator
+      def grabFiles directory
+        puts "Directory: #{directory}"
+        files = Dir.entries(directory)
+        files.collect! { |f| directory + f }
+        delete_files = []
+        files.each do |file|
+          if file =~ /.*\.\.?\Z/
+            delete_files.push file
+          elsif File.directory?(file)
+            delete_files.push file
+            files << grabFiles(file + "/")
+            files.flatten!
+          end
+        end
+
+        files.delete_if { |f| delete_files.count(f) > 0 }
+
+        return files
+      end
+
+      def cullNonScriptableFiles files
+        h_files = []
+
+        files.each do |file|
+          if file =~ /\A.*\.hp{2}?\Z/
+            h_files << file
+          end
+        end
+
+        scriptable_files = []
+        scriptable_filenames = []
+        h_files.each do |filename|
+          file = File.readlines(filename).join("")
+
+          if file =~ /\s*\/\/=\s*SCRIPTABLE\s*$/
+            scriptable_filenames << filename
+            scriptable_files << file
+          end
+        end
+
+        return scriptable_files, scriptable_filenames
+      end
+
+      def extractNamespace file
+        namespace_regex = /\s*namespace\s+(\w+)\s*{\s*/
+        matches = file.scan(namespace_regex)
+
+        if matches.size > 0
+          return matches.join("::")
+        else
+          return nil
+        end
+      end
+
+      def extractClassNameAndBody file
+        class_regex = /\/\/=\sSCRIPTABLE.*(\/\/=\sSCRIPTABLE\sBASES.*$|\s*)^(?!enum)\s*class\s+([a-zA-Z]+)[^;]*$.*\/\/=\s*BEGIN\s*SCRIPTABLE(.*)\/\/=\s*END\s*SCRIPTABLE.*?}/m
+        matches = class_regex.match(file)
+        if matches != nil
+          return matches.captures[1], matches.captures[2]
+        else
+          return nil
+        end
+      end
+
+      def extractBaseClasses file
+        base_class_regex = /\/\/=\s*SCRIPTABLE\s*BASES(.*)$/
+
+        matches = base_class_regex.match(file)
+
+        if matches != nil
+          base_classes = matches.captures[0].split(" ").collect {|base| base.strip }
+          return base_classes
+        else
+          return nil
+        end
+      end
+
+      def extractMethods text, full_text
+        methods = {}
+        text = text.split "\n"
+
+        function_regex = /([^:]*?)?\s+(\w*?)\((.*?),?\)\s*.*$/
+
+        template_types = []
+        text.each do |line|
+          matches = function_regex.match(line)
+          if !line.include?("= delete") && matches != nil
+            type = matches.captures[0].strip
+            name = matches.captures[1].strip
+            args = matches.captures[2].strip
+            overloaded = full_text.scan(/\s#{Regexp.quote(name)}\(/).count > 1
+            static = line.include?("static ")
+
+
+            arg_list = matches.captures[2].split(",").map { |a| a.split(/\s=/)[0] }
+            if(methods[name] == nil)
+              methods[name] = [[type, arg_list, overloaded, static]]
+            else
+              methods[name] << [type, arg_list, overloaded, static]
+            end
+          end
+        end
+        return methods
+      end
+
+      def extractEnums file_text
+        enums = {}
+
+        scriptable_enum_regex = /\s*\/\/=\s*SCRIPTABLE\s*ENUM\s+(\/\*.*?\*\/)\s*\senum\s*[clas]*\s+(\w+)(\W*|\s*:\s*[a-zA-Z ]+){(.*?)};/m
+
+        class_regex = /^(?!enum)\s*class\s+([a-zA-Z]+).*/
+
+        matches = file_text.scan(scriptable_enum_regex)
+        class_matches = class_regex.match(file_text)
+
+        if matches != []
+          matches.each do |match|
+            name = match[1]
+
+            if class_matches != nil && file_text.index(class_matches[0]) < file_text.index(/\/\/=\s*SCRIPTABLE\s*ENUM\s*/)
+              name = class_matches.captures[0] + "::" + name
+            end
+
+            args = match[3].split(",").collect {|val| val.strip }
+
+            enums[name] = args
+          end
+        end
+
+        return enums
+      end
+
+      def generateGetModule class_name, metadata, base_classes
+         constructors = []
+         methods = []
+
+         metadata.each do |func_name, func_meta|
+
+          func_meta.each do |overload|
+            args = overload[1].join(", ")
+            #NO RETURN TYPE
+            if overload[0].empty?
+              constructors.push "chaiscript::constructor<#{class_name}(#{args})>(),"
+            #RETURN TYPE
+            else
+              overload[0].slice!("static ")
+              if overload[2] == false
+                methods.push "chaiscript::fun(&#{class_name}::#{func_name}), \"#{overload[3]?class_name + "_" : ""}#{func_name}\""
+              else
+                methods.push "chaiscript::fun([](#{class_name}& c#{args.length > 0 ? ", " + args : ""}) { c.#{func_name}(#{args.length > 0 ? (args.split(", ").map { |a| a.split(" ")[-1]}).join(", ") : ""}); }), \"#{func_name}\""
+                #methods.push "chaiscript::fun<#{overload[0]}, #{class_name}#{args.length > 0 ? ", " + args : ""}>(&#{class_name}::#{func_name}), \"#{func_name}\""
+              end
+            end
+          end
+         end
+
+        get_module = %?chaiscript::ModulePtr get#{class_name}Module() {
+          chaiscript::ModulePtr module = std::make_shared<chaiscript::Module>();
+
+          chaiscript::utility::add_class<#{class_name}>(*module, std::string("#{class_name}"),
+          ?
+
+        get_module += "{\n"
+        constructors.each do |c|
+          get_module += c + "\n"
+        end
+
+        get_module += "},\n"
+
+        get_module += "{\n"
+        methods.each do |m|
+          get_module += "{" + m + "},\n"
+        end
+
+        get_module.chomp! ","
+
+
+        get_module += "});\n"
+
+        if base_classes != nil
+          base_classes.each do |b|
+            get_module += "  module->add(chaiscript::base_class<#{b}, #{class_name}>());\n"
+          end
+        end
+        get_module += "return module;\n"
+        get_module += "}\n"
+
+        return get_module, "get#{class_name}Module()"
+      end
+
+      def generateEnumModule enum_name, enum_contents
+        get_module = %?chaiscript::ModulePtr get#{enum_name.split("::").join("")}Module() {
+          chaiscript::ModulePtr module = std::make_shared<chaiscript::Module>();
+          std::vector<std::pair<unsigned int, std::string>> vec = {?
+
+        enum_contents.each do |c|
+          get_module += "{ #{enum_name.split('::').size > 1 ? enum_name.split("::")[0] + "::" : ""}#{c}, \"#{enum_name.split("::").join("_")}_#{c}\" },\n"
+        end
+
+        get_module += "};\n"
+
+        get_module += "chaiscript::utility::add_class<#{enum_name}>(*module, std::string(\"#{enum_name.split("::").join("_")}\"),\n"
+        get_module += "vec);\n"
+
+        get_module += "return module;\n"
+        get_module += "}\n"
+
+        return get_module, "get#{enum_name.split("::").join("")}Module()"
+      end
+
+      def getAllBases klass, names_to_bases
+        bases = names_to_bases[klass]
+
+        if bases != nil
+          bases.each do |base|
+            next_bases = getAllBases(base, names_to_bases)
+            if next_bases != nil
+              bases += getAllBases(base, names_to_bases)
+            end
+          end
+        end
+
+        return bases
+      end
+
+      def run src_path, dst_path
+        puts "Running nymph-generate on path #{src_path}"
+        files = grabFiles(src_path + "/")
+
+        culled_files, culled_filenames = cullNonScriptableFiles(files)
+
+        class_names_to_bodies = {}
+        class_names_to_file_text = {}
+        class_names_to_filenames =  {}
+        class_names_to_base_classes = {}
+        namespaces = []
+        enums = {}
+        enum_filenames = []
+
+        culled_files.zip(culled_filenames).each do |file, filename|
+          class_name, body = extractClassNameAndBody(file)
+          namespace = extractNamespace(file)
+          bases = extractBaseClasses(file)
+
+          ems = extractEnums(file)
+          if(ems != {})
+            enums.merge! ems
+            enum_filenames << filename
+          end
+
+          if(namespace != nil && namespaces.count(namespace) == 0)
+            namespaces << namespace
+          end
+
+          if(class_name != nil)
+            class_names_to_bodies[class_name] = body
+            class_names_to_file_text[class_name] = file
+            class_names_to_filenames[class_name] = filename
+            class_names_to_base_classes[class_name] = bases
+          end
+        end
+
+        #cascade up the bases
+        ctb = class_names_to_base_classes.clone
+
+        ctb.each do |klass, bases|
+          if bases != nil
+            bases.each do |base|
+              if ctb[base] != nil
+                class_names_to_base_classes[klass] += getAllBases(base, ctb)
+                class_names_to_base_classes[klass].uniq!
+              end
+            end
+          end
+        end
+
+        classes = {}
+
+        class_names_to_bodies.each_pair do |key, value|
+          classes[key] = extractMethods(value, class_names_to_file_text[key])
+        end
+
+        func_def_file = %?#ifndef GENERATED_REGISTRATIONS_H
+        #define GENERATED_REGISTRATIONS_H
+        //THIS FILE WAS GENERATED BY nymph-generate
+        //DO NOT EDIT IT AS IT WILL BE OVERWRITTEN WHEN nymph-generate IS RUN AGAIN
+        ?
+
+        filenames = class_names_to_filenames.values | enum_filenames
+
+        func_def_file += "#include <chaiscript/utility/utility.hpp>\n"
+        func_def_file += "#include <vector>\n#include <map>\n"
+        filenames.each do |fn|
+          fn.slice! "./src/"
+          func_def_file += "#include \"#{fn}\"\n"
+        end
+
+
+        func_def_file += "namespace generated {\n"
+
+        namespaces.each do  |n|
+          func_def_file += "  using namespace #{n};\n"
+        end
+
+        func_calls = []
+
+        enums.each_pair do |name, vals|
+          mod, func_name = generateEnumModule(name, vals)
+
+          func_def_file += "\n#{mod}\n"
+          func_calls << func_name
+        end
+
+        classes.each_pair do |name, meta|
+          mod, func_name = generateGetModule(name, meta, class_names_to_base_classes[name])
+
+          func_def_file += "\n#{mod}\n"
+          func_calls << func_name
+        end
+
+
+        func_def_file += "void registerModules(std::shared_ptr<chaiscript::ChaiScript> chai) {\n"
+
+        func_calls.each do |f|
+          func_def_file += "chai->add(#{f});\n"
+        end
+
+        func_def_file += "}\n"
+        func_def_file += "}\n"
+        func_def_file += "#endif"
+
+        if(!Dir.exists? dst_path)
+          Dir.mkdir(dst_path)
+        end
+
+        puts "Writing #{dst_path}/generated_registrations.h"
+        File.open("#{dst_path}/generated_registrations.h", "w") { |f| f.write(func_def_file) }
+        puts "Wrote #{`cat #{dst_path}/generated_registrations.h | wc -l`.chomp!.strip!} lines!"
+      end
+    end
+  end
+end

data/lib/nymph/generate/version.rb

@@ -0,0 +1,5 @@
+module Nymph
+  module Generate
+    VERSION = "0.1.0"
+  end
+end

data/lib/nymph/generate.rb

@@ -0,0 +1,6 @@
+require "nymph/generate/version"
+
+module Nymph
+  module Generate
+  end
+end

data/nymph-generate.gemspec

@@ -0,0 +1,25 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "nymph/generate/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "nymph-generate"
+  spec.version       = Nymph::Generate::VERSION
+  spec.authors       = ["Adaleigh Martin"]
+  spec.email         = ["adaleigh.martin@gmail.com"]
+
+  spec.summary       = %q{This is a Ruby Gem called nymph-generate to be used alongside the Nymph Game Engine}
+  spec.description   = %q{nymph-generate is to be used alongside the Nymph Game Engine for generating Chaiscript modules for specified C++ classes and methods.}
+  spec.homepage      = "https://sainteos.github.io/nymph-game-engine"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "bin"
+  spec.executables << "nymph-generate"
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: nymph-generate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adaleigh Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: nymph-generate is to be used alongside the Nymph Game Engine for generating
+  Chaiscript modules for specified C++ classes and methods.
+email:
+- adaleigh.martin@gmail.com
+executables:
+- nymph-generate
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/nymph-generate
+- bin/setup
+- lib/nymph/generate.rb
+- lib/nymph/generate/generator.rb
+- lib/nymph/generate/version.rb
+- nymph-generate.gemspec
+homepage: https://sainteos.github.io/nymph-game-engine
+licenses: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: This is a Ruby Gem called nymph-generate to be used alongside the Nymph Game
+  Engine
+test_files: []