cybertrain 0.1.0

data/cybertrain/cli.rb

@@ -0,0 +1,100 @@
+# The `cybertrain` command: exe/cybertrain under CRuby (the gem), or
+# bin/cybertrain.rb built by spin (`spin install` from a checkout).
+#
+#   cybertrain new NAME [--path DIR | --version V] [--skip-spin]
+#   cybertrain generate scaffold NAME field:type ... [parent:references]
+#   cybertrain version | help
+require "cybertrain/version"
+require "cybertrain/cli/templates"
+require "cybertrain/cli/new_app"
+require "cybertrain/cli/scaffold"
+
+module Cybertrain
+  module CLI
+    USAGE = <<~TEXT
+      Usage:
+        cybertrain new NAME [--path DIR | --version V] [--skip-spin]
+            Create an application in NAME, then run `spin lock` and
+            `spin run gen` in it (skipped with --skip-spin). Its spin.toml
+            depends on this cybertrain's release by default:
+              git tag v#{Cybertrain::VERSION} of #{Cybertrain::REPOSITORY}
+            --path DIR: the framework checkout at DIR (relative to the
+            current directory; written as an absolute path).
+            --version V: the index version constraint V.
+        cybertrain generate scaffold NAME field:type ... [parent:references]
+            Add a resource to the application in the current directory.
+            Types: #{Field::TYPES.join(", ")} (default string).
+        cybertrain version
+        cybertrain help
+    TEXT
+
+    # Returns the process exit code.
+    def self.run(argv)
+      command = argv.empty? ? "" : argv[0]
+      case command
+      when "new" then run_new(argv)
+      when "generate", "g" then run_generate(argv)
+      when "version", "--version", "-v"
+        puts "cybertrain #{Cybertrain::VERSION}"
+        0
+      when "help", "--help", "-h"
+        puts USAGE
+        0
+      else
+        puts "Unknown command '#{command}'" unless command == ""
+        puts USAGE
+        1
+      end
+    rescue InvalidArgument => e
+      puts "error: #{e.message}"
+      1
+    end
+
+    def self.run_new(argv)
+      raise InvalidArgument, "usage: cybertrain new NAME [--path DIR | --version V] [--skip-spin]" if argv.size < 2
+
+      dir = argv[1]
+      raise InvalidArgument, "'#{File.basename(dir)}' is not a valid app name (lowercase letters, digits and _)" unless Templates.identifier?(File.basename(dir))
+      raise InvalidArgument, "#{dir} already exists" if File.exist?(dir)
+
+      NewApp.create(dir, framework_dep(argv))
+      return 0 if argv.include?("--skip-spin")
+
+      NewApp.bootstrap(dir) ? 0 : 1
+    end
+
+    # The spin.toml value of the `cybertrain =` dependency. By default the
+    # release tag matching this CLI, so the templates it just wrote and the
+    # framework the app builds against are the same version.
+    # A relative --path is expanded against the current directory: spin
+    # resolves `path =` from the new app's directory, not from where the
+    # command ran.
+    def self.framework_dep(argv)
+      path = option(argv, "--path")
+      version = option(argv, "--version")
+      raise InvalidArgument, "pass either --path or --version, not both" unless path == "" || version == ""
+      return "\"#{version}\"" unless version == ""
+      return "{ path = \"#{File.expand_path(path, Dir.pwd)}\" }" unless path == ""
+
+      "{ git = \"#{Cybertrain::REPOSITORY}\", ref = \"v#{Cybertrain::VERSION}\" }"
+    end
+
+    # The value after `--flag`, or "" when the flag is absent.
+    def self.option(argv, flag)
+      i = argv.index(flag)
+      return "" if i.nil?
+      raise InvalidArgument, "#{flag} needs a value" if i + 1 >= argv.size
+
+      argv[i + 1]
+    end
+
+    def self.run_generate(argv)
+      kind = argv.size > 1 ? argv[1] : ""
+      raise InvalidArgument, "only `generate scaffold` is supported" unless kind == "scaffold"
+      raise InvalidArgument, "usage: cybertrain generate scaffold NAME field:type ..." if argv.size < 3
+
+      Scaffold.generate(".", argv[2], argv[3, argv.size - 3])
+      0
+    end
+  end
+end

data/cybertrain/generator/inflector.rb

