evva 0.1.0

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+ruby '2.3.3'
+
+gem 'colorize',   '~> 0.7'
+gem 'rubocop',    '~> 0.49.1'
+gem 'safe_yaml',  '~> 1.0'
+gem 'xml-simple', '~> 1.1'
+
+gem 'rspec'
+gem 'rspec-its'
+gem 'simplecov', require: false, group: :test
+gem 'simplecov-rcov', require: false
+gem 'webmock', '~> 1.20'

data/Gemfile.lock

@@ -0,0 +1,79 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.1)
+      public_suffix (~> 2.0, >= 2.0.2)
+    ast (2.3.0)
+    colorize (0.8.1)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    hashdiff (0.3.5)
+    json (2.1.0)
+    parallel (1.12.0)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    public_suffix (2.0.5)
+    rainbow (2.2.2)
+      rake
+    rake (12.0.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-its (1.2.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    rubocop (0.49.1)
+      parallel (~> 1.10)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    safe_yaml (1.0.4)
+    simplecov (0.15.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    simplecov-rcov (0.2.3)
+      simplecov (>= 0.4.1)
+    unicode-display_width (1.3.0)
+    webmock (1.24.6)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+    xml-simple (1.1.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  colorize (~> 0.7)
+  rspec
+  rspec-its
+  rubocop (~> 0.49.1)
+  safe_yaml (~> 1.0)
+  simplecov
+  simplecov-rcov
+  webmock (~> 1.20)
+  xml-simple (~> 1.1)
+
+RUBY VERSION
+   ruby 2.3.3p222
+
+BUNDLED WITH
+   1.15.4

data/README.md

@@ -0,0 +1,27 @@
+Evva
+
+# Instalation
+
+` gem install evva `
+
+# Usage
+ 1. Open the terminal in app project base
+ 2. Run `evva`
+ 3. That's it (given that someone already configured Evva)
+
+# Configuration
+ Evva's configuration comes from a evva_config.yml file that should be placed on your
+ app root directory. The .yml file has the following structure.
+
+ ```
+ type: Android|iOS
+
+ data_source:
+  type: google_sheet
+  sheet_id: <GOOGLE-DRIVE-SHEET-ID>
+
+ out_path: /folder/where/analytics/classes/are
+ event_file_name: /file/with/tracking/functions
+ event_enum_file_name: /file/with/event/names
+ people_file_name: /file/with/people/properties
+ ```

data/bin/evva

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'evva'
+Evva.run(ARGV)

data/evva.gemspec

@@ -0,0 +1,24 @@
+require_relative 'lib/evva/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'evva'
+  s.version     = Evva::VERSION
+  s.date        = Evva::VERSION_UPDATED_AT
+  s.summary     = 'An event generating service'
+  s.description = 'Evva generates all the analytics event tracking functions for you'
+  s.authors     = ['RicardoTrindade']
+  s.email       = 'ricardo.trindade743@gmail.com'
+  s.license     = 'MIT'
+  s.homepage    = 'https://github.com/hole19/'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+
+  s.executables << 'evva'
+
+  s.add_runtime_dependency 'safe_yaml',  '~> 1.0'
+  s.add_runtime_dependency 'colorize',   '~> 0.7'
+  s.add_runtime_dependency 'xml-simple', '~> 1.1'
+
+  s.add_development_dependency 'webmock', '~> 1.20'
+end

data/evva_config.yml

@@ -0,0 +1,10 @@
+type: Android
+
+data_source:
+  type: google_sheet
+  sheet_id: 1LaJd68os3g_GFlerogC64grNIlXb2iukMznOvdml7A4
+
+out_path: analytics
+event_file_name: MixpanelAnalytics
+event_enum_file_name: MixpanelEvent
+people_file_name: MixpanelProperties

data/lib/evva.rb

@@ -0,0 +1,95 @@
+require 'optparse'
+require 'yaml'
+
+require 'evva/logger'
+require 'evva/google_sheet'
+require 'evva/config'
+require 'evva/file_reader'
+require 'evva/data_source'
+require 'evva/mixpanel_event'
+require 'evva/mixpanel_enum'
+require 'evva/object_extension'
+require 'evva/version'
+require 'evva/android_generator'
+require 'evva/swift_generator'
+
+module Evva
+  extend self
+  def run(options)
+    file_reader = Evva::FileReader.new
+    options = command_line_options(options)
+    unless config_file = file_reader.open_file('evva_config.yml', 'r', true)
+      Logger.error("Could not open evva_config.yml")
+      return
+    end
+
+    config = Evva::Config.new(hash: YAML.safe_load(config_file))
+    bundle = analytics_data(config: config.data_source)
+    case config.type.downcase
+    when 'android'
+      generator = Evva::AndroidGenerator.new
+      evva_write(bundle, generator, config, 'kt')
+    when 'ios'
+      generator = Evva::SwiftGenerator.new
+      evva_write(bundle, generator, config, 'swift')
+    end
+    Evva::Logger.print_summary
+  end
+
+  def evva_write(bundle, generator, configuration, extension)
+    path = "#{configuration.out_path}/#{configuration.event_file_name}.#{extension}"
+    write_to_file(path, generator.events(bundle[:events]))
+
+    path = "#{configuration.out_path}/#{configuration.event_enum_file_name}.#{extension}"
+    write_to_file(path, generator.event_enum(bundle[:events]))
+
+    path = "#{configuration.out_path}/#{configuration.people_file_name}.#{extension}"
+    write_to_file(path, generator.people_properties(bundle[:people]))
+
+    bundle[:enums].each do |enum|
+      path = "#{configuration.out_path}/#{enum.enum_name}.#{extension}"
+      write_to_file(path, generator.special_property_enum(enum))
+    end
+  end
+
+  def analytics_data(config:)
+    source =
+      case config[:type]
+      when 'google_sheet'
+        Evva::GoogleSheet.new(config[:sheet_id])
+      end
+    events_bundle = {}
+    events_bundle[:events] = source.events
+    events_bundle[:people] = source.people_properties
+    events_bundle[:enums] = source.enum_classes
+    events_bundle
+  end
+
+  def command_line_options(options)
+    opts_hash = {}
+
+    opts_parser = OptionParser.new do |opts|
+      opts.on_tail('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+
+      opts.on_tail('-v', '--version', 'Show version') do
+        puts Evva::VERSION
+        exit
+      end
+    end
+    opts_parser.parse!(options)
+
+    opts_hash
+  end
+
+  def write_to_file(path, data)
+    file_reader = Evva::FileReader.new
+    if file = file_reader.open_file(path, "w", false)
+      file_reader.write_to_file(file, data)
+    else
+      Logger.error("Could not write to file in #{path}")
+    end
+  end
+end

data/lib/evva/android_generator.rb

@@ -0,0 +1,115 @@
+module Evva
+  class AndroidGenerator
+    KOTLIN_EVENT_HEADER =
+      "package com.hole19golf.hole19.analytics\n\n"\
+      "import com.hole19golf.hole19.analytics.Event\n"\
+      "import com.hole19golf.hole19.analytics.MixpanelAnalyticsMask\n"\
+      "import org.json.JSONObject\n\n"\
+      "open class MixpanelEvents(private val mixpanelMask: MixpanelAnalyticsMask) {\n".freeze
+
+    KOTLIN_PEOPLE_HEADER =
+      "package com.hole19golf.hole19.analytics\n"\
+      "import com.hole19golf.hole19.analytics.Event\n\n"\
+      "enum class MixpanelProperties(val key: String) {\n".freeze
+
+    KOTLIN_BUNDLE_HEADER =
+      "package com.hole19golf.hole19.analytics\n"\
+      "import com.hole19golf.hole19.analytics.Event\n\n"\
+      "enum class MixpanelEvent(override val key: String) : Event {\n".freeze
+
+    KOTIN_PEOPLE_FUNCTIONS =
+      "\topen fun updateProperties(property: MixpanelProperties, value: Any) {\n"\
+      "\t\tmixpanelMask.updateProperties(property.key, value)"\
+      "\t\n} \n"\
+      "\topen fun incrementCounter(property: MixpanelProperties) {\n"\
+      "\t\tmixpanelMask.incrementCounter(property.key)"\
+      "\t\n} \n".freeze
+
+    NATIVE_TYPES = %w[Long Int String Double Float Boolean].freeze
+
+    def events(bundle)
+      event_file = KOTLIN_EVENT_HEADER
+      bundle.each do |event|
+        event_file += "\n#{kotlin_function(event)}"
+      end
+      event_file += KOTIN_PEOPLE_FUNCTIONS
+      event_file += "\n}"
+    end
+
+    def people_properties(people_bundle)
+      properties = KOTLIN_PEOPLE_HEADER
+      properties += people_bundle.map { |prop| "\t\t#{prop.upcase}(\"#{prop}\")" }.join(",\n")
+      properties += ";\n}\n"
+    end
+
+    def event_enum(bundle)
+      event_file = KOTLIN_BUNDLE_HEADER
+      event_file += bundle.map { |event| "\t\t#{event.event_name.upcase}(\"#{event.event_name}\")"}.join(", \n")
+      event_file += "\n}\n"
+    end
+
+    def kotlin_function(event_data)
+      function_name = 'track' + titleize(event_data.event_name)
+      function_arguments = event_data.properties.map { |name, type| "#{name}: #{type}" }.join(', ')
+      if !function_arguments.empty?
+        props = json_props(event_data.properties)
+        function_body =
+          "open fun #{function_name}(#{function_arguments}) {"\
+          "#{props}"\
+          "\tmixpanelMask.trackEvent(MixpanelEvent.#{event_data.event_name.upcase}, properties)\n"
+      else
+        function_body =
+          "open fun #{function_name}() {\n"\
+          "\tmixpanelMask.trackEvent(MixpanelEvent.#{event_data.event_name.upcase})\n"
+      end
+      function_body += "}\n"
+    end
+
+    def special_property_enum(enum)
+      enum_body = "package com.hole19golf.hole19.analytics\n\n"
+      enum_body += "enum class #{enum.enum_name}(val key: String) {\n"
+      enum_body += enum.values.map { |vals| "\t#{vals.tr(' ', '_').upcase}(\"#{vals}\")"}.join(",\n")
+      enum_body += "\n}\n"
+    end
+
+    private
+
+    def json_props(properties)
+      split_properties =
+        properties
+        .map do |name, type|
+          if special_property?(type)
+            if optional_property?(type)
+              "#{name}?.let { put(\"#{name}\", it.key) }"
+            else
+              "put(\"#{name}\", #{name}.key)"
+            end
+          else
+            if optional_property?(type)
+              "#{name}?.let { put(\"#{name}\", it) }"
+            else
+              "put(\"#{name}\", #{name})"
+            end
+          end
+        end
+        .map { |line| "\t\t#{line}" }
+        .join("\n")
+
+      resulting_json = "\n\tval properties = JSONObject().apply {\n" +
+                       +split_properties.to_s
+      resulting_json += "\n\t}\n"
+    end
+
+    def special_property?(type)
+      !NATIVE_TYPES.include?(type.chomp('?'))
+    end
+
+    def optional_property?(type)
+      type.include?('?')
+    end
+
+    def titleize(str)
+      str.split('_').collect(&:capitalize).join
+    end
+  end
+end

data/lib/evva/config.rb

@@ -0,0 +1,68 @@
+module Evva
+  class Config
+    def initialize(hash:)
+      @hash = hash.deep_symbolize
+      @hash.validate_structure!(CONFIG_STRUCT)
+
+      unless dict_struct = DICTIONARY_STRUCT[@hash[:data_source][:type]]
+        raise ArgumentError, "unknown data source type '#{@hash[:data_source][:type]}'"
+      end
+
+      @hash[:data_source].validate_structure!(dict_struct)
+    end
+
+    def to_h
+      @hash
+    end
+
+    def data_source
+      @hash[:data_source]
+    end
+
+    def type
+      @hash[:type]
+    end
+
+    def out_path
+      @hash[:out_path]
+    end
+
+    def event_file_name
+      @hash[:event_file_name]
+    end
+
+    def people_file_name
+      @hash[:people_file_name]
+    end
+
+    def event_enum_file_name
+      @hash[:event_enum_file_name]
+    end
+
+    CONFIG_STRUCT = {
+      type: Hash,
+      elements: {
+        type: { type: String },
+        data_source: { type: Hash, elements: {
+          type: { type: String }
+        } },
+        out_path: { type: String },
+        event_file_name: { type: String },
+        event_enum_file_name: { type: String },
+        people_file_name: { type: String }
+      }
+    }.freeze
+
+    GOOGLE_SHEET_STRUCT = {
+      type: Hash,
+      elements: {
+        type: { type: String },
+        sheet_id: { type: String }
+      }
+    }.freeze
+
+    DICTIONARY_STRUCT = {
+      'google_sheet' => GOOGLE_SHEET_STRUCT
+    }.freeze
+  end
+end

data/lib/evva/data_source.rb

@@ -0,0 +1,23 @@
+module Evva
+  class DataSource
+    def initialize(keys)
+      unless keys.is_a?(Hash)
+        raise ArgumentError, "keys: expected Hash, got #{keys.class}"
+      end
+
+      keys.each do |property, v|
+        unless v.is_a?(Hash)
+          raise ArgumentError, "keys['#{property}']: expected Hash, got #{v.class}"
+        end
+
+        v.each do |key, v|
+          unless v.is_a?(String) || v.nil?
+            raise ArgumentError, "keys['#{property}']['#{key}']: expected String, got #{v.class}"
+          end
+        end
+      end
+
+      @keys = Hash[keys.map { |k, v| [k.downcase, v] }]
+    end
+  end
+end