foobara-typescript-react-command-form-generator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 046d876be59b51bea2745841e8155702344c33560214efb6b2a6b2381a49bc72
+  data.tar.gz: '0955731184338275963f896dd867544cbfcc2b0bfe8886b1c54715e9bc5878ed'
+SHA512:
+  metadata.gz: 6369d3afc06b6b163aa3320baa2983ff8e17b15bc561aeb2f59262d272a09d0c5af83fe5f436dca88885341586376a76543f4a8267afd1a5423db0f2f4af4aa7
+  data.tar.gz: 75e11096949e2439fe1daaee35c09f5670e098893c5b128a6b2ecb06cd6aadbcfd8c7b5fee79d76fdec326271eb3ac40970a693a05eee472514a6d5b2498bfa6

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## [0.0.1] - 2024-06-17
+
+- Add Apache-2.0 license
+
+## [0.0.0] - 2024-03-13
+
+- Project birth

data/LICENSE.txt

@@ -0,0 +1,8 @@
+This project is dual licensed under your choice of the Apache-2.0 license and the MIT license.
+
+Apache-2.0 License: LICENSE-APACHE.txt or https://www.apache.org/licenses/LICENSE-2.0.txt
+MIT License: LICENSE-MIT.txt or https://opensource.org/licenses/MIT
+
+This is equivalent to the following SPDX License Expression: Apache-2.0 OR MIT
+
+Copyright (c) 2024 Miles Georgi

data/README.md

@@ -0,0 +1,52 @@
+# Foobara::CommandGenerator
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library
+into a gem. Put your Ruby code in the file `lib/foobara/typescript_react_command_form_generator`. To experiment with
+that code,
+run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it
+to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with
+instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+If using Foobara locally, then run the following (TODO: make this no-longer necessary.)
+
+```bash
+bundle config set local.foobara ../foobara
+bundle config set disable_local_branch_check true
+```
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can
+also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub
+at https://github.com/[USERNAME]/foobara-typescript-react-command-form-generator.
+
+## License
+
+This project is licensed under your choice of the Apache-2.0 license or the MIT license.
+See [LICENSE.txt](LICENSE.txt) for more info about licensing.

data/lib/foobara/typescript_react_command_form_generator.rb

@@ -0,0 +1,4 @@
+require "foobara/all"
+require "foobara/typescript_remote_command_generator"
+
+Foobara::Util.require_directory "#{__dir__}/../../src"

data/src/generate_typescript_react_command_form.rb

@@ -0,0 +1,66 @@
+module Foobara
+  module Generators
+    module TypescriptReactCommandFormGenerator
+      class GenerateTypescriptReactCommandForm < Foobara::RemoteGenerator::GenerateTypescript
+        class BadCommandNameError < Value::DataError
+          class << self
+            def context_type_declaration
+              {
+                bad_name: :string,
+                valid_names: [:string]
+              }
+            end
+          end
+        end
+
+        possible_input_error :command_name, BadCommandNameError
+
+        inputs do
+          raw_manifest :associative_array
+          manifest_url :string
+          command_name :string, :required
+        end
+
+        attr_accessor :manifest_data, :command_manifest
+
+        def base_generator
+          Generators::TypescriptReactCommandFormGenerator
+        end
+
+        def execute
+          load_manifest_if_needed
+          find_command_manifest
+          add_command_manifest_to_set_of_elements_to_generate
+
+          each_element_to_generate do
+            generate_element
+          end
+
+          paths_to_source_code
+        end
+
+        def find_command_manifest
+          self.command_manifest = Manifest::Command.new(manifest_data, [:command, command_name])
+        rescue Manifest::InvalidPath
+          valid_keys = manifest_data["command"].keys.sort
+          message = "Invalid command name: #{command_name}. Expected one of #{valid_keys.join(", ")}"
+          error = BadCommandNameError.new(
+            message:,
+            context: {
+              bad_name: command_name,
+              valid_names: valid_keys
+            },
+            path: [:command_name]
+          )
+
+          add_input_error(error)
+          halt!
+        end
+
+        def add_command_manifest_to_set_of_elements_to_generate
+          elements_to_generate << command_manifest
+        end
+      end
+    end
+  end
+end