@@ -0,0 +1,126 @@
+module Cybertrain
+  # The handful of Rails inflections the generators need. Singular/plural
+  # forms come from a small irregulars table plus English suffix rules;
+  # a word that is in neither simply gets the rules ("octopus" -> "octopuses").
+  module Inflector
+    IRREGULARS = {
+      "person" => "people", "man" => "men", "woman" => "women",
+      "child" => "children", "mouse" => "mice", "ox" => "oxen"
+    }
+    UNCOUNTABLE = %w[equipment information rice money species series fish sheep news jeans]
+    # Singulars ending in "s" whose plural adds "es" (Rails' alias/status/bus rules).
+    ES_WORDS = %w[status alias bus]
+
+    # "posts_controller" -> "PostsController"; "admin/posts" -> "Admin::Posts".
+    def self.camelize(str)
+      out = +""
+      upper = true
+      str.each_char do |ch|
+        if ch == "_"
+          upper = true
+        elsif ch == "/"
+          out << "::"
+          upper = true
+        elsif upper
+          out << ch.upcase
+          upper = false
+        else
+          out << ch
+        end
+      end
+      out
+    end
+
+    # "PostsController" -> "posts_controller"; "HTMLParser" -> "html_parser".
+    def self.underscore(str)
+      # Two steps: in a threaded program a collection inside `chars` freed the
+      # unnamed gsub result it was splitting ("Post" came back as "").
+      path = str.gsub("::", "/")
+      chars = path.chars
+      out = +""
+      chars.each_with_index do |ch, i|
+        if upper?(ch)
+          prev = i > 0 ? chars[i - 1] : ""
+          nxt = i + 1 < chars.size ? chars[i + 1] : ""
+          if prev != "" && prev != "/" && (lower_or_digit?(prev) || (upper?(prev) && lower_or_digit?(nxt)))
+            out << "_"
+          end
+          out << ch.downcase
+        else
+          out << ch
+        end
+      end
+      out
+    end
+
+    # "posts" -> "post"; only the last "_" word is inflected ("blog_posts").
+    def self.singularize(str)
+      parts = split_last_word(str)
+      parts[0] + singular_word(parts[1])
+    end
+
+    # "post" -> "posts"; only the last "_" word is inflected.
+    def self.pluralize(str)
+      parts = split_last_word(str)
+      parts[0] + plural_word(parts[1])
+    end
+
+    def self.singular_word(word)
+      return word if UNCOUNTABLE.include?(word)
+
+      IRREGULARS.each { |singular, plural| return singular if word == plural }
+      return word if IRREGULARS.key?(word)
+
+      if word.end_with?("ies") && word.size > 3 && !vowel?(word[word.size - 4])
+        word[0, word.size - 3] + "y"
+      elsif ES_WORDS.include?(word[0, word.size - 2]) || word.end_with?("sses") ||
+            word.end_with?("xes") || word.end_with?("ches") || word.end_with?("shes")
+        word[0, word.size - 2]
+      elsif word.end_with?("ss") || ES_WORDS.include?(word)
+        word
+      elsif word.end_with?("s")
+        word[0, word.size - 1]
+      else
+        word
+      end
+    end
+
+    def self.plural_word(word)
+      return word if UNCOUNTABLE.include?(word)
+
+      plural = IRREGULARS[word]
+      return plural unless plural.nil?
+
+      if word.end_with?("y") && word.size > 1 && !vowel?(word[word.size - 2])
+        word[0, word.size - 1] + "ies"
+      elsif ES_WORDS.include?(word) || word.end_with?("ss") || word.end_with?("x") ||
+            word.end_with?("ch") || word.end_with?("sh")
+        word + "es"
+      elsif word.end_with?("s")
+        word
+      else
+        word + "s"
+      end
+    end
+
+    # "sales_people" -> ["sales_", "people"].
+    def self.split_last_word(str)
+      i = str.rindex("_")
+      return ["", str] if i.nil?
+
+      [str[0, i + 1], str[i + 1, str.size - i - 1]]
+    end
+
+    def self.vowel?(ch)
+      ch == "a" || ch == "e" || ch == "i" || ch == "o" || ch == "u"
+    end
+
+    def self.upper?(ch)
+      ch >= "A" && ch <= "Z"
+    end
+
+    def self.lower_or_digit?(ch)
+      (ch >= "a" && ch <= "z") || (ch >= "0" && ch <= "9")
+    end
+  end
+end

data/cybertrain/version.rb

@@ -0,0 +1,8 @@
+module Cybertrain
+  VERSION = "0.1.0"
+
+  # Where `cybertrain new` points an app's spin.toml by default: the git tag
+  # "v#{VERSION}" of this repository. Kept here because the gem (CRuby) and
+  # the spin-built CLI read the same file.
+  REPOSITORY = "https://github.com/saeki-mototsune/cybertrain"
+end

data/exe/cybertrain

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# The `cybertrain` command as installed by `gem install cybertrain`: the CLI
+# sources are plain Ruby that also run under CRuby (bin/cybertrain.rb is the
+# same entry point, compiled by spin).
+require "cybertrain/cli"
+
+exit(Cybertrain::CLI.run(ARGV))

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: cybertrain
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Saeki Mototsune
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  cybertrain is a Rails-shaped web framework written for Spinel, which
+  compiles an application into a native binary. This gem installs the
+  `cybertrain` command (`cybertrain new`, `cybertrain generate scaffold`);
+  building and running an application needs Spinel's `spin` on PATH.
+executables:
+- cybertrain
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- cybertrain/cli.rb
+- cybertrain/cli/new_app.rb
+- cybertrain/cli/scaffold.rb
+- cybertrain/cli/templates.rb
+- cybertrain/generator/inflector.rb
+- cybertrain/version.rb
+- exe/cybertrain
+homepage: https://github.com/saeki-mototsune/cybertrain
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/saeki-mototsune/cybertrain
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- "."
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: 'The cybertrain CLI: scaffold Rails-shaped apps for the Spinel AOT Ruby compiler'
+test_files: []