evva 0.1.4.3 → 0.4.0

data/lib/evva/google_sheet.rb

@@ -1,79 +1,104 @@
 require 'net/https'
-require 'xmlsimple'
+require 'csv'
 
 module Evva
   class GoogleSheet
-    def initialize(sheet_id)
-      @sheet_id = sheet_id
+    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
+      @enum_classes_url = enum_classes_url
     end
 
     def events
-      event_list = []
-      iterate_entries(raw_data(@sheet_id, 0)) do |entry|
-        event_name = entry['eventname'].first
-        properties = hash_parser(entry['eventproperties'].first)
-        event_list << Evva::MixpanelEvent.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
-      people_list = []
-      iterate_entries(raw_data(@sheet_id, 1)) do |entry|
-        value = entry['propertyname'].first
-        people_list << value
+      @people_properties_csv ||= begin
+        Logger.info("Downloading data from Google Sheet at #{@people_properties_url}")
+        get_csv(@people_properties_url)
+      end
+
+      @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
-      enum_list = []
-      iterate_entries(raw_data(@sheet_id, 2)) do |entry|
-        enum_name = entry['enumname'].first
-        values = entry['possiblevalues'].first.split(',')
-        enum_list << Evva::MixpanelEnum.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
 
-    def iterate_entries(data)
-      Logger.info('Downloading dictionary from Google Sheet...')
-      non_language_columns = %w[id updated category title content link]
-      data['entry'].each do |entry|
-        filtered_entry = entry.reject { |c| non_language_columns.include?(c) }
-        yield(filtered_entry)
+    def get_csv(url)
+      data = get(url)
+
+      begin
+        CSV.parse(data, headers: true)
+      rescue StandardError => e
+        raise "Cannot parse. Expected CSV at #{url}: #{e}"
       end
     end
 
-    def xml_data(uri, headers = nil)
-      uri = URI.parse(uri)
+    def get(url, max_redirects = 1)
+      raise "Too may redirects" if max_redirects == -1
+
+      uri = URI(url)
+
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
       http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      data = http.get(uri.path, headers)
-      unless data.code.to_i == 200
-        raise "Cannot access sheet at #{uri} - HTTP #{data.code}"
-      end
 
-      begin
-        XmlSimple.xml_in(data.body, 'KeyAttr' => 'name')
-      rescue
-        raise "Cannot parse. Expected XML at #{uri}"
-      end
-    end
+      request = Net::HTTP::Get.new(uri.request_uri)
+      response = http.request(request)
+
+      return get(response['location'], max_redirects - 1) if response.is_a? Net::HTTPRedirection
+
+      raise "Http Error #{response.body}" if response.code.to_i >= 400
 
-    def raw_data(sheet_id, sheet_number)
-      Logger.info('Downloading Google Sheet...')
-      sheet = xml_data("https://spreadsheets.google.com/feeds/worksheets/#{sheet_id}/public/full")
-      url   = sheet['entry'][sheet_number]['link'][0]['href']
-      xml_data(url)
+      response.body
     end
 
     def hash_parser(property_array)
       h = {}
-      unless property_array.empty?
+      unless property_array.nil? || property_array.empty?
         property_array.split(',').each do |prop|
           split_prop = prop.split(':')
           prop_name = split_prop[0].to_sym

data/lib/evva/swift_generator.rb

@@ -1,121 +1,132 @@
+require 'erb'
+
 module Evva
   class SwiftGenerator
-    EXTENSION_HEADER =
-      "\nimport Foundation\n\n"\
-      "extension Analytics {\n\n".freeze
+    BASE_TEMPLATE = File.expand_path("./templates/swift/base.swift", __dir__)
+    EVENTS_TEMPLATE = File.expand_path("./templates/swift/events.swift", __dir__)
+    PEOPLE_PROPERTIES_TEMPLATE = File.expand_path("./templates/swift/people_properties.swift", __dir__)
+    SPECIAL_PROPERTY_ENUMS_TEMPLATE = File.expand_path("./templates/swift/special_property_enums.swift", __dir__)
+    DESTINATIONS_TEMPLATE = File.expand_path("./templates/swift/destinations.swift", __dir__)
 
