wrappix 0.1.0

data/lib/wrappix/templates/readme.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Readme
+      def self.render(api_name, module_name, config)
+        base_url = config["base_url"] || "https://api.example.com"
+        auth_instructions = auth_setup_instructions(config)
+        resource_docs = generate_resource_docs(module_name, config)
+
+        <<~MARKDOWN
+          # #{module_name} API Client
+
+          A Ruby API wrapper for the #{api_name} API.
+
+          ## Installation
+
+          Add this line to your application's Gemfile:
+
+          ```ruby
+          gem '#{api_name}'
+          ```
+
+          And then execute:
+
+          ```bash
+          $ bundle install
+          ```
+
+          Or install it yourself as:
+
+          ```bash
+          $ gem install #{api_name}
+          ```
+
+          ## Configuration
+
+          ```ruby
+          #{module_name}.configure do |config|
+            config.base_url = "#{base_url}"
+            #{auth_instructions}
+          end
+          ```
+
+          ## Usage
+
+          ### Initializing the client
+
+          ```ruby
+          # Initialize the client
+          client = #{module_name}.client
+          ```
+
+          ### Examples
+
+          ```ruby
+          #{usage_examples(module_name, config)}
+          ```
+
+          ### Working with responses
+
+          Objects returned by the API can be accessed using dot notation:
+
+          ```ruby
+          user = client.users.get(123)
+          puts user.id          # => 123
+          puts user.name        # => "John Doe"
+          puts user.email       # => "john@example.com"
+          ```
+
+          Collections include pagination support:
+
+          ```ruby
+          users = client.users.list
+
+          # Iterate through items
+          users.data.each do |user|
+            puts user.name
+          end
+
+          # Check pagination info
+          if users.next_href
+            # More results available
+          end
+          ```
+
+          ## Resources and Endpoints
+
+          #{resource_docs}
+
+          ## Error Handling
+
+          ```ruby
+          begin
+            response = client.users.get(123)
+          rescue #{module_name}::Error => e
+            puts "Error: \#{e.message}"
+            puts "Status: \#{e.status}"
+            puts "Details: \#{e.body}"
+          end
+          ```
+
+          ## API Documentation
+
+          Detailed API documentation is available in the `docs/api.md` file, which includes:
+
+          - All available endpoints
+          - Required parameters
+          - Example requests and responses
+          - Authentication details
+
+          ## Advanced Usage
+
+          ### Caching
+
+          #{module_name} uses a caching solution to improve efficiency (e.g., for caching tokens). By default, it uses a simple memory cache,
+          but you can change the cache method by setting the `#{module_name}.cache` attribute.
+
+          ```ruby
+          # Use Redis cache
+          #{module_name}.cache = Redis.new
+
+          # Or use Rails cache
+          #{module_name}.cache = Rails.cache
+
+          # Or use file-based cache
+          #{module_name}.cache = #{module_name}::FileCache.new
+
+          # Or any object that responds to read/write/delete/clear
+          #{module_name}.cache = YourCustomCache.new
+          ```
+
+          ### Custom Headers
+
+          You can set custom headers for all requests:
+
+          ```ruby
+          #{module_name}.configure do |config|
+            config.headers["User-Agent"] = "MyApp/1.0"
+            config.headers["X-Custom-Header"] = "Value"
+          end
+          ```
+        MARKDOWN
+      end
+
+      def self.auth_setup_instructions(config)
+        case config["auth_type"]
+        when "oauth"
+          <<~RUBY.strip
+            config.client_id = "your_client_id"
+            config.client_secret = "your_client_secret"
+            config.access_token = "your_access_token"
+          RUBY
+        when "basic"
+          <<~RUBY.strip
+            config.username = "your_username"
+            config.password = "your_password"
+          RUBY
+        when "api_key"
+          <<~RUBY.strip
+            config.api_key = "your_api_key"
+            config.api_key_header = "#{config["api_key_header"] || "X-Api-Key"}"
+          RUBY
+        else
+          "# No authentication required"
+        end
+      end
+
+      def self.usage_examples(_module_name, config)
+        resources = config["resources"] || {}
+        examples = []
+
+        resources.each do |resource_name, resource_config|
+          endpoints = resource_config["endpoints"] || []
+          next if endpoints.empty?
+
+          # Take the first endpoint as an example
+          endpoint = endpoints.first
+          method = endpoint["method"] || "get"
+          has_params = endpoint["path"].to_s.include?("{")
+
+          if has_params
+            # Extract parameters
+            params = endpoint["path"].scan(/\{([^}]+)\}/).flatten
+            param_values = params.map { |_p| "123" } # Example values
+            args = param_values.join(", ")
+
+            examples << "# #{resource_name.capitalize} - #{endpoint["name"]} example"
+            examples << "response = client.#{resource_name}.#{endpoint["name"]}(#{args})"
+          else
+            examples << "# #{resource_name.capitalize} - #{endpoint["name"]} example"
+            examples << if %w[post put patch].include?(method)
+                          "response = client.#{resource_name}.#{endpoint["name"]}({name: 'value', other_field: 'value'})"
+                        else
+                          "response = client.#{resource_name}.#{endpoint["name"]}"
+                        end
+          end
+
+          examples << ""
+        end
+
+        examples.join("\n")
+      end
+
+      def self.generate_resource_docs(_module_name, config)
+        resources = config["resources"] || {}
+        docs = []
+
+        resources.each do |resource_name, resource_config|
+          docs << "### #{resource_name.capitalize}"
+          endpoints = resource_config["endpoints"] || []
+
+          endpoints.each do |endpoint|
+            name = endpoint["name"]
+            method = endpoint["method"] || "get"
+            path = endpoint["path"] || name
+            has_params = path.include?("{")
+
+            docs << "#### `#{name}`"
+            docs << "- HTTP Method: `#{method.upcase}`"
+            docs << "- Path: `#{path}`"
+
+            if has_params
+              params = path.scan(/\{([^}]+)\}/).flatten
+              docs << "- Path Parameters: #{params.map { |p| "`#{p}`" }.join(", ")}"
+            end
+
+            docs << "- Accepts additional query parameters" if endpoint["params"]
+
+            # Usage example
+            docs << "\n```ruby"
+            if has_params
+              params = path.scan(/\{([^}]+)\}/).flatten
+              param_args = params.map { |p| "#{p}: 123" }.join(", ")
+
+              docs << if endpoint["params"]
+                        "client.#{resource_name}.#{name}(#{param_args}, {param1: 'value', param2: 'value'})"
+                      else
+                        "client.#{resource_name}.#{name}(#{param_args})"
+                      end
+            else
+              docs << if %w[post put patch].include?(method)
+                        "client.#{resource_name}.#{name}({field1: 'value', field2: 'value'})"
+                      elsif endpoint["params"]
+                        "client.#{resource_name}.#{name}({param1: 'value', param2: 'value'})"
+                      else
+                        "client.#{resource_name}.#{name}"
+                      end
+            end
+            docs << "```\n"
+          end
+        end
+
+        docs.join("\n")
+      end
+    end
+  end
+end

