advanced_code_generator 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 789748d3f9da47e662a6a064d1ec96b474c1d4c8575926a2cb0be6c171db38ba
+  data.tar.gz: fe9b5f6fe4222a4aa2af67b8cdc02eea3870c61df80a4e1873d1685104bd893f
+SHA512:
+  metadata.gz: 6f21e274a7800a1fd5bd0c4b231d5c4a62acb253601d88e120a44436000bde70453e8056b8a2e54b24ace11b43e8d586296cf9c1756be8c390745f19177dd446
+  data.tar.gz: 9d96e6669bd01b946a59e29653805fd3bfcc2821f0a5113a98579343c435fec3211f1d0509f0ba9b0ce4a8e18641bef47b0d9f07b775452855bf21e803acae9d

data/.rspec

@@ -0,0 +1,4 @@
+--require rspec
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,17 @@
+inherit_from: .rubocop_todo.yml
+
+plugins:
+  - rubocop-sorted_methods_by_call
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.7
+
+Layout/LineLength:
+  Max: 120
+
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
+SortedMethodsByCall/Waterfall:
+  Enabled: true

data/.rubocop_todo.yml

@@ -0,0 +1,23 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2025-11-06 17:49:32 UTC using RuboCop version 1.81.7.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
+Metrics/AbcSize:
+  Max: 18
+
+# Offense count: 4
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+# AllowedMethods: refine
+Metrics/BlockLength:
+  Max: 179
+
+# Offense count: 3
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+Metrics/MethodLength:
+  Max: 18

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-10-14
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at TODO: Write your email address. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 unurgunite
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,217 @@
+# AdvancedCodeGenerator (ACG)
+
+![Repobeats](https://repobeats.axiom.co/api/embed/b945bee4de2921a512eff2d30b19f333915701e7.svg "Repobeats analytics image")
+[![Gem Version](https://badge.fury.io/rb/code_generator.svg)](https://rubygems.org/gems/advanced_code_generator)
+[![CI](https://github.com/unurgunite/code_generator/actions/workflows/ci.yml/badge.svg)](https://github.com/unurgunite/advanced_code_generator/actions)
+
+**A fluent DSL for generating Ruby classes with stubbed methods for testing and prototyping.**
+
+* [AdvancedCodeGenerator (ACG)](#advancedcodegenerator-acg)
+    * [Features](#features)
+    * [Installation](#installation)
+    * [Usage Examples](#usage-examples)
+        * [Basic Public Method](#basic-public-method)
+        * [Method with Parameters](#method-with-parameters)
+        * [Private and Protected Methods](#private-and-protected-methods)
+        * [Class Methods](#class-methods)
+        * [Random Value Generation](#random-value-generation)
+    * [Testing](#testing)
+    * [Development](#development)
+        * [Available Commands](#available-commands)
+        * [Release Process](#release-process)
+    * [Requirements](#requirements)
+    * [Contributing](#contributing)
+    * [License](#license)
+    * [Code of Conduct](#code-of-conduct)
+
+## Features
+
+- **Fluent DSL**: Clean, readable syntax for defining methods
+- **Full visibility support**: Public, private, and protected instance methods
+- **Class method support**: Public and private class methods
+- **Parameter configuration**: Define required, optional, and keyword parameters
+- **Smart return values**: Return specific objects or generate random values
+- **Zero dependencies**: Pure Ruby, no external requirements
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'advanced_code_generator'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself:
+
+```bash
+gem install advanced_code_generator
+```
+
+## Usage Examples
+
+### Basic Public Method
+
+```ruby
+generator = AdvancedCodeGenerator::Generator.new do |g|
+  g.public_method :hello do |m|
+    m.returns "world"
+  end
+end
+
+Klass = generator.build
+obj = Klass.new
+obj.hello # => "world"
+```
+
+### Method with Parameters
+
+```ruby
+generator = AdvancedCodeGenerator::Generator.new do |g|
+  g.public_method :greet do |m|
+    m.required :name
+    m.optional :greeting, default: "Hello"
+    m.keyword_required :format
+    m.returns true
+  end
+end
+
+Klass = generator.build
+obj = Klass.new
+obj.greet("Alice", format: :json) # => true
+obj.greet("Bob", "Hi", format: :xml) # => true
+```
+
+### Private and Protected Methods
+
+```ruby
+generator = AdvancedCodeGenerator::Generator.new do |g|
+  g.private_method :secret_calculation do |m|
+    m.returns 42
+  end
+
+  g.protected_method :internal_logic do |m|
+    m.returns "protected result"
+  end
+end
+
+Klass = generator.build
+obj = Klass.new
+obj.send(:secret_calculation) # => 42
+# obj.secret_calculation                    # => NoMethodError
+
+# Protected method access through subclass
+Subclass = Class.new(Klass) do
+  def access_protected
+    internal_logic
+  end
+end
+Subclass.new.access_protected # => "protected result"
+```
+
+### Class Methods
+
+```ruby
+generator = AdvancedCodeGenerator::Generator.new do |g|
+  g.public_class_method :factory do |m|
+    m.returns "class helper"
+  end
+
+  g.private_class_method :setup do |m|
+    m.returns "private setup"
+  end
+end
+
+Klass = generator.build
+Klass.factory # => "class helper"
+Klass.send(:setup) # => "private setup"
+```
+
+### Random Value Generation
+
+```ruby
+generator = AdvancedCodeGenerator::Generator.new do |g|
+  g.public_method :random_int do |m|
+    m.returns Integer
+    m.generate true
+  end
+
+  g.public_method :random_string do |m|
+    m.returns String
+    m.generate true
+  end
+end
+
+Klass = generator.build
+obj = Klass.new
+obj.random_int # => 42891 (random integer)
+obj.random_string # => "aB3xY9zK2m" (random string)
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+bundle exec rspec
+```
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bin/setup
+```
+
+This will install dependencies and start an interactive console.
+
+### Available Commands
+
+- `bin/console` - Interactive development console
+- `bin/setup` - Install dependencies and build gem
+- `bundle exec rake` - Run tests and linting
+
+### Release Process
+
+1. Update version in `lib/code_generator/version.rb`
+2. Create and push a git tag: `git tag v0.1.0 && git push origin v0.1.0`
+3. GitHub Actions will automatically:
+    - Build the gem
+    - Publish to RubyGems.org
+    - Create a GitHub release
+
+## Requirements
+
+- **Ruby**: >= 2.7.0
+- **No external dependencies**
+
+## Contributing
+
+Bug reports and pull requests are welcome! Please follow these guidelines:
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -am 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a pull request
+
+Please ensure your code passes all tests and follows the existing style.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting with this project is expected to follow the [Code of Conduct](CODE_OF_CONDUCT.md).
+
+---
+
+> **Note**: This gem is designed for **testing and prototyping**. Generated methods accept any parameters and return
+> configured values, making it perfect for creating test doubles and stubs.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/code_generator.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'lib/advanced_code_generator/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'advanced_code_generator'
+  spec.version = AdvancedCodeGenerator::VERSION
+  spec.authors = ['unurgunite']
+  spec.email = ['senpaiguru1488@gmail.com']
+
+  spec.summary = 'Code generation tool based on preferences.'
+  spec.description = <<~TEXT
+    This gem makes it possible to generate code based on preferences. You can use it to avoid the boring routine of writing tests, use some classes for other purposes, or just for fun.
+  TEXT
+  spec.homepage = 'https://github.com/unurgunite/advanced_code_generator.'
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/unurgunite/advanced_code_generator'
+  spec.metadata['changelog_uri'] = 'https://github.com/unurgunite/advanced_code_generator/CHANGELOG.md'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  # 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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.24'
+  spec.add_development_dependency 'rubocop-sorted_methods_by_call'
+  spec.add_development_dependency 'yard'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/advanced_code_generator/generator.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module AdvancedCodeGenerator
+  # Generates Ruby classes with stubbed methods using a fluent DSL.
+  #
+  # This class provides a domain-specific language (DSL) for defining
+  # methods with various visibility levels, parameters, and return values.
+  # It's primarily designed for testing and prototyping scenarios where
+  # you need to create mock objects or stub classes quickly.
+  #
+  # @example Basic usage
+  #   generator = CodeGenerator::Generator.new do |g|
+  #     g.public_method :hello do |m|
+  #       m.returns "world"
+  #     end
+  #   end
+  #   Klass = generator.build
+  #   obj = Klass.new
+  #   obj.hello # => "world"
+  #
+  # @example Method with parameters
+  #   generator = CodeGenerator::Generator.new do |g|
+  #     g.public_method :greet do |m|
+  #       m.required :name
+  #       m.optional :greeting, default: "Hello"
+  #       m.returns true
+  #     end
+  #   end
+  class Generator
+    # @return [Array<AdvancedCodeGenerator::MethodConfig>] List of instance method configurations
+    attr_reader :methods
+
+    # @return [Array<AdvancedCodeGenerator::MethodConfig>] List of class method configurations
+    attr_reader :class_methods
+
+    # Initializes a new Generator instance with empty method collections.
+    #
+    # This constructor is typically called internally by {Generator.new}
+    # and should not be called directly in most cases.
+    #
+    # @return [void]
+    def initialize
+      @methods = []
+      @class_methods = []
+    end
+
+    # Creates a new Generator instance and evaluates the given block in its context.
+    #
+    # This is the primary entry point for using the DSL. The block parameter
+    # provides access to the generator's DSL methods for defining methods.
+    #
+    # @yield [generator] The generator instance for DSL configuration
+    # @yieldparam generator [CodeGenerator::Generator] The current generator instance
+    # @return [AdvancedCodeGenerator::Generator] A configured generator instance
+    #
+    # @example
+    #   generator = CodeGenerator::Generator.new do |g|
+    #     g.public_method :test_method do |m|
+    #       m.returns "test"
+    #     end
+    #   end
+    def self.new(&block)
+      generator = allocate
+      generator.__send__(:initialize)
+      generator.instance_eval(&block) if block
+      generator
+    end
+
+    # Builds and returns a new Ruby class with all configured methods defined.
+    #
+    # This method creates an anonymous class and defines all the methods
+    # that were configured through the DSL. The returned class can be
+    # instantiated and used like any other Ruby class.
+    #
+    # @return [Class] A new class with all configured methods
+    #
+    # @example
+    #   generator = CodeGenerator::Generator.new do |g|
+    #     g.public_method :hello do |m|
+    #       m.returns "world"
+    #     end
+    #   end
+    #   Klass = generator.build
+    #   obj = Klass.new
+    #   puts obj.hello # => "world"
+    def build
+      klass = Class.new
+      define_instance_methods(klass)
+      define_class_methods(klass)
+      klass
+    end
+
+    # Defines a public instance method on the generated class.
+    #
+    # @param name [Symbol, String] The name of the method to define
+    # @yield [method_config] Configuration block for the method
+    # @yieldparam method_config [CodeGenerator::MethodConfig] Method configuration object
+    # @return [void]
+    #
+    # @example
+    #   g.public_method :calculate do |m|
+    #     m.required :x
+    #     m.optional :y, default: 10
+    #     m.returns 42
+    #   end
+    def public_method(name, &block)
+      method_config = MethodConfig.new(name, :public, &block)
+      @methods << method_config
+    end
+
+    # Defines a private instance method on the generated class.
+    #
+    # Private methods can only be called within the class or its instances
+    # using {Object#send} or from within other instance methods.
+    #
+    # @param name [Symbol, String] The name of the method to define
+    # @yield [method_config] Configuration block for the method
+    # @yieldparam method_config [CodeGenerator::MethodConfig] Method configuration object
+    # @return [void]
+    #
+    # @example
+    #   g.private_method :internal_calculation do |m|
+    #     m.returns "private result"
+    #   end
+    def private_method(name, &block)
+      method_config = MethodConfig.new(name, :private, &block)
+      @methods << method_config
+    end
+
+    # Defines a protected instance method on the generated class.
+    #
+    # Protected methods can be called by instances of the same class
+    # or its subclasses, but not from outside the inheritance hierarchy.
+    #
+    # @param name [Symbol, String] The name of the method to define
+    # @yield [method_config] Configuration block for the method
+    # @yieldparam method_config [CodeGenerator::MethodConfig] Method configuration object
+    # @return [void]
+    #
+    # @example
+    #   g.protected_method :shared_logic do |m|
+    #     m.returns "protected result"
+    #   end
+    def protected_method(name, &block)
+      method_config = MethodConfig.new(name, :protected, &block)
+      @methods << method_config
+    end
+
+    # Defines a public class method on the generated class.
+    #
+    # Class methods are called on the class itself rather than instances.
+    #
+    # @param name [Symbol, String] The name of the method to define
+    # @yield [method_config] Configuration block for the method
+    # @yieldparam method_config [CodeGenerator::MethodConfig] Method configuration object
+    # @return [void]
+    #
+    # @example
+    #   g.public_class_method :factory do |m|
+    #     m.returns "class helper"
+    #   end
+    def public_class_method(name, &block)
+      method_config = MethodConfig.new(name, :public_class, &block)
+      @class_methods << method_config
+    end
+
+    # Defines a private class method on the generated class.
+    #
+    # Private class methods can only be called within the class context
+    # using {Object#send} on the class itself.
+    #
+    # @param name [Symbol, String] The name of the method to define
+    # @yield [method_config] Configuration block for the method
+    # @yieldparam method_config [CodeGenerator::MethodConfig] Method configuration object
+    # @return [void]
+    #
+    # @example
+    #   g.private_class_method :internal_setup do |m|
+    #     m.returns "private setup"
+    #   end
+    def private_class_method(name, &block)
+      method_config = MethodConfig.new(name, :private_class, &block)
+      @class_methods << method_config
+    end
+
+    private
+
+    # Defines all configured instance methods on the target class.
+    #
+    # @param klass [Class] The class to define methods on
+    # @return [void]
+    def define_instance_methods(klass)
+      return unless @methods
+
+      @methods.each do |method_config|
+        case method_config.visibility
+        when :public
+          define_method_with_params(klass, method_config, :define_method)
+        when :private
+          define_method_with_params(klass, method_config, :define_method)
+          klass.send(:private, method_config.name)
+        when :protected
+          define_method_with_params(klass, method_config, :define_method)
+          klass.send(:protected, method_config.name)
+        end
+      end
+    end
+
+    # Defines all configured class methods on the target class.
+    #
+    # @param klass [Class] The class to define class methods on
+    # @return [void]
+    def define_class_methods(klass)
+      return unless class_methods
+
+      class_methods.each do |method_config|
+        case method_config.visibility
+        when :public_class
+          define_method_with_params(klass.singleton_class, method_config, :define_method)
+        when :private_class
+          define_method_with_params(klass.singleton_class, method_config, :define_method)
+          klass.singleton_class.send(:private, method_config.name)
+        end
+      end
+    end
+
+    # Defines a single method on the target class with proper parameter handling.
+    #
+    # This method handles both simple methods (no parameters) and complex
+    # methods (with parameter definitions) by either using define_method
+    # with a proc or generating a method definition string with class_eval.
+    #
+    # @param target_class [Class, #singleton_class] The class to define the method on
+    # @param method_config [AdvancedCodeGenerator::MethodConfig] The method configuration
+    # @param define_method_name [Symbol] The method used to define methods (:define_method)
+    # @return [void]
+    def define_method_with_params(target_class, method_config, define_method_name)
+      if method_config.parameters.empty?
+        return_value = calculate_return_value(method_config)
+        target_class.send(define_method_name, method_config.name) do |*_args, **_kwargs|
+          return_value
+        end
+      else
+        # Generate actual method with proper parameter validation
+        param_string = method_config.parameters.map(&:to_ruby_param).join(', ')
+        return_value = calculate_return_value(method_config)
+
+        # Create the method definition as a string
+        method_code = "def #{method_config.name}(#{param_string}); #{return_value.inspect}; end"
+
+        # Evaluate it in the target class context
+        target_class.class_eval(method_code)
+      end
+    end
+
+    # Calculates the actual return value for a method configuration.
+    #
+    # Handles both static return values and random object generation
+    # based on the method configuration settings.
+    #
+    # @param method_config [AdvancedCodeGenerator::MethodConfig] The method configuration
+    # @return [Object, nil] The calculated return value
+    def calculate_return_value(method_config)
+      if method_config.generate_random && method_config.return_value.is_a?(Class)
+        generate_random_object(method_config.return_value)
+      else
+        method_config.return_value
+      end
+    end
+
+    # Generates a random object of the specified class type.
+    #
+    # Supports Integer, String, and Symbol types with appropriate
+    # random generation logic. For unsupported classes, returns
+    # the class itself.
+    #
+    # @param klass [Class] The class to generate a random instance of
+    # @return [Object] A random object of the specified type, or the class itself
+    #
+    # @example
+    #   generate_random_object(Integer) # => 42891
+    #   generate_random_object(String)  # => "aB3xY9zK2m"
+    #   generate_random_object(Symbol)  # => :random_symbol
+    #   generate_random_object(Object)  # => Object
+    def generate_random_object(klass)
+      case klass.name
+      when 'Integer'
+        rand(1..1_000_000)
+      when 'String'
+        SecureRandom.alphanumeric(10)
+      when 'Symbol'
+        SecureRandom.alphanumeric(10).to_sym
+      else
+        klass
+      end
+    end
+  end
+end

data/lib/advanced_code_generator/method_config.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module AdvancedCodeGenerator
+  # Represents the configuration for a single method definition.
+  #
+  # This class encapsulates all the metadata needed to define a method,
+  # including its name, visibility, parameters, return value, and generation
+  # settings. It's used internally by {CodeGenerator::Generator} to store
+  # method configuration data collected through the DSL.
+  #
+  # @example Method configuration usage
+  #   config = CodeGenerator::MethodConfig.new(:calculate, :public) do |m|
+  #     m.required :x
+  #     m.optional :y, default: 10
+  #     m.returns 42
+  #   end
+  #
+  # @see CodeGenerator::Generator
+  # @see CodeGenerator::Parameter
+  class MethodConfig
+    # @return [Symbol] The name of the method to be defined
+    attr_reader :name
+
+    # @return [Symbol] The visibility level (:public, :private, :protected, :public_class, :private_class)
+    attr_reader :visibility
+
+    # @return [Array<AdvancedCodeGenerator::Parameter>] List of method parameters
+    attr_reader :parameters
+
+    # @return [Object, nil] The value that the method should return
+    attr_reader :return_value
+
+    # @return [Boolean] Whether to generate random values for class return types
+    attr_reader :generate_random
+
+    # Valid visibility options for method definitions.
+    #
+    # @return [Array<Symbol>]
+    VALID_VISIBILITIES = %i[public private protected public_class private_class].freeze
+
+    # Initializes a new MethodConfig instance.
+    #
+    # @param name [Symbol, String] The name of the method to configure
+    # @param visibility [Symbol] The visibility level (must be one of {VALID_VISIBILITIES})
+    # @yield [method_config] Configuration block for method parameters and settings
+    # @yieldparam method_config [CodeGenerator::MethodConfig] The current method configuration instance
+    # @raise [ArgumentError] If name is not a Symbol/String or visibility is invalid
+    #
+    # @example
+    #   config = CodeGenerator::MethodConfig.new(:my_method, :public) do |m|
+    #     m.required :param1
+    #     m.returns "result"
+    #   end
+    def initialize(name, visibility)
+      raise ArgumentError, 'Method name must be a Symbol or String' unless name.is_a?(Symbol) || name.is_a?(String)
+      raise ArgumentError, "Invalid visibility: #{visibility}" unless VALID_VISIBILITIES.include?(visibility)
+
+      @name = name.to_sym
+      @visibility = visibility
+      @parameters = []
+      @return_value = nil
+      @generate_random = false
+
+      yield self if block_given?
+    end
+
+    # Adds a required positional parameter to the method.
+    #
+    # Required parameters must be provided when calling the method.
+    #
+    # @param param_name [Symbol] The name of the required parameter
+    # @return [void]
+    # @raise [ArgumentError] If param_name is not a Symbol
+    #
+    # @example
+    #   m.required :user_id
+    #   # Generates: def method_name(user_id)
+    def required(param_name)
+      validate_param_name(param_name)
+      parameters << Parameter.new(:required, param_name)
+    end
+
+    # Adds an optional positional parameter to the method.
+    #
+    # Optional parameters have a default value and can be omitted when calling the method.
+    #
+    # @param param_name [Symbol] The name of the optional parameter
+    # @param default [Object] The default value for the parameter (defaults to nil)
+    # @return [void]
+    # @raise [ArgumentError] If param_name is not a Symbol
+    #
+    # @example
+    #   m.optional :options, default: {}
+    #   # Generates: def method_name(options = {})
+    def optional(param_name, default: nil)
+      validate_param_name(param_name)
+      parameters << Parameter.new(:optional, param_name, default: default)
+    end
+
+    # Adds a required keyword parameter to the method.
+    #
+    # Required keyword parameters must be provided as named arguments when calling the method.
+    #
+    # @param param_name [Symbol] The name of the required keyword parameter
+    # @return [void]
+    # @raise [ArgumentError] If param_name is not a Symbol
+    #
+    # @example
+    #   m.keyword_required :format
+    #   # Generates: def method_name(format:)
+    def keyword_required(param_name)
+      validate_param_name(param_name)
+      parameters << Parameter.new(:keyword_required, param_name)
+    end
+
+    # Adds an optional keyword parameter to the method.
+    #
+    # Optional keyword parameters have a default value and can be omitted when calling the method.
+    #
+    # @param param_name [Symbol] The name of the optional keyword parameter
+    # @param default [Object] The default value for the parameter (defaults to nil)
+    # @return [void]
+    # @raise [ArgumentError] If param_name is not a Symbol
+    #
+    # @example
+    #   m.keyword :timeout, default: 30
+    #   # Generates: def method_name(timeout: 30)
+    def keyword(param_name, default: nil)
+      validate_param_name(param_name)
+      parameters << Parameter.new(:keyword, param_name, default: default)
+    end
+
+    # Sets the return value for the method.
+    #
+    # The method will return this value when called. If combined with {#generate},
+    # and the return value is a Class, it will generate random instances of that class.
+    #
+    # @param value [Object] The value to return from the method
+    # @return [Object] The provided value
+    #
+    # @example
+    #   m.returns "success"
+    #   m.returns Integer  # Will generate random integers if #generate is true
+    def returns(value)
+      self.return_value = value
+    end
+
+    # Enables random value generation for class return types.
+    #
+    # When enabled and the return value is a Class (like Integer, String, Symbol),
+    # the method will return random instances of that class instead of the class itself.
+    #
+    # @param value [Boolean] Whether to enable random generation (defaults to true)
+    # @return [Boolean] The provided value
+    #
+    # @example
+    #   m.returns Integer
+    #   m.generate true
+    #   # Method will return random integers like 42891, not the Integer class
+    def generate(value: true)
+      self.generate_random = value
+    end
+
+    private
+
+    # @!attribute [rw] parameters
+    #   @return [Array<AdvancedCodeGenerator::Parameter>]
+    attr_writer :parameters
+
+    # @!attribute [rw] return_value
+    #   @return [Object, nil]
+    attr_writer :return_value
+
+    # @!attribute [rw] generate_random
+    #   @return [Boolean]
+    attr_writer :generate_random
+
+    # Validates that a parameter name is a Symbol.
+    #
+    # @param name [Object] The parameter name to validate
+    # @raise [ArgumentError] If name is not a Symbol
+    # @return [void]
+    def validate_param_name(name)
+      raise ArgumentError, 'Parameter name must be a Symbol' unless name.is_a?(Symbol)
+    end
+  end
+end

data/lib/advanced_code_generator/parameter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module AdvancedCodeGenerator
+  # Represents a single method parameter configuration.
+  #
+  # This class encapsulates the metadata for a method parameter, including
+  # its type (required, optional, keyword, etc.), name, and default value.
+  # It's used internally by {CodeGenerator::MethodConfig} to store parameter
+  # definitions that are later converted to Ruby method signatures.
+  #
+  # @example Parameter usage
+  #   param = CodeGenerator::Parameter.new(:required, :user_id)
+  #   param.to_ruby_param # => "user_id"
+  #
+  # @see CodeGenerator::MethodConfig
+  class Parameter
+    # Valid parameter types for method definitions.
+    #
+    # @return [Array<Symbol>]
+    VALID_TYPES = %i[required optional keyword_required keyword].freeze
+
+    # @return [Symbol] The type of parameter (:required, :optional, :keyword_required, :keyword)
+    attr_reader :type
+
+    # @return [Symbol] The name of the parameter
+    attr_reader :name
+
+    # @return [Object, nil] The default value for optional parameters (nil for required parameters)
+    attr_reader :default
+
+    # Initializes a new Parameter instance.
+    #
+    # @param type [Symbol] The parameter type (must be one of {VALID_TYPES})
+    # @param name [Symbol] The parameter name
+    # @param default [Object, nil] The default value for optional parameters (defaults to nil)
+    # @raise [ArgumentError] If type is invalid or name is not a Symbol
+    #
+    # @example
+    #   # Required parameter
+    #   param = CodeGenerator::Parameter.new(:required, :id)
+    #
+    #   # Optional parameter with default
+    #   param = CodeGenerator::Parameter.new(:optional, :options, default: {})
+    #
+    #   # Required keyword parameter
+    #   param = CodeGenerator::Parameter.new(:keyword_required, :format)
+    #
+    #   # Optional keyword parameter
+    #   param = CodeGenerator::Parameter.new(:keyword, :timeout, default: 30)
+    def initialize(type, name, default: nil)
+      raise ArgumentError, "Invalid parameter type: #{type}" unless VALID_TYPES.include?(type)
+      raise ArgumentError, 'Parameter name must be a Symbol' unless name.is_a?(Symbol)
+
+      @type = type
+      @name = name
+      @default = default
+    end
+
+    # Converts the parameter configuration to a Ruby method parameter string.
+    #
+    # This method generates the appropriate Ruby syntax for the parameter
+    # based on its type and configuration, which is used when defining
+    # methods with {CodeGenerator::Generator}.
+    #
+    # @return [String] The Ruby parameter string
+    #
+    # @example
+    #   CodeGenerator::Parameter.new(:required, :name).to_ruby_param
+    #   # => "name"
+    #
+    #   CodeGenerator::Parameter.new(:optional, :options, default: {}).to_ruby_param
+    #   # => "options = {}"
+    #
+    #   CodeGenerator::Parameter.new(:keyword_required, :format).to_ruby_param
+    #   # => "format:"
+    #
+    #   CodeGenerator::Parameter.new(:keyword, :timeout, default: 30).to_ruby_param
+    #   # => "timeout: 30"
+    def to_ruby_param
+      case type
+      when :required
+        name.to_s
+      when :optional
+        if default.nil?
+          "#{name} = nil"
+        else
+          "#{name} = #{default.inspect}"
+        end
+      when :keyword_required
+        "#{name}:"
+      when :keyword
+        if default.nil?
+          "#{name}: nil"
+        else
+          "#{name}: #{default.inspect}"
+        end
+      end
+    end
+
+    # Returns the parameter name as a Symbol.
+    #
+    # This is a convenience method that simply returns the {#name} attribute.
+    #
+    # @return [Symbol] The parameter name
+    #
+    # @example
+    #   param = CodeGenerator::Parameter.new(:required, :user_id)
+    #   param.ruby_param_name # => :user_id
+    def ruby_param_name
+      name
+    end
+  end
+end

data/lib/advanced_code_generator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AdvancedCodeGenerator
+  VERSION = '1.0.0'
+end

data/lib/advanced_code_generator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'advanced_code_generator/version'
+require_relative 'advanced_code_generator/parameter'
+require_relative 'advanced_code_generator/method_config'
+require_relative 'advanced_code_generator/generator'
+
+module AdvancedCodeGenerator
+  class Error < StandardError; end
+end

data/rakelib/docs.rake

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'yard'
+require 'fileutils'
+
+GEM_NAME = Bundler.load_gemspec(Dir.glob('*.gemspec').first).name
+DOCS_REPO_NAME = "#{GEM_NAME}_docs"
+DOCS_REPO_PATH = "../#{DOCS_REPO_NAME}"
+
+namespace :docs do
+  desc 'Generate new docs and push them to repo'
+  task generate: :clean do
+    puts 'Generating docs...'
+    YARD::CLI::Yardoc.run
+    puts 'OK!'
+  end
+
+  desc 'Clean existing docs'
+  task :clean do
+    if File.directory?('doc')
+      FileUtils.rm_rf('doc')
+      puts 'Cleaned existing docs directory'
+    end
+  end
+
+  desc 'Pushes docs to github'
+  task push: :generate do
+    unless File.directory?(DOCS_REPO_PATH)
+      puts "Error: Docs repo not found at #{DOCS_REPO_PATH}"
+      puts 'Please clone the docs repo first:'
+      puts "  git clone git@github.com:unurgunite/#{DOCS_REPO_NAME}.git #{DOCS_REPO_PATH}"
+      exit 1
+    end
+
+    puts "Copying docs to #{DOCS_REPO_PATH}..."
+    FileUtils.mkdir_p('doc') unless File.directory?('doc')
+    FileUtils.cp_r('doc/.', DOCS_REPO_PATH)
+
+    puts 'Changing dir...'
+    Dir.chdir(DOCS_REPO_PATH) do
+      puts 'Checking git status...'
+      status_output = `git status --porcelain`
+
+      if status_output.strip.empty?
+        puts 'No changes to commit'
+      else
+        puts 'Committing git changes...'
+        puts `git add .`
+        commit_result = `git commit -m "Update docs for #{GEM_NAME} #{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S UTC')}"`
+        puts commit_result
+
+        if $CHILD_STATUS.success?
+          puts 'Pushing to GitHub...'
+          push_result = `git push origin master 2>&1`
+          puts push_result
+          if $CHILD_STATUS.success?
+            puts 'Docs successfully pushed!'
+          else
+            puts 'Push failed!'
+            exit 1
+          end
+        else
+          puts 'Commit failed!'
+          exit 1
+        end
+      end
+    end
+  end
+
+  desc 'Generate and push docs in one command'
+  task deploy: :push
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: advanced_code_generator
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- unurgunite
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.24'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.24'
+- !ruby/object:Gem::Dependency
+  name: rubocop-sorted_methods_by_call
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'This gem makes it possible to generate code based on preferences. You
+  can use it to avoid the boring routine of writing tests, use some classes for other
+  purposes, or just for fun.
+
+  '
+email:
+- senpaiguru1488@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- code_generator.gemspec
+- lib/advanced_code_generator.rb
+- lib/advanced_code_generator/generator.rb
+- lib/advanced_code_generator/method_config.rb
+- lib/advanced_code_generator/parameter.rb
+- lib/advanced_code_generator/version.rb
+- rakelib/docs.rake
+homepage: https://github.com/unurgunite/advanced_code_generator.
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/unurgunite/advanced_code_generator.
+  source_code_uri: https://github.com/unurgunite/advanced_code_generator
+  changelog_uri: https://github.com/unurgunite/advanced_code_generator/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Code generation tool based on preferences.
+test_files: []