-    EXTENSION_FOOTER =
-      "\n\n}\n"
+    TAB_SIZE = "    " # \t -> 4 spaces
 
-    NATIVE_TYPES = %w[Int String Double Float Bool].freeze
+    NATIVE_TYPES = %w[Int String Double Float Bool Date].freeze
 
-    def events(bundle, file_name)
+    def events(bundle, _file_name, _enums_file_name, _destinations_file_name)
       header_footer_wrapper do
-"""\tenum Event {
-#{bundle.map { |e| event_case(e) }.join("\n")}
-
-\t\tvar data: EventData {
-\t\t\tswitch self {
-#{bundle.map { |e| event_data(e) }.join("\n\n")}
-\t\t\t}
-\t\t}
-\t}"""
+        events = bundle.map do |event|
+          properties = event.properties.map { |k, v|
+            type = native_type(v)
+
+            value_fetcher = k.to_s
+
+            if is_special_property?(type)
+              if type.end_with?('?')
+                # optional value, we need ? to access a parameter
+                value_fetcher += "?"
+              end
+              value_fetcher += ".rawValue"
+            end
+
+            {
+              name: k.to_s,
+              type: type,
+              value: value_fetcher,
+            }
+          }
+
+          {
+            case_name: camelize(event.event_name),
+            event_name: event.event_name,
+            properties: properties,
+            destinations: event.destinations.map { |p| camelize(p) },
+          }
+        end
+
+        template_from(EVENTS_TEMPLATE).result(binding)
       end
     end
 
-    def event_case(event_data)
-      function_name = camelize(event_data.event_name)
-      if event_data.properties.empty?
-        "\t\tcase #{function_name}"
-      else
-        trimmed_properties = event_data.properties.map { |k, v| k.to_s + ': ' + native_type(v) }.join(", ")
-        "\t\tcase #{function_name}(#{trimmed_properties})"
-      end
+    def event_enum
+      # empty
     end
 
-    def event_data(event_data)
-      function_name = camelize(event_data.event_name)
-      if event_data.properties.empty?
-        function_body = "\t\t\tcase .#{function_name}:\n" \
-                        "\t\t\t\treturn EventData(name: \"#{event_data.event_name}\")"
-      else
-        function_header = prepend_let(event_data.properties)
-        function_arguments = dictionary_pairs(event_data.properties)
-        function_body = "\t\t\tcase .#{function_name}(#{function_header}):\n"\
-                        "\t\t\t\treturn EventData(name: \"#{event_data.event_name}\", properties: [\n"\
-                        "\t\t\t\t\t#{function_arguments.join(",\n\t\t\t\t\t")} ]\n"\
-                        "\t\t\t\t)"
+    def people_properties(people_bundle, _file_name, _enums_file_name, _destinations_file_name)
+      header_footer_wrapper do
+        properties = people_bundle.map do |p|
+          type = native_type(p.type)
+          {
+            case_name: camelize(p.property_name),
+            property_name: p.property_name,
+            type: type,
+            is_special_property: is_special_property?(type),
+            destinations: p.destinations.map { |p| camelize(p) },
+          }
+        end
+
+        template_from(PEOPLE_PROPERTIES_TEMPLATE).result(binding)
       end
-      function_body
     end
 
-    def event_enum(enum, file_name)
+    def people_properties_enum
       # empty
     end
 
-    def people_properties(people_bundle, file_name)
+    def special_property_enums(enums_bundle)
       header_footer_wrapper do
-        props = "\tenum Property: String {\n"
-        people_bundle.each do |prop|
-          props << "\t\tcase #{camelize(prop)} = \"#{prop}\"\n"
+        enums = enums_bundle.map do |enum|
+          values = enum.values.map do |value|
+            {
+              case_name: camelize(value),
+              value: value
+            }
+          end
+
+          {
+            name: enum.enum_name,
+            values: values
+          }
         end