data/src/typescript_react_command_form_generator.rb

@@ -0,0 +1,229 @@
+module Foobara
+  module Generators
+    module TypescriptReactCommandFormGenerator
+      module Generators
+        class TypescriptReactCommandFormGenerator < RemoteGenerator::Services::TypescriptFromManifestBaseGenerator
+          class << self
+            def manifest_to_generator_classes(manifest)
+              case manifest
+              when Manifest::Command
+                [
+                  Generators::TypescriptReactCommandFormGenerator
+                ]
+              else
+                # :nocov:
+                super
+                # :nocov:
+              end
+            end
+          end
+
+          def template_path
+            "CommandForm.tsx.erb"
+          end
+
+          def target_path
+            *parts, command_name = scoped_full_path
+
+            ["forms", *parts, "#{command_name}Form.tsx"]
+          end
+
+          def command_generator
+            @command_generator ||= RemoteGenerator::Services::CommandGenerator.new(command_manifest)
+          end
+
+          def model_generators(type = inputs_type, initial = true)
+            return @model_generators if defined?(@model_generators)
+
+            generators = if type.entity?
+                           generator_class = RemoteGenerator::Services::UnloadedEntityGenerator
+                           [generator_class.new(type.to_entity)]
+                         elsif type.model?
+                           generator_class = RemoteGenerator::Services::AtomModelGenerator
+                           [generator_class.new(type.to_model)]
+                         elsif type.type.to_sym == :attributes
+                           type.attribute_declarations.values.map do |attribute_declaration|
+                             model_generators(attribute_declaration, false)
+                           end.flatten.uniq
+                         elsif type.is_a?(Manifest::Array)
+                           if type.element_type
+                             model_generators(type.element_type, false)
+                           end
+                         else
+                           # TODO: handle tuples and associative arrays
+                           []
+                         end
+
+            if initial
+              @model_generators = generators
+            end
+
+            generators
+          end
+
+          def dependencies
+            [model_generators, *model_generators.map(&:dependencies)].flatten.uniq
+          end
+
+          def dependencies_to_generate
+            []
+          end
+
+          alias command_manifest relevant_manifest
+
+          def templates_dir
+            "#{__dir__}/../templates"
+          end
+
+          def inputs_class_name
+            "#{command_name}Inputs"
+          end
+
+          def result_class_name
+            "#{command_name}Result"
+          end
+
+          def error_class_name
+            "#{command_name}Error"
+          end
+
+          def command_name_english
+            Util.humanize(Util.underscore(command_name))
+          end
+
+          def non_colliding_inputs(type_declaration = inputs_type, result = [], path = [])
+            if type_declaration.attributes?
+              type_declaration.attribute_declarations.each_pair do |attribute_name, attribute_declaration|
+                non_colliding_inputs(attribute_declaration, result, [*path, attribute_name])
+              end
+            elsif type_declaration.entity?
+              # TODO: figure out how to not pass self here...
+              result << FlattenedAttribute.new(self, path, type_declaration.to_type.primary_key_type)
+            elsif type_declaration.model?
+              non_colliding_inputs(type_declaration.to_type.attributes_type, result, path)
+            elsif type_declaration.array?
+              if type_declaration.element_type
+                model_generators(type_declaration.element_type, false)
+              end
+            else
+              result << FlattenedAttribute.new(self, path, type_declaration)
+            end
+
+            result
+          end
+
+          def populated_inputs_object
+            result = {}
+
+            non_colliding_inputs.each do |flattened_attribute|
+              DataPath.set_value_at(result, flattened_attribute.name, flattened_attribute.path)
+            rescue DataPath::BadPathError
+              value = result
+              parts = flattened_attribute.path[..-2]
+
+              parts.each do |part|
+                value = value[part] ||= {}
+              end
+
+              DataPath.set_value_at(result, flattened_attribute.name, flattened_attribute.path)
+            end
+
+            _to_ts_string(result)
+          end
+
+          # TODO: come up with a better name for this and its parameter
+          def _to_ts_string(result, depth: 0)
+            if result.is_a?(::Hash)
+              output = "#{" " * depth}{\n"
+              result.each_pair.with_index do |(key, value), index|
+                output << "#{" " * depth}  #{key}: #{_to_ts_string(value, depth: depth + 2)}"
+
+                if index != result.size - 1
+                  output << ","
+                end
+
+                output << "\n"
+              end
+
+              "#{output}#{" " * depth}}\n"
+            elsif result.is_a?(::String)
+              result
+            else
+              # :nocov:
+              raise "Not sure how to handle #{result}"
+              # :nocov:
+            end
+          end
+
+          class FlattenedAttribute
+            attr_accessor :path, :type_declaration, :generator
+
+            def initialize(generator, path, type_declaration)
+              self.generator = generator
+              self.path = path
+              self.type_declaration = type_declaration
+            end
+
+            def name
+              first, *rest = path
+
+              first = Util.camelize(first)
+              rest = rest.map { |part| Util.camelize(part) }
+
+              [first, *rest].join
+            end
+
+            def name_upcase
+              [name[0].upcase, name[1..]].compact.join
+            end
+
+            def ts_type
+              generator.foobara_type_to_ts_type(
+                type_declaration,
+                dependency_group: generator.dependency_group
+              )
+            end
+
+            def has_default?
+              type_declaration.attribute? && default
+            end
+
+            def default
+              type_declaration.default
+            end
+
+            def ts_default
+              generator.value_to_ts_value(default)
+            end
+
+            def name_english
+              Util.underscore(name).gsub("_", " ")
+            end
+
+            def html_input
+              # TODO: handle boolean, etc
+              one_of = type_declaration.one_of
+
+              if one_of
+                ts_type = generator.foobara_type_to_ts_type(type_declaration)
+
+                "<select
+                  value={#{name} ?? \"\"}
+                  onChange={(e) => { set#{name_upcase}(e.target.value as #{ts_type}) }}
+                >
+                  #{one_of.map { |value| "<option value=\"#{value}\">#{value}</option>" }.join}
+                </select>"
+              else
+                "<input
+                    value={#{name} ?? \"\"}
+                    onChange={(e) => { set#{name_upcase}(e.target.value) }}
+                    placeholder=\"#{name_english}\"
+                  />"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/src/write_typescript_react_command_form_to_disk.rb

@@ -0,0 +1,86 @@
+require_relative "generate_typescript_react_command_form"
+
+module Foobara
+  module Generators
+    module TypescriptReactCommandFormGenerator
+      class WriteTypescriptReactCommandFormToDisk < RemoteGenerator::WriteTypescriptToDisk
+        class NoManifestError < Foobara::RuntimeError
+          class << self
+            def context_type_declaration
+              {}
+            end
+          end
+        end
+
+        class << self
+          def generator_key
+            "typescript-react-command-form"
+          end
+        end
+
+        inputs do
+          raw_manifest :associative_array, :allow_nil
+          manifest_url :string, :allow_nil
+          command_name :string, :required
+          output_directory :string
+        end
+
+        depends_on GenerateTypescriptReactCommandForm
+
+        def execute
+          load_manifest_if_needed
+          generate_typescript
+          write_all_files_to_disk
+          run_post_generation_tasks
+
+          stats
+        end
+
+        def validate
+          # We don't want to fail if there is no manifest because we might be able to load it from manifest.json
+        end
+
+        def raw_manifest
+          @raw_manifest || inputs[:raw_manifest]
+        end
+
+        def load_manifest_if_needed
+          if !raw_manifest && !manifest_url
+            manifest_path = "#{output_directory}/manifest.json"
+            if File.exist?(manifest_path)
+              @raw_manifest = JSON.parse(File.read(manifest_path))
+            else
+              message = "Because there is no manifest.json to read manifest from, " \
+                        "you must either provide a manifest_url or raw_manifest."
+              error = NoManifestError.new(message:, context: {})
+
+              add_runtime_error(error)
+            end
+          end
+        end
+
+        def output_directory
+          inputs[:output_directory] || default_output_directory
+        end
+
+        def default_output_directory
+          # :nocov:
+          "src/domains"
+          # :nocov:
+        end
+
+        def generate_typescript
+          # TODO: we need a way to allow values to be nil in type declarations
+          inputs = raw_manifest ? { raw_manifest: } : { manifest_url: }
+          inputs.merge!(command_name:)
+
+          self.paths_to_source_code = run_subcommand!(GenerateTypescriptReactCommandForm, inputs)
+        end
+
+        def run_post_generation_tasks
+          eslint_fix
+        end
+      end
+    end
+  end
+end

data/templates/CommandForm.tsx.erb

@@ -0,0 +1,72 @@
+import React, { useState } from 'react'
+
+import { Outcome } from "<%= path_to_root %>/base/Outcome"
+
+import { <%= command_name %> } from "<%= path_to_root %><%= command_generator.import_path %>"
+import <%= inputs_class_name %> from "<%= path_to_root %><%= command_generator.import_path %>/Inputs"
+import <%= result_class_name %> from "<%= path_to_root %><%= command_generator.import_path %>/Result"
+import { Error as <%= error_class_name %> } from "<%= path_to_root %><%= command_generator.import_path %>/Errors"
+
+export default function <%= command_name %>Form (): JSX.Element {
+  <% non_colliding_inputs.each do |flattened_attribute| %>
+    <% if flattened_attribute.has_default? %>
+      const [<%= flattened_attribute.name %>, set<%= flattened_attribute.name_upcase %>] = useState<<%= flattened_attribute.ts_type %>>(<%= flattened_attribute.ts_default %>)
+    <% else %>
+      const [<%= flattened_attribute.name %>, set<%= flattened_attribute.name_upcase %>] = useState<<%= flattened_attribute.ts_type %> | undefined>(undefined)
+    <% end %>
+  <% end %>
+
+  const [result, setResult] = useState<string | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  function toVoid (fn: () => Promise<void>): () => void {
+    return (): void => {
+      void (async (): Promise<void> => { await fn() })()
+    }
+  }
+
+  const run = toVoid(async (): Promise<void> => {
+    <% non_colliding_inputs.each do |flattened_attribute| %>
+      if (<%= flattened_attribute.name %> == null) {
+        // TODO: perform some kind of validation error
+        return
+      }
+    <% end %>
+
+    const inputs: <%= inputs_class_name %> = <%= populated_inputs_object %>
+
+    const command = new <%= command_name %>(inputs)
+
+    try {
+      setResult("Thinking...")
+      setError(null)
+      const outcome: Outcome<<%= result_class_name %>, <%= error_class_name %>> = await command.run()
+
+      if (outcome.isSuccess()) {
+        const result: <%= result_class_name %> = outcome.result
+        setResult(typeof result === 'string' ? result : JSON.stringify(result))
+      } else {
+        setError(outcome.errorMessage)
+        setResult(null)
+      }
+    } catch (error) {
+      setError('Error executing command')
+      setResult(null)
+    }
+  })
+
+  return (
+    <div className="CommandForm">
+      <div>
+        <% non_colliding_inputs.each do |flattened_attribute| %>
+          <%= flattened_attribute.html_input %>
+        <% end %>
+
+        <button onClick={run}><%= command_name_english %></button>
+      </div>
+
+      {(result != null) && <p>{result}</p>}
+      {(error != null) && <p className="error-message">{error}</p>}
+    </div>
+  )
+}

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: foobara-typescript-react-command-form-generator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Miles Georgi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: foobara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: foobara-files-generator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: foobara-typescript-remote-command-generator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- azimux@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/foobara/typescript_react_command_form_generator.rb
+- src/generate_typescript_react_command_form.rb
+- src/typescript_react_command_form_generator.rb
+- src/write_typescript_react_command_form_to_disk.rb
+- templates/CommandForm.tsx.erb
+homepage: https://github.com/foobara/generators-typescript-react-command-form-generator
+licenses:
+- Apache-2.0
+- MIT
+metadata:
+  homepage_uri: https://github.com/foobara/generators-typescript-react-command-form-generator
+  source_code_uri: https://github.com/foobara/generators-typescript-react-command-form-generator
+  changelog_uri: https://github.com/foobara/generators-typescript-react-command-form-generator/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Generates Typescript React forms for Foobara remote commands
+test_files: []