serrano-vk 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a3f9a5c639bfa422a1441b9399fe91bb858f072787b6ff882f13dbbb706d1e1
-  data.tar.gz: 50a6aec6958948a931bbfd6bfbd55208adb241dca6c2d79cf3bc7329c79cebb4
+  metadata.gz: 2ce8d324bd08bb913b2bb6b1c3f62b1e2eeed43a0fb34ecb123f1fcf1f9fcb1a
+  data.tar.gz: 45aa053034a7bb22fa3c3ca4a17a7d767a3b11c1fb8828a7535708cc0f0cf390
 SHA512:
-  metadata.gz: 77d117adcb1376fc62219aad4d05798b5075ba511f4e36bf8377e963c868231333c979d3842315def62d88f1543bb0a3ef1f9ef03644152441b5d17081d62372
-  data.tar.gz: d4573e52bed1ce97874e1f4b11aef7b3cee8f697d5e0b35066545e888ca59ccf011b85d6f2ec34ada12a0ccf758425b92dcfb1fcb87723166c027fc8102b8c02
+  metadata.gz: 4f8316342eee52daa26d5a1a69790f0349b1a775d03771823c35657ec7a5475e22d5a37258bf514f9e330046abd85720d5e842ca640f705357cd1935f758de6f
+  data.tar.gz: 01e32c0cdf34631cf0084710feacb99d0a7aad55ef817b5c4afae20ac4ac7ff37b292b7f57f237b4dc75e1d9c901d00a78efb6177a1aa366088b25b3bbeda106

data/EXAMPLES.md

@@ -1,8 +1,18 @@
-# Serrano - Full Examples
-
-This document is the usage cookbook for the framework and CLI.
-
-## 1) Core Runtime: Minimal HTTP App
+# Serrano - Full Examples
+
+This document is the usage cookbook for the framework and CLI.
+
+## 0) Server setup note
+
+Serrano only provides HTTP core + CLI scaffolding. It does not assume a fixed production server.
+In your project, you can run with any Rack-compatible server you prefer (for local quickstart, `rackup` is used in examples).
+
+If you want to use a different server (for example puma, falcon, unicorn), start the app by running that server with your `config.ru`.
+
+- Add `server` gem to your project Gemfile if needed.
+- Keep `config.ru` exposing `run app` as shown below.
+
+## 1) Core Runtime: Minimal HTTP App
 
 ### 1.1 files
 
@@ -82,8 +92,8 @@ def crash(_request)
 end
 ```
 
-- status `500`
-- body `{"error":"Internal Server Error"}`
+- status `500`
+- body `{"error":"RuntimeError: boom"}`
 
 ---
 
@@ -130,37 +140,52 @@ request['id']
 
 ---
 
-## 5) CLI: bootstrap new projects
-
-## 5.1 create full project (recommended)
-
-```bash
-bundle exec serrano new my_app
-```
+## 5) CLI: bootstrap new projects
+
+Use:
+
+```bash
+serrano new my_app
+```
+
+`serrano new` creates the project structure only. It does not register any routes by itself.
+For first endpoint (`/articles`) do:
+
+```bash
+cd my_app
+serrano generate resource Article title:string content:text
+```
+This command inserts the routes into `config.ru` automatically.
+
+## 5.1 create full project (recommended)
+
+```bash
+serrano new my_app
+```
 
 Generated structure includes `app/`, `config.ru`, `Gemfile`, `config/db.rb`, `db/migrations/`.
 
 ## 5.2 create full project + sqlite db
 
-```bash
-bundle exec serrano new my_app --db=sqlite
-```
+```bash
+serrano new my_app --db=sqlite
+```
 
 Adds sqlite dependency and DB config.
 
 ## 5.3 minimal project
 
-```bash
-bundle exec serrano new my_app --minimal
-```
+```bash
+serrano new my_app --minimal
+```
 
 Only boot files, no app/db scaffolding.
 
 ## 5.4 minimal + db
 
-```bash
-bundle exec serrano new my_app --minimal --db=postgres
-```
+```bash
+serrano new my_app --minimal --db=postgres
+```
 
 Orthogonal behavior: `--minimal` does not disable DB files.
 
@@ -178,9 +203,9 @@ bundle exec rackup
 
 ### 6.1 scaffold full resource
 
-```bash
-bundle exec serrano generate resource Article title:string content:text
-```
+```bash
+serrano generate resource Article title:string content:text
+```
 
 Creates:
 
@@ -193,11 +218,11 @@ Creates:
 
 ### 6.2 generate individual files
 
-```bash
-bundle exec serrano generate controller Comments
-bundle exec serrano generate service Reports::Monthly
-bundle exec serrano generate repository Comment
-```
+```bash
+serrano generate controller Comments
+serrano generate service Reports::Monthly
+serrano generate repository Comment
+```
 
 ---
 
@@ -211,11 +236,11 @@ This example assumes you are inside an app where `generate resource` already cre
 bundle exec rackup
 ```
 
