evva 0.1.0

data/lib/evva/file_reader.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+module Evva
+  class FileReader
+    def open_file(file_name, method, should_exist)
+      unless File.file?(File.expand_path(file_name))
+        if should_exist
+          Logger.error("File #{file_name} not found!")
+          return nil
+        else
+          FileUtils.mkdir_p(File.dirname(file_name))
+        end
+      end
+
+      File.open(File.expand_path(file_name), method)
+    end
+
+    def write_to_file(file, data)
+      file.write(data)
+      file.flush
+      file.close
+    end
+  end
+end

data/lib/evva/google_sheet.rb

@@ -0,0 +1,91 @@
+require 'net/https'
+require 'xmlsimple'
+
+module Evva
+  class GoogleSheet
+    def initialize(sheet_id)
+      @sheet_id = sheet_id
+    end
+
+    def events
+      raw = raw_data(@sheet_id, 0)
+      Logger.info('Downloading dictionary from Google Sheet...')
+      non_language_columns = %w[id updated category
+                                title content link]
+      event_list = []
+      raw['entry'].each do |entry|
+        filtered_entry = entry.reject { |c| non_language_columns.include?(c) }
+        event_name = filtered_entry['eventname'].first
+        properties = hash_parser(filtered_entry['props'].first)
+        event_list.push(Evva::MixpanelEvent.new(event_name, properties))
+      end
+      event_list
+    end
+
+    def people_properties
+      raw = raw_data(@sheet_id, 1)
+      people_list = []
+      Logger.info('Downloading dictionary from Google Sheet...')
+      non_language_columns = %w[id updated category title content link]
+      raw['entry'].each do |entry|
+        filtered_entry = entry.reject { |c| non_language_columns.include?(c) }
+        value = filtered_entry['value'].first
+        people_list << value
+      end
+      people_list
+    end
+
+    def enum_classes
+      raw = raw_data(@sheet_id, 2)
+      Logger.info('Downloading dictionary from Google Sheet...')
+      non_language_columns = %w[id updated category title content link]
+      enum_list = []
+      raw['entry'].each do |entry|
+        filtered_entry = entry.reject { |c| non_language_columns.include?(c) }
+        enum_name = filtered_entry['enum'].first
+        values = filtered_entry['values'].first.split(',')
+        enum_list.push(Evva::MixpanelEnum.new(enum_name, values))
+      end
+      enum_list
+    end
+
+    def xml_data(uri, headers = nil)
+      uri = URI.parse(uri)
+      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
+
+    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)
+    end
+
+    private
+
+    def hash_parser(property_array)
+      h = {}
+      unless property_array.empty?
+        property_array.split(',').each do |prop|
+          split_prop = prop.split(':')
+          prop_name = split_prop[0].to_sym
+          prop_type = split_prop[1].to_s
+          h[prop_name] = prop_type
+        end
+      end
+      h
+    end
+  end
+end

data/lib/evva/logger.rb

@@ -0,0 +1,61 @@
+require 'singleton'
+require 'colorize'
+
+module Evva
+  module Logger
+    extend self
+
+    def info(msg)
+      log :info, msg
+    end
+
+    def warn(msg)
+      log :warn, msg
+    end
+
+    def error(msg)
+      log :error, msg
+    end
+
+    def clean_summary
+      @levels.each { |k, _| @levels[k] = 0 }
+    end
+
+    def summary
+      @levels
+    end
+
+    def print_summary
+      if @levels[:warn] > 0 || @levels[:error] > 0
+        info ''
+        info 'Finished with:'
+        info "  #{@levels[:warn]} warnings" if @levels[:warn]  > 0
+        info "  #{@levels[:error]} errors"  if @levels[:error] > 0
+        info ''
+      end
+    end
+
+    def silent_mode=(value)
+      @silent_mode = value
+    end
+
+    private
+
+    @levels = { info: 0, warn: 0, error: 0 }
+    @silent_mode = false
+
+    def log(level, msg)
+      unless @levels.keys.include?(level)
+        return log(:error, "Unknown log level: #{level}")
+      end
+
+      @levels[level] += 1
+
+      msg = "[#{level.upcase}] #{msg}"
+      msg = msg.yellow if level.eql?(:warn)
+      msg = msg.red    if level.eql?(:error)
+
+      puts msg unless @silent_mode
+    end
+  end
+end

data/lib/evva/mixpanel_enum.rb

