wrappix 0.1.0

data/lib/wrappix/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Wrappix
+  class Configuration
+    attr_accessor :base_url, :headers, :timeout
+    attr_reader :resources
+
+    def initialize
+      @base_url = nil
+      @headers = {}
+      @timeout = 30
+      @resources = {}
+    end
+
+    def add_resource(name, options = {})
+      @resources[name.to_sym] = options
+    end
+
+    def resources=(resource_hash)
+      resource_hash.each do |name, options|
+        add_resource(name, options)
+      end
+    end
+  end
+end

data/lib/wrappix/request.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Wrappix
+  class Request
+    def initialize(url, config = Wrappix.configuration)
+      @url = url
+      @config = config
+    end
+
+    def get(params: {}, headers: {})
+      handle_response connection.get(@url, params, headers)
+    end
+
+    def post(body: {}, headers: {})
+      handle_response connection.post(@url, body, headers)
+    end
+
+    def patch(body: {}, headers: {})
+      handle_response connection.patch(@url, body, headers)
+    end
+
+    def put(body: {}, headers: {})
+      handle_response connection.put(@url, body, headers)
+    end
+
+    def delete(params: {}, headers: {})
+      handle_response connection.delete(@url, params, headers)
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new do |conn|
+        conn.url_prefix = @config.base_url
+
+        # Configurar autenticación según el tipo
+        case @config.auth_type
+        when :oauth
+          conn.request :authorization, :Bearer, @config.access_token
+        when :basic
+          conn.basic_auth(@config.username, @config.password)
+        when :api_key
+          conn.headers[@config.api_key_header] = @config.api_key
+        end
+
+        conn.request :json
+        conn.response :json, content_type: "application/json", parser_options: { symbolize_names: true }
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def handle_response(response)
+      return response 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 Wrappix::Error.new(error_message, response.body, response.status)
+    end
+  end
+
+  class Error < StandardError
+    attr_reader :body, :status
+
+    def initialize(message, body = nil, status = nil)
+      @body = body
+      @status = status
+      super(message)
+    end
+  end
+end