-        props << "\t}"
+
+        template_from(SPECIAL_PROPERTY_ENUMS_TEMPLATE).result(binding)
       end
     end
 
-    def special_property_enums(enums)
+    def destinations(destinations_bundle, _file_name)
       header_footer_wrapper do
-        enums.map do |enum|
-          body = "\tenum #{enum.enum_name}: String {\n"
-          enum.values.each do |value|
-            body << "\t\tcase #{camelize(value)} = \"#{value}\"\n"
-          end
-          body << "\t}"
-        end.join("\n\n")
+        destinations = destinations_bundle.map { |p| camelize(p) }
+
+        template_from(DESTINATIONS_TEMPLATE).result(binding)
       end
     end
 
     private
 
     def header_footer_wrapper
-"""// This file was automatically generated by evva: https://github.com/hole19/evva
-
-import Foundation
+      content = yield
+        .gsub(/^/, "\t").gsub(/^\t+$/, "") # add tabs, unless it's an empty line
+        .chop # trim trailing newlines created by sublime
 
-extension Analytics {
-
-#{yield.gsub("\t", "    ")}
-}
-"""
+      template_from(BASE_TEMPLATE).result(binding).gsub("\t", TAB_SIZE)
     end
 
-    def dictionary_pairs(props)
-      props.map do |name, type|
-        pair = "\"#{name}\": #{name}"
-        if is_raw_representable_property?(type)
-          if is_optional_property?(type)
-            pair += "?"
-          end
-          pair += ".rawValue"
-        end
-        pair += " as Any"
-      end
-    end
+    def template_from(path)
+      file = File.read(path)
 
-    def is_raw_representable_property?(type)
-      !NATIVE_TYPES.include?(native_type(type).chomp('?'))
-    end
-
-    def is_optional_property?(type)
-      type.end_with?('?')
+      # - 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
 
     def native_type(type)
-      type.gsub('Boolean','Bool').gsub('Long', 'Int')
+      type
+        .gsub('Boolean','Bool')
+        .gsub('Long', 'Int')
     end
 
-    def prepend_let(props)
-      props.map { |k, v| "let #{k}" }.join(', ')
+    def is_special_property?(type)
+      !NATIVE_TYPES.include?(type.chomp('?'))
     end
 
     def camelize(term)
