develoz-rails 0.1.0

data/lib/develoz/canonical_fetcher.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "base64"
+require "json"
+require "fileutils"
+
+module Develoz
+  class CanonicalFetcher
+    GITHUB_API_BASE = "https://api.github.com"
+
+    def self.fetch(repo:, path:, dest:)
+      new.fetch(repo: repo, path: path, dest: dest)
+    end
+
+    def fetch(repo:, path:, dest:)
+      url = "#{GITHUB_API_BASE}/repos/#{repo}/contents/#{path}"
+      token = fetch_token
+
+      response = make_request(url, token)
+      raise "Failed to fetch #{repo}/#{path}: #{response.code}" unless response.code == "200"
+
+      content = JSON.parse(response.body)["content"]
+      decoded = Base64.decode64(content)
+
+      FileUtils.mkdir_p(File.dirname(dest))
+      File.write(dest, decoded)
+    end
+
+    private
+
+    def fetch_token
+      ENV["GH_TOKEN"] || shell_token
+    end
+
+    def shell_token
+      `gh auth token 2>/dev/null`.strip
+    rescue StandardError => e
+      warn "Unable to retrieve GitHub token: #{e.message}"
+      nil
+    end
+
+    def make_request(url, token)
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = 5
+      http.read_timeout = 5
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request["Authorization"] = "token #{token}" if token
+
+      http.request(request)
+    end
+  end
+end

data/lib/develoz/cli.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "thor"
+require "tty-prompt"
+require_relative "version"
+
+module Develoz
+  class CLI < Thor
+    OPT_IN_FLAGS = %i[api auth pwa push active_resource admin ui kamal docker db_backup].freeze
+    FLAG_LABELS = {
+      api: "API layer", auth: "authentication", pwa: "PWA support",
+      push: "push notifications", active_resource: "ActiveResource",
+      admin: "admin dashboard", ui: "develoz-ui", kamal: "Kamal deployment",
+      docker: "Docker setup", db_backup: "database backups"
+    }.freeze
+    RAILS_NEW_SKIPS = %w[--skip-test --skip-ci --skip-bundle].freeze
+
+    desc "version", "Show version"
+    def version
+      puts "develoz #{Develoz::VERSION}"
+    end
+
+    desc "new APP_NAME", "Generate a new Develoz Rails app"
+    option :api, type: :boolean
+    option :auth, type: :boolean
+    option :pwa, type: :boolean
+    option :push, type: :boolean
+    option :active_resource, type: :boolean
+    option :admin, type: :boolean
+    option :ui, type: :boolean
+    option :kamal, type: :boolean
+    option :docker, type: :boolean
+    option :db_backup, type: :boolean
+    option :skip_pagy, type: :boolean
+    option :ruby, type: :string
+    option :rails, type: :string
+    option :yes, type: :boolean
+    def new(app_name)
+      resolved = resolve_flags
+      resolver = Develoz::VersionResolver.new
+      versions = resolver.resolve(ruby: options[:ruby], rails: options[:rails])
+      run_rails_new(app_name, versions[:rails])
+      write_version_files(app_name, versions, resolver)
+      invoke_install(app_name, resolved)
+      puts "Created #{app_name} with Develoz Rails template."
+    end
+
+    private
+
+    def resolve_flags
+      OPT_IN_FLAGS.index_with { |flag| resolve_flag(flag) }
+    end
+
+    def resolve_flag(flag)
+      return options[flag] unless options[flag].nil?
+      return false if options[:yes]
+
+      prompt.yes?("Include #{FLAG_LABELS[flag]}?")
+    end
+
+    def prompt
+      @prompt ||= TTY::Prompt.new
+    end
+
+    def run_rails_new(app_name, rails_version)
+      return if system("rails", "new", app_name, "--rails-version=#{rails_version}", *RAILS_NEW_SKIPS)
+
+      raise "Failed to generate Rails app: #{app_name}"
+    end
+
+    def write_version_files(app_name, versions, resolver)
+      dir = File.expand_path(app_name)
+      resolver.write_tool_versions(dir, ruby: versions[:ruby])
+      resolver.write_ruby_version(dir, ruby: versions[:ruby])
+    end
+
+    def invoke_install(app_name, resolved)
+      opts = resolved.merge(skip_pagy: options[:skip_pagy])
+      Dir.chdir(app_name) do
+        Develoz::Generators::InstallGenerator.new([], opts, destination_root: Dir.pwd).install
+      end
+    end
+  end
+end