data/lib/wrappix/templates/cache.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Cache
+      def self.render(module_name, _config)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          module #{module_name}
+            # Memory cache implementation
+            class MemoryCache
+              def initialize
+                @store = {}
+              end
+
+              def read(key)
+                @store[key]
+              end
+
+              def write(key, value)
+                @store[key] = value
+              end
+
+              def delete(key)
+                @store.delete(key)
+              end
+
+              def clear
+                @store = {}
+              end
+            end
+
+            # File cache implementation
+            class FileCache
+              def initialize(path = "#{module_name.downcase}_cache.yaml")
+                require "yaml/store"
+                @store = YAML::Store.new(path)
+              end
+
+              def read(key)
+                @store.transaction(true) { @store[key] }
+              end
+
+              def write(key, value)
+                @store.transaction { @store[key] = value }
+              end
+
+              def delete(key)
+                @store.transaction { @store.delete(key) }
+              end
+
+              def clear
+                @store.transaction { @store.roots.each { |key| @store.delete(key) } }
+              end
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/wrappix/templates/client.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Client
+      def self.render(module_name, config)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          module #{module_name}
+            class Client
+              def initialize(configuration = #{module_name}.configuration)
+                @configuration = configuration
+              end
+
+              #{resource_methods(module_name, config)}
+            end
+          end
+        RUBY
+      end
+
+      def self.resource_methods(_module_name, config)
+        resources = config["resources"] || {}
+
+        resources.map do |name, _config|
+          <<~RUBY.strip
+            def #{name}
+              @#{name} ||= Resources::#{name.capitalize}.new(self)
+            end
+          RUBY
+        end.join("\n\n")
+      end
+    end
+  end
+end

data/lib/wrappix/templates/collection.rb

@@ -0,0 +1,32 @@
+# lib/wrappix/templates/collection.rb
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Collection
+      def self.render(module_name, _config)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          module #{module_name}
+            class Collection
+              attr_reader :data, :next_href
+
+              def self.from_response(response_body, type:)
+                new(
+                  data: response_body[:data]&.map { |attrs| type.new(attrs) },
+                  next_href: response_body[:next_href]
+                )
+              end
+
+              def initialize(data:, next_href:)
+                @data = data
+                @next_href = next_href
+              end
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/wrappix/templates/configuration.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Configuration
+      def self.render(module_name, config)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          module #{module_name}
+            class Configuration
+              attr_accessor :base_url, :timeout, :headers
+              #{auth_config_attributes(config)}
+
+              def initialize
+                @base_url = "#{config["base_url"] || "https://api.example.com"}"
+                @timeout = 30
+                @headers = {
+                  "Content-Type" => "application/json",
+                  "Accept" => "application/json"
+                }
+                #{auth_config_initialization(config)}
+              end
+            end
+          end
+        RUBY
+      end
+
+      def self.auth_config_attributes(config)
+        case config["auth_type"]
+        when "oauth"
+          "attr_accessor :client_id, :client_secret, :token_url, :access_token"
+        when "basic"
+          "attr_accessor :username, :password"
+        when "api_key"
+          "attr_accessor :api_key, :api_key_header"
+        else
+          ""
+        end
+      end
+
+      def self.auth_config_initialization(config)
+        case config["auth_type"]
+        when "oauth"
+          <<~RUBY.strip
+            @client_id = nil
+            @client_secret = nil
+            @token_url = "#{config["token_url"] || "https://api.example.com/oauth/token"}"
+            @access_token = nil
+          RUBY
+        when "basic"
+          <<~RUBY.strip
+            @username = nil
+            @password = nil
+          RUBY
+        when "api_key"
+          <<~RUBY.strip
+            @api_key = nil
+            @api_key_header = "#{config["api_key_header"] || "X-Api-Key"}"
+          RUBY
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/wrappix/templates/documentation.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Documentation
+      def self.render(_api_name, module_name, config)
+        base_url = config["base_url"] || "https://api.example.com"
+        resources = config["resources"] || {}
+
+        # Cabecera y descripción general
+        doc = <<~MARKDOWN
+          # #{module_name} API Documentation
+
+          This document provides detailed information about the endpoints available in the #{module_name} API client.
+
+          **API Base URL:** `#{base_url}`
+
+          ## Table of Contents
+
+          - [Authentication](#authentication)
+          #{resources.keys.map { |r| "- [#{r.capitalize}](##{r})" }.join("\n  ")}
+
+          ## Authentication
+
+          #{render_authentication_docs(config)}
+
+          ## Resources
+
+        MARKDOWN
+
+        # Añadir documentación para cada recurso
+        resources.each do |resource_name, resource_config|
+          doc += render_resource_docs(resource_name, resource_config, module_name, base_url)
+        end
+
+        doc
+      end
+
+      def self.render_authentication_docs(config)
+        case config["auth_type"]
+        when "oauth"
+          <<~MARKDOWN
+            This API uses OAuth 2.0 authentication. You need to obtain an access token from the authorization server.
+
+            ```ruby
+            #{config["api_name"].gsub("-", "_").capitalize}.configure do |config|
+              config.client_id = "YOUR_CLIENT_ID"
+              config.client_secret = "YOUR_CLIENT_SECRET"
+            end
+            ```
+          MARKDOWN
+        when "basic"
+          <<~MARKDOWN
+            This API uses HTTP Basic Authentication.
+
+            ```ruby
+            #{config["api_name"].gsub("-", "_").capitalize}.configure do |config|
+              config.username = "YOUR_USERNAME"
+              config.password = "YOUR_PASSWORD"
+            end
+            ```
+          MARKDOWN
+        when "api_key"
+          header = config["api_key_header"] || "X-Api-Key"
+          <<~MARKDOWN
+            This API uses API Key authentication. The key should be provided in the `#{header}` header.
+
+            ```ruby
+            #{config["api_name"].gsub("-", "_").capitalize}.configure do |config|
+              config.api_key = "YOUR_API_KEY"
+            end
+            ```
+          MARKDOWN
+        else
+          "This API does not require authentication."
+        end
+      end
+
+      def self.render_resource_docs(resource_name, resource_config, module_name, base_url)
+        endpoints = resource_config["endpoints"] || []
+        singular_name = resource_name.end_with?("s") ? resource_name.chop : resource_name
+
+        doc = <<~MARKDOWN
+
+          <a name="#{resource_name}"></a>
+          ## #{resource_name.capitalize}
+
+        MARKDOWN
+
+        endpoints.each do |endpoint|
+          doc += render_endpoint_docs(endpoint, resource_name, singular_name, module_name, base_url)
+        end
+
+        doc
+      end
+
+      def self.render_endpoint_docs(endpoint, resource_name, singular_name, _module_name, base_url)
+        name = endpoint["name"]
+        method = endpoint["method"]&.upcase || "GET"
+        path = endpoint["path"] || name
+
+        # Extraer los parámetros del path
+        path_params = path.scan(/\{([^}]+)\}/).flatten
+
+        # Generar la URL completa para la documentación
+        full_url = "#{base_url.chomp("/")}/#{path}"
+
+        # Generar la llamada al método para la documentación
+        method_params = []
+        method_params.concat(path_params)
+        method_params << "params" if endpoint["params"]
+        method_params << "body" if %w[POST PUT PATCH].include?(method)
+
+        client_call = "client.#{resource_name}.#{name}(#{method_params.join(", ")})"
+
+        # Documentación del endpoint
+        doc = <<~MARKDOWN
+
+          ### #{name}
+
+          **#{method}** `#{full_url}`
+
+          #{endpoint["description"] || "No description provided."}
+
+          #### Parameters
+        MARKDOWN
+
+        # Añadir documentación de parámetros
+        if path_params.empty? && !endpoint["params"] && !%w[POST PUT PATCH].include?(method)
+          doc += "\nThis endpoint does not require any parameters.\n"
+        else
+          if path_params.any?
+            doc += "\n**Path Parameters:**\n\n"
+            path_params.each do |param|
+              doc += "- `#{param}`: Required. #{param_description(param)}\n"
+            end
+          end
+
+          if endpoint["params"]
+            doc += "\n**Query Parameters:**\n\n"
+            doc += "- This endpoint accepts additional query parameters.\n"
+          end
+
+          if %w[POST PUT PATCH].include?(method)
+            doc += "\n**Request Body:**\n\n"
+            doc += "- This endpoint accepts a request body with the resource attributes.\n"
+          end
+        end
+
+        # Añadir ejemplos de uso
+        doc += <<~MARKDOWN
+
+          #### Example Usage
+
+          ```ruby
+          #{client_call}
+          ```
+
+          #### Response
+
+          #{response_example(name, singular_name, endpoint["collection"])}
+        MARKDOWN
+
+        doc
+      end
+
+      def self.param_description(param)
+        case param
+        when "id"
+          "The unique identifier of the resource."
+        when "customer_id"
+          "The identifier of the customer."
+        when /^(\w+)_id$/
+          "The identifier of the #{::Regexp.last_match(1)}."
+        else
+          "Description not available."
+        end
+      end
+
+      def self.response_example(name, resource_name, _is_collection)
+        case name
+        when "list", "all", "index", "search"
+          <<~MARKDOWN
+            ```ruby
+            # Returns a Collection object
+            collection.data.each do |#{resource_name}|
+              puts #{resource_name}.id
+              puts #{resource_name}.name
+              # Other attributes...
+            end
+
+            # Pagination information
+            puts collection.next_href  # URL for the next page, if available
+            ```
+          MARKDOWN
+        when "get", "find", "show"
+          <<~MARKDOWN
+            ```ruby
+            # Returns a single Object
+            puts #{resource_name}.id
+            puts #{resource_name}.name
+            # Other attributes...
+            ```
+          MARKDOWN
+        when "create"
+          <<~MARKDOWN
+            ```ruby
+            # Returns the created object
+            puts #{resource_name}.id
+            puts #{resource_name}.created_at
+            # Other attributes...
+            ```
+          MARKDOWN
+        when "update"
+          <<~MARKDOWN
+            ```ruby
+            # Returns the updated object
+            puts #{resource_name}.id
+            puts #{resource_name}.updated_at
+            # Other attributes...
+            ```
+          MARKDOWN
+        when "delete", "destroy", "remove"
+          <<~MARKDOWN
+            ```ruby
+            # Returns a success indicator or the deleted object
+            puts "Resource deleted successfully"
+            ```
+          MARKDOWN
+        else
+          <<~MARKDOWN
+            ```ruby
+            # Returns a response specific to this endpoint
+            puts response  # Examine the response structure
+            ```
+          MARKDOWN
+        end
+      end
+    end
+  end
+end

data/lib/wrappix/templates/error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Error
+      def self.render(module_name, _config)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          module #{module_name}
+            class Error < StandardError
+              attr_reader :body, :status
+
+              def initialize(message, body = nil, status = nil)
+                @body = body
+                @status = status
+                super(message)
+              end
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/wrappix/templates/main.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Main
+      def self.render(api_name, module_name, config)
+        # api_name ya debería estar normalizado aquí
+        resources = config["resources"] || {}
+        resource_requires = resources.keys.map do |r|
+          "require_relative \"#{api_name}/resources/#{r}\""
+        end.join("\n")
+
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require_relative "#{api_name}/version"
+          require_relative "#{api_name}/configuration"
+          require_relative "#{api_name}/error"
+          require_relative "#{api_name}/request"
+          require_relative "#{api_name}/object"
+          require_relative "#{api_name}/collection"
+          require_relative "#{api_name}/client"
+          require_relative "#{api_name}/cache"
+
+          # Resources
+          #{resource_requires}
+
+          module #{module_name}
+            class << self
+              attr_accessor :configuration, :cache
+
+              def configure
+                self.configuration ||= Configuration.new
+                yield(configuration) if block_given?
+                self
+              end
+
+              # Método para acceder al cliente
+              def client
+                @client ||= Client.new(configuration)
+              end
+            end
+
+            # Default to memory cache
+            self.cache = MemoryCache.new
+            self.configuration = Configuration.new
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/wrappix/templates/object.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Wrappix
+  module Templates
+    class Object
+      def self.render(module_name, _config)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "ostruct"
+
+          module #{module_name}
+            class Object < OpenStruct
+              def initialize(attributes)
+                super(to_ostruct(attributes))
+              end
+
+              def to_ostruct(obj)
+                if obj.is_a?(Hash)
+                  OpenStruct.new(obj.transform_values { |val| to_ostruct(val) })
+                elsif obj.is_a?(Array)
+                  obj.map { |o| to_ostruct(o) }
+                else
+                  obj
+                end
+              end
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end