@@ -125,6 +136,5 @@ extension Analytics {
       string.gsub!("/".freeze, "::".freeze)
       string
     end
-
   end
 end

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

@@ -0,0 +1,7 @@
+package <%= package_name %>
+
+/**
+ * This file was automatically generated by evva: https://github.com/hole19/evva
+ */
+
+<%= content %>

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

@@ -0,0 +1,5 @@
+enum class <%= class_name %> {
+	<%- destinations.each_with_index do |destination, index| -%>
+	<%= destination %><%= index == destinations.count - 1 ? ";" : "," %>
+	<%- end -%>
+}

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

@@ -0,0 +1,5 @@
+enum class <%= class_name %>(val key: String) {
+	<%- events.each_with_index do |event, index| -%>
+	<%= event[:name] %>("<%= event[:value] %>")<%= index == events.count - 1 ? ";" : "," %>
+	<%- end -%>
+}

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

@@ -0,0 +1,34 @@
+sealed class <%= class_name %>(event: <%= enums_class_name %>) {
+    val name = event.key
+
+    open val properties: Map<String, Any?>? = null
+    open val destinations: Array<<%= destinations_class_name %>> = []
+
+    <%- events.each_with_index do |e, index| -%>
+    <%- if e[:is_object] -%>
+    object <%= e[:class_name] %> : <%= class_name %>(<%= enums_class_name %>.<%= e[:event_name] %>)
+    <%- else -%>
+    data class <%= e[:class_name] %><% if e[:properties].count > 0 %>(
+        <%= e[:properties].map { |p| "val #{p[:param_name]}: #{p[:type]}" }.join(", ") %>
+    )<% end %> : <%= class_name %>(<%= enums_class_name %>.<%= e[:event_name] %>) {
+        <%- if e[:properties].count > 0 -%>
+        override val properties = mapOf(
+            <%- e[:properties].each_with_index do |p, index| -%>
+            "<%= p[:name] %>" to <%= p[:value_fetcher] %><% if index < e[:properties].count - 1 %>,<% end %>
+            <%- end -%>
+        )
+        <%- end -%>
+        <%- if e[:destinations].count > 0 -%>
+        override val destinations = [
+            <%- e[:destinations].each_with_index do |d, index| -%>
+            <%= destinations_class_name %>.<%= d %><% if index < e[:destinations].count - 1 %>,<% end %>
+            <%- end -%>
+        ]
+        <%- end -%>
+    }
+    <%- end -%>
+    <%- unless index == events.count - 1 -%>
+
+    <%- end -%>
+    <%- end -%>
+}

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

@@ -0,0 +1,24 @@
+sealed class <%= class_name %>(property: <%= enums_class_name %>) {
+	val name = property.key
+
+	open val value: Any = ""
+	open val destinations: Array<<%= destinations_class_name %>> = []
+
+	<%- properties.each_with_index do |property, index| -%>
+	data class <%= property[:class_name] %>(
+		val value: <%= property[:type] %>
+	) : <%= class_name %>(<%= enums_class_name %>.<%= property[:property_name] %>) {
+		override val value = value<% if property[:is_special_property] %>.key<% end %>
+		<%- if property[:destinations].count > 0 -%>
+		override val destinations = [
+			<%- property[:destinations].each_with_index do |d, index| -%>
+			<%= destinations_class_name %>.<%= d %><% if index < property[:destinations].count - 1 %>,<% end %>
+			<%- end -%>
+		]
+		<%- end -%>
+	}
+	<%- unless index == properties.count - 1 -%>
+
+	<%- end -%>
+	<%- end -%>
+}

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

@@ -0,0 +1,5 @@
+enum class <%= class_name %>(val key: String) {
+	<%- properties.each_with_index do |property, index| -%>
+	<%= property[:name] %>("<%= property[:value] %>")<%= index == properties.count - 1 ? ";" : "," %>
+	<%- end -%>
+}

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

@@ -0,0 +1,10 @@
+<%- enums.each_with_index do |enum, index| -%>
+enum class <%= enum[:class_name] %>(val key: String) {
+	<%- enum[:values].each_with_index do |v, index| -%>
+	<%= v[:name] %>("<%= v[:value] %>")<%= index == enum[:values].count - 1 ? ";" : "," %>
+	<%- end -%>
+}
+<%- unless index == enums.count - 1 -%>
+
+<%- end -%>
+<%- end -%>

data/lib/evva/templates/swift/base.swift

@@ -0,0 +1,7 @@
+// This file was automatically generated by evva: https://github.com/hole19/evva
+
+import Foundation
+
+extension Analytics {
+<%= content %>
+}

data/lib/evva/templates/swift/destinations.swift

@@ -0,0 +1,5 @@
+enum Destination {
+	<%- destinations.each do |d| -%>
+	case <%= d %>
+	<%- end -%>
+}

data/lib/evva/templates/swift/events.swift

@@ -0,0 +1,65 @@
+struct EventData {
+	let name: String
+	var properties: [String: Any]?
+	let destinations: [Destination]
+
+	init(name: String, properties: [String: Any]?, destinations: [Destination]) {
+		self.name = name
+		self.properties = properties
+		self.destinations = destinations
+	}
+
+	init(name: EventName, properties: [String: Any]?, destinations: [Destination]) {
+		self.init(name: name.rawValue, properties: properties, destinations: destinations)
+	}
+}
+
+enum EventName: String {
+	<%- events.each do |e| -%>
+	case <%= e[:case_name] %> = "<%= e[:event_name] %>"
+	<%- end -%>
+}
+
+enum Event {
+	<%- events.each do |e| -%>
+	<%- if e[:properties].count == 0 -%>
+	case <%= e[:case_name] %>
+	<%- else -%>
+	case <%= e[:case_name] %>(<%= e[:properties].map { |p| "#{p[:name]}: #{p[:type]}" }.join(", ") %>)
+	<%- end -%>
+	<%- end -%>
+
+	var data: EventData {
+		switch self {
+		<%- events.each_with_index do |e, index| -%>
+		<%- if e[:properties].count == 0 -%>
+		case .<%= e[:case_name] %>:
+		<%- else -%>
+		case let .<%= e[:case_name] %>(<%= e[:properties].map { |p| p[:name] }.join(", ") %>):
+		<%- end -%>
+			return EventData(name: .<%= e[:case_name] %>,
+				<%- if e[:properties].count == 0 -%>
+							 properties: nil,
+				<%- else -%>
+							 properties: [
+					<%- e[:properties].each do |p| -%>
+								"<%= p[:name] %>": <%= p[:value] %> as Any,
+					<%- end -%>
+							 ],
+				<%- end -%>
+				<%- if e[:destinations].count == 0 -%>
+							 destinations: [])
+				<%- else -%>
+							 destinations: [
+					<%- e[:destinations].each do |d| -%>
+								.<%= d %>,
+					<%- end -%>
+							 ])
+				<%- end -%>
+				<%- unless index == events.count - 1 -%>
+
+				<%- end -%>
+		<%- end -%>
+		}
+	}
+}