-### 7.2 routes examples
-
-```bash
-curl -i http://localhost:9292/articles
-curl -i http://localhost:9292/articles/1
+### 7.2 routes examples
+
+```bash
+curl -i http://localhost:9292/articles
+curl -i http://localhost:9292/articles/1
 curl -i -X POST http://localhost:9292/articles \
   -H "Content-Type: application/x-www-form-urlencoded" \
   --data-raw "title=First&content=Hello"
@@ -230,8 +255,17 @@ Expected mapping:
 - `GET /articles` -> `index`
 - `GET /articles/:id` -> `show`
 - `POST /articles` -> `create`
-- `PUT /articles/:id` -> `update`
-- `DELETE /articles/:id` -> `destroy`
+- `PUT /articles/:id` -> `update`
+- `DELETE /articles/:id` -> `destroy`
+
+### 7.3 pass params
+
+```bash
+curl -i "http://localhost:9292/articles/1?source=cli"
+curl -i -X POST "http://localhost:9292/articles" \
+  -H "Content-Type: application/x-www-form-urlencoded" \
+  --data "title=First&content=Hello"
+```
 
 ---
 
@@ -259,10 +293,10 @@ def crash(_request)
 end
 ```
 
-Expect:
-
-- `500`
-- body `{"error":"Internal Server Error"}`
+Expect:
+
+- `500`
+- body `{"error":"StandardError: boom"}`
 
 ---
 

data/README.md

@@ -24,21 +24,22 @@ If you want database or CRUD tooling, use the optional CLI and example scaffoldi
 
 ---
 
-## Core Contracts
-
-- Supported methods: `GET`, `POST`, `PUT`, `DELETE`
-- Route DSL:
+## Core Contracts
+
+- Supported methods: `GET`, `POST`, `PUT`, `DELETE`
+- Route DSL:
   - `get(path, controller, action)`
   - `post(path, controller, action)`
   - `put(path, controller, action)`
   - `delete(path, controller, action)`
-- Controller return values:
-  - `Hash` => JSON response, status `200`
-  - `String` => `text/plain`, status `200`
-  - `Serrano::Response` => use as-is
-  - other values => `500` with `Internal Server Error`
-- Missing route => `404 Not Found`
-- Missing method for existing path => `405 Method Not Allowed` with lowercase `allow` header and supported methods
+- Controller return values:
+  - `Hash` => JSON response, status `200`
+  - `String` => `text/plain`, status `200`
+  - `Serrano::Response` => use as-is
+  - other values => `500` with JSON error
+- Missing route => `404 Not Found`
+- Missing method for existing path => `405 Method Not Allowed` with lowercase `allow` header and supported methods
+- Controller exceptions => `500` JSON error response. Example: `{"error":"RuntimeError: boom"}`
 
 See [EXAMPLES.md](./EXAMPLES.md) for full request/response demos.
 
@@ -95,11 +96,14 @@ Run:
 bundle exec rackup
 ```
 