data/lib/wrappix/templates/request.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Request
+      def self.render(module_name, config)
+        oauth_token_logic = if config["auth_type"] == "oauth"
+                              <<~RUBY
+                                def get_access_token
+                                  # Try to get token from cache first
+                                  token = #{module_name}.cache.read("access_token")
+                                  return token if token
+
+                                  # If not in cache, fetch new token
+                                  response = Faraday.post(@config.token_url, {
+                                    client_id: @config.client_id,
+                                    client_secret: @config.client_secret,
+                                    grant_type: "client_credentials"
+                                  })
+
+                                  if response.status == 200
+                                    data = JSON.parse(response.body)
+                                    token = data["access_token"]
+                                    expires_in = data["expires_in"] || 3600
+
+                                    # Cache the token
+                                    #{module_name}.cache.write("access_token", token)
+
+                                    # Cache expiration handling could be improved
+                                    token
+                                  else
+                                    raise #{module_name}::Error.new("Failed to obtain access token", response.body, response.status)
+                                  end
+                                end
+                              RUBY
+                            else
+                              ""
+                            end
+
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "faraday"
+          require "json"
+
+          module #{module_name}
+            class Request
+              def initialize(path, config = #{module_name}.configuration)
+                @path = path
+                @config = config
+                @base_url = config.base_url
+              end
+
+              def get(params: {}, headers: {})
+                make_request(:get, params: params, headers: headers)
+              end
+
+              def post(body: {}, headers: {})
+                make_request(:post, body: body, headers: headers)
+              end
+
+              def put(body: {}, headers: {})
+                make_request(:put, body: body, headers: headers)
+              end
+
+              def patch(body: {}, headers: {})
+                make_request(:patch, body: body, headers: headers)
+              end
+
+              def delete(params: {}, headers: {})
+                make_request(:delete, params: params, headers: headers)
+              end
+
+              private
+
+              def make_request(method, params: {}, body: nil, headers: {})
+                response = connection.public_send(method) do |req|
+                  req.url @path
+                  req.params = params if params && !params.empty?
+                  req.body = body.to_json if body && !body.empty?
+                  req.headers.merge!(headers) if headers && !headers.empty?
+                  req.options.timeout = @config.timeout
+                end
+
+                handle_response(response)
+              end
+
+              def connection
+                @connection ||= Faraday.new(url: @base_url) do |conn|
+                  #{connection_auth_config(config)}
+                  conn.headers = @config.headers
+                  conn.response :json, content_type: /\\bjson$/
+                  conn.adapter Faraday.default_adapter
+                end
+              end
+
+              def handle_response(response)
+                return response.body if response.status.between?(200, 299)
+
+                error_message = if response.body.is_a?(Hash)
+                                response.body["message"] || response.body["error"] || "Error \#{response.status}"
+                              else
+                                "Error \#{response.status}"
+                              end
+
+                raise #{module_name}::Error.new(error_message, response.body, response.status)
+              end
+
+              #{oauth_token_logic}
+            end
+          end
+        RUBY
+      end
+
+      def self.connection_auth_config(config)
+        case config["auth_type"]
+        when "oauth"
+          "conn.request :authorization, 'Bearer', get_access_token if @config.client_id && @config.client_secret"
+        when "basic"
+          "conn.basic_auth(@config.username, @config.password) if @config.username && @config.password"
+        when "api_key"
+          "conn.headers[@config.api_key_header] = @config.api_key if @config.api_key"
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/wrappix/templates/resource.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Resource
+      def self.render(module_name, resource_name, resource_config)
+        endpoints = resource_config["endpoints"] || []
+        methods = endpoints.map do |endpoint|
+          endpoint_method(module_name, resource_name, endpoint, resource_config)
+        end.join("\n\n")
+
+        # Para normalizar el nombre del recurso
+        class_name = resource_name.capitalize
+
+        <<~RUBY
+          # frozen_string_literal: true
+
+          module #{module_name}
+            module Resources
+              class #{class_name}
+                def initialize(client)
+                  @client = client
+                  @config = #{module_name}.configuration
+                end
+
+                #{methods}
+              end
+            end
+          end
+        RUBY
+      end
+
+      def self.endpoint_method(module_name, _resource_name, endpoint, resource_config)
+        name = endpoint["name"]
+        method = endpoint["method"] || "get"
+        path = endpoint["path"] || name
+
+        # Obtener configuración de formato de respuesta
+        response_format = resource_config["response_format"] || {}
+
+        # Determinar si es una colección
+        is_collection = endpoint["collection"] || %w[all list index search].include?(name)
+
+        # Procesar parámetros del path
+        has_params = path.include?("{")
+        param_list = has_params ? path.scan(/\{([^}]+)\}/).flatten : []
+
+        # Preparar los parámetros del método
+        endpoint_params = []
+        endpoint_params.concat(param_list)
+        endpoint_params << "params = {}" if endpoint["params"]
+        endpoint_params << "body = {}" if %w[post put patch].include?(method)
+
+        # Preparar argumentos para el método request
+        request_args = []
+        request_args << "params: params" if endpoint["params"]
+        request_args << "body: body" if %w[post put patch].include?(method)
+        request_options = request_args.empty? ? "" : "(#{request_args.join(", ")})"
+
+        # Generar path con reemplazos de variables
+        path_with_params = path
+        param_list.each do |param|
+          path_with_params = path_with_params.gsub(/\{#{param}\}/, "\#{#{param}}")
+        end
+
+        # Código para transformar la respuesta basada en la configuración
+        response_transform = if is_collection
+                               "#{module_name}::Collection.from_response(response, type: #{module_name}::Object)"
+                             else
+                               item_root = response_format["item_root"]
+                               if item_root
+                                 "#{module_name}::Object.new(response[:#{item_root}] || response[\"#{item_root}\"] || response)"
+                               else
+                                 "#{module_name}::Object.new(response)"
+                               end
+                             end
+
+        <<~RUBY.strip
+          def #{name}(#{endpoint_params.join(", ")})
+            request = #{module_name}::Request.new("#{path_with_params}")
+            response = request.#{method}#{request_options}
+
+            #{response_transform}
+          end
+        RUBY
+      end
+
+      def self.generate_response_transform(module_name, is_collection, response_format)
+        if is_collection
+          collection_root = response_format["collection_root"] || "data"
+          pagination_config = response_format["pagination"] || {}
+          next_page_key = pagination_config["next_page_key"] || "next_href"
+
+          # Código para extraer datos considerando la estructura de paginación
+          <<~RUBY
+            data = response[:#{collection_root}] || response["#{collection_root}"] || []
+            next_href = response[:#{next_page_key}] || response["#{next_page_key}"]
+
+            #{module_name}::Collection.from_response({
+              data: data,
+              next_href: next_href
+            }, type: #{module_name}::Object)
+          RUBY
+        else
+          item_root = response_format["item_root"]
+          if item_root
+            "#{module_name}::Object.new(response[:#{item_root}] || response[\"#{item_root}\"] || response)"
+          else
+            "#{module_name}::Object.new(response)"
+          end
+        end
+      end
+    end
+  end
+end