evva 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32699d4abc90a02f944c069ac0cefc8e26fbf972d42342f86ad55652d198f0c2
-  data.tar.gz: d9e9c0e5a62a712636ebede3bf3b04a9f47c8bc36bac4f06ea4d27b48ff3703f
+  metadata.gz: f74dbff0766dc7623ca1ac518e7636172440511a4470398d594fefef8364fba9
+  data.tar.gz: 4793e14af612e48d0e7cf85aa313d5c6c4f92c5eb440be7a853503f39fd093e6
 SHA512:
-  metadata.gz: cd70916584265dc7077907d324049b93000f5805bf43bb9dda152547e36181740ba8524980606400a8bd128c556dbf09ad641d4c634d513e714b2748639a4498
-  data.tar.gz: a9a95c538e9d88011507e5a12e64afb84b91fbee6a5b70e0d48f431a05496a0384347c2f6edc97ad3a3164f80677ff05e0b700d4a2c7ea08bce69d7e59ab8145
+  metadata.gz: ebbee6abfa8abd7e6717f20246a1271a7d7b35e4b9a42414293ff436cff842e82ac45beb7638dc642cdb00c1408f7c81cb4b8dcfdd7d4ee6dafa04f121388b5a
+  data.tar.gz: 18c42c24f8f2b7d923c9a99b5ec58a43d258340b2523fdb4bf8f136bb0d4d9a075f3497b4c0c8a8176c4e01b07db56f116066b1139389104497db86e6ed9e30b

data/README.md

@@ -24,7 +24,6 @@ Evva automatically generates code for triggering events based on a Google Sheets
 
  data_source:
   type: google_sheet
-  sheet_id: <GOOGLE-DRIVE-SHEET-ID>
   events_url: <GOOGLE-DRIVE-EVENTS-SHEET-URL>
   people_properties_url: <GOOGLE-DRIVE-PEOPLE-PROPERTIES-SHEET-URL>
   enum_classes_url: <GOOGLE-DRIVE-ENUM-CLASSES-SHEET-URL>
@@ -33,5 +32,7 @@ Evva automatically generates code for triggering events based on a Google Sheets
  event_file_name: /file/with/tracking/functions
  event_enum_file_name: /file/with/event/names
  people_file_name: /file/with/people/properties
