tina4ruby 3.13.89 → 3.13.91

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9a4969bc3af1b2a6f203d215043c4fb9497aa40e71a0f7d1c17d92eddeecea3
-  data.tar.gz: 67a4a34e48ca3e167201ab06ac5cab96be36b4f4224a97f04cae0c58f700184c
+  metadata.gz: 3df8f30ccbf4fc6d984ec4af8fa3262045b16ac1f05c7516f6a6818691fad547
+  data.tar.gz: 1236689bdee9821f1994bc27d1a69684fd312cc774f33a2bba6b10fa57bd86d8
 SHA512:
-  metadata.gz: a89938265a10f5b8f0a48966f370c55006937a236285fe6b8f2fd9c5f75464d5c4fc0fc65cf1583f76539e24cd095701e3c092d87fb9d1197978d1d9774f552c
-  data.tar.gz: af228d8eebfab34598468e44f6962ac701280d4ad1207e4184f2eee6aabc631c5dda36753de7c99b1e8aea4dde7cff635fa2c44c30fff469532124cab0d9f11a
+  metadata.gz: c51b11ed1b2c9361c162ab6d54f999381d13b8b6be74f4cd94ebfa0d72492f0805f9428e9080ee06b2eb6efd52dc5fd72e1a9d073743d5ad03ec9582c3894b8b
+  data.tar.gz: 4f8265ec9da1f6bd427ed844d808e4e2c67ee55ec934a0d24ea37f40b1a88861ce86bc9c09b162cd534f6d879825ed31a05e0baf32e73322ea8584097d9b8346

data/lib/tina4/cli.rb

@@ -233,6 +233,21 @@ module Tina4
       to_snake_case(name)
     end
 
+    # Called without --fields, the generators fall back to a single `name`
+    # string column. That default MUST be materialised here, in one place, and
+    # then flow into the model, the migration, the form, the view and the spec
+    # alike. It used to live only inside the model template, so `generate model
+    # X` / `generate crud X` wrote a model declaring `name` while the migration
+    # - built from the parsed field list, which was empty - created only id +
+    # created_at. The first write then failed with "no such column: name".
+    DEFAULT_FIELDS = [["name", "string"]].freeze
+
+    # Parsed --fields, or the default single `name` column when none given.
+    def fields_or_default(fields_str)
+      parsed = parse_fields(fields_str)
+      parsed.any? ? parsed : DEFAULT_FIELDS.map(&:dup)
+    end
+
     # Parse "name:string,price:float" -> [["name","string"], ["price","float"]]
     def parse_fields(fields_str)
       return [] if fields_str.nil? || fields_str.strip.empty?
@@ -1231,19 +1246,15 @@ module Tina4
     # ── Generator: model ─────────────────────────────────────────────────
 
     def generate_model(name, flags, emit_test: true)
-      fields = parse_fields(flags["fields"])
+      fields = fields_or_default(flags["fields"])
       table = to_table_name(name)
       snake = to_snake_case(name)
 
       # Build field lines
       field_lines = ["  integer_field :id, primary_key: true, auto_increment: true"]
-      if fields.any?
-        fields.each do |fname, ftype|
-          info = FIELD_TYPE_MAP[ftype] || FIELD_TYPE_MAP["string"]
-          field_lines << "  #{info[:orm]} :#{fname}"
-        end
-      else
-        field_lines << "  string_field :name"
+      fields.each do |fname, ftype|
+        info = FIELD_TYPE_MAP[ftype] || FIELD_TYPE_MAP["string"]
+        field_lines << "  #{info[:orm]} :#{fname}"
       end
       field_lines << "  string_field :created_at"
 
@@ -1355,6 +1366,11 @@ module Tina4
           Tina4::Router.post "/api/#{route_path}" do |request, response|
           #{ext_create.chomp}
             item = #{model}.create(request.body)
+            # create/save signal failure by RETURN VALUE, they do not raise -
+            # unchecked, a failed write surfaces as an unrelated NoMethodError
+            # on false and hides the real cause.
+            next response.json({ error: "Could not create #{singular}" }, 400) if item == false
+
             response.json(item.to_h, 201)
           end#{no_auth}
 
@@ -1368,7 +1384,8 @@ module Tina4
               setter = "#{'#'}{key}="
               item.send(setter, value) if item.respond_to?(setter)
             end
-            item.save
+            next response.json({ error: "Could not update #{singular}" }, 400) if item.save == false
+
             response.json(item.to_h)
           end#{no_auth}
 
@@ -1521,7 +1538,11 @@ module Tina4
       end
 
       # Build SQL columns from fields
-      fields = fields_override || parse_fields(flags["fields"])
+      # An EMPTY array is truthy in Ruby, so a plain `fields_override || parse`
+      # short-circuits to [] and the fallback never fires - that is exactly how
+      # a model declaring `name` ended up with a column-less migration. Test for
+      # content, not truthiness, so the semantics match Python/Node.
+      fields = fields_override&.any? ? fields_override : parse_fields(flags["fields"])
       is_create = name.start_with?("create_") || !fields_override.nil?
 
       filename = "#{timestamp}_#{name}.sql"
@@ -1771,7 +1792,7 @@ module Tina4
     # ── Generator: form ──────────────────────────────────────────────────
 
     def generate_form(name, flags = {})
-      fields = parse_fields(flags["fields"])
+      fields = fields_or_default(flags["fields"])
       table = to_table_name(name)
       route_name = "#{table}s"
 
@@ -1794,8 +1815,7 @@ module Tina4
 
       # Build form fields
       field_html = ""