@@ -0,0 +1,14 @@
+module Evva
+  class MixpanelEnum
+    attr_reader :enum_name, :values
+    def initialize(enum_name, values)
+      @enum_name = enum_name
+      @values = values
+    end
+
+    def ==(other)
+      enum_name == other.enum_name
+      values == other.values
+    end
+  end
+end

data/lib/evva/mixpanel_event.rb

@@ -0,0 +1,13 @@
+module Evva
+  class MixpanelEvent
+    attr_reader :event_name, :properties
+    def initialize(event_name, properties = {})
+      @event_name = event_name
+      @properties = properties
+    end
+
+    def ==(other)
+      event_name == other.event_name
+    end
+  end
+end

data/lib/evva/object_extension.rb

@@ -0,0 +1,41 @@
+Object.class_eval do
+  def deep_symbolize
+    case self
+    when Array
+      map(&:deep_symbolize)
+    when Hash
+      each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v.deep_symbolize; }
+    else
+      self
+    end
+  end
+
+  def validate_structure!(structure, error_prefix = [])
+    return if nil? && structure[:optional]
+
+    prepend_error = error_prefix.empty? ? '' : (['self'] + error_prefix + [': ']).join
+
+    unless is_a? structure[:type]
+      raise ArgumentError, "#{prepend_error}Expected #{structure[:type]}, got #{self.class}"
+    end
+
+    return unless structure[:elements]
+
+    case self
+    when Array
+      each_with_index do |e, i|
+        e.validate_structure!(structure[:elements], error_prefix + ["[#{i}]"])
+      end
+    when Hash
+      mandatory_keys = structure[:elements].map { |k, s| k unless s[:optional] }.compact
+
+      unless (missing = mandatory_keys - keys).empty?
+        raise ArgumentError, "#{prepend_error}Missing keys: #{missing.join(', ')}"
+      end
+
+      structure[:elements].each do |key, structure|
+        self[key].validate_structure!(structure, error_prefix + ["[:#{key}]"])
+      end
+    end
+  end
+end

data/lib/evva/swift_generator.rb

@@ -0,0 +1,128 @@
+module Evva
+  class SwiftGenerator
+    SWIFT_EVENT_HEADER =
+      "import CoreLocation\n"\
+      "import Foundation\n"\
+      "import SharedCode\n\n"\
+      "class MixpanelHelper: NSObject {\n"\
+      "enum Event {\n".freeze
+
+    SWIFT_EVENT_DATA_HEADER =
+      "private var data: EventData {\n"\
+      "switch self {\n\n\n".freeze
+
+    SWIFT_PEOPLE_HEADER = "fileprivate enum Counter: String {\n".freeze
+
+    SWIFT_INCREMENT_FUNCTION =
+      "func increment(times: Int = 1) {\n"\
+      "MixpanelAPI.instance.incrementCounter(rawValue, times: times)\n"\
+      '}'.freeze
+
+    def events(bundle)
+      event_file = SWIFT_EVENT_HEADER
+      bundle.each do |event|
+        event_file += swift_case(event)
+      end
+      event_file += "}\n"
+      event_file += "private var data: EventData {\n"\
+      "switch self {\n\n"
+      bundle.each do |event|
+        event_file += swift_event_data(event)
+      end
+      event_file += "}\n}\n"
+    end
+
+    def swift_case(event_data)
+      function_name = 'track' + titleize(event_data.event_name)
+      if event_data.properties.nil?
+        case_body = "\t\tcase #{function_name}\n"
+      else
+        trimmed_properties = event_data.properties.gsub('Boolean', 'Bool')
+        case_body = "\t\tcase #{function_name}(#{trimmed_properties})\n"
+      end
+    end
+
+    def swift_event_data(event_data)
+      function_name = 'track' + titleize(event_data.event_name)
+      if event_data.properties.nil?
+        function_body = "case .#{function_name} \n" \
+                        "\treturn EventData(name:" + %("#{event_data.event_name}") + ")\n\n"
+      else
+        function_header = prepend_let(event_data.properties)
+        function_arguments = process_arguments(event_data.properties.gsub('Boolean', 'Bool'))
+        function_body = "case .#{function_name}(#{function_header}):\n" \
+                        "\treturn EventData(name:" + %("#{event_data.event_name}") + ", properties: [#{function_arguments}])\n\n"
+      end
+
+      function_body
+    end
+
+    def event_enum(enum)
+      # empty
+    end
+
+    def people_properties(people_bundle)
+      properties = SWIFT_PEOPLE_HEADER
+      people_bundle.each do |prop|
+        properties += swift_people_const(prop)
+      end
+      properties += SWIFT_INCREMENT_FUNCTION + "\n}"
+    end
+
+    def special_property_enum(enum)
+      enum_body = "import Foundation\n\n"
+      enum_values = enum.values.split(',')
+      enum_body += "enum #{enum.enum_name}: String {\n"
+      enum_values.each do |vals|
+        enum_body += "\tcase #{vals.tr(' ', '_')} = " + %("#{vals}") + "\n"
+      end
+      enum_body += "} \n"
+    end
+
+    def process_arguments(props)
+      arguments = ''
+      props.split(',').each do |property|
+        if is_special_property(property)
+          if is_optional_property(property)
+
+          else
+            arguments += %("#{property.split(':').first}") + ':' + property.split(':').first + '.rawValue, '
+          end
+        else
+          arguments += %("#{property.split(':').first}") + ':' + property.split(':').first + ', '
+        end
+      end
+      arguments.chomp(', ')
+    end
+
+    private
+
+    def is_special_property(prop)
+      types_array = %w[Long Int String Double Float Boolean]
+      type = prop.split(':')[1]
+      types_array.include?(type) ? false : true
+    end
+
+    def is_optional_property(prop)
+      type = prop.split(':')[1]
+      type.include?('?') ? true : false
+    end
+
+
+    def prepend_let(props)
+      function_header = ''
+      props.split(',').each do |property|
+        function_header += 'let ' + property.split(':')[0] + ', '
+      end
+      function_header.chomp(', ')
+    end
+
+    def swift_people_const(prop)
+      case_body = "\tcase #{prop.property_name} = " + %("#{prop.property_value}") + "\n"
+    end
+
+    def titleize(str)
+      str.split('_').collect(&:capitalize).join
+    end
+  end
+end