data/lib/develoz/generators/base.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Develoz
+  module Generators
+    class Base < Rails::Generators::Base
+      cattr_accessor :migration_counter, default: 0
+
+      def self.next_migration_timestamp
+        self.migration_counter += 1
+        (Time.now.utc + migration_counter).strftime("%Y%m%d%H%M%S")
+      end
+
+      delegate :next_migration_timestamp, to: :class
+
+      def self.source_root
+        File.expand_path("../../../templates", __dir__)
+      end
+
+      def app_name
+        File.basename(destination_root)
+      end
+
+      def app_class
+        app_name.camelize
+      end
+
+      def inject_once(into:, content:, after: nil, before: nil, marker: nil)
+        file_path = File.join(destination_root, into)
+        return unless File.exist?(file_path)
+
+        file_content = File.read(file_path)
+
+        if marker && file_content.include?(marker)
+          say "#{into}: marker '#{marker}' already present, skipping", :green
+          return
+        end
+
+        if file_content.include?(content)
+          say "#{into}: content already present, skipping", :green
+          return
+        end
+
+        if after
+          inject_into_file(into, "#{content}\n", after: after)
+        elsif before
+          inject_into_file(into, "#{content}\n", before: before)
+        else
+          inject_into_file(into, "#{content}\n")
+        end
+      end
+
+      def add_gem(name, version = nil, group: nil, **)
+        file_path = File.join(destination_root, "Gemfile")
+        return unless File.exist?(file_path)
+
+        gemfile_content = File.read(file_path)
+
+        if gemfile_content.match?(/^\s*gem\s+["']#{Regexp.escape(name)}["']/)
+          say "Gemfile: gem '#{name}' already present, skipping", :green
+          return
+        end
+
+        gem(name, version, group: group, **)
+        gemfile = File.read(file_path)
+        formatted_gemfile = gemfile.gsub(/group: \[([^\]\n]+)\]/, 'group: [ \1 ]')
+        File.write(file_path, formatted_gemfile) if formatted_gemfile != gemfile
+      end
+
+      def insert_route(route_line)
+        file_path = File.join(destination_root, "config/routes.rb")
+        return unless File.exist?(file_path)
+
+        routes_content = File.read(file_path)
+
+        if routes_content.include?(route_line)
+          say "config/routes.rb: route already present, skipping", :green
+          return
+        end
+
+        inject_into_file("config/routes.rb", "  #{route_line}\n", before: /^end\s*$/)
+      end
+
+      def append_env(key, value, example: true)
+        env_file = File.join(destination_root, ".env")
+        env_example_file = File.join(destination_root, ".env.example")
+
+        if File.exist?(env_file)
+          env_content = File.read(env_file)
+          if env_content.include?("#{key}=")
+            say ".env: key '#{key}' already present, skipping", :green
+          else
+            append_to_file(".env", "#{key}=#{value}\n")
+          end
+        end
+
+        return unless example && File.exist?(env_example_file)
+
+        example_content = File.read(env_example_file)
+        if example_content.include?("#{key}=")
+          say ".env.example: key '#{key}' already present, skipping", :green
+        else
+          append_to_file(".env.example", "#{key}=\n")
+        end
+      end
+
+      def ensure_gitignore(pattern)
+        file_path = File.join(destination_root, ".gitignore")
+        return unless File.exist?(file_path)
+
+        gitignore_content = File.read(file_path)
+
+        if gitignore_content.include?(pattern)
+          say ".gitignore: pattern '#{pattern}' already present, skipping", :green
+          return
+        end
+
+        append_to_file(".gitignore", "#{pattern}\n")
+      end
+
+      def migration_exists?(name)
+        Dir.glob(File.join(destination_root, "db/migrate/*_#{name}.rb")).any?
+      end
+
+      def apply_template(name, destination)
+        template_file = File.join(self.class.source_root, name)
+        return unless File.exist?(template_file)
+
+        copy_file(name, destination)
+      end
+    end
+  end
+end

data/lib/develoz/manifest.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Develoz
+  class Manifest
+    Entry = Struct.new(:name, :description)
+
+    class << self
+      def load
+        manifest_path = File.expand_path("../../config/generators.yml", __dir__)
+        yaml_content = File.read(manifest_path)
+        YAML.safe_load(yaml_content) || {}
+      end
+
+      def for(options)
+        manifest = load
+        auto_include_pwa(options)
+        entries = []
+
+        manifest.each do |name, config|
+          if config["always"]
+            entries << Entry.new(name, config["description"])
+          else
+            requires = config["requires"] || []
+            entries << Entry.new(name, config["description"]) if requires_met?(options, requires)
+          end
+        end
+
+        entries
+      end
+
+      private
+
+      def auto_include_pwa(options)
+        options.instance_variable_set(:@pwa, true) if options.push? && !options.pwa?
+      end
+
+      def requires_met?(options, requires)
+        requires.all? { |flag| options.public_send("#{flag}?") }
+      end
+    end
+  end
+end

data/lib/develoz/options.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Develoz
+  class Options
+    # Opt-in feature flags (default false)
+    OPT_IN_FLAGS = %i[api auth pwa push active_resource admin ui kamal docker db_backup].freeze
+
+    # Opt-out flags (default false → feature is included unless skipped)
+    OPT_OUT_FLAGS = %i[skip_pagy].freeze
+
+    # All valid flag keys
+    VALID_KEYS = (OPT_IN_FLAGS + OPT_OUT_FLAGS + %i[app_name ruby_version rails_version]).freeze
+
+    attr_reader :app_name, :ruby_version, :rails_version
+
+    def initialize(options = {})
+      unknown_keys = options.keys - VALID_KEYS
+      raise ArgumentError, "Unknown option(s): #{unknown_keys.join(', ')}" if unknown_keys.any?
+
+      @app_name = options[:app_name]
+      @ruby_version = options[:ruby_version]
+      @rails_version = options[:rails_version]
+
+      # Initialize opt-in flags (default false)
+      OPT_IN_FLAGS.each do |flag|
+        instance_variable_set("@#{flag}", options[flag] || false)
+      end
+
+      # Initialize opt-out flags (default false)
+      OPT_OUT_FLAGS.each do |flag|
+        instance_variable_set("@#{flag}", options[flag] || false)
+      end
+    end
+
+    # Predicate readers for opt-in flags
+    OPT_IN_FLAGS.each do |flag|
+      define_method("#{flag}?") { instance_variable_get("@#{flag}") }
+    end
+
+    # Predicate readers for opt-out flags
+    OPT_OUT_FLAGS.each do |flag|
+      define_method("#{flag}?") { instance_variable_get("@#{flag}") }
+    end
+
+    def to_h
+      {
+        app_name: @app_name,
+        ruby_version: @ruby_version,
+        rails_version: @rails_version,
+        **OPT_IN_FLAGS.index_with { |flag| instance_variable_get("@#{flag}") },
+        **OPT_OUT_FLAGS.index_with { |flag| instance_variable_get("@#{flag}") }
+      }
+    end
+  end
+end

data/lib/develoz/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Develoz
+  VERSION = "0.1.0"
+end

data/lib/develoz/version_resolver.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module Develoz
+  class VersionResolver
+    RUBY_FALLBACK = "4.0.5"
+    RAILS_FALLBACK = "8.1"
+
+    RUBY_VERSION_URL = "https://cache.ruby-lang.org/pub/misc/latest_ruby"
+    RAILS_VERSION_URL = "https://rubygems.org/api/v1/versions/rails/latest.json"
+
+    TIMEOUT_SECONDS = 5
+
+    def self.resolve(ruby: nil, rails: nil)
+      new.resolve(ruby:, rails:)
+    end
+
+    def resolve(ruby: nil, rails: nil)
+      {
+        ruby: ruby || fetch_ruby_version,
+        rails: rails || fetch_rails_version
+      }
+    end
+
+    def self.write_tool_versions(dir, ruby:, node: "24.15.0")
+      new.write_tool_versions(dir, ruby:, node:)
+    end
+
+    def write_tool_versions(dir, ruby:, node: "24.15.0")
+      path = File.join(dir, ".tool-versions")
+      content = "ruby #{ruby}\nnodejs #{node}\n"
+      File.write(path, content)
+    end
+
+    def self.write_ruby_version(dir, ruby:)
+      new.write_ruby_version(dir, ruby:)
+    end
+
+    def write_ruby_version(dir, ruby:)
+      path = File.join(dir, ".ruby-version")
+      content = "#{ruby}\n"
+      File.write(path, content)
+    end
+
+    private
+
+    def fetch_ruby_version
+      response = fetch_url(RUBY_VERSION_URL)
+      unless response
+        warn "Unable to fetch Ruby version; using fallback #{RUBY_FALLBACK}"
+        return RUBY_FALLBACK
+      end
+
+      version = response.strip
+      return version unless version.empty?
+
+      warn "Ruby version response was empty; using fallback #{RUBY_FALLBACK}"
+      RUBY_FALLBACK
+    end
+
+    def fetch_rails_version
+      response = fetch_url(RAILS_VERSION_URL)
+      unless response
+        warn "Unable to fetch Rails version; using fallback #{RAILS_FALLBACK}"
+        return RAILS_FALLBACK
+      end
+
+      data = JSON.parse(response)
+      version = data["version"]
+      return version if version.present?
+
+      warn "Rails version response was empty; using fallback #{RAILS_FALLBACK}"
+      RAILS_FALLBACK
+    rescue JSON::ParserError => e
+      warn "Unable to parse Rails version response (#{e.message}); using fallback #{RAILS_FALLBACK}"
+      RAILS_FALLBACK
+    end
+
+    def fetch_url(url)
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = TIMEOUT_SECONDS
+      http.read_timeout = TIMEOUT_SECONDS
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+      response = http.request(request)
+
+      return response.body if response.is_a?(Net::HTTPSuccess)
+
+      nil
+    rescue StandardError => e
+      warn_fetch_failure(url, e)
+      nil
+    end
+
+    def warn_fetch_failure(url, error)
+      warn "Unable to fetch version from #{url} (#{error.message})"
+    end
+  end
+end

data/lib/develoz.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Develoz
+  class Error < StandardError; end
+end
+
+require_relative "develoz/version"
+
+Dir[File.expand_path("develoz/**/*.rb", __dir__)].each do |file|
+  require file unless file.end_with?("version.rb")
+end
+
+Dir[File.expand_path("generators/develoz/**/*.rb", __dir__)].each do |file|
+  require file
+end

data/lib/generators/develoz/active_resource/active_resource_generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "develoz"
+
+module Develoz
+  module Generators
+    class ActiveResourceGenerator < Develoz::Generators::Base
+      def self.source_root
+        File.expand_path("templates", __dir__)
+      end
+
+      def add_activeresource_gem
+        add_gem "activeresource"
+      end
+
+      def create_application_resource
+        template "application_resource.rb.tt", "app/models/application_resource.rb"
+      end
+
+      def create_example_resource
+        template "example_resource.rb.tt", "app/models/example_resource.rb"
+      end
+    end
+  end
+end

data/lib/generators/develoz/active_resource/templates/application_resource.rb.tt

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ApplicationResource < ActiveResource::Base
+  self.site = ENV.fetch("ACTIVE_RESOURCE_SITE", "")
+  self.headers["Authorization"] = ENV.fetch("ACTIVE_RESOURCE_AUTHORIZATION", "")
+  self.headers["Accept"] = "application/json"
+end

data/lib/generators/develoz/active_resource/templates/example_resource.rb.tt

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ExampleResource < ApplicationResource
+  # self.element_name = "example"
+end

data/lib/generators/develoz/admin/admin_generator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "develoz"
+
+module Develoz
+  module Generators
+    class AdminGenerator < Develoz::Generators::Base
+      def self.source_root
+        File.expand_path("templates", __dir__)
+      end
+
+      class_option :ui, type: :boolean, default: false
+
+      def create_admin_base_controller
+        template "admin_base_controller.rb.tt", "app/controllers/admin/base_controller.rb"
+      end
+
+      def create_admin_layout
+        template "admin_layout.html.erb.tt", "app/views/layouts/admin.html.erb"
+      end
+
+      def create_dashboard_controller
+        template "dashboard_controller.rb.tt", "app/controllers/admin/dashboard_controller.rb"
+      end
+
+      def create_dashboard_view
+        template "dashboard_index.html.erb.tt",
+                 "app/views/admin/dashboard/index.html.erb"
+      end
+
+      def insert_admin_routes
+        inject_once(
+          into: "config/routes.rb",
+          content: "  namespace :admin do\n    root \"dashboard#index\"\n  end",
+          before: /^end\s*$/
+        )
+      end
+
+      def ui_enabled?
+        options[:ui]
+      end
+    end
+  end
+end

data/lib/generators/develoz/admin/templates/admin_base_controller.rb.tt

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Admin
+  class BaseController < ApplicationController
+    layout "admin"
+  end
+end

data/lib/generators/develoz/admin/templates/admin_layout.html.erb.tt

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Admin &middot; <%%= app_name %></title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; }
+    body { margin: 0; font-family: system-ui, -apple-system, sans-serif; color: #1a1a1a; background: #f5f5f5; }
+    .admin-shell { display: flex; min-height: 100vh; }
+    .admin-nav { width: 220px; background: #1f2937; color: #e5e7eb; padding: 1.5rem 1rem; }
+    .admin-nav h1 { font-size: 1rem; margin: 0 0 1.5rem; color: #fff; text-transform: uppercase; letter-spacing: 0.05em; }
+    .admin-nav a { display: block; padding: 0.5rem 0.75rem; color: #e5e7eb; text-decoration: none; border-radius: 0.25rem; }
+    .admin-nav a:hover { background: #374151; color: #fff; }
+    .admin-main { flex: 1; padding: 2rem; overflow-y: auto; }
+    .admin-flash { margin-bottom: 1rem; padding: 0.75rem 1rem; border-radius: 0.25rem; }
+    .admin-flash.alert { background: #fee2e2; color: #991b1b; }
+    .admin-flash.notice { background: #dcfce7; color: #166534; }
+  </style>
+</head>
+<body>
+  <div class="admin-shell">
+    <nav class="admin-nav">
+      <h1>Admin</h1>
+      <%%= link_to "Dashboard", admin_root_path %>
+    </nav>
+    <main class="admin-main">
+      <%% if flash[:alert] %>
+        <div class="admin-flash alert"><%%= flash[:alert] %></div>
+      <%% end %>
+      <%% if flash[:notice] %>
+        <div class="admin-flash notice"><%%= flash[:notice] %></div>
+      <%% end %>
+      <%%= yield %>
+    </main>
+  </div>
+</body>
+</html>

data/lib/generators/develoz/admin/templates/dashboard_controller.rb.tt

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Admin
+  class DashboardController < Admin::BaseController
+    def index; end
+  end
+end

data/lib/generators/develoz/admin/templates/dashboard_index.html.erb.tt

@@ -0,0 +1,2 @@
+<h1>Dashboard</h1>
+<p>Welcome to the admin dashboard.</p>

data/lib/generators/develoz/admin/templates/routes.rb.tt

@@ -0,0 +1,3 @@
+  namespace :admin do
+    root "dashboard#index"
+  end