code-ruby 3.1.2 → 4.0.1

data/lib/code/object/ics.rb

@@ -3,6 +3,34 @@
 class Code
   class Object
     class Ics < Object
+      CLASS_DOCUMENTATION = {
+        name: "Ics",
+        description:
+          "parses icalendar text and exposes events as dictionaries.",
+        examples: [
+          "Ics.parse(\"BEGIN:VCALENDAR\\nBEGIN:VEVENT\\nSUMMARY:meet\\nEND:VEVENT\\nEND:VCALENDAR\")",
+          "Ics.parse(\"BEGIN:VCALENDAR\\nVERSION:2.0\\nEND:VCALENDAR\")",
+          "Ics.parse(\"\")"
+        ]
+      }.freeze
+      CLASS_FUNCTIONS = {
+        "parse" => {
+          name: "parse",
+          description: "returns event dictionaries parsed from icalendar text.",
+          examples: [
+            "Ics.parse(\"BEGIN:VCALENDAR\\nBEGIN:VEVENT\\nUID:1\\nSUMMARY:demo\\nEND:VEVENT\\nEND:VCALENDAR\")",
+            "Ics.parse(\"BEGIN:VCALENDAR\\nEND:VCALENDAR\")",
+            "Ics.parse(\"not calendar data\")"
+          ]
+        }
+      }.freeze
+
+      def self.function_documentation(scope)
+        return CLASS_FUNCTIONS if scope == :class
+
+        {}
+      end
+
       EVENT_ATTRIBUTES = %i[
         uid
         summary
@@ -15,6 +43,9 @@ class Code
         attendees
         geo
       ].freeze
+      MISSING_ATTRIBUTE = Object.new.freeze
+      MAX_EVENTS = 10_000
+      MAX_NESTING = 50
 
       def self.call(**args)
         code_operator = args.fetch(:operator, nil).to_code
@@ -32,11 +63,14 @@ class Code
 
       def self.code_parse(value)
         source = value.to_code.raw
+        ::Code.ensure_input_size!(source, label: "ics")
         calendars = ::Icalendar::Calendar.parse(source)
-        calendars
-          .flat_map(&:events)
-          .map { |event| serialize_event(event) }
-          .to_code
+        events = calendars.flat_map(&:events)
+        raise Error, "ics has too many events" if events.size > MAX_EVENTS
+
+        events.map { |event| serialize_event(event) }.to_code
+      rescue ::Code::Error
+        raise
       rescue StandardError
         [].to_code
       end
@@ -44,9 +78,9 @@ class Code
       def self.serialize_event(event)
         EVENT_ATTRIBUTES
           .each_with_object({}) do |attribute, result|
-            next unless event.respond_to?(attribute)
+            serialized = serialize_value(event_attribute(event, attribute))
+            next if serialized == MISSING_ATTRIBUTE
 
-            serialized = serialize_value(event.public_send(attribute))
             serialized =
               if attribute == :categories && serialized.is_a?(::Array)
                 serialized.flatten(1)
@@ -67,7 +101,36 @@ class Code
           .compact
       end
 
-      def self.serialize_value(value)
+      def self.event_attribute(event, attribute)
+        case attribute
+        when :uid
+          event.uid
+        when :summary
+          event.summary
+        when :description
+          event.description
+        when :location
+          event.location
+        when :url
+          event.url
+        when :status
+          event.status
+        when :organizer
+          event.organizer
+        when :categories
+          event.categories
+        when :attendees
+          event.attendees
+        when :geo
+          event.geo
+        end
+      rescue NoMethodError
+        MISSING_ATTRIBUTE
+      end
+
+      def self.serialize_value(value, depth: 0)
+        raise Error, "ics is too deeply nested" if depth > MAX_NESTING
+
         case value
         when nil
           nil
@@ -76,17 +139,17 @@ class Code
         when ::Symbol, ::Integer, ::Float, ::BigDecimal, true, false
           value
         when ::Array
-          value.map { |item| serialize_value(item) }
+          value.map { |item| serialize_value(item, depth: depth + 1) }
         when ::Hash
-          value.transform_values { |item| serialize_value(item) }
+          value.transform_values do |item|
+            serialize_value(item, depth: depth + 1)
+          end
         else
           serialized_date = serialize_date_like(value)
           return serialized_date unless serialized_date.nil?
 
-          if value.respond_to?(:value)
-            serialize_value(value.value)
-          elsif value.respond_to?(:to_ical)
-            normalize_string(value.to_ical)
+          if value.is_a?(::Icalendar::Value)
+            serialize_value(value.value, depth: depth + 1)
           else
             normalize_string(value.to_s)
           end

data/lib/code/object/identifier_list.rb

@@ -3,6 +3,16 @@
 class Code
   class Object
     class IdentifierList < List
+      CLASS_DOCUMENTATION = {
+        name: "IdentifierList",
+        description:
+          "stores ordered identifier names used to assign nested values.",
+        examples: [
+          "IdentifierList",
+          "IdentifierList.new([:user, :name]).first",
+          "IdentifierList.new([:user, :name]).join(\".\")"
+        ]
+      }.freeze
       def call(**args)
         code_operator = args.fetch(:operator, nil).to_code
         code_arguments = args.fetch(:arguments, []).to_code
@@ -83,11 +93,13 @@ class Code
           end
 
         if assignment_operator == "="
-          receiver.call(
-            **args,
-            operator: "#{raw.last}=",
-            arguments: Object::List.new([code_value])
-          )
+          receiver
+            .call(
+              **args,
+              operator: "#{raw.last}=",
+              arguments: Object::List.new([code_value])
+            )
+            .tap { persist_class_receiver(receiver, args.fetch(:context)) }
         else
           next_value =
             receiver.call(
@@ -100,13 +112,21 @@ class Code
               arguments: Object::List.new([code_value])
             )
 
-          receiver.call(
-            **args,
-            operator: "#{raw.last}=",
-            arguments: Object::List.new([next_value])
-          )
+          receiver
+            .call(
+              **args,
+              operator: "#{raw.last}=",
+              arguments: Object::List.new([next_value])
+            )
+            .tap { persist_class_receiver(receiver, args.fetch(:context)) }
         end
       end
+
+      def persist_class_receiver(receiver, context)
+        return unless receiver.is_a?(Object::Class)
+
+        context.code_set(raw.first, receiver)
+      end
     end
   end
 end