data/lib/evva/templates/swift/people_properties.swift

@@ -0,0 +1,49 @@
+struct PropertyData {
+	let name: String
+	let value: Any
+	let destinations: [Destination]
+
+	init(name: String, value: Any, destinations: [Destination]) {
+		self.name = name
+		self.value = value
+		self.destinations = destinations
+	}
+
+	init(name: PropertyName, value: Any, destinations: [Destination]) {
+		self.init(name: name.rawValue, value: value, destinations: destinations)
+	}
+}
+
+enum PropertyName: String {
+	<%- properties.each do |p| -%>
+	case <%= p[:case_name] %> = "<%= p[:property_name ] %>"
+	<%- end -%>
+}
+
+enum Property {
+	<%- properties.each do |p| -%>
+	case <%= p[:case_name] %>(<%= p[:type] %>)
+	<%- end -%>
+
+	var data: PropertyData {
+		switch self {
+		<%- properties.each_with_index do |p, index| -%>
+		case let .<%= p[:case_name] %>(value):
+			return PropertyData(name: .<%= p[:case_name] %>,
+								value: value<% if p[:is_special_property] %>.rawValue<% end %>,
+			<%- if p[:destinations].count == 0 -%>
+								destinations: [])
+			<%- else -%>
+								destinations: [
+				<%- p[:destinations].each do |d| -%>
+									.<%= d %>,
+				<%- end -%>
+								])
+			<%- end -%>
+			<%- unless index == properties.count - 1 -%>
+
+			<%- end -%>
+		<%- end -%>
+		}
+	}
+}

data/lib/evva/templates/swift/special_property_enums.swift

@@ -0,0 +1,10 @@
+<%- enums.each_with_index do |enum, index| -%>
+enum <%= enum[:name] %>: String {
+	<%- enum[:values].each do |v| -%>
+	case <%= v[:case_name] %> = "<%= v[:value ] %>"
+	<%- end -%>
+}
+<%- unless index == enums.count - 1 -%>
+
+<%- end -%>
+<%- end -%>

data/lib/evva/version.rb

@@ -1,4 +1,4 @@
 module Evva
-  VERSION = '0.1.4.3'.freeze
-  VERSION_UPDATED_AT = '2018-10-12'.freeze
+  VERSION = '0.4.0'.freeze
+  VERSION_UPDATED_AT = '2021-12-21'.freeze
 end