evva 0.8.5 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 573d6c9048cd876148a4cb32de26aaf1bfd1c9a7e269b98f8922a81d9b6d5187
-  data.tar.gz: 229f516b92262bb14fb67de48b4f0be7462272d049a2b465a3eeb063a348ebf4
+  metadata.gz: dec4f42e824897d939df66cc400f64c7d0f8ed0afa61d7c47f90e35a3730593f
+  data.tar.gz: 46151f2d8987db8501e73c84dd1d7cddf96fa8364d71495b9e838817bf73b24e
 SHA512:
-  metadata.gz: 497f43e9b4d3a96c45cc514743e9c131ef92cb9a8a60e1f4c9314bd8b140ab708ce15fbb269583fc9d316b9499b6a028b70f1ca4127b0365ed783b60dd5e258b
-  data.tar.gz: 41f177ed9ef2c34ba43fa1d1a3352e66509fc24b313dcc208680bee488b60ecd1cf3272ae4d957db46b744e06cc428bb68f2efb5dfeb499e74b7e65f1d33fd22
+  metadata.gz: 0e48b6d338ad0cbea9604afe19ca59b1bcf4842cb28d10681c918a1a3e4532afc9346939c4748bc85cb753f5520e5552c3bc5fa7c45f08050da301249d9f1de9
+  data.tar.gz: 0bea87253e07e92fbd7546ee66dd798b6418a7534c1f5655f42990f4d8ec83617bc081c763422ddb1a6c13eec40a1c2d33dc0e4e008c4ce638c17bb732328837

data/.rubocop_todo.yml

@@ -109,6 +109,7 @@ Layout/SpaceInsideHashLiteralBraces:
   Exclude:
     - 'lib/evva/config.rb'
     - 'lib/evva/logger.rb'
+    - 'spec/evva_spec.rb'
     - 'spec/lib/evva/config_spec.rb'
     - 'spec/lib/evva/google_sheet_spec.rb'
     - 'spec/lib/evva/kotlin_generator_spec.rb'
@@ -253,6 +254,8 @@ Style/HashSyntax:
     - 'Gemfile'
     - 'Rakefile'
     - 'lib/evva.rb'
+    - 'spec/evva_spec.rb'
+    - 'spec/platform_filter_spec.rb'
     - 'lib/evva/config.rb'
     - 'lib/evva/google_sheet.rb'
     - 'lib/evva/kotlin_generator.rb'
@@ -359,6 +362,7 @@ Style/SymbolProc:
 # SupportedStylesForMultiline: comma, consistent_comma, no_comma
 Style/TrailingCommaInArrayLiteral:
   Exclude:
+    - 'spec/evva_spec.rb'
     - 'spec/lib/evva/google_sheet_spec.rb'
     - 'spec/lib/evva/kotlin_generator_spec.rb'
     - 'spec/lib/evva/swift_generator_spec.rb'
@@ -370,6 +374,7 @@ Style/TrailingCommaInArrayLiteral:
 Style/TrailingCommaInHashLiteral:
   Exclude:
     - 'lib/evva/config.rb'
+    - 'spec/evva_spec.rb'
     - 'lib/evva/kotlin_generator.rb'
     - 'lib/evva/swift_generator.rb'
     - 'spec/lib/evva/config_spec.rb'

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    evva (0.8.4)
+    evva (0.10.0)
       colorize (~> 1.0)
-      csv (>= 3.0)
+      csv (~> 3.0)
       safe_yaml (~> 1.0)
 
 GEM

data/README.md

@@ -36,4 +36,43 @@ Evva automatically generates code for triggering events based on a Google Sheets
  destinations_file_name: /file/with/destinations
  special_enum_file_name: /file/with/special/enum/properties/
  swift_public: false  # optional; when true (iOS), generated Swift uses the public access modifier for generated extensions
