toon-ruby 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa973e72399a80aea212aefe4128d37ee2f25951962b5f7eb42573c4ba8c297f
-  data.tar.gz: 29e84d1f0c664914ea03c349922c6a47bcfe97d34374ab724197984cffe96870
+  metadata.gz: 969d3f21e6040a3b02a19330c293083c5bfd6d8ca837cdee0857bf72e8f86e7e
+  data.tar.gz: 2a5f93ec87c0bf3bf2fcddbfbc63cbbb291f4562fe107a8ba71886b737b70f57
 SHA512:
-  metadata.gz: 97a54e987de421c56c2f736c873d567f1ab5f82b1dc022f560d8b3677fe826a7b42b6bbda26a4715bdad3fbf085ef8cff849c8d7f9a0c2892eb6c12436e1f685
-  data.tar.gz: bb30d9a9f276fa9f0666c45f1238f84ef6c30dd57025627d0e17d36100e600e3b2f408be8b9e667857fca4e6b39a6d7e5c69ce0ee54abb8468268a60e6d10479
+  metadata.gz: 9b6beb81830ee688fafc938df44736a172e765d01493508c27e9bdf6f611fba8c6558aa20cb1331700d323dc2a8f667815f65915e5495a84bd337fd30197a332
+  data.tar.gz: 8575faca3894db0161f03bfdcedfd303cc9a3763383365c108ae456b53c5a36301042e3704aeeb75f0c2d6064d6603798271046577e5316fee4003677de2a960

data/README.md

@@ -30,7 +30,7 @@ users[2]{id,name,role}:
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'toon'
+gem 'toon-ruby'
 ```
 
 And then execute:
@@ -42,7 +42,7 @@ bundle install
 Or install it yourself as:
 
 ```bash