-Quick check:
-
-```bash
-curl -i http://localhost:9292/users
-```
+Quick check:
+
+```bash
+curl -i http://localhost:9292/users
+```
+
+If you used `serrano new`, routes are not present until you generate resources or define them yourself.
+Without matching routes, responses are `404` (path-aware payload).
 
 ---
 
@@ -107,19 +111,30 @@ curl -i http://localhost:9292/users
 
 The CLI is optional and depends on the core runtime.
 
-### Available commands
-
-```bash
-bundle exec serrano new APP_NAME [--minimal] [--db=sqlite|postgres|mysql]
-bundle exec serrano generate resource Article title:string content:text
-bundle exec serrano generate controller Name
-bundle exec serrano generate service Namespace::Name
-bundle exec serrano generate repository Name
-```
-
-- `new` creates project files (minimal mode and DB options are orthogonal)
-- `generate resource` creates controller, services (`index`, `show`, `create`, `update`, `destroy`), repository, entity, migration
-- route code is suggested in terminal output; automatic `config.ru` route editing is handled by generator logic when app file exists
+### Available commands
+
+```bash
+serrano new APP_NAME [--minimal] [--db=sqlite|postgres|mysql]
+serrano generate resource Article title:string content:text
+serrano generate controller Name
+serrano generate service Namespace::Name
+serrano generate repository Name
+```
+
+- `new` creates project files (minimal mode and DB options are orthogonal)
+- `generate resource` creates controller, services (`index`, `show`, `create`, `update`, `destroy`), repository, entity, migration
+- `generate resource` updates `config.ru` with required `require_relative` and route lines when possible.
+
+### Parameters in requests
+
+Using controller params:
+
+```bash
+curl -i "http://localhost:9292/users/12?foo=abc"
+curl -i -X POST "http://localhost:9292/articles" \
+  -H "Content-Type: application/x-www-form-urlencoded" \
+  --data "title=First&content=Hello"
+```
 
 For full command usage with sample outputs and full flows, read [EXAMPLES.md](./EXAMPLES.md).
 

data/lib/serrano/cli/generate.rb

@@ -17,7 +17,6 @@ module Serrano
         )
 
         write_template("controller.rb.tt", target_path("app/controllers/#{resource[:plural_snake]}_controller.rb"), context)
-        write_template("entity_validatable.rb.tt", target_path("app/entities/concerns/validatable.rb"), context)
         write_template("service_index.rb.tt", target_path("app/services/#{resource[:plural_snake]}/index.rb"), context)
         write_template("service_show.rb.tt", target_path("app/services/#{resource[:plural_snake]}/show.rb"), context)
         write_template("service_create.rb.tt", target_path("app/services/#{resource[:plural_snake]}/create.rb"), context)

data/lib/serrano/cli/templates/entity.rb.tt

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "./concerns/validatable"
-
 class <%= resource[:singular_camel] %>
-  include Validatable
+  include Serrano::Validation
 
 <% fields.each do |field| -%>
 <% rules = [] -%>

data/lib/serrano/dispatcher.rb

@@ -11,13 +11,13 @@ module Serrano
     def call(env)
       request = Request.new(env)
       route = @router.resolve(request.method, request.path)
-
-      unless route
-        allowed_methods = @router.allowed_methods(request.path)
-        return method_not_allowed(allowed_methods) unless allowed_methods.empty?
-
-        return not_found
-      end
+
+      unless route
+        allowed_methods = @router.allowed_methods(request.path)
+        return method_not_allowed(allowed_methods) unless allowed_methods.empty?
+
+        return not_found(request.path)
+      end
 
       controller = route[:controller].new
       request.set_path_params(route[:path_params] || {})
@@ -44,11 +44,11 @@ module Serrano
       ).to_rack
     end
 
-    def not_found
+    def not_found(path)
       Response.new(
         status: 404,
         headers: { 'content-type' => 'application/json' },
-        body: '{"error":"Not Found"}'
+        body: JSON.generate(error: 'Not Found', path: path)
       ).to_rack
     end
 

