hati-rails-api 0.1.0.beta1

data/lib/hati_rails_api/context/core/error_handler.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  module Context
+    module Core
+      # Comprehensive error handling module for the context system
+      # Provides consistent error handling and user-friendly messages
+      module ErrorHandler
+        # Custom errors for the context system
+        class ContextError < StandardError; end
+        class ConfigurationError < ContextError; end
+        class GenerationError < ContextError; end
+        class RollbackError < ContextError; end
+
+        private
+
+        # Wraps operations with comprehensive error handling
+        #
+        # @param operation_name [String] Name of the operation for logging
+        # @yield The block to execute with error handling
+        # @return [Object] The result of the block
+        # @raise [ContextError] Various context-specific errors
+        def with_error_handling(operation_name = caller_locations(1, 1)[0].label)
+          yield
+        rescue ArgumentError => e
+          handle_argument_error(e, operation_name)
+        rescue StandardError => e
+          handle_standard_error(e, operation_name)
+        end
+
+        # Handle argument errors with user-friendly messages
+        def handle_argument_error(error, operation_name)
+          puts "Invalid arguments for #{operation_name}: #{error.message}"
+          puts 'Please check the documentation for correct usage'
+          raise ConfigurationError, error.message
+        end
+
+        # Handle standard errors with context information
+        def handle_standard_error(error, operation_name)
+          puts "Error during #{operation_name}: #{error.message}"
+          puts "Location: #{error.backtrace&.first}"
+
+          case operation_name
+          when /configure/
+            puts 'Check your configuration syntax and required parameters'
+            raise ConfigurationError, error.message
+          when /generate/
+            puts 'Verify your generation block and file permissions'
+            raise GenerationError, error.message
+          when /rollback/
+            puts 'Check if the timestamp exists and files are accessible'
+            raise RollbackError, error.message
+          else
+            raise ContextError, error.message
+          end
+        end
+
+        # Log successful operations
+        def log_success(operation, details = nil)
+          puts "#{operation} completed successfully"
+          puts "#{details}" if details
+        end
+
+        # Log warnings
+        def log_warning(message)
+          puts "Warning: #{message}"
+        end
+
+        # Log information
+        def log_info(message)
+          puts "#{message}"
+        end
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/core/loader.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  module Context
+    module Core
+      # Handles loading of all context components in the correct dependency order
+      # Ensures proper initialization and prevents circular dependencies
+      module Loader
+        # Load all components in the correct order
+        def self.load_all_components
+          load_extensions
+          load_configurations
+          load_shared_components
+          load_layers
+          load_generators
+          load_managers
+        end
+
+        private_class_method def self.load_extensions
+          require_relative '../extensions/string_extensions'
+        end
+
+        private_class_method def self.load_configurations
+          require_relative '../configuration/configuration'
+          require_relative '../configuration/domain_configuration'
+        end
+
+        private_class_method def self.load_shared_components
+          require_relative '../shared/layer_factory'
+          require_relative '../shared/content_generators'
+        end
+
+        private_class_method def self.load_layers
+          require_relative '../layers/standard_layer'
+          require_relative '../layers/operation_layer'
+        end
+
+        private_class_method def self.load_generators
+          require_relative '../generators/base_generator'
+          require_relative '../generators/file_generation'
+          require_relative '../generators/model_endpoint_generator'
+          require_relative '../generators/layer_component_generator'
+          require_relative '../generators/operation_generator'
+          require_relative '../generators/domain_generator'
+          require_relative '../generators/generator'
+        end
+
+        private_class_method def self.load_managers
+          require_relative '../managers/rollback_manager'
+        end
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/core/migration.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  module Context
+    # Base class for context migrations
+    # Provides Rails-like migration interface for context generation
+    class Migration
+      def initialize
+        @generator = nil
+      end
+
+      # Domain definition method
+      #
+      # @param name [Symbol] Domain name
+      # @param block [Proc] Domain configuration block
+      def domain(name, &block)
+        ensure_generator
+        @generator.domain(name, &block)
+      end
+
+      # Model generation method
+      #
+      # @param names [Array, Symbol] Model names to generate
+      def model(names)
+        ensure_generator
+        Array(names).each { |name| @generator.model(name) }
+      end
+
+      # Endpoint generation method
+      #
+      # @param names [Array, Symbol] Endpoint names to generate
+      def endpoint(names)
+        ensure_generator
+        Array(names).each { |name| @generator.endpoint(name) }
+      end
+
+      # Execute the migration - called automatically after change
+      def execute
+        return unless @generator
+
+        @generator.execute
+      end
+
+      # Method to be overridden by migration classes
+      def change
+        raise NotImplementedError, 'Migration classes must implement the change method'
+      end
+
+      # Run the migration (calls change then execute)
+      def run
+        change
+        execute
+      end
+
+      private
+
+      def ensure_generator
+        return if @generator
+
+        # Get the global configuration
+        config = HatiRailsApi::Context.instance_variable_get(:@global_config)
+
+        # Create a new generator instance with force option
+        @generator = HatiRailsApi::Context::Generator.new(config, force: true)
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/core/public_api.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'error_handler'
+
+module HatiRailsApi
+  module Context
+    module Core
+      # Public API module providing all external-facing methods
+      # Includes comprehensive error handling and validation
+      module PublicAPI
+        include ErrorHandler
+
+        # Global configuration storage
+        attr_accessor :global_config
+
+        # Configure the context system with global settings
+        #
+        # @param block [Proc] Configuration block
+        # @return [Configuration] The configuration object
+        # @raise [ArgumentError] If no block is provided
+        #
+        # @example
+        #   Context.configure do |config|
+        #     config.base_path 'app/contexts'
+        #     config.model path: 'app/models', base: 'ApplicationRecord'
+        #   end
+        def configure(&block)
+          raise ArgumentError, 'Configuration block is required' unless block_given?
+
+          with_error_handling do
+            @global_config = Configuration.new
+            @global_config.instance_eval(&block)
+            @global_config
+          end
+        end
+
+        # Generate files based on configuration
+        #
+        # @param force [Boolean] Force overwrite existing files
+        # @param block [Proc] Generation block
+        # @return [Boolean] True if generation was successful
+        # @raise [ArgumentError] If no block is provided
+        #
+        # @example
+        #   Context.generate do |ctx|
+        #     ctx.domain :user do |domain|
+        #       domain.operation { |op| op.component [:create, :update] }
+        #       domain.endpoint enabled: true
+        #     end
+        #   end
+        def generate(force: false, &block)
+          raise ArgumentError, 'Generation block is required' unless block_given?
+
+          with_error_handling do
+            generator = Generator.new(@global_config, force: force)
+            generator.instance_eval(&block)
+            generator.execute
+            true
+          end
+        end
+
+        # Rollback generated files by timestamp or last generation
+        #
+        # @param timestamp [String, nil] Specific timestamp to rollback, or nil for last
+        # @return [Boolean] True if rollback was successful
+        #
+        # @example
+        #   Context.rollback('20240101120000')  # specific timestamp
+        #   Context.rollback                    # last generation
+        def rollback(timestamp = nil)
+          with_error_handling do
+            rollback_manager = RollbackManager.new
+
+            if timestamp
+              rollback_manager.rollback_by_timestamp?(timestamp)
+            else
+              rollback_manager.rollback_last?
+            end
+          end
+        end
+
+        # List all tracked generations with detailed information
+        #
+        # @return [Boolean] True if listing was successful
+        #
+        # @example
+        #   Context.list_generations
+        def list_generations
+          with_error_handling do
+            RollbackManager.new.list_generations
+            true
+          end
+        end
+
+        # Reset the global configuration
+        #
+        # @return [Boolean] True if reset was successful
+        def reset_configuration
+          with_error_handling do
+            @global_config = nil
+            true
+          end
+        end
+
+        # Check if the system is configured
+        #
+        # @return [Boolean] True if configured
+        def configured?
+          !@global_config.nil?
+        end
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/core.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Core components
+require_relative 'core/loader'
+require_relative 'core/public_api'
+require_relative 'core/error_handler'
+require_relative 'core/migration'
+
+module HatiRailsApi
+  module Context
+    # Core module containing all essential components
+    # Provides a clean separation of concerns and proper error handling
+    module Core
+      # Initialize the core system
+      Loader.load_all_components
+    end
+  end
+end