-gem install toon
+gem install toon-ruby
 ```
 
 ## Quick Start
@@ -115,7 +115,7 @@ Toon.encode({ 'items' => items })
 # => "items[2]{sku,qty,price}:\n  A1,2,9.99\n  B2,1,14.5"
 
 # Custom delimiter (tab)
-Toon.encode(items, delimiter: "\t")
+Toon.encode({ 'items' => items }, delimiter: "\t")
 # => "items[2\t]{sku\tqty\tprice}:\n  A1\t2\t9.99\n  B2\t1\t14.5"
 
 # Length marker
@@ -318,7 +318,7 @@ rake
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/johannschopplich/toon.
+Bug reports and pull requests are welcome on GitHub at https://github.com/andrepcg/toon-ruby.
 
 ## License
 

data/lib/toon/encoders.rb

@@ -9,20 +9,18 @@ module Toon
   module Encoders
     module_function
 
-    extend Normalizer
-    extend Primitives
 
     # Encode normalized value
     def encode_value(value, options)
-      if json_primitive?(value)
-        return encode_primitive(value, options[:delimiter])
+      if Normalizer.json_primitive?(value)
+        return Primitives.encode_primitive(value, options[:delimiter])
       end
 
       writer = LineWriter.new(options[:indent])
 
-      if json_array?(value)
+      if Normalizer.json_array?(value)
         encode_array(nil, value, writer, 0, options)
-      elsif json_object?(value)
+      elsif Normalizer.json_object?(value)
         encode_object(value, writer, 0, options)
       end
 
@@ -39,13 +37,13 @@ module Toon
     end
 
     def encode_key_value_pair(key, value, writer, depth, options)
-      encoded_key = encode_key(key)
+      encoded_key = Primitives.encode_key(key)
 
-      if json_primitive?(value)
-        writer.push(depth, "#{encoded_key}: #{encode_primitive(value, options[:delimiter])}")
-      elsif json_array?(value)
+      if Normalizer.json_primitive?(value)
+        writer.push(depth, "#{encoded_key}: #{Primitives.encode_primitive(value, options[:delimiter])}")
+      elsif Normalizer.json_array?(value)
         encode_array(key, value, writer, depth, options)
-      elsif json_object?(value)
+      elsif Normalizer.json_object?(value)
         nested_keys = value.keys
         if nested_keys.empty?
           # Empty object
@@ -60,20 +58,20 @@ module Toon
     # Array encoding
     def encode_array(key, value, writer, depth, options)
       if value.empty?
-        header = format_header(0, key: key, delimiter: options[:delimiter], length_marker: options[:length_marker])
+        header = Primitives.format_header(0, key: key, delimiter: options[:delimiter], length_marker: options[:length_marker])
         writer.push(depth, header)
         return
       end
 
       # Primitive array
-      if array_of_primitives?(value)
+      if Normalizer.array_of_primitives?(value)
         encode_inline_primitive_array(key, value, writer, depth, options)
         return
       end
 
       # Array of arrays (all primitives)
-      if array_of_arrays?(value)
-        all_primitive_arrays = value.all? { |arr| array_of_primitives?(arr) }
+      if Normalizer.array_of_arrays?(value)
+        all_primitive_arrays = value.all? { |arr| Normalizer.array_of_primitives?(arr) }
         if all_primitive_arrays
           encode_array_of_arrays_as_list_items(key, value, writer, depth, options)
           return
@@ -81,7 +79,7 @@ module Toon
       end
 
       # Array of objects
-      if array_of_objects?(value)
+      if Normalizer.array_of_objects?(value)
         header = detect_tabular_header(value)
         if header
           encode_array_of_objects_as_tabular(key, value, header, writer, depth, options)
@@ -96,27 +94,27 @@ module Toon
     end
 
     # Primitive array encoding (inline)
-    def encode_inline_primitive_array(prefix, values, writer, depth, options)
-      formatted = format_inline_array(values, options[:delimiter], prefix, options[:length_marker])
+    def encode_inline_primitive_array(key, values, writer, depth, options)
+      formatted = format_inline_array(values, options[:delimiter], key, options[:length_marker])
       writer.push(depth, formatted)
     end
 
     # Array of arrays (expanded format)
-    def encode_array_of_arrays_as_list_items(prefix, values, writer, depth, options)
-      header = format_header(values.length, key: prefix, delimiter: options[:delimiter], length_marker: options[:length_marker])
+    def encode_array_of_arrays_as_list_items(key, values, writer, depth, options)
+      header = Primitives.format_header(values.length, key: key, delimiter: options[:delimiter], length_marker: options[:length_marker])
       writer.push(depth, header)
 
       values.each do |arr|
-        if array_of_primitives?(arr)
+        if Normalizer.array_of_primitives?(arr)
           inline = format_inline_array(arr, options[:delimiter], nil, options[:length_marker])
           writer.push(depth + 1, "#{LIST_ITEM_PREFIX}#{inline}")
         end
       end
     end
 
-    def format_inline_array(values, delimiter, prefix = nil, length_marker = false)
-      header = format_header(values.length, key: prefix, delimiter: delimiter, length_marker: length_marker)
-      joined_value = join_encoded_values(values, delimiter)
+    def format_inline_array(values, delimiter, key = nil, length_marker = false)
+      header = Primitives.format_header(values.length, key: key, delimiter: delimiter, length_marker: length_marker)
+      joined_value = Primitives.join_encoded_values(values, delimiter)
       # Only add space if there are values
       if values.empty?
         header
@@ -126,8 +124,8 @@ module Toon
     end
 
     # Array of objects (tabular format)
-    def encode_array_of_objects_as_tabular(prefix, rows, header, writer, depth, options)
-      header_str = format_header(rows.length, key: prefix, fields: header, delimiter: options[:delimiter], length_marker: options[:length_marker])
+    def encode_array_of_objects_as_tabular(key, rows, header, writer, depth, options)
+      header_str = Primitives.format_header(rows.length, key: key, fields: header, delimiter: options[:delimiter], length_marker: options[:length_marker])
       writer.push(depth, header_str)
 
       write_tabular_rows(rows, header, writer, depth + 1, options)
@@ -156,7 +154,7 @@ module Toon
 
         # Check that all header keys exist in the row and all values are primitives
         header.all? do |key|
-          row.key?(key) && json_primitive?(row[key])
+          row.key?(key) && Normalizer.json_primitive?(row[key])
         end
       end
     end
@@ -164,27 +162,27 @@ module Toon
     def write_tabular_rows(rows, header, writer, depth, options)
       rows.each do |row|
         values = header.map { |key| row[key] }
-        joined_value = join_encoded_values(values, options[:delimiter])
+        joined_value = Primitives.join_encoded_values(values, options[:delimiter])
         writer.push(depth, joined_value)
       end
     end
 
     # Array of objects (expanded format)
-    def encode_mixed_array_as_list_items(prefix, items, writer, depth, options)
-      header = format_header(items.length, key: prefix, delimiter: options[:delimiter], length_marker: options[:length_marker])
+    def encode_mixed_array_as_list_items(key, items, writer, depth, options)
+      header = Primitives.format_header(items.length, key: key, delimiter: options[:delimiter], length_marker: options[:length_marker])
       writer.push(depth, header)
 
       items.each do |item|
-        if json_primitive?(item)
+        if Normalizer.json_primitive?(item)
           # Direct primitive as list item
-          writer.push(depth + 1, "#{LIST_ITEM_PREFIX}#{encode_primitive(item, options[:delimiter])}")
-        elsif json_array?(item)
+          writer.push(depth + 1, "#{LIST_ITEM_PREFIX}#{Primitives.encode_primitive(item, options[:delimiter])}")
+        elsif Normalizer.json_array?(item)
           # Direct array as list item
-          if array_of_primitives?(item)
+          if Normalizer.array_of_primitives?(item)
             inline = format_inline_array(item, options[:delimiter], nil, options[:length_marker])
             writer.push(depth + 1, "#{LIST_ITEM_PREFIX}#{inline}")
           end
-        elsif json_object?(item)
+        elsif Normalizer.json_object?(item)
           # Object as list item
           encode_object_as_list_item(item, writer, depth + 1, options)
         end
@@ -200,22 +198,22 @@ module Toon
 
       # First key-value on the same line as "- "
       first_key = keys[0]
-      encoded_key = encode_key(first_key)
+      encoded_key = Primitives.encode_key(first_key)
       first_value = obj[first_key]
 
-      if json_primitive?(first_value)
-        writer.push(depth, "#{LIST_ITEM_PREFIX}#{encoded_key}: #{encode_primitive(first_value, options[:delimiter])}")
-      elsif json_array?(first_value)
-        if array_of_primitives?(first_value)
+      if Normalizer.json_primitive?(first_value)
+        writer.push(depth, "#{LIST_ITEM_PREFIX}#{encoded_key}: #{Primitives.encode_primitive(first_value, options[:delimiter])}")
+      elsif Normalizer.json_array?(first_value)
+        if Normalizer.array_of_primitives?(first_value)
           # Inline format for primitive arrays
           formatted = format_inline_array(first_value, options[:delimiter], first_key, options[:length_marker])
           writer.push(depth, "#{LIST_ITEM_PREFIX}#{formatted}")
-        elsif array_of_objects?(first_value)
+        elsif Normalizer.array_of_objects?(first_value)
           # Check if array of objects can use tabular format
           header = detect_tabular_header(first_value)
           if header
             # Tabular format for uniform arrays of objects
-            header_str = format_header(first_value.length, key: first_key, fields: header, delimiter: options[:delimiter], length_marker: options[:length_marker])
+            header_str = Primitives.format_header(first_value.length, key: first_key, fields: header, delimiter: options[:delimiter], length_marker: options[:length_marker])
             writer.push(depth, "#{LIST_ITEM_PREFIX}#{header_str}")
             write_tabular_rows(first_value, header, writer, depth + 1, options)
           else
@@ -231,17 +229,17 @@ module Toon
 
           # Encode array contents at depth + 1
           first_value.each do |item|
-            if json_primitive?(item)
-              writer.push(depth + 1, "#{LIST_ITEM_PREFIX}#{encode_primitive(item, options[:delimiter])}")
-            elsif json_array?(item) && array_of_primitives?(item)
+            if Normalizer.json_primitive?(item)
+              writer.push(depth + 1, "#{LIST_ITEM_PREFIX}#{Primitives.encode_primitive(item, options[:delimiter])}")
+            elsif Normalizer.json_array?(item) && Normalizer.array_of_primitives?(item)
               inline = format_inline_array(item, options[:delimiter], nil, options[:length_marker])
               writer.push(depth + 1, "#{LIST_ITEM_PREFIX}#{inline}")
-            elsif json_object?(item)
+            elsif Normalizer.json_object?(item)
               encode_object_as_list_item(item, writer, depth + 1, options)
             end
           end
         end
-      elsif json_object?(first_value)
+      elsif Normalizer.json_object?(first_value)
         nested_keys = first_value.keys
         if nested_keys.empty?
           writer.push(depth, "#{LIST_ITEM_PREFIX}#{encoded_key}:")

data/lib/toon/normalizer.rb

@@ -9,14 +9,12 @@ module Toon
 
     # Normalization (unknown → JSON-compatible value)
     def normalize_value(value)
-      # null
-      return nil if value.nil?
-
-      # Primitives
-      return value if value.is_a?(String) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
-
-      # Numbers: handle special cases
-      if value.is_a?(Numeric)
+      case value
+      when nil
+        nil
+      when String, TrueClass, FalseClass
+        value
+      when Numeric
         # Float special cases
         if value.is_a?(Float)
           # -0.0 becomes 0
@@ -24,48 +22,25 @@ module Toon
           # NaN and Infinity become nil
           return nil unless value.finite?
         end
-        return value
-      end
-
-      # Symbol → string
-      return value.to_s if value.is_a?(Symbol)
-
-      # Time → ISO8601 string
-      if value.is_a?(Time)
-        return value.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
-      end
-
-      # DateTime → ISO8601 string
-      if value.respond_to?(:iso8601) && !value.is_a?(Date)
-        return value.iso8601
-      end
-
-      # Date → ISO8601 string
-      if value.is_a?(Date)
-        return value.to_time.utc.iso8601
+        value
+      when Symbol
+        value.to_s
+      when Time
+        value.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+      when ->(v) { v.respond_to?(:iso8601) && !v.is_a?(Date) }
+        value.iso8601
+      when Date
+        value.to_time.utc.iso8601
+      when Array
+        value.map { |v| normalize_value(v) }
+      when Set
+        value.to_a.map { |v| normalize_value(v) }
+      when Hash
+        value.each_with_object({}) { |(k, v), h| h[k.to_s] = normalize_value(v) }
+      else
+        # Fallback: anything else becomes nil (functions, etc.)
+        nil
       end
-
-      # Array
-      if value.is_a?(Array)
-        return value.map { |v| normalize_value(v) }
-      end
-
-      # Set → array
-      if value.is_a?(Set)
-        return value.to_a.map { |v| normalize_value(v) }
-      end
-
-      # Hash/object
-      if value.is_a?(Hash)
-        result = {}
-        value.each do |k, v|
-          result[k.to_s] = normalize_value(v)
-        end
-        return result
-      end
-
-      # Fallback: anything else becomes nil (functions, etc.)
-      nil
     end
 
     # Type guards

data/lib/toon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Toon
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/toon/writer.rb

@@ -16,4 +16,5 @@ module Toon
       @lines.join("\n")
     end
   end
+  private_constant :LineWriter
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toon-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - André Perdigão