data/lib/serrano/validation.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Serrano
+  module Validation
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def validations
+        @validations ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def validates(field, rules = {})
+        validations[field.to_sym] << rules
+      end
+
+      def validate(input)
+        attrs = symbolize_keys(input || {})
+        errors = []
+
+        validations.each do |field, field_rules|
+          value = attrs[field]
+          field_rules.each do |rules|
+            validate_presence(field, value, rules, errors)
+            validate_length(field, value, rules, errors)
+            validate_format(field, value, rules, errors)
+            validate_inclusion(field, value, rules, errors)
+            validate_exclusion(field, value, rules, errors)
+            validate_numericality(field, value, rules, errors)
+            validate_range(field, value, rules, errors)
+          end
+        end
+
+        if errors.empty?
+          { ok: true, attrs: attrs }
+        else
+          { ok: false, errors: errors, attrs: attrs }
+        end
+      end
+
+      private
+
+      def symbolize_keys(input)
+        input.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value }
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      def validate_presence(field, value, rules, errors)
+        return unless rules[:presence]
+
+        errors << "#{field} is required" if blank?(value)
+      end
+
+      def validate_length(field, value, rules, errors)
+        config = rules[:length]
+        return unless config
+        return if blank?(value)
+
+        str = value.to_s
+        if config[:min] && str.length < config[:min]
+          errors << "#{field} is too short (minimum is #{config[:min]})"
+        end
+        if config[:max] && str.length > config[:max]
+          errors << "#{field} is too long (maximum is #{config[:max]})"
+        end
+      end
+
+      def validate_format(field, value, rules, errors)
+        pattern = rules[:format]
+        return unless pattern
+        return if blank?(value)
+
+        errors << "#{field} is invalid" unless pattern.match?(value.to_s)
+      end
+
+      def validate_inclusion(field, value, rules, errors)
+        allowed = rules[:inclusion]
+        return unless allowed
+        return if blank?(value)
+
+        errors << "#{field} is not included in the list" unless allowed.include?(value)
+      end
+
+      def validate_exclusion(field, value, rules, errors)
+        blocked = rules[:exclusion]
+        return unless blocked
+        return if blank?(value)
+
+        errors << "#{field} is reserved" if blocked.include?(value)
+      end
+
+      def validate_numericality(field, value, rules, errors)
+        config = rules[:numericality]
+        return unless config
+        return if blank?(value)
+
+        number = begin
+          Float(value)
+        rescue StandardError
+          nil
+        end
+
+        if number.nil?
+          errors << "#{field} is not a number"
+          return
+        end
+
+        if config.is_a?(Hash) && config[:only_integer] && number != number.to_i
+          errors << "#{field} must be an integer"
+        end
+      end
+
+      def validate_range(field, value, rules, errors)
+        config = rules[:range]
+        return unless config
+        return if blank?(value)
+
+        number = begin
+          Float(value)
+        rescue StandardError
+          nil
+        end
+        return if number.nil?
+
+        if config[:min] && number < config[:min]
+          errors << "#{field} must be greater than or equal to #{config[:min]}"
+        end
+        if config[:max] && number > config[:max]
+          errors << "#{field} must be less than or equal to #{config[:max]}"
+        end
+      end
+    end
+  end
+end

data/lib/serrano/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Serrano
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/serrano.rb

@@ -6,6 +6,7 @@ require_relative 'serrano/router'
 require_relative 'serrano/request'
 require_relative 'serrano/response'
 require_relative 'serrano/dispatcher'
+require_relative 'serrano/validation'
 
 module Serrano
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: serrano-vk
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Jesus Martinez
@@ -692,7 +692,6 @@ files:
 - lib/serrano/cli/generate.rb
 - lib/serrano/cli/templates/controller.rb.tt
 - lib/serrano/cli/templates/entity.rb.tt