data/lib/hati_rails_api/context/extensions/string_extensions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Simple string extension for camelize if ActiveSupport is not available
+class String
+  def camelize
+    return self if empty?
+
+    # Handle underscored strings - capitalize all words
+    split('_').map(&:capitalize).join
+  end
+end

data/lib/hati_rails_api/context/generators/base_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'file_generation'
+
+module HatiRailsApi
+  module Context
+    # Base generator class providing common functionality
+    # Follows DRY principle - shared functionality for all generators
+    class BaseGenerator
+      include FileGeneration
+
+      TIMESTAMP_PATTERN = '%Y%m%d%H%M%S'
+
+      attr_reader :config, :generated_files, :timestamp, :force
+
+      def initialize(config = nil, force: false)
+        @config = config
+        @generated_files = []
+        @timestamp = Time.now.strftime(TIMESTAMP_PATTERN)
+        @force = force
+        @override_all = nil
+      end
+
+      private
+
+      def override_all_state(value = nil)
+        return @override_all if value.nil?
+
+        @override_all = value
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/generators/domain_generator.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative 'base_generator'
+require_relative '../shared/layer_factory'
+require_relative 'file_generation'
+require_relative 'model_endpoint_generator'
+require_relative 'layer_component_generator'
+require_relative 'operation_generator'
+
+module HatiRailsApi
+  module Context
+    # Domain generator class for handling domain-specific generation
+    # Follows Single Responsibility Principle - handles domain context generation
+    class DomainGenerator
+      include LayerFactory
+      include FileGeneration
+      include ModelEndpointGenerator
+      include LayerComponentGenerator
+      include OperationGenerator
+
+      DEFAULT_DOMAIN_STATE = { enabled: false }.freeze
+      CONTEXT_PATH = 'app/contexts'
+      HATI_OPERATION_BASE = 'hati_operation/base'
+      DEFAULT_OPTIONS = {}.freeze
+      DEFAULT_FILES = [].freeze
+
+      attr_reader :name, :config, :layers, :options
+
+      def initialize(
+        name:,
+        config:,
+        options: DEFAULT_OPTIONS,
+        generated_files: DEFAULT_FILES,
+        force: false,
+        override_all: nil
+      )
+        @name = name
+        @config = config
+        @options = options
+        @generated_files = generated_files
+        @force = force
+        @override_all = override_all
+
+        @domain_model = DEFAULT_DOMAIN_STATE.dup
+        @domain_endpoint = DEFAULT_DOMAIN_STATE.dup
+
+        @layers = {}
+        @ctx_reference = nil
+
+        setup_layers
+      end
+
+      def operation(&block)
+        @layers[:operation] = create_operation_layer(&block)
+      end
+
+      def layer(name, &block)
+        @layers[name.to_sym] = create_standard_layer(name, &block)
+      end
+
+      def model(enabled_or_options = true, **options)
+        @domain_model =
+          case enabled_or_options
+          when false
+            DEFAULT_DOMAIN_STATE
+          when Hash
+            { enabled: true, options: enabled_or_options }
+          else
+            { enabled: true, options: options }
+          end
+      end
+
+      def endpoint(enabled_or_components = true, components: [], **options)
+        # Handle different argument patterns:
+        # endpoint true
+        # endpoint enabled: true
+        # endpoint [:comp1, :comp2]
+        # endpoint enabled: true, components: [:comp1]
+
+        enabled =
+          case enabled_or_components
+          when Array
+            true
+          when Hash
+            enabled_or_components.fetch(:enabled, true)
+          else
+            enabled_or_components
+          end
+
+        components_to_use =
+          case enabled_or_components
+          when Array
+            enabled_or_components
+          else
+            components
+          end
+
+        @domain_endpoint = create_endpoint_state(enabled, components_to_use, options)
+      end
+
+      def generate
+        generate_domain_model    if @domain_model[:enabled]
+        generate_domain_endpoint if @domain_endpoint[:enabled]
+        generate_layers
+      end
+
+      def context_reference=(ctx)
+        @ctx_reference = ctx
+      end
+
+      private
+
+      def generate_layers
+        base_path = File.join(@config&.base_path || CONTEXT_PATH, @name.to_s)
+
+        # Safety check: remove file if contexts exists as file instead of directory
+        contexts_root = @config&.base_path || CONTEXT_PATH
+        File.delete(contexts_root) if File.exist?(contexts_root) && !File.directory?(contexts_root)
+
+        FileUtils.mkdir_p(base_path)
+
+        @layers.each do |layer_name, layer_config|
+          generate_layer(
+            base_path: base_path,
+            layer_name: layer_name,
+            layer_config: layer_config
+          )
+        end
+      end
+
+      def setup_layers
+        if options[:layers]
+          copy_default_layers
+          setup_specific_layers
+        else
+          copy_default_layers
+        end
+      end
+
+      def setup_specific_layers
+        requested_layers = options[:layers]
+        requested_components = options[:components]
+
+        setup_requested_layers(requested_layers, requested_components)
+        cleanup_unrequested_layers(requested_layers)
+      end
+
+      def setup_requested_layers(layers, components)
+        layers.each do |layer_name|
+          if @layers[layer_name]
+            update_existing_layer(layer_name, components)
+          else
+            create_new_layer(layer_name, components)
+          end
+        end
+      end
+
+      def update_existing_layer(name, components)
+        layer = @layers[name]
+        layer.component(components) if components
+      end
+
+      def create_new_layer(name, components)
+        @layers[name] =
+          if name == :operation
+            create_operation_layer_with_components(components)
+          else
+            create_standard_layer_with_components(name, components)
+          end
+      end
+
+      def create_operation_layer_with_components(components)
+        OperationLayer.new.tap do |layer|
+          layer.base(HATI_OPERATION_BASE)
+          layer.component(components) if components
+        end
+      end
+
+      def create_standard_layer_with_components(name, components)
+        StandardLayer.new(name).tap do |layer|
+          layer.base("application_#{name}")
+          layer.component(components) if components
+        end
+      end
+
+      def cleanup_unrequested_layers(requested_layers)
+        @layers.select! { |name, _| requested_layers.include?(name) }
+      end
+
+      def copy_default_layers
+        return unless @config&.domain_config&.layers
+
+        @config.domain_config.layers.each do |name, layer|
+          @layers[name] = layer.dup
+        end
+      end
+
+      def method_missing(method_name, ...)
+        result = create_dynamic_layer(method_name, ...)
+        return super unless result
+
+        @layers[method_name.to_sym] = result
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+
+      def create_endpoint_state(enabled, components, options)
+        case enabled
+        when false then DEFAULT_DOMAIN_STATE
+        when true  then { enabled: true, options: options, explicit_components: components.empty? ? nil : components }
+        when Array then { enabled: true, options: options, explicit_components: enabled }
+        when Hash  then { enabled: true, options: enabled, explicit_components: nil }
+        end
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/generators/file_generation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module HatiRailsApi
+  module Context
+    # Shared concern for file generation operations
+    # Eliminates duplicate file handling code across generators
+    module FileGeneration
+      ALL_RGX = [/^a/, /all/, /^a=all$/].freeze
+      SKIP_RGX = [/^s/, /skip/, /^s=skip$/].freeze
+      YES_RGX = [/^y/, /yes$/].freeze
+      NO_RGX = [/^n/, /no$/].freeze
+
+      def generate_file?(file_path, content)
+        FileUtils.mkdir_p(File.dirname(file_path))
+
+        if create_file?(file_path)
+          File.write(file_path, content)
+          @generated_files << file_path
+          puts "Created: #{file_path}"
+          true
+        else
+          puts "Skipped: #{file_path} (already exists or user declined)"
+          false
+        end
+      end
+
+      def create_file?(file_path)
+        return true unless File.exist?(file_path)
+        return true if @force
+        return override_all? unless override_all?.nil?
+
+        prompt_for_override(file_path)
+      end
+
+      def override_all?
+        return @override_all_ref.call(:get) if shared_override_state?
+
+        @override_all
+      end
+
+      def shared_override_state?
+        respond_to?(:use_shared_override_state?) && use_shared_override_state?
+      end
+
+      def prompt_for_override(file_path)
+        print "File '#{file_path}' already exists. Override? (y/N/a=all/s=skip all): "
+        handle_override_response($stdin.gets&.chomp&.downcase || 'n')
+      end
+
+      def handle_override_response(response)
+        case response
+        when *ALL_RGX  then self.override_all_state = true
+        when *SKIP_RGX then self.override_all_state = false
+        when *YES_RGX  then true
+        else false
+        end
+      end
+
+      def override_all_state=(value)
+        use_shared = respond_to?(:use_shared_override_state?) && use_shared_override_state?
+
+        use_shared ? @override_all_ref&.call(value) : @override_all = value
+      end
+
+      def use_shared_override_state?
+        @override_all_ref&.respond_to?(:call)
+      end
+    end
+  end
+end