- special_enum_file_name: //file/with/special/enum/properties/
+ people_file_name: /file/with/people/property/names
+ destinations_file_name: /file/with/destinations
+ special_enum_file_name: /file/with/special/enum/properties/
  ```

data/changelog.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## [0.4.0] - 2021-12-21
+- Adds type to people properties
+- Adds a list of destinations to events and people properties
+
 ## [0.3.0] - 2021-12-16
 - Revamp Android generator to generate events as classes instead of methods.
 

data/lib/evva/analytics_enum.rb

@@ -1,6 +1,7 @@
 module Evva
   class AnalyticsEnum
     attr_reader :enum_name, :values
+
     def initialize(enum_name, values)
       @enum_name = enum_name
       @values = values

data/lib/evva/analytics_event.rb

@@ -1,13 +1,17 @@
 module Evva
   class AnalyticsEvent
-    attr_reader :event_name, :properties
-    def initialize(event_name, properties = {})
+    attr_reader :event_name, :properties, :destinations
+
+    def initialize(event_name, properties, destinations)
       @event_name = event_name
       @properties = properties
+      @destinations = destinations
     end
 
     def ==(other)
-      event_name == other.event_name
+      event_name == other.event_name &&
+      properties == other.properties &&
+      destinations == other.destinations
     end
   end
 end

data/lib/evva/analytics_property.rb

@@ -0,0 +1,17 @@
+module Evva
+  class AnalyticsProperty
+    attr_reader :property_name, :type, :destinations
+
+    def initialize(property_name, type, destinations)
+      @property_name = property_name
+      @type = type
+      @destinations = destinations
+    end
+
+    def ==(other)
+      property_name == other.property_name &&
+      type == other.type &&
+      destinations == other.destinations
+    end
+  end
+end

data/lib/evva/android_generator.rb

@@ -6,115 +6,158 @@ module Evva
       @package_name = package_name
     end
 
-    NATIVE_TYPES = %w[Long Int String Double Float Boolean].freeze
+    BASE_TEMPLATE = File.expand_path("./templates/kotlin/base.kt", __dir__)
+    EVENTS_TEMPLATE = File.expand_path("./templates/kotlin/events.kt", __dir__)
+    EVENT_ENUM_TEMPLATE = File.expand_path("./templates/kotlin/event_enum.kt", __dir__)
+    PEOPLE_PROPERTIES_TEMPLATE = File.expand_path("./templates/kotlin/people_properties.kt", __dir__)
+    PEOPLE_PROPERTIES_ENUM_TEMPLATE = File.expand_path("./templates/kotlin/people_properties_enum.kt", __dir__)
+    SPECIAL_PROPERTY_ENUMS_TEMPLATE = File.expand_path("./templates/kotlin/special_property_enums.kt", __dir__)
+    DESTINATIONS_TEMPLATE = File.expand_path("./templates/kotlin/destinations.kt", __dir__)
 
-    def events(bundle, file_name)
+    TAB_SIZE = "    " # \t -> 4 spaces
+
+    NATIVE_TYPES = %w[Long Int String Double Float Boolean Date].freeze
+
+    def events(bundle, file_name, enums_file_name, destinations_file_name)
       header_footer_wrapper do
-"""sealed class #{file_name}(event: AnalyticsEvents) {
-\tval name = event.key
+        class_name = file_name
+        enums_class_name = enums_file_name
+        destinations_class_name = destinations_file_name
+
+        events = bundle.map do |event|
+          properties = event.properties.map do |name, type|
+            param_name = camelize(name.to_s, false)
+            value_fetcher = param_name
+
+            if is_special_property?(type)
+              if type.end_with?('?')
+                # optional value, we need ? to access a parameter
+                value_fetcher += "?"
+              end
+              value_fetcher += ".key"
+            end
 
-\topen val properties: Map<String, Any?>? = null
+            {
+              param_name: param_name,
+              value_fetcher: value_fetcher,
+              type: type,
+              name: name.to_s,
+            }
+          end
 
-#{bundle.map { |e| event_class(e, file_name) }.join("\n\n")}
-}"""
-      end
-    end
+          destinations = event.destinations.map { |p| constantize(p) }
 
-    def people_properties(people_bundle, file_name)
-      header_footer_wrapper do
-        body = "enum class #{file_name}(val key: String) {\n"
-        body << people_bundle.map { |prop| "\t#{prop.upcase}(\"#{prop}\")" }.join(",\n")
-        body << ";\n}"
+          {
+            class_name: camelize(event.event_name),
+            event_name: constantize(event.event_name),
+            properties: properties,
+            destinations: destinations,
+            is_object: properties.count == 0 && destinations.count == 0,
+          }
+        end
+
+        template_from(EVENTS_TEMPLATE).result(binding)
       end
     end
 
     def event_enum(bundle, file_name)
       header_footer_wrapper do
-        body = "enum class #{file_name}(val key: String) {\n"
-        body << bundle.map(&:event_name).map { |prop| "\t#{prop.upcase}(\"#{prop}\")" }.join(",\n")
-        body << ";\n}"
+        class_name = file_name
+
+        events = bundle.map(&:event_name).map do |event_name|
+          {
+            name: constantize(event_name),
+            value: event_name,
+          }
+        end
+
+        template_from(EVENT_ENUM_TEMPLATE).result(binding)
       end
     end
 
-    def special_property_enums(enums)
+    def people_properties(people_bundle, file_name, enums_file_name, destinations_file_name)
       header_footer_wrapper do
-        enums.map do |enum|
-          body = "enum class #{enum.enum_name}(val key: String) {\n"
-          body << enum.values.map { |vals| "\t#{vals.tr(' ', '_').upcase}(\"#{vals}\")"}.join(",\n")
-          body << ";\n}"
-        end.join("\n\n")
+        class_name = file_name
+        enums_class_name = enums_file_name
+        destinations_class_name = destinations_file_name
+
+        properties = people_bundle.map do |property|
+          {
+            class_name: camelize(property.property_name),
+            property_name: constantize(property.property_name),
+            type: property.type,
+            is_special_property: is_special_property?(property.type),
+            destinations: property.destinations.map { |p| constantize(p) },
+          }
+        end
+
+        template_from(PEOPLE_PROPERTIES_TEMPLATE).result(binding)
       end
     end
 
-    private
+    def people_properties_enum(people_bundle, file_name)
+      header_footer_wrapper do
+        class_name = file_name
+
+        properties = people_bundle.map(&:property_name).map do |property_name|
+          {
+            name: constantize(property_name),
+            value: property_name,
+          }
+        end
 
-    def imports_header(imports = [])
-      return unless imports.length > 0
-      imports.map { |ev| ev. gsub("packagename", @package_name) }
-             .join("\n") + "\n\n"
+        template_from(PEOPLE_PROPERTIES_ENUM_TEMPLATE).result(binding)
+      end
     end
 
-    def header_footer_wrapper(imports = [])
-<<-Kotlin
-package #{@package_name}
+    def special_property_enums(enums_bundle)
+      header_footer_wrapper do
+        enums = enums_bundle.map do |enum|
+          values = enum.values.map do |value|
+            {
+              name: constantize(value),
+              value: value,
+            }
+          end
 
-#{imports_header(imports)}/**
- * This file was automatically generated by evva: https://github.com/hole19/evva
- */
+          {
+            class_name: enum.enum_name,
+            values: values,
+          }
+        end
 
-#{yield.gsub("\t", "    ")}
-Kotlin
+        template_from(SPECIAL_PROPERTY_ENUMS_TEMPLATE).result(binding)
+      end
     end
 
-    def event_class(event_data, superclass_name)
-      class_name = camelize(event_data.event_name)
-      class_arguments = event_data.properties.map { |name, type| "val #{camelize(name, false)}: #{type}" }.join(', ')
-      if !class_arguments.empty?
-        props = props_map(event_data.properties)
+    def destinations(bundle, file_name)
+      header_footer_wrapper do
+        class_name = file_name
 
-"""\tdata class #{class_name}(
-\t\t#{class_arguments}
-\t) : #{superclass_name}(AnalyticsEvents.#{event_data.event_name.upcase}) {
-#{props}
-\t}"""
+        destinations = bundle.map { |d| constantize(d) }
 
-      else
-"""\tobject #{class_name} : #{superclass_name}(AnalyticsEvents.#{event_data.event_name.upcase})"""
+        template_from(DESTINATIONS_TEMPLATE).result(binding)
       end
     end
 
-    def props_map(properties)
-      split_properties =
-        properties
-        .map.with_index do |data, index|
-          name, type = data
-          prop = "\t\t\t\"#{name}\" to #{camelize(name, false)}"
+    private
 
-          if special_property?(type)
-            if optional_property?(type)
-              prop = "#{prop}?"
-            end
-            prop = "#{prop}.key"
-          end
+    def header_footer_wrapper
+      package_name = @package_name
 
-          if index < properties.size - 1
-            # add list comma to every property except the last one
-            prop = "#{prop},"
-          end
+      content = yield
+        .chop # trim trailing newlines created by sublime
 
-          prop
-        end
-        .join("\n")
-
-      "\t\toverride val properties = mapOf(\n#{split_properties}\n\t\t)"
+      template_from(BASE_TEMPLATE).result(binding).gsub("\t", TAB_SIZE)
     end
 
-    def special_property?(type)
-      !NATIVE_TYPES.include?(type.chomp('?'))
-    end
+    def template_from(path)
+      file = File.read(path)
 
-    def optional_property?(type)
-      type.include?('?')
+      # - 2nd argument (nil) changes nothing
+      # - 3rd argument activates trim mode using "-" so that you can decide to
+      # not include a line (useful on loops and if statements)
+      ERB.new(file, nil, '-')
     end
 
     # extracted from Rails' ActiveSupport
@@ -127,5 +170,13 @@ Kotlin
       end
       string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::")
     end
+
+    def constantize(string)
+      string.tr(' ', '_').upcase
+    end
+
+    def is_special_property?(type)
+      !NATIVE_TYPES.include?(type.chomp('?'))
+    end
   end
 end

data/lib/evva/config.rb

@@ -31,18 +31,26 @@ module Evva
       @hash[:event_file_name]
     end
 
+    def event_enum_file_name
+      @hash[:event_enum_file_name]
+    end
+
     def people_file_name
       @hash[:people_file_name]
     end
 
-    def event_enum_file_name
-      @hash[:event_enum_file_name]
+    def people_enum_file_name
+      @hash[:people_enum_file_name]
     end
 
     def special_enum_file_name
       @hash[:special_enum_file_name]
     end
 
+    def destinations_file_name
+      @hash[:destinations_file_name]
+    end
+
     def package_name
       @hash[:package_name]
     end
@@ -58,6 +66,8 @@ module Evva
         event_file_name: { type: String },
         event_enum_file_name: { type: String },
         people_file_name: { type: String },
+        people_enum_file_name: { type: String },
+        destinations_file_name: { type: String },
         package_name: { type: String }
       }
     }.freeze

data/lib/evva/google_sheet.rb

@@ -3,6 +3,17 @@ require 'csv'
 
 module Evva
   class GoogleSheet
+    EVENT_NAME = 'Event Name'
+    EVENT_PROPERTIES = 'Event Properties'
+    EVENT_DESTINATION = 'Event Destination'
+
+    PROPERTY_NAME = 'Property Name'
+    PROPERTY_TYPE = 'Property Type'
+    PROPERTY_DESTINATION = 'Property Destination'
+
+    ENUM_NAME = 'Enum Name'
+    ENUM_VALUES = 'Possible Values'
+
     def initialize(events_url, people_properties_url, enum_classes_url)
       @events_url = events_url
       @people_properties_url = people_properties_url
@@ -10,41 +21,48 @@ module Evva
     end
 
     def events
-      Logger.info("Downloading data from Google Sheet at #{@events_url}")
-      csv = get_csv(@events_url)
-
-      event_list = []
-      csv.each do |row|
-        event_name = row['Event Name']
-        properties = hash_parser(row['Event Properties'])
-        event_list << Evva::AnalyticsEvent.new(event_name, properties)
+      @events_csv ||= begin
+        Logger.info("Downloading data from Google Sheet at #{@events_url}")
+        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 || [])
       end
-      event_list
     end
 
     def people_properties
-      Logger.info("Downloading data from Google Sheet at #{@people_properties_url}")
-      csv = get_csv(@people_properties_url)
+      @people_properties_csv ||= begin
+        Logger.info("Downloading data from Google Sheet at #{@people_properties_url}")
+        get_csv(@people_properties_url)
+      end
 
-      people_list = []
-      csv.each do |row|
-        value = row['Property Name']
-        people_list << value
+      @people_properties ||= @people_properties_csv.map do |row|
+        property_name = row[PROPERTY_NAME]
+        property_type = row[PROPERTY_TYPE]
+        destinations = row[PROPERTY_DESTINATION]&.split(',')
+        Evva::AnalyticsProperty.new(property_name, property_type, destinations || [])
       end
-      people_list
     end
 
     def enum_classes
-      Logger.info("Downloading data from Google Sheet at #{@enum_classes_url}")
-      csv = get_csv(@enum_classes_url)
-
-      enum_list = []
-      csv.each do |row|
-        enum_name = row['Enum Name']
-        values = row['Possible Values'].split(',')
-        enum_list << Evva::AnalyticsEnum.new(enum_name, values)
+      @enum_classes_csv ||= begin
+        Logger.info("Downloading data from Google Sheet at #{@enum_classes_url}")
+        get_csv(@enum_classes_url)
+      end
+
+      @enum_classes ||= @enum_classes_csv.map do |row|
+        enum_name = row[ENUM_NAME]
+        values = row[ENUM_VALUES].split(',')
+        Evva::AnalyticsEnum.new(enum_name, values)
       end
-      enum_list
+    end
+
+    def destinations
+      @destinations ||= events.map(&:destinations).flatten.uniq
     end
 
     private