+ filter_by_platforms:  # optional; array of platforms to keep (e.g. [ios])
+   - ios
  ```
+
+## The events sheet
+
+ The events sheet is read by column header, so column order does not matter and
+ unknown columns are ignored.
+
+ | Column | Required | Meaning |
+ | --- | --- | --- |
+ | `Event Name` | yes | The event name |
+ | `Event Properties` | no | Comma separated `name:Type` pairs |
+ | `Event Destination` | no | Comma separated destinations |
+ | `Platform` | no | Which platforms track the event |
+
+### Platform
+
+ `Platform` tags an event with the platforms it belongs to. Filtering is driven
+ by the `filter_by_platforms` key in `evva_config.yml`: only events matching one
+ of the listed platforms (or unrestricted events) are generated. When the key is
+ absent, every event is generated.
+
+ Any value is accepted as a platform name (case insensitive, comma separated).
+ An empty cell means the event is unrestricted and will never be filtered out.
+
+ The header is matched ignoring case and surrounding whitespace, so `platform` and
+ `Platform ` are both found.
+
+ When no `Platform` column is found the run says so, because "every event was
+ generated" is otherwise indistinguishable from a header that failed to match:
+
+ ```
+ [INFO] No Platform column in the events sheet, every event will be generated for every platform
+ ```
+
+ Enums whose only referencing events were filtered out are pruned, unless a
+ people property also references them.
+
+ People properties have no `Platform` column and are never filtered.

data/changelog.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-10-13
+
+- Support optional people properties in Kotlin: `innerValue` is now `Any?` and optional special properties use `value?.key`
+
+## [0.9.0] - 2026-09-04
+
+- Add `Platform` column support in the events sheet and `filter_by_platforms` configuration to filter generated events by platform
+
 ## [0.8.5] - 2026-08-21
 
 - Fix `native_type` replacing `Long`/`Boolean` substrings inside custom type names (e.g. `FlyoverLongPressAction` → `FlyoverIntPressAction`)

data/evva.gemspec

@@ -19,6 +19,6 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 3.2.0"
 
   s.add_runtime_dependency "colorize", "~> 1.0"
-  s.add_runtime_dependency "csv", ">= 3.0"
+  s.add_runtime_dependency "csv", "~> 3.0"
   s.add_runtime_dependency "safe_yaml", "~> 1.0"
 end

data/lib/evva/analytics_event.rb

@@ -1,17 +1,25 @@
 module Evva
   class AnalyticsEvent
-    attr_reader :event_name, :properties, :destinations
+    attr_reader :event_name, :properties, :destinations, :platforms
 
-    def initialize(event_name, properties, destinations)
+    def initialize(event_name, properties, destinations, platforms = nil)
       @event_name = event_name
       @properties = properties
       @destinations = destinations
+      @platforms = platforms
+    end
+
+    def supports_platform?(platform)
+      return true if platforms.nil?
+
+      platforms.include?(platform.to_s.downcase)
     end
 
     def ==(other)
       event_name == other.event_name &&
       properties == other.properties &&
-      destinations == other.destinations
+      destinations == other.destinations &&
+      platforms == other.platforms
     end
   end
 end

data/lib/evva/config.rb

@@ -68,6 +68,10 @@ module Evva
       @hash[:exclude_destinations] || []
     end
 
+    def filter_by_platforms
+      @hash[:filter_by_platforms]
+    end
+
     CONFIG_STRUCT = {
       type: Hash,
       elements: {
@@ -83,7 +87,8 @@ module Evva
         destinations_file_name: { type: String },
         package_name: { type: String },
         swift_public: { type: Object, optional: true },
-        exclude_destinations: { type: Array, optional: true }
+        exclude_destinations: { type: Array, optional: true },
+        filter_by_platforms: { type: Array, optional: true }
       }
     }.freeze
 

data/lib/evva/google_sheet.rb

@@ -6,6 +6,7 @@ module Evva
     EVENT_NAME = "Event Name"
     EVENT_PROPERTIES = "Event Properties"
     EVENT_DESTINATION = "Event Destination"
+    EVENT_PLATFORM = "Platform"
 
     PROPERTY_NAME = "Property Name"
     PROPERTY_TYPE = "Property Type"
@@ -26,11 +27,17 @@ module Evva
         get_csv(@events_url)
       end
 
-      @events ||= @events_csv.map do |row|
-        event_name = row[EVENT_NAME]
-        properties = hash_parser(row[EVENT_PROPERTIES])
-        destinations = row[EVENT_DESTINATION]&.split(",")
-        Evva::AnalyticsEvent.new(event_name, properties, destinations || [])
+      @events ||= begin
+        platform_header = header_matching(@events_csv, EVENT_PLATFORM)
+        Logger.info("No #{EVENT_PLATFORM} column in the events sheet, every event will be generated for every platform") if platform_header.nil?
+
+        @events_csv.map do |row|
+          event_name = row[EVENT_NAME]
+          properties = hash_parser(row[EVENT_PROPERTIES])
+          destinations = row[EVENT_DESTINATION]&.split(",")
+          platforms = platform_parser(platform_header && row[platform_header])
+          Evva::AnalyticsEvent.new(event_name, properties, destinations || [], platforms)
+        end
       end
     end
 
@@ -96,6 +103,21 @@ module Evva
       response.body
     end
 
+    # Matched ignoring case and surrounding whitespace, because a header of
+    # "platform" or "Platform " means what it plainly means.
+    def header_matching(csv, name)
+      csv.headers.compact.find { |header| header.to_s.strip.casecmp?(name) }
+    end
+
+    # nil (no Platform column or empty cell) means unrestricted (never filtered out).
+    # Concrete platform tokens are stored lowercased and deduplicated.
+    def platform_parser(platform_list)
+      tokens = platform_list.to_s.split(",").map(&:strip).reject(&:empty?)
+      return nil if tokens.empty?
+
+      tokens.map(&:downcase).uniq
+    end
+
     def hash_parser(property_array)
       h = {}
       unless property_array.nil? || property_array.empty?

data/lib/evva/kotlin_generator.rb

@@ -84,11 +84,21 @@ module Evva
 
         properties = people_bundle.map do |property|
           type = native_type(property.type)
+          value_fetcher = "value"
+
+          if special_property?(type)
+            if type.end_with?("?")
+              # optional value, we need ? to access a parameter
+              value_fetcher += "?"
+            end
+            value_fetcher += ".key"
+          end
+
           {
             class_name: camelize(property.property_name),
             property_name: constantize(property.property_name),
             type: type,
-            is_special_property: special_property?(property.type),
+            value_fetcher: value_fetcher,
             destinations: property.destinations.map { |p| constantize(p) },
           }
         end

data/lib/evva/templates/kotlin/people_properties.kt

@@ -1,6 +1,6 @@
 sealed class <%= class_name %>(
 	property: <%= enums_class_name %>,
-	val innerValue: Any,
+	val innerValue: Any?,
 	val destinations: Array<<%= destinations_class_name %>> = emptyArray(),
 ) {
 	val name = property.key
@@ -10,7 +10,7 @@ sealed class <%= class_name %>(
 		val value: <%= property[:type] %>,
 	) : <%= class_name %>(
 		property = <%= enums_class_name %>.<%= property[:property_name] %>,
-		innerValue = value<% if property[:is_special_property] %>.key<% end %>,
+		innerValue = <%= property[:value_fetcher] %>,
 		<%- if property[:destinations].count > 0 -%>
 		destinations = arrayOf(
 			<%- property[:destinations].each_with_index do |d, index| -%>

data/lib/evva/version.rb

@@ -1,4 +1,4 @@
 module Evva
-  VERSION = "0.8.5".freeze
-  VERSION_UPDATED_AT = "2026-08-21".freeze
+  VERSION = "0.10.0".freeze
+  VERSION_UPDATED_AT = "2026-10-13".freeze
 end

data/lib/evva.rb

@@ -26,6 +26,7 @@ module Evva
     config = Evva::Config.new(hash: YAML.safe_load(config_file))
     bundle = analytics_data(config: config.data_source)
     filter_destinations!(bundle, config.exclude_destinations)
+    filter_platforms!(bundle, config.filter_by_platforms)
     case config.type.downcase
     when "android"
       generator = Evva::KotlinGenerator.new(config.package_name)
@@ -102,6 +103,40 @@ module Evva
     bundle[:people].each { |p| p.destinations.reject! { |d| excluded.include?(d) } }
   end
 
+  def filter_platforms!(bundle, platforms)
+    return if platforms.nil? || platforms.empty?
+
+    normalized = platforms.map { |p| p.to_s.downcase }
+
+    kept, filtered = bundle[:events].partition { |event|
+      normalized.any? { |p| event.supports_platform?(p) }
+    }
+    return if filtered.empty?
+
+    bundle[:events] = kept
+    Logger.info("Filtered #{filtered.size} events (#{filtered.map(&:event_name).join(', ')})")
+
+    # Only what the dropped events were keeping alive. An enum that had no
+    # reference before this run keeps its place on purpose: pruning those would
+    # change the output of sheets that have no Platform column at all.
+    orphaned = types_referenced_by(filtered) - types_referenced_by(kept, bundle[:people])
+    pruned, remaining = bundle[:enums].partition { |enum| orphaned.include?(enum.enum_name) }
+    return if pruned.empty?
+
+    bundle[:enums] = remaining
+    Logger.info("Pruned #{pruned.size} enums (#{pruned.map(&:enum_name).join(', ')})")
+  end
+
+  # Every property type these events and people properties name, with the
+  # optional marker stripped. The caller compares against real enum names, so
+  # this never has to decide whether a type is an enum. People properties are
+  # never platform filtered but still hold references, so an enum kept alive only
+  # by one must survive.
+  def types_referenced_by(events, people = [])
+    types = events.flat_map { |event| event.properties.values } + people.map(&:type)
+    types.map { |type| type.to_s.chomp("?") }
+  end
+
   def write_to_file(path, data)
     file_reader = Evva::FileReader.new
     if file = file_reader.open_file(path, "w", false)

data/spec/evva_spec.rb

@@ -57,6 +57,189 @@ describe Evva do
     end
   end
 
+  describe ".filter_platforms!" do
+    def event(name, platforms, properties = {})
+      Evva::AnalyticsEvent.new(name, properties, ["firebase"], platforms)
+    end
+
+    let(:unrestricted) { event("unrestricted", nil) }
+    let(:ios_only) { event("ios_only", ["ios"], { from_screen: "IosOnlyEnum" }) }
+    let(:android_only) { event("android_only", ["android"], { from_screen: "AndroidOnlyEnum" }) }
+
+    let(:events) { [unrestricted, ios_only, android_only] }
+
+    let(:enums) do
+      [
+        Evva::AnalyticsEnum.new("IosOnlyEnum", ["a"]),
+        Evva::AnalyticsEnum.new("AndroidOnlyEnum", ["b"]),
+        Evva::AnalyticsEnum.new("NeverReferenced", ["c"]),
+      ]
+    end
+
+    let(:people) { [Evva::AnalyticsProperty.new("total_friends", "Int", [])] }
+
+    let(:bundle) do
+      { destinations: ["firebase"], events: events, people: people, enums: enums }
+    end
+
+    def enum_names
+      bundle[:enums].map(&:enum_name)
+    end
+
+    def event_names
+      bundle[:events].map(&:event_name)
+    end
+
+    context "when filtering for iOS" do
+      before { Evva.filter_platforms!(bundle, ["ios"]) }
+
+      it "keeps unrestricted events" do
+        expect(event_names).to include("unrestricted")
+      end
+
+      it "keeps iOS events" do
+        expect(event_names).to include("ios_only")
+      end
+
+      it "drops Android events" do
+        expect(event_names).not_to include("android_only")
+      end
+    end
+
+    context "when filtering for Android" do
+      before { Evva.filter_platforms!(bundle, ["android"]) }
+
+      it "keeps unrestricted events" do
+        expect(event_names).to include("unrestricted")
+      end
+
+      it "keeps Android events" do
+        expect(event_names).to include("android_only")
+      end
+
+      it "drops iOS events" do
+        expect(event_names).not_to include("ios_only")
+      end
+    end
+
+    context "when filtering for multiple platforms" do
+      before { Evva.filter_platforms!(bundle, ["ios", "android"]) }
+
+      it "keeps events matching any of them" do
+        expect(event_names).to eq(["unrestricted", "ios_only", "android_only"])
+      end
+    end
+
+    context "when filter_by_platforms is nil" do
+      before { Evva.filter_platforms!(bundle, nil) }
+
+      it "does not filter anything" do
+        expect(event_names).to eq(["unrestricted", "ios_only", "android_only"])
+      end
+    end
+
+    context "when filter_by_platforms is empty" do
+      before { Evva.filter_platforms!(bundle, []) }
+
+      it "does not filter anything" do
+        expect(event_names).to eq(["unrestricted", "ios_only", "android_only"])
+      end
+    end
+
+    it "accounts for every event it was given" do
+      events_in = bundle[:events].size
+      Evva.filter_platforms!(bundle, ["ios"])
+      events_out = bundle[:events].size
+      events_filtered = events.count { |e| !e.supports_platform?("ios") }
+
+      expect(events_in).to eq(events_out + events_filtered)
+    end
+
+    context "when no event is filtered out" do
+      let(:events) { [unrestricted] }
+
+      it "leaves the events untouched" do
+        expect { Evva.filter_platforms!(bundle, ["ios"]) }.not_to change { bundle[:events] }
+      end
+
+      it "leaves the enums untouched, orphans included" do
+        expect { Evva.filter_platforms!(bundle, ["ios"]) }.not_to change { enum_names }
+      end
+
+      it "logs nothing" do
+        expect {
+          Evva.filter_platforms!(bundle, ["ios"])
+        }.to not_change { Evva::Logger.summary[:info] }
+      end
+    end
+
+    describe "enum pruning" do
+      it "prunes an enum whose only event was filtered out" do
+        Evva.filter_platforms!(bundle, ["ios"])
+
+        expect(enum_names).not_to include("AndroidOnlyEnum")
+      end
+
+      it "keeps an enum still referenced by a surviving event" do
+        Evva.filter_platforms!(bundle, ["ios"])
+
+        expect(enum_names).to include("IosOnlyEnum")
+      end
+
+      it "keeps an enum that was already unreferenced before filtering" do
+        Evva.filter_platforms!(bundle, ["ios"])
+
+        expect(enum_names).to include("NeverReferenced")
+      end
+
+      context "when a filtered event's enum is also referenced by a people property" do
+        let(:people) do
+          [Evva::AnalyticsProperty.new("wearable_platform", "AndroidOnlyEnum", [])]
+        end
+
+        it "keeps the enum" do
+          Evva.filter_platforms!(bundle, ["ios"])
+
+          expect(enum_names).to include("AndroidOnlyEnum")
+        end
+      end
+
+      context "when the reference is optional" do
+        let(:android_only) { event("android_only", ["android"], { from_screen: "AndroidOnlyEnum?" }) }
+        let(:ios_only) { event("ios_only", ["ios"], { from_screen: "IosOnlyEnum?" }) }
+
+        it "prunes the filtered platform's enum" do
+          Evva.filter_platforms!(bundle, ["ios"])
+
+          expect(enum_names).not_to include("AndroidOnlyEnum")
+        end
+
+        it "keeps the surviving platform's enum" do
+          Evva.filter_platforms!(bundle, ["ios"])
+
+          expect(enum_names).to include("IosOnlyEnum")
+        end
+      end
+    end
+
+    describe "logging" do
+      subject(:messages) do
+        logged = []
+        allow(Evva::Logger).to receive(:info) { |msg| logged << msg }
+        Evva.filter_platforms!(bundle, ["ios"])
+        logged
+      end
+
+      it "names the filtered events" do
+        expect(messages).to include("Filtered 1 events (android_only)")
+      end
+
+      it "names the pruned enums" do
+        expect(messages).to include("Pruned 1 enums (AndroidOnlyEnum)")
+      end
+    end
+  end
+
   context "when generic.yml does not exist locally" do
     let(:error) { "Could not open yml file" }
     before do

data/spec/fixtures/sample_public_enums_with_platform.csv

@@ -0,0 +1,6 @@
+Enum Name,Possible Values
+PageViewSourceScreen,"course_discovery,synced_courses,nearby,deal"
+IosOnlyEnum,"a,b"
+AndroidOnlyEnum,"c,d"
+SharedEnum,"e,f"
+WearableAppPlatform,"wear_os,watch_os"

data/spec/fixtures/sample_public_events_with_platform.csv

@@ -0,0 +1,7 @@
+Event Name,Platform,Event Properties,Added in,Event Destination,Description
+cp_page_view,,"course_id:Long,course_name:String",1.0,"firebase,custom destination",Empty cell means every platform
+ios_only_event,iOS,from_screen:IosOnlyEnum,1.1,firebase,Only tracked on iOS
+android_only_event,Android,from_screen:AndroidOnlyEnum,1.1,firebase,Only tracked on Android
+multi_platform_event,"iOS, Android",source:SharedEnum,1.2,firebase,Both platforms spelled out as a list
+mixed_case_event,IOS,,1.2,firebase,Casing is normalised
+wear_sync_event,iOS,platform:WearableAppPlatform,1.3,firebase,Enum also referenced by a people property

data/spec/lib/evva/config_spec.rb

@@ -65,6 +65,24 @@ describe Evva::Config do
     end
   end
 
+  describe "#filter_by_platforms" do
+    context "when not set" do
+      its(:filter_by_platforms) { should be_nil }
+    end
+
+    context "when set to an array" do
+      before { hash[:filter_by_platforms] = ["ios"] }
+
+      its(:filter_by_platforms) { should eq(["ios"]) }
+    end
+
+    context "when not an array" do
+      before { hash[:filter_by_platforms] = "ios" }
+
+      it { expect { config }.to raise_error(ArgumentError, /Expected Array, got String/) }
+    end
+  end
+
   describe "#swift_public?" do
     context "when swift_public is true" do
       before { hash[:swift_public] = true }

data/spec/lib/evva/google_sheet_spec.rb

@@ -23,14 +23,120 @@ describe Evva::GoogleSheet do
 
     it "returns an array with the corresponding events" do
       expected = [
-        Evva::AnalyticsEvent.new("cp_page_view", { course_id: "Long", course_name: "String" }, ["firebase", "custom destination"]),
-        Evva::AnalyticsEvent.new("nav_feed_tap", {}, []),
-        Evva::AnalyticsEvent.new("cp_view_scorecard", { course_id: "Long", course_name: "String" }, ["custom destination"]),
-        Evva::AnalyticsEvent.new("side_game_delete", { fromScreen: "SideGameFromScreen", round_group_creation_token: "String" }, ["firebase"]),
+        Evva::AnalyticsEvent.new("cp_page_view", { course_id: "Long", course_name: "String" }, ["firebase", "custom destination"], nil),
+        Evva::AnalyticsEvent.new("nav_feed_tap", {}, [], nil),
+        Evva::AnalyticsEvent.new("cp_view_scorecard", { course_id: "Long", course_name: "String" }, ["custom destination"], nil),
+        Evva::AnalyticsEvent.new("side_game_delete", { fromScreen: "SideGameFromScreen", round_group_creation_token: "String" }, ["firebase"], nil),
       ]
       expect(events).to eq(expected)
     end
 
+    context "when the sheet has no Platform column" do
+      it "leaves platforms as nil (unrestricted)" do
+        expect(events.map(&:platforms)).to all(be_nil)
+      end
+    end
+
+    context "when the sheet has a Platform column" do
+      let(:events_file) { File.read("spec/fixtures/sample_public_events_with_platform.csv") }
+
+      def platforms_for(event_name)
+        events.find { |event| event.event_name == event_name }.platforms
+      end
+
+      it do
+        expect { events }.not_to raise_error
+      end
+
+      it "reads the column by header name, whatever its position" do
+        expect(events.map(&:event_name)).to eq(%w[
+          cp_page_view
+          ios_only_event
+          android_only_event
+          multi_platform_event
+          mixed_case_event
+          wear_sync_event
+        ])
+      end
+
+      it "treats an empty cell as unrestricted" do
+        expect(platforms_for("cp_page_view")).to be_nil
+      end
+
+      it "reads a single platform" do
+        expect(platforms_for("ios_only_event")).to eq(["ios"])
+        expect(platforms_for("android_only_event")).to eq(["android"])
+      end
+
+      it "reads a comma separated list of platforms" do
+        expect(platforms_for("multi_platform_event")).to eq(["ios", "android"])
+      end
+
+      it "normalises casing" do
+        expect(platforms_for("mixed_case_event")).to eq(["ios"])
+      end
+    end
+
+    ["platform", "Platform ", " Platform", "PLATFORM", "pLaTfOrM"].each do |header|
+      context "when the Platform header is written as #{header.inspect}" do
+        let(:events_file) { %(Event Name,"#{header}"\nsome_event,Android\n) }
+
+        it "still finds the column" do
+          expect(events.first.platforms).to eq(["android"])
+        end
+      end
+    end
+
+    context "when there is no Platform column" do
+      let(:events_file) { "Event Name,Event Destination\nsome_event,firebase\n" }
+
+      it "says so, so that a mistyped header is not mistaken for a filter that ran" do
+        logged = []
+        allow(Evva::Logger).to receive(:info) { |msg| logged << msg }
+
+        events
+
+        expect(logged).to include(/No Platform column/)
+      end
+    end
+
+    context "when the Platform column is present" do
+      let(:events_file) { "Event Name,Platform\nsome_event,iOS\n" }
+
+      it "does not report a missing column" do
+        logged = []
+        allow(Evva::Logger).to receive(:info) { |msg| logged << msg }
+
+        events
+
+        expect(logged).not_to include(/No Platform column/)
+      end
+    end
+
+    context "when a platform cell is written in another casing" do
+      let(:events_file) { "Event Name,Platform\nsome_event,  AnDrOiD  \n" }
+
+      it "normalises it" do
+        expect(events.first.platforms).to eq(["android"])
+      end
+    end
+
+    context "when a platform cell repeats a platform" do
+      let(:events_file) { "Event Name,Platform\nsome_event,\"ios,iOS\"\n" }
+
+      it "does not duplicate it" do
+        expect(events.first.platforms).to eq(["ios"])
+      end
+    end
+
+    context "when a platform cell has an unknown token" do
+      let(:events_file) { "Event Name,Platform\nsome_event,Windows\n" }
+
+      it "stores it as-is (lowercased)" do
+        expect(events.first.platforms).to eq(["windows"])
+      end
+    end
+
     context "when given an inexistent sheet" do
       before { stub_request(:get, events_sheet).to_return(status: 400, body: "Not Found", headers: {}) }
 

data/spec/lib/evva/kotlin_generator_spec.rb

@@ -156,9 +156,10 @@ Kotlin
   describe "#people_properties" do
     subject { generator.people_properties(people_bundle, "AnalyticsProperty", "AnalyticsProperties", "AnalyticsDestinations") }
     let(:people_bundle) { [
-      Evva::AnalyticsProperty.new("rounds_with_wear", "String", []),
+      Evva::AnalyticsProperty.new("rounds_with_wear", "String?", []),
       Evva::AnalyticsProperty.new("last_active_at", "Date", []),
-      Evva::AnalyticsProperty.new("wear_platform", "WearableAppPlatform", ["firebase", "custom destination"]),
+      Evva::AnalyticsProperty.new("upgrade_source", "PremiumFrom", []),
+      Evva::AnalyticsProperty.new("wear_platform", "WearableAppPlatform?", ["firebase", "custom destination"]),
     ] }
     let(:expected) {
 <<-Kotlin
@@ -170,13 +171,13 @@ package com.hole19golf.hole19.analytics
 
 sealed class AnalyticsProperty(
     property: AnalyticsProperties,
-    val innerValue: Any,
+    val innerValue: Any?,
     val destinations: Array<AnalyticsDestinations> = emptyArray(),
 ) {
     val name = property.key
 
     data class RoundsWithWear(
-        val value: String,
+        val value: String?,
     ) : AnalyticsProperty(
         property = AnalyticsProperties.ROUNDS_WITH_WEAR,
         innerValue = value,
@@ -189,11 +190,18 @@ sealed class AnalyticsProperty(
         innerValue = value,
     )
 
+    data class UpgradeSource(
+        val value: PremiumFrom,
+    ) : AnalyticsProperty(
+        property = AnalyticsProperties.UPGRADE_SOURCE,
+        innerValue = value.key,
+    )
+
     data class WearPlatform(
-        val value: WearableAppPlatform,
+        val value: WearableAppPlatform?,
     ) : AnalyticsProperty(
         property = AnalyticsProperties.WEAR_PLATFORM,
-        innerValue = value.key,
+        innerValue = value?.key,
         destinations = arrayOf(
             AnalyticsDestinations.FIREBASE,
             AnalyticsDestinations.CUSTOM_DESTINATION,

data/spec/platform_filter_spec.rb

@@ -0,0 +1,147 @@
+describe "filtering by platform end to end" do
+  let(:events_url) { "https://wtvr1" }
+  let(:people_url) { "https://wtvr2" }
+  let(:enum_url) { "https://wtvr3" }
+
+  let(:events_fixture) { "sample_public_events_with_platform.csv" }
+  let(:enums_fixture) { "sample_public_enums_with_platform.csv" }
+
+  before do
+    stub_request(:get, events_url).to_return(status: 200, body: fixture(events_fixture))
+    stub_request(:get, people_url).to_return(status: 200, body: fixture("sample_public_people_properties.csv"))
+    stub_request(:get, enum_url).to_return(status: 200, body: fixture(enums_fixture))
+  end
+
+  def fixture(name)
+    File.read("spec/fixtures/#{name}")
+  end
+
+  def unfiltered_bundle
+    source = {
+      type: "google_sheet",
+      events_url: events_url,
+      people_properties_url: people_url,
+      enum_classes_url: enum_url
+    }
+    Evva.analytics_data(config: source)
+  end
+
+  def bundle_for(platforms)
+    bundle = unfiltered_bundle
+    Evva.filter_platforms!(bundle, platforms)
+    bundle
+  end
+
+  def logged_while
+    logged = []
+    allow(Evva::Logger).to receive(:info) { |msg| logged << msg }
+    yield
+    logged
+  end
+
+  describe "for iOS" do
+    let(:bundle) { bundle_for(["ios"]) }
+
+    it "keeps the iOS and unrestricted events" do
+      expect(bundle[:events].map(&:event_name)).to eq(%w[
+        cp_page_view
+        ios_only_event
+        multi_platform_event
+        mixed_case_event
+        wear_sync_event
+      ])
+    end
+
+    it "accounts for every event it was given" do
+      filtered = logged_while { bundle }.grep(/^Filtered/).first.to_s[/\((.*)\)/, 1].to_s.split(", ")
+
+      expect(bundle[:events].size + filtered.size).to eq(unfiltered_bundle[:events].size)
+    end
+
+    it "prunes the Android only enum and keeps the rest" do
+      expect(bundle[:enums].map(&:enum_name)).to eq(%w[
+        PageViewSourceScreen
+        IosOnlyEnum
+        SharedEnum
+        WearableAppPlatform
+      ])
+    end
+  end
+
+  describe "for Android" do
+    let(:bundle) { bundle_for(["android"]) }
+
+    it "keeps the Android and unrestricted events" do
+      expect(bundle[:events].map(&:event_name)).to eq(%w[
+        cp_page_view
+        android_only_event
+        multi_platform_event
+      ])
+    end
+
+    it "prunes the iOS only enum" do
+      expect(bundle[:enums].map(&:enum_name)).not_to include("IosOnlyEnum")
+    end
+
+    # wear_sync_event is iOS only and gets filtered here, but the
+    # wearable_platform people property still references the enum.
+    it "keeps an enum held only by a people property" do
+      expect(bundle[:enums].map(&:enum_name)).to include("WearableAppPlatform")
+    end
+
+    it "keeps the enum no event ever referenced" do
+      expect(bundle[:enums].map(&:enum_name)).to include("PageViewSourceScreen")
+    end
+  end
+
+  describe "for multiple platforms" do
+    let(:bundle) { bundle_for(["ios", "android"]) }
+
+    it "keeps events matching any of the platforms" do
+      expect(bundle[:events].map(&:event_name)).to eq(%w[
+        cp_page_view
+        ios_only_event
+        android_only_event
+        multi_platform_event
+        mixed_case_event
+        wear_sync_event
+      ])
+    end
+  end
+
+  # What protects the sheets that predate the column.
+  # The generators are pure functions of the bundle and are untouched here, so a
+  # bundle the filter left alone generates exactly what it generated before.
+  describe "a sheet with no Platform column" do
+    let(:events_fixture) { "sample_public_events.csv" }
+    let(:enums_fixture) { "sample_public_enums.csv" }
+
+    [["ios"], ["android"]].each do |platforms|
+      it "leaves the #{platforms} bundle untouched" do
+        before_filtering = unfiltered_bundle
+        after_filtering = bundle_for(platforms)
+
+        expect(after_filtering[:events].map(&:event_name)).to eq(before_filtering[:events].map(&:event_name))
+        expect(after_filtering[:enums].map(&:enum_name)).to eq(before_filtering[:enums].map(&:enum_name))
+        expect(after_filtering[:people].map(&:property_name)).to eq(before_filtering[:people].map(&:property_name))
+      end
+    end
+
+    it "keeps enums that no event references" do
+      expect(bundle_for(["ios"])[:enums].map(&:enum_name)).to eq(%w[PageViewSourceScreen PremiumClickBuy])
+    end
+
+    it "reports no filtering" do
+      expect(logged_while { bundle_for(["ios"]) }.grep(/filtered|pruned/)).to be_empty
+    end
+  end
+
+  describe "when filter_by_platforms is nil" do
+    it "leaves the bundle untouched" do
+      before_filtering = unfiltered_bundle
+      after_filtering = bundle_for(nil)
+
+      expect(after_filtering[:events].map(&:event_name)).to eq(before_filtering[:events].map(&:event_name))
+    end
+  end
+end

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: evva
 version: !ruby/object:Gem::Version
-  version: 0.8.5
+  version: 0.10.0
 platform: ruby
 authors:
 - André Andrade
 - João Costa
 - Ricardo Trindade
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-21 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -30,14 +29,14 @@ dependencies:
   name: csv
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
@@ -99,7 +98,9 @@ files:
 - lib/evva/version.rb
 - spec/evva_spec.rb
 - spec/fixtures/sample_public_enums.csv
+- spec/fixtures/sample_public_enums_with_platform.csv
 - spec/fixtures/sample_public_events.csv
+- spec/fixtures/sample_public_events_with_platform.csv
 - spec/fixtures/sample_public_people_properties.csv
 - spec/fixtures/test.yml
 - spec/lib/evva/config_spec.rb
@@ -108,12 +109,12 @@ files:
 - spec/lib/evva/logger_spec.rb
 - spec/lib/evva/object_extension_spec.rb
 - spec/lib/evva/swift_generator_spec.rb
+- spec/platform_filter_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/hole19/
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,8 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: An event generating service
 test_files: []