ginny 0.5.0

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task(default: :test)

data/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ginny"
+
+# You can add fixtures and/or initialization code here to make experimenting with your gem easier.
+
+require "pry"
+Pry.start

data/bin/docs

@@ -0,0 +1,2 @@
+# Rebuild project documentation and serve it locally.
+rm -rf .yardoc && yard server -r

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/exe/ginny

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require "ginny"
+require "optparse"
+options = {}
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: ginny [options] [path]"
+  options[:verbose] = false
+  opts.on("-v", "--verbose", "Output more information") do
+    options[:verbose] = true
+  end
+  opts.on("-h", "--help", "Display this screen") do
+    puts(opts)
+    exit(0)
+  end
+end
+
+optparse.parse!
+
+ARGV.each do |f|
+  Ginny::Class.create(Ginny.load_file(f)).generate()
+end

data/ginny.gemspec

@@ -0,0 +1,43 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ginny/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ginny"
+  spec.version       = Ginny::VERSION
+  spec.required_ruby_version = ">= 2.3.0"
+  spec.description   = "Generate Ruby code."
+  spec.summary       = spec.description
+  spec.authors       = ["Clay Dunston"]
+  spec.email         = ["dunstontc@gmail.com"]
+  spec.homepage      = "https://github.com/tcd/ginny"
+  spec.license       = "MIT"
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "documentation_uri" => "https://www.rubydoc.info/gems/ginny/#{spec.version}",
+    "changelog_uri" => "https://github.com/tcd/ginny/blob/master/CHANGELOG.md",
+    "yard.run" => "yri", # use "yard" to build full HTML docs.
+  }
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = ["ginny"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "coveralls", "~> 0.8.23"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-focus", "~> 1.1"
+  spec.add_development_dependency "minitest-reporters", "~> 1.4"
+  spec.add_development_dependency "pry", "~> 0.12.2"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "simplecov"
+
+  spec.add_runtime_dependency "dry-inflector", "~> 0.2.0"
+end

data/lib/ginny.rb

@@ -0,0 +1,6 @@
+# Ruby code generator.
+module Ginny
+  QUOTE = '"'.freeze
+end
+
+Dir.glob(File.join(__dir__, "ginny", "**/*.rb")).each { |file| require file }

data/lib/ginny/error.rb

@@ -0,0 +1,5 @@
+module Ginny
+  # Exceptions raised by Ginny inherit from Error.
+  # @abstract
+  class Error < StandardError; end
+end

data/lib/ginny/load.rb

@@ -0,0 +1,45 @@
+require "pathname"
+require "json"
+require "yaml"
+
+module Ginny
+
+  # Load data from a YAML file.
+  #
+  # @param path [String]
+  # @return [Hash<Symbol>]
+  def self.load_yaml(path)
+    return Ginny.symbolize_keys(YAML.load_file(File.expand_path(path)))
+  end
+
+  # Load data from a JSON file.
+  #
+  # @param path [String]
+  # @return [Hash<Symbol>]
+  def self.load_json(path)
+    return JSON.parse(File.read(File.expand_path(path)), symbolize_names: true)
+  end
+
+  # @param path [String] Path of the file to determine the extension of.
+  # @return [String]
+  def self.get_extension(path)
+    file = Pathname.new(path)
+    return file.extname.downcase
+  end
+
+  # Load data from a YAML or JSON file.
+  #
+  # @param path [String]
+  # @return [Hash<Symbol>]
+  def self.load_file(path)
+    case Pathname.new(path).extname.downcase
+    when ".yml", ".yaml"
+      return self.load_yaml(path)
+    when ".json"
+      return self.load_json(path)
+    else
+      raise Ginny::Error "invalid file type"
+    end
+  end
+
+end

data/lib/ginny/mod.rb

@@ -0,0 +1,32 @@
+module Ginny
+
+  # Used to generate a [module](https://ruby-doc.org/core-2.6.5/doc/syntax/modules_and_classes_rdoc.html).
+  #
+  # More accurately, wrap the `body` (first argument) with any following module definitions (additional arguments).
+  #
+  # @example
+  #   Ginny.mod("puts('Hello World')", "Level1", "Level2")
+  #   #=> module Level1
+  #         module Level2
+  #           puts('Hello World')
+  #         end
+  #       end
+  #
+  # @param body [String] Name of module namespaces.
+  # @param names [String,Array<String>] Name of module namespaces.
+  # @return [String]
+  def self.mod(body, *names)
+    names.flatten!
+    count = names.length
+    return body unless count.positive?()
+    level = 0
+    head = []
+    tail = []
+    names.each do |name|
+      head.push("module #{name}".indent(level))
+      tail.unshift("end".indent(level))
+      level += 2
+    end
+    return (head + [body&.indent(level)] + tail).compact.join("\n")
+  end
+end

data/lib/ginny/models/attr.rb

@@ -0,0 +1,73 @@
+module Ginny
+  # Used to generate an instance variable with getters/setters.
+  #
+  # [attr]: https://docs.ruby-lang.org/en/master/Module.html#method-i-attr
+  # [attr_accessor]: https://docs.ruby-lang.org/en/master/Module.html#method-i-attr_accessor
+  # [attr_reader]: https://docs.ruby-lang.org/en/master/Module.html#method-i-attr_reader
+  class Attr
+
+    # Name of the attribute.
+    # @return [String]
+    attr_accessor :name
+    # Description of the attribute. [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) is supported.
+    # @return [String]
+    attr_accessor :description
+    # [Type](https://rubydoc.info/gems/yard/file/docs/GettingStarted.md#Declaring_Types) of the attribute.
+    # @return [String]
+    attr_accessor :type
+    # Default value for the attribute; set in it's Class's `initialize` function.
+    # @return [String]
+    attr_accessor :default
+    # If `true`, an `attr_reader` will be generated for the attribute instead of an `attr_accessor`.
+    # @return [Boolean]
+    attr_accessor :read_only
+
+    # @return [void]
+    def initialize()
+      self.read_only = false
+    end
+
+    # Constructor for an Attr. Use `create`, not `new`.
+    #
+    # @param args [Hash]
+    # @return [Attr]
+    def self.create(args = {})
+      a = Ginny::Attr.new()
+      a.name        = args[:name]
+      a.description = args[:description]
+      a.type        = args[:type]
+      a.read_only   = args[:read_only]
+      return a
+    end
+
+    # @param array [Array<Hash>]
+    # @return [Array<Ginny::Attr>]
+    def self.from_array(array)
+      return array.map { |f| self.create(f) }
+    end
+
+    # @return [String]
+    def render()
+      parts = []
+      parts << (@description&.length&.positive? ? @description.comment : nil)
+      parts << "@return [#{self.type}]".comment
+      parts << "attr_#{self.read_only ? 'reader' : 'accessor'} :#{self.name.downcase}"
+      return parts.compact.join("\n").gsub(/\s+$/, "")
+    end
+
+    # Used for documenting attributes that are "declared dynamically via meta-programming".
+    # See the documentation on [YARD directives][1] for more info.
+    #
+    # [1]: https://www.rubydoc.info/gems/yard/file/docs/Tags.md#attribute
+    #
+    # @return [String]
+    def render_dynamic()
+      parts = []
+      parts << "@!attribute #{self.name.downcase} [#{self.read_only ? 'r' : 'rw'}]".comment
+      parts << (@description&.length&.positive? ? @description.indent(2).comment : nil)
+      parts << "@return [#{self.type}]".indent(2).comment
+      return parts.compact.join("\n").gsub(/\s+$/, "")
+    end
+
+  end
+end

data/lib/ginny/models/class.rb

@@ -0,0 +1,94 @@
+require "dry/inflector"
+
+module Ginny
+  # Used to generate a [class](https://ruby-doc.org/core-2.6.5/Class.html)
+  class Class
+
+    # Name of the class.
+    # @return [String]
+    attr_accessor :name
+    # Description of the class. [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) is supported.
+    # @return [String]
+    attr_accessor :description
+    # Name of a class to inherit from. (Ex: `YourNewClass < Parent`)
+    # @return [String]
+    attr_accessor :parent
+    # List of modules to declare the class inside.
+    # @return [String]
+    attr_accessor :modules
+    # An array of {Ginny::Attr}s.
+    # @return [Array<Ginny::Attr>]
+    attr_accessor :attrs
+    # String to write into the body of the class.
+    # @return [String]
+    attr_accessor :body
+    # String to prepend to the name of the generated file.
+    # @return [String]
+    attr_accessor :file_prefix
+
+    # @return [void]
+    def initialize()
+      self.attrs = []
+      self.modules = []
+      self.file_prefix = ""
+    end
+
+    # Constructor for a Class. Use `create`, not `new`.
+    #
+    # @param args [Hash<Symbol>]
+    # @return [Class]
+    def self.create(args = {})
+      c = Ginny::Class.new()
+      c.name        = args[:name]
+      c.description = args[:description]
+      c.parent      = args[:parent]
+      c.modules     = args[:modules] unless args[:modules].nil?
+      c.attrs       = Ginny::Attr.from_array(args[:attrs]) if args[:attrs]&.is_a?(Array)
+      c.body        = args[:body] unless args[:body].nil?
+      c.file_prefix = args[:file_prefix] || ""
+      return c
+    end
+
+    # @param folder [String]
+    # @return [String]
+    def generate(folder = ".")
+      path = File.join(File.expand_path(folder), self.file_name())
+      File.open(path, "a") { |f| f.write(self.render() + "\n") }
+      return path
+    end
+
+    # @return [String]
+    def render()
+      parts = []
+      parts << (self.description&.length&.positive? ? self.description.comment.strip : nil)
+      parts << (self.parent.nil? ? "class #{self.class_name()}" : "class #{self.class_name()} < #{self.parent}")
+      parts << self.render_attributes()
+      parts << (self.body&.length&.positive? ? self.body.indent(2) : nil)
+      parts << "end"
+      if self.modules.length > 0
+        body = parts.compact.join("\n").gsub(/\s+$/, "")
+        return Ginny.mod(body, self.modules)
+      end
+      return parts.compact.join("\n").gsub(/\s+$/, "")
+    end
+
+    # @return [String]
+    def render_attributes()
+      return nil unless self.attrs.length > 0
+      return self.attrs.map(&:render).join("\n").indent(2)
+    end
+
+    # @return [String]
+    def class_name()
+      inflector = Dry::Inflector.new
+      return inflector.classify(inflector.underscore(self.name))
+    end
+
+    # @return [String]
+    def file_name()
+      inflector = Dry::Inflector.new
+      return self.file_prefix + inflector.underscore(self.name) + ".rb"
+    end
+
+  end
+end

data/lib/ginny/models/func.rb

@@ -0,0 +1,86 @@
+module Ginny
+  # Used to generate a [method][2].
+  #
+  # [1]: https://ruby-doc.org/core-2.6.5/Method.html
+  # [2]: https://ruby-doc.org/core-2.6.5/doc/syntax/methods_rdoc.html
+  class Func
+
+    # Name of the function.
+    # @return [String]
+    attr_accessor :name
+    # Description of the function. [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) is supported.
+    # @return [String]
+    attr_accessor :description
+    # Return [type](https://rubydoc.info/gems/yard/file/docs/GettingStarted.md#Declaring_Types) of the function.
+    # @return [String]
+    attr_accessor :return_type
+    # String to write into the body of the function.
+    # @return [String]
+    attr_accessor :body
+    # List of modules to declare the function inside of.
+    # @return [String]
+    attr_accessor :modules
+    # An array of {Ginny::Param}s.
+    # @return [Array<Param>]
+    attr_accessor :params
+
+    # @return [void]
+    def initialize()
+      self.params = []
+      self.modules = []
+    end
+
+    # Constructor for a Func. Use `create`, not `new`.
+    #
+    # @param args [Hash<Symbol>]
+    # @return [Ginny::Func]
+    def self.create(args = {})
+      f = Ginny::Func.new()
+      f.name        = args[:name]
+      f.description = args[:description]
+      f.return_type = args[:return_type]
+      f.body        = args[:body]
+      f.modules     = args[:modules] unless args[:modules].nil?
+      f.params      = Ginny::Param.from_array(args[:params]) if args[:params]&.is_a?(Array)
+      return f
+    end
+
+    # @return [String]
+    def render()
+      # return self.render_compact() if self.body.nil? && self.params.length == 0
+      parts = []
+      parts << self.render_description()
+      parts << self.params.map(&:render_doc).join("\n") unless self.params.length == 0
+      parts << self.render_return_type()
+      parts << "def " + self.name + self.render_params()
+      parts << self.body.indent(2) unless self.body.nil?
+      parts << "end"
+
+      body = parts.compact.join("\n").gsub(/\s+$/, "")
+
+      return Ginny.mod(body, self.modules) if self.modules.length > 0
+      return body
+    end
+
+    # @return [String]
+    def render_params()
+      return "()" if self.params.length == 0
+      # if self.params.length >= 5
+      #   return "(\n" + self.params.map(&:render).join(",\n").indent(2) + "\n)"
+      # end
+      return "(" + self.params.map(&:render).join(", ") + ")"
+    end
+
+    # @return [String]
+    def render_return_type
+      type = self.return_type.nil? ? "void" : self.return_type
+      return "# @return [#{type}]"
+    end
+
+    # @return [String]
+    def render_description()
+      return (self.description&.length&.positive? ? self.description.comment.strip : nil)
+    end
+
+  end
+end