-- lib/serrano/cli/templates/entity_validatable.rb.tt
 - lib/serrano/cli/templates/migration.rb.tt
 - lib/serrano/cli/templates/new_default_config.ru.tt
 - lib/serrano/cli/templates/new_default_db.rb.tt
@@ -713,6 +712,7 @@ files:
 - lib/serrano/request.rb
 - lib/serrano/response.rb
 - lib/serrano/router.rb
+- lib/serrano/validation.rb
 - lib/serrano/version.rb
 homepage: https://github.com/vurokrazia/serrano
 licenses:

data/lib/serrano/cli/templates/entity_validatable.rb.tt

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module Validatable
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    def validations
-      @validations ||= Hash.new { |hash, key| hash[key] = [] }
-    end
-
-    def validates(field, rules = {})
-      validations[field.to_sym] << rules
-    end
-
-    def validate(input)
-      attrs = symbolize_keys(input || {})
-      errors = []
-
-      validations.each do |field, field_rules|
-        value = attrs[field]
-        field_rules.each do |rules|
-          validate_presence(field, value, rules, errors)
-          validate_length(field, value, rules, errors)
-          validate_format(field, value, rules, errors)
-          validate_inclusion(field, value, rules, errors)
-          validate_exclusion(field, value, rules, errors)
-          validate_numericality(field, value, rules, errors)
-          validate_range(field, value, rules, errors)
-        end
-      end
-
-      if errors.empty?
-        { ok: true, attrs: attrs }
-      else
-        { ok: false, errors: errors, attrs: attrs }
-      end
-    end
-
-    private
-
-    def symbolize_keys(input)
-      input.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value }
-    end
-
-    def blank?(value)
-      value.nil? || value.to_s.strip.empty?
-    end
-
-    def validate_presence(field, value, rules, errors)
-      return unless rules[:presence]
-
-      errors << "#{field} is required" if blank?(value)
-    end
-
-    def validate_length(field, value, rules, errors)
-      config = rules[:length]
-      return unless config
-      return if blank?(value)
-
-      str = value.to_s
-      if config[:min] && str.length < config[:min]
-        errors << "#{field} is too short (minimum is #{config[:min]})"
-      end
-      if config[:max] && str.length > config[:max]
-        errors << "#{field} is too long (maximum is #{config[:max]})"
-      end
-    end
-
-    def validate_format(field, value, rules, errors)
-      pattern = rules[:format]
-      return unless pattern
-      return if blank?(value)
-
-      errors << "#{field} is invalid" unless pattern.match?(value.to_s)
-    end
-
-    def validate_inclusion(field, value, rules, errors)
-      allowed = rules[:inclusion]
-      return unless allowed
-      return if blank?(value)
-
-      errors << "#{field} is not included in the list" unless allowed.include?(value)
-    end
-
-    def validate_exclusion(field, value, rules, errors)
-      blocked = rules[:exclusion]
-      return unless blocked
-      return if blank?(value)
-
-      errors << "#{field} is reserved" if blocked.include?(value)
-    end
-
-    def validate_numericality(field, value, rules, errors)
-      config = rules[:numericality]
-      return unless config
-      return if blank?(value)
-
-      number = begin
-        Float(value)
-      rescue StandardError
-        nil
-      end
-
-      if number.nil?
-        errors << "#{field} is not a number"
-        return
-      end
-
-      if config.is_a?(Hash) && config[:only_integer] && number != number.to_i
-        errors << "#{field} must be an integer"
-      end
-    end
-
-    def validate_range(field, value, rules, errors)
-      config = rules[:range]
-      return unless config
-      return if blank?(value)
-
-      number = begin
-        Float(value)
-      rescue StandardError
-        nil
-      end
-      return if number.nil?
-
-      if config[:min] && number < config[:min]
-        errors << "#{field} must be greater than or equal to #{config[:min]}"
-      end
-      if config[:max] && number > config[:max]
-        errors << "#{field} must be less than or equal to #{config[:max]}"
-      end
-    end
-  end
-end