data/lib/evva/version.rb

@@ -0,0 +1,4 @@
+module Evva
+  VERSION = '0.1.0'.freeze
+  VERSION_UPDATED_AT = '2017-10-26'.freeze
+end

data/rubocop.yml

@@ -0,0 +1,54 @@
+Metrics/BlockNesting:
+  Max: 2
+
+Metrics/LineLength:
+  AllowURI: true
+  Enabled: false
+
+Metrics/MethodLength:
+  CountComments: false
+  Max: 15
+
+Metrics/ParameterLists:
+  Max: 4
+  CountKeywordArgs: true
+
+Style/AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+Style/CollectionMethods:
+  PreferredMethods:
+    map:      'collect'
+    reduce:   'inject'
+    find:     'detect'
+    find_all: 'select'
+
+Style/Documentation:
+  Enabled: false
+
+Style/DotPosition:
+  EnforcedStyle: trailing
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/EachWithObject:
+  Enabled: false
+
+Style/Encoding:
+  Enabled: false
+
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+Style/Lambda:
+  Enabled: false
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Style/TrailingComma:
+  EnforcedStyleForMultiline: 'comma'

data/spec/evva_spec.rb

@@ -0,0 +1,40 @@
+describe Evva do
+  subject(:run) { Evva.run([]) }
+
+  context "when there is a config.yml file" do
+    let(:file) { File.open("spec/fixtures/test.yml") }
+
+    before do
+      allow_any_instance_of(Evva::FileReader).to receive(:open_file).and_return(file)
+      allow_any_instance_of(Evva::GoogleSheet).to receive(:events).and_return(
+        [Evva::MixpanelEvent.new('trackEvent',[])])
+
+      allow_any_instance_of(Evva::GoogleSheet).to receive(:people_properties).and_return([])
+      allow_any_instance_of(Evva::GoogleSheet).to receive(:enum_classes).and_return([])
+
+      allow(Evva).to receive(:write_to_file)
+    end
+
+    it { expect { run }.not_to raise_error }
+
+    it "logs an error" do
+      expect {
+        run
+      }.to not_change { Evva::Logger.summary[:warn] }
+       .and not_change { Evva::Logger.summary[:error] }
+    end
+  end
+
+  context "when generic.yml does not exist locally" do
+    let(:error) { "Could not open yml file" }
+    before do
+      allow_any_instance_of(Evva::FileReader).to receive(:open_file).and_return(false)
+    end
+    it { expect { run }.to_not raise_error }
+
+    it "logs an error" do
+      expect { run }.to not_change { Evva::Logger.summary[:warn] }
+                    .and change { Evva::Logger.summary[:error] }.by(1)
+    end
+  end
+end