-      form_fields = fields.any? ? fields : [["name", "string"]]
-      form_fields.each do |fname, ftype|
+      fields.each do |fname, ftype|
         itype = input_types[ftype] || "text"
         label = fname.tr("_", " ").split.map(&:capitalize).join(" ")
         step = %w[float numeric decimal].include?(ftype) ? ' step="0.01"' : ""
@@ -1850,11 +1870,11 @@ module Tina4
     # ── Generator: view ──────────────────────────────────────────────────
 
     def generate_view(name, flags = {})
-      fields = parse_fields(flags["fields"])
+      fields = fields_or_default(flags["fields"])
       table = to_table_name(name)
       route_name = "#{table}s"
 
-      cols = fields.any? ? fields.map { |f, _| f } : ["name"]
+      cols = fields.map { |f, _| f }
 
       dir = "src/templates/pages"
       FileUtils.mkdir_p(dir)
@@ -2480,7 +2500,10 @@ module Tina4
 
     # model -> real SQLite roundtrip (create / read back / missing -> nil).
     def emit_model_test(model, table, fields)
-      fields = fields.empty? ? [["name", "string"]] : fields
+      # Reuse the single DEFAULT_FIELDS constant rather than re-stating the
+      # literal, so the co-emitted spec can never describe a shape the model
+      # does not actually have.
+      fields = fields.empty? ? DEFAULT_FIELDS.map(&:dup) : fields
       payload = fields.map { |fname, ftype| %("#{fname}" => #{sample_literal(ftype)}) }.join(", ")
       # Assert a STRING field round-trips (type-safe); else just the id round-trips
       # (avoids datetime/bool/float equality pitfalls on the read-back).

data/lib/tina4/metrics.rb

@@ -254,7 +254,7 @@ module Tina4
         end
 
         lines = source.lines.map(&:chomp)
-        loc = lines.count { |l| !l.strip.empty? && !l.strip.start_with?('#') }
+        loc = lines.count { |l| _code_line?(l) }
 
         # Extract imports (require/require_relative)
         imports = _extract_imports(lines)
@@ -509,7 +509,7 @@ module Tina4
       end
 
       lines = source.lines.map(&:chomp)
-      loc = lines.count { |l| !l.strip.empty? && !l.strip.start_with?('#') }
+      loc = lines.count { |l| _code_line?(l) }
 
       functions = _extract_functions(source, tokens, lines)
       functions.sort_by! { |f| -f["complexity"] }
@@ -763,6 +763,17 @@ module Tina4
       buffers
     end
 
+    # True for a line that counts toward LOC: not blank, not a comment.
+    #
+    # The single definition of the rule. Method LOC used to ignore it and return a
+    # raw line span while file LOC excluded blanks and comments, so `loc` meant
+    # two different things in one payload - the dashboard sized bubbles in one
+    # unit and printed the method table in the other.
+    def self._code_line?(line)
+      stripped = line.strip
+      !stripped.empty? && !stripped.start_with?("#")
+    end
+
     def self._extract_functions(source, _tokens, _lines)
       functions = []
       # Operate on a neutralised copy: string/regex/comment CONTENT is blanked
@@ -811,7 +822,9 @@ module Tina4
             # Find method end and calculate LOC
             method_start = i
             method_end = _find_method_end(lines, i)
-            method_loc = method_end - method_start + 1
+            # Code lines over the method's span, by the same rule as file LOC.
+            # Floor of 1: a one-line body must never report 0.
+            method_loc = [1, lines[method_start..method_end].count { |l| _code_line?(l) }].max
 
             # Calculate complexity for this method's body
             method_lines = lines[method_start..method_end]
@@ -842,6 +855,51 @@ module Tina4
         i += 1
       end
 
+      _charge_nested_complexity_to_the_nested_function(functions)
+    end
+
+    # Stop a function being charged for the complexity of the functions nested
+    # inside it.
+    #
+    # Each function's raw score is measured over its whole span, so a branch
+    # inside a nested function landed on BOTH that function and every function
+    # enclosing it. The over-count compounded with depth: a wrapper around twenty
+    # inner handlers absorbed the entire file's complexity and topped the
+    # offenders list, hiding the genuine hot spots.
+    #
+    # The correction is exact. A raw score is 1 + every decision in the span, so
+    # (raw - 1) is the total decision count of a function's whole subtree.
+    # Subtracting that for each DIRECT child leaves the function's own branches:
+    #
+    #   own(F) = raw(F) - sum over direct children C of (raw(C) - 1)
+    #
+    # Blocks and lambdas are deliberately unaffected: they are not reported as
+    # functions of their own, so nothing subtracts them and their decisions stay
+    # with the method that contains them - moved, never lost.
+    def self._charge_nested_complexity_to_the_nested_function(functions)
+      return functions if functions.length < 2
+
+      last_line = ->(f) { f["line"] + [1, f["loc"]].max - 1 }
+      contains = ->(outer, inner) do
+        inner["line"] > outer["line"] && last_line.call(inner) <= last_line.call(outer)
+      end
+
+      raw = functions.map { |f| f["complexity"] }
+      functions.each_with_index do |outer, i|
+        subtract = 0
+        functions.each_with_index do |inner, j|
+          next if i == j || !contains.call(outer, inner)
+
+          # Direct child only: skip it if another function sits between the two,
+          # or its complexity would be subtracted twice.
+          nested_deeper = functions.each_with_index.any? do |mid, k|
+            k != i && k != j && contains.call(outer, mid) && contains.call(mid, inner)
+          end
+          subtract += raw[j] - 1 unless nested_deeper
+        end
+        outer["complexity"] = [1, raw[i] - subtract].max
+      end
+
       functions
     end