zendesk_apps_support 4.29.4

data/lib/zendesk_apps_support/location.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ZendeskAppsSupport
+  class Location
+    extend ZendeskAppsSupport::Finders
+    attr_reader :id, :name, :orderable, :collapsible, :visible, :product_code, :v2_only
+
+    def self.unique_ids
+      @ids ||= Set.new
+    end
+
+    def initialize(attrs)
+      @id = attrs.fetch(:id)
+      raise 'Duplicate id' if Location.unique_ids.include? @id
+      Location.unique_ids.add @id
+      @name = attrs.fetch(:name)
+      @orderable = attrs.fetch(:orderable, false)
+      @collapsible = attrs.fetch(:collapsible, false)
+      @visible = attrs.fetch(:visible, false)
+      @product_code = attrs.fetch(:product_code)
+      @v2_only = attrs.fetch(:v2_only, product != Product::SUPPORT)
+    end
+
+    def product
+      Product.find_by(code: product_code)
+    end
+
+    def self.all
+      LOCATIONS_AVAILABLE
+    end
+
+    # the ids below match the enum values on the database, do not change them!
+    LOCATIONS_AVAILABLE = [
+      Location.new(id: 1, orderable: true, name: 'top_bar',
+                   product_code: Product::SUPPORT.code, visible: true),
+      Location.new(id: 2, orderable: true, name: 'nav_bar',
+                   product_code: Product::SUPPORT.code, visible: true),
+      Location.new(id: 3, orderable: true, collapsible: true, name: 'ticket_sidebar',
+                   product_code: Product::SUPPORT.code, visible: true),
+      Location.new(id: 4, orderable: true, collapsible: true, name: 'new_ticket_sidebar',
+                   product_code: Product::SUPPORT.code, visible: true),
+      Location.new(id: 5, orderable: true, collapsible: true, name: 'user_sidebar',
+                   product_code: Product::SUPPORT.code, visible: true),
+      Location.new(id: 6, orderable: true, collapsible: true, name: 'organization_sidebar',
+                   product_code: Product::SUPPORT.code, visible: true),
+      Location.new(id: 7, name: 'background', product_code: Product::SUPPORT.code),
+      Location.new(id: 8, orderable: true, collapsible: true, name: 'chat_sidebar',
+                   product_code: Product::CHAT.code, visible: true),
+      Location.new(id: 9, name: 'modal', product_code: Product::SUPPORT.code, v2_only: true),
+      Location.new(id: 10, name: 'ticket_editor', product_code: Product::SUPPORT.code, v2_only: true, visible: true),
+      Location.new(id: 11, name: 'nav_bar', product_code: Product::STANDALONE_CHAT.code, v2_only: false, visible: true),
+      Location.new(id: 12, name: 'system_top_bar', product_code: Product::SUPPORT.code),
+      Location.new(id: 13, name: 'system_top_bar',
+                   product_code: Product::STANDALONE_CHAT.code, v2_only: false),
+      Location.new(id: 14, name: 'background',
+                   product_code: Product::CHAT.code),
+      Location.new(id: 15, name: 'deal_card', product_code: Product::SELL.code, collapsible: true, visible: true),
+      Location.new(id: 16, name: 'person_card', product_code: Product::SELL.code, collapsible: true, visible: true),
+      Location.new(id: 17, name: 'company_card', product_code: Product::SELL.code, collapsible: true, visible: true),
+      Location.new(id: 18, name: 'lead_card', product_code: Product::SELL.code, collapsible: true, visible: true),
+      Location.new(id: 19, name: 'background', product_code: Product::SELL.code),
+      Location.new(id: 20, name: 'modal', product_code: Product::SELL.code),
+      Location.new(id: 21, name: 'dashboard', product_code: Product::SELL.code, visible: true),
+      Location.new(id: 22, name: 'note_editor', product_code: Product::SELL.code, visible: true),
+      Location.new(id: 23, name: 'call_log_editor', product_code: Product::SELL.code, visible: true),
+      Location.new(id: 24, name: 'email_editor', product_code: Product::SELL.code, visible: true),
+      Location.new(id: 25, name: 'top_bar', product_code: Product::SELL.code, visible: true),
+      Location.new(id: 26, name: 'visit_editor', product_code: Product::SELL.code, visible: true)
+    ].freeze
+  end
+end

data/lib/zendesk_apps_support/manifest.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module ZendeskAppsSupport
+  class Manifest
+    LEGACY_URI_STUB = '_legacy'
+
+    RUBY_TO_JSON = {
+      requirements_only: 'requirementsOnly',
+      marketing_only: 'marketingOnly',
+      version: 'version',
+      author: 'author',
+      name: 'name', # currently only used in ZAT
+      experiments: 'experiments',
+      framework_version: 'frameworkVersion',
+      single_install: 'singleInstall',
+      signed_urls: 'signedUrls',
+      no_template: 'noTemplate',
+      default_locale: 'defaultLocale',
+      original_locations: 'location',
+      private: 'private',
+      oauth: 'oauth',
+      original_parameters: 'parameters',
+      domain_whitelist: 'domainWhitelist',
+      remote_installation_url: 'remoteInstallationURL',
+      terms_conditions_url: 'termsConditionsURL',
+      google_analytics_code: 'gaID'
+    }.freeze
+
+    attr_reader(*RUBY_TO_JSON.keys)
+
+    alias_method :requirements_only?, :requirements_only
+    alias_method :marketing_only?, :marketing_only
+    alias_method :signed_urls?, :signed_urls
+    alias_method :single_install?, :single_install
+    alias_method :private?, :private
+
+    def no_template?
+      if no_template.is_a?(Array)
+        false
+      else
+        no_template
+      end
+    end
+
+    def no_template_locations
+      no_template || []
+    end
+
+    def products
+      @products ||=
+        if requirements_only?
+          [ Product::SUPPORT ]
+        elsif marketing_only?
+          products_ignore_locations || [ Product::SUPPORT ]
+        else
+          products_from_locations
+        end
+    end
+
+    def products_ignore_locations
+      locations.keys.map do |product_name|
+        Product.find_by(name: product_name)
+      end
+    end
+
+    def location_options
+      @location_options ||= locations.flat_map do |product_key, locations|
+        product = Product.find_by(name: product_key)
+        locations.map do |location_key, location_options|
+          location = product && Location.find_by(product_code: product.code, name: location_key)
+          options_with_defaults = {
+            'signed' => signed_urls?
+          }.merge(location_options)
+          Manifest::LocationOptions.new(location, options_with_defaults)
+        end
+      end
+    end
+
+    def app_class_properties
+      {
+        experiments: experiments,
+        location: locations,
+        noTemplate: no_template_locations,
+        singleInstall: single_install?,
+        signedUrls: signed_urls?
+      }.reject { |_k, v| v.nil? }
+    end
+
+    def unknown_locations(host)
+      product = Product.find_by(name: host)
+
+      if locations.key?(host)
+        product_locations = Location.where(product_code: product.code)
+        locations[host].keys.uniq - product_locations.map(&:name)
+      else
+        []
+      end
+    end
+
+    def unknown_hosts
+      @unknown_hosts ||=
+        @used_hosts - Product::PRODUCTS_AVAILABLE.flat_map { |p| [p.name, p.legacy_name] }
+    end
+
+    def iframe_only?
+      framework_version && Gem::Version.new(framework_version) >= Gem::Version.new('2')
+    end
+
+    def parameters
+      @parameters ||= begin
+        parameter_array = @original_parameters.is_a?(Array) ? @original_parameters : []
+        parameter_array.map do |parameter_hash|
+          Parameter.new(parameter_hash)
+        end
+      end
+    end
+
+    def enabled_experiments
+      experiments.select { |_k, v| v }.keys
+    end
+
+    def initialize(manifest_text)
+      m = parse_json(manifest_text)
+      RUBY_TO_JSON.each do |ruby, json|
+        instance_variable_set(:"@#{ruby}", m[json])
+      end
+      @requirements_only ||= false
+      @marketing_only ||= false
+      @single_install ||= false
+      @private = m.fetch('private', true)
+      @signed_urls ||= false
+      @no_template ||= false
+      @experiments ||= {}
+      set_locations_and_hosts
+    end
+
+    LEGACY_LOCATION_OBJECT = { 'url' => LEGACY_URI_STUB }.freeze
+    private_constant :LEGACY_LOCATION_OBJECT
+
+    private
+
+    attr_reader :locations
+
+    def products_from_locations
+      location_options.map { |lo| lo.location && lo.location.product_code }
+                      .compact
+                      .uniq
+                      .map { |code| Product.find_by(code: code) }
+    end
+
+    def set_locations_and_hosts
+      @locations =
+        case original_locations
+        when Hash
+          @used_hosts = original_locations.keys
+          replace_legacy_locations original_locations
+        when Array
+          @used_hosts = ['support']
+          new_locations = NoOverrideHash[original_locations.map { |location| [ location, LEGACY_LOCATION_OBJECT ] }]
+          { 'support' => new_locations }
+        when String
+          @used_hosts = ['support']
+          { 'support' => { original_locations => LEGACY_LOCATION_OBJECT } }
+        # TODO: error out for numbers and Booleans
+        else # NilClass
+          @used_hosts = ['support']
+          { 'support' => {} }
+        end
+    end
+
+    def replace_legacy_locations(original_locations)
+      NoOverrideHash.new.tap do |new_locations_obj|
+        Product::PRODUCTS_AVAILABLE.each do |product|
+          product_key = product.name.to_s
+          legacy_key = product.legacy_name.to_s
+          value_for_product = original_locations.fetch(product_key, original_locations[legacy_key])
+          value_for_product && new_locations_obj[product_key] = replace_string_uris(value_for_product)
+        end
+      end
+    end
+
+    def replace_string_uris(product_locations)
+      product_locations.each_with_object({}) do |(k, v), new_locations|
+        new_locations[k] = if v.is_a? Hash
+                             v
+                           else
+                             { 'url' => v }
+                           end
+      end
+    end
+
+    def parse_json(manifest_text)
+      parser_opts = { object_class: Manifest::NoOverrideHash }
+      JSON.parse(manifest_text, parser_opts)
+    end
+  end
+end

data/lib/zendesk_apps_support/manifest/location_options.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ZendeskAppsSupport
+  class Manifest
+    class LocationOptions
+      RUBY_TO_JSON = {
+        legacy: 'legacy',
+        auto_load: 'autoLoad',
+        auto_hide: 'autoHide',
+        signed: 'signed',
+        url: 'url'
+      }.freeze
+
+      attr_reader :location
+      attr_reader(*RUBY_TO_JSON.keys)
+
+      alias_method :signed?, :signed
+      alias_method :legacy?, :legacy
+      alias_method :auto_load?, :auto_load
+      alias_method :auto_hide?, :auto_hide
+
+      def initialize(location, options)
+        @location = location
+
+        RUBY_TO_JSON.each do |ruby, json|
+          instance_variable_set(:"@#{ruby}", options[json])
+        end
+        @legacy ||= @url == ZendeskAppsSupport::Manifest::LEGACY_URI_STUB
+        @auto_load = options.fetch('autoLoad', true)
+        @auto_hide ||= false
+        @signed ||= false
+      end
+    end
+  end
+end

data/lib/zendesk_apps_support/manifest/no_override_hash.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ZendeskAppsSupport
+  class Manifest
+    class OverrideError < StandardError
+      attr_reader :key, :original, :attempted
+      attr_accessor :message
+      def initialize(key, original, attempted)
+        @key = key
+        @original = original
+        @attempted = attempted
+      end
+
+      def message
+        @message ||= begin
+          translated_error_key = 'txt.apps.admin.error.app_build.duplicate_reference'
+          translated_error = ZendeskAppsSupport::I18n.t(translated_error_key, key: key)
+
+          # if the error contains the word `_legacy` in the second sentence, let's
+          # only use the first one.
+          if [original, attempted].any? { |val| val =~ /_legacy/ }
+            return translated_error
+          end
+          translated_detail_key = 'txt.apps.admin.error.app_build.duplicate_reference_values'
+          translated_detail = ZendeskAppsSupport::I18n.t(translated_detail_key,
+                                                         original: original,
+                                                         attempted: attempted)
+          "#{translated_error} #{translated_detail}"
+        end
+      end
+    end
+
+    class NoOverrideHash < Hash
+      class << self
+        def [](array)
+          new.tap do |hash|
+            array.each do |key, value|
+              hash[key] = value
+            end
+          end
+        end
+      end
+
+      def []=(key, value)
+        raise OverrideError.new(key, self[key], value) if key? key
+        super
+      end
+    end
+  end
+end

data/lib/zendesk_apps_support/manifest/parameter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ZendeskAppsSupport
+  class Manifest
+    class Parameter
+      TYPES = %w[text password checkbox url number multiline hidden oauth].freeze
+      ATTRIBUTES = %i[name type required secure default].freeze
+      attr_reader(*ATTRIBUTES)
+      def default?
+        @has_default
+      end
+
+      def initialize(p)
+        @name = p['name']
+        @type = p['type'] || 'text'
+        @required = p['required'] || false
+        @secure = p['secure'] || false
+        @has_default = p.key? 'default'
+        @default = p['default'] if @has_default
+      end
+    end
+  end
+end

data/lib/zendesk_apps_support/package.rb

@@ -0,0 +1,402 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'erubis'
+require 'json'
+
+module ZendeskAppsSupport
+  class Package
+    extend Gem::Deprecate
+    include ZendeskAppsSupport::BuildTranslation
+
+    MANIFEST_FILENAME = 'manifest.json'
+    REQUIREMENTS_FILENAME = 'requirements.json'
+
+    DEFAULT_LAYOUT = Erubis::Eruby.new(File.read(File.expand_path('../assets/default_template.html.erb', __FILE__)))
+    DEFAULT_SCSS   = File.read(File.expand_path('../assets/default_styles.scss', __FILE__))
+    SRC_TEMPLATE   = Erubis::Eruby.new(File.read(File.expand_path('../assets/src.js.erb', __FILE__)))
+
+    LOCATIONS_WITH_ICONS_PER_PRODUCT = {
+      Product::SUPPORT => %w[top_bar nav_bar system_top_bar ticket_editor].freeze,
+      Product::SELL => %w[top_bar].freeze
+    }.freeze
+
+    attr_reader :lib_root, :root, :warnings
+
+    def initialize(dir, is_cached = true)
+      @root     = Pathname.new(File.expand_path(dir))
+      @lib_root = Pathname.new(File.join(root, 'lib'))
+
+      @is_cached = is_cached # disabled by ZAT for development
+      @warnings = []
+    end
+
+    def validate(marketplace: true, skip_marketplace_translations: false)
+      errors = []
+      errors << Validations::Manifest.call(self)
+
+      if has_valid_manifest?(errors)
+        errors << Validations::Marketplace.call(self) if marketplace
+        errors << Validations::Source.call(self)
+        errors << Validations::Translations.call(self, skip_marketplace_translations: skip_marketplace_translations)
+        errors << Validations::Requirements.call(self)
+
+        # only adds warnings
+        Validations::SecureSettings.call(self)
+        Validations::Requests.call(self)
+
+        unless manifest.requirements_only? || manifest.marketing_only? || manifest.iframe_only?
+          errors << Validations::Templates.call(self)
+          errors << Validations::Stylesheets.call(self)
+        end
+      end
+
+      errors << Validations::Banner.call(self) if has_banner?
+      errors << Validations::Svg.call(self) if has_svgs?
+      errors << Validations::Mime.call(self)
+
+      # only adds warnings
+      Validations::Secrets.call(self)
+
+      errors.flatten.compact
+    end
+
+    def validate!(marketplace: true, skip_marketplace_translations: false)
+      errors = validate(marketplace: marketplace, skip_marketplace_translations: skip_marketplace_translations)
+      raise errors.first if errors.any?
+      true
+    end
+
+    def assets
+      @assets ||= Dir.chdir(root) do
+        Dir['assets/**/*'].select { |f| File.file?(f) }
+      end
+    end
+
+    def path_to(file)
+      File.join(root, file)
+    end
+
+    def requirements_path
+      path_to(REQUIREMENTS_FILENAME)
+    end
+
+    def locales
+      translations.keys
+    end
+
+    def files
+      files = []
+      Dir[root.join('**/**')].each do |f|
+        next unless File.file?(f)
+        relative_file_name = f.sub(%r{#{root}/?}, '')
+        next if relative_file_name =~ %r{^tmp/}
+        files << AppFile.new(self, relative_file_name)
+      end
+      files
+    end
+
+    def text_files
+      @text_files ||= files.select { |f| f =~ %r{.*(html?|xml|js|json?)$} }
+    end
+
+    def js_files
+      @js_files ||= files.select { |f| f =~ %r{^.*\.jsx?$} }
+    end
+
+    def html_files
+      @html_files ||= files.select { |f| f =~ %r{.*\.html?$} }
+    end
+
+    def lib_files
+      @lib_files ||= js_files.select { |f| f =~ %r{^lib/} }
+    end
+
+    def svg_files
+      @svg_files ||= files.select { |f| f =~ %r{^assets/.*\.svg$} }
+    end
+
+    def template_files
+      files.select { |f| f =~ %r{^templates/.*\.hdbs$} }
+    end
+
+    def translation_files
+      files.select { |f| f =~ %r{^translations/} }
+    end
+
+    # this is not really compile_js, it compiles the whole app including scss for v1 apps
+    def compile(options)
+      begin
+        app_id = options.fetch(:app_id)
+        asset_url_prefix = options.fetch(:assets_dir)
+        name = options.fetch(:app_name)
+      rescue KeyError => e
+        raise ArgumentError, e.message
+      end
+
+      locale = options.fetch(:locale, 'en')
+
+      source = manifest.iframe_only? ? nil : app_js
+      app_class_name = "app-#{app_id}"
+      # if no_template is an array, we still need the templates
+      templates = manifest.no_template == true ? {} : compiled_templates(app_id, asset_url_prefix)
+
+      SRC_TEMPLATE.result(
+        name: name,
+        version: manifest.version,
+        source: source,
+        app_class_properties: manifest.app_class_properties,
+        asset_url_prefix: asset_url_prefix,
+        logo_asset_hash: generate_logo_hash(manifest.products),
+        location_icons: location_icons,
+        app_class_name: app_class_name,
+        author: manifest.author,
+        translations: manifest.iframe_only? ? nil : runtime_translations(translations_for(locale)),
+        framework_version: manifest.framework_version,
+        templates: templates,
+        modules: commonjs_modules,
+        iframe_only: manifest.iframe_only?
+      )
+    end
+
+    alias compile_js compile
+    deprecate :compile_js, :compile, 2017, 1
+
+    def manifest_json
+      @manifest_json ||= read_json(MANIFEST_FILENAME)
+    end
+    deprecate :manifest_json, :manifest, 2016, 9
+
+    def manifest
+      @manifest ||= Manifest.new(read_file(MANIFEST_FILENAME))
+    end
+
+    def requirements_json
+      return nil unless has_requirements?
+      @requirements ||= read_json(REQUIREMENTS_FILENAME, object_class: Manifest::NoOverrideHash)
+    end
+
+    def is_no_template
+      manifest.no_template?
+    end
+    deprecate :is_no_template, 'manifest.no_template?', 2016, 9
+
+    def no_template_locations
+      manifest.no_template_locations
+    end
+    deprecate :no_template_locations, 'manifest.no_template_locations', 2016, 9
+
+    def compiled_templates(app_id, asset_url_prefix)
+      compiler = ZendeskAppsSupport::StylesheetCompiler.new(DEFAULT_SCSS + app_css, app_id, asset_url_prefix)
+      compiled_css = compiler.compile(sassc: manifest.enabled_experiments.include?('newCssCompiler'))
+
+      layout = templates['layout'] || DEFAULT_LAYOUT.result
+
+      templates.tap do |templates|
+        templates['layout'] = "<style>\n#{compiled_css}</style>\n#{layout}"
+      end
+    end
+
+    def translations_for(locale)
+      trans = translations
+      return trans[locale] if trans[locale]
+      trans[manifest.default_locale]
+    end
+
+    def has_file?(path)
+      File.file?(path_to(path))
+    end
+
+    def has_svgs?
+      svg_files.any?
+    end
+
+    def has_requirements?
+      has_file?(REQUIREMENTS_FILENAME)
+    end
+
+    def self.has_custom_object_requirements?(requirements_hash)
+      return false if requirements_hash.nil?
+
+      custom_object_requirements = requirements_hash.fetch(AppRequirement::CUSTOM_OBJECTS_KEY, {})
+      types = custom_object_requirements.fetch(AppRequirement::CUSTOM_OBJECTS_TYPE_KEY, [])
+      relationships = custom_object_requirements.fetch(AppRequirement::CUSTOM_OBJECTS_RELATIONSHIP_TYPE_KEY, [])
+
+      (types | relationships).any?
+    end
+
+    def app_css
+      return File.read(path_to('app.scss')) if has_file?('app.scss')
+      return File.read(path_to('app.css')) if has_file?('app.css')
+      ''
+    end
+
+    def app_js
+      if @is_cached
+        @app_js ||= read_file('app.js')
+      else
+        read_file('app.js')
+      end
+    end
+
+    def iframe_only?
+      manifest.iframe_only?
+    end
+    deprecate :iframe_only?, 'manifest.iframe_only?', 2016, 9
+
+    def templates
+      templates_dir = path_to('templates')
+      Dir["#{templates_dir}/*.hdbs"].each_with_object({}) do |file, memo|
+        str = File.read(file)
+        str.chomp!
+        memo[File.basename(file, File.extname(file))] = str
+        memo
+      end
+    end
+
+    def translations
+      return @translations if @is_cached && @translations
+
+      @translations = begin
+        translation_dir = path_to('translations')
+        return {} unless File.directory?(translation_dir)
+
+        locale_path = "#{translation_dir}/#{manifest.default_locale}.json"
+        default_translations = process_translations(locale_path, default_locale: true)
+
+        Dir["#{translation_dir}/*.json"].each_with_object({}) do |path, memo|
+          locale = File.basename(path, File.extname(path))
+
+          locale_translations = if locale == manifest.default_locale
+                                  default_translations
+                                else
+                                  deep_merge_hash(default_translations, process_translations(path))
+                                end
+
+          memo[locale] = locale_translations
+        end
+      end
+    end
+
+    def location_icons
+      Hash.new { |h, k| h[k] = {} }.tap do |location_icons|
+        manifest.location_options.each do |location_options|
+          # no location information in the manifest
+          next unless location_options.location
+
+          product = location_options.location.product
+          location_name = location_options.location.name
+          # the location on the product does not support icons
+          next unless LOCATIONS_WITH_ICONS_PER_PRODUCT.fetch(product, []).include?(location_name)
+
+          host = location_options.location.product.name
+          product_directory = manifest.products.count > 1 ? "#{host}/" : ''
+          location_icons[host][location_name] = build_location_icons_hash(location_name, product_directory)
+        end
+      end
+    end
+
+    private
+
+    def generate_logo_hash(products)
+      {}.tap do |logo_hash|
+        products.each do |product|
+          product_directory = products.count > 1 ? "#{product.name.downcase}/" : ''
+          logo_hash[product.name.downcase] = "#{product_directory}logo-small.png"
+        end
+      end
+    end
+
+    def has_valid_manifest?(errors)
+      has_manifest? && errors.flatten.empty?
+    end
+
+    def runtime_translations(translations)
+      result = translations.dup
+      result.delete('name')
+      result.delete('short_description')
+      result.delete('long_description')
+      result.delete('installation_instructions')
+      result
+    end
+
+    def process_translations(locale_path, default_locale: false)
+      translations = File.exist?(locale_path) ? JSON.parse(File.read(locale_path)) : {}
+      translations['app'].delete('name') if !default_locale && translations.key?('app')
+      translations['app'].delete('package') if translations.key?('app')
+      remove_zendesk_keys(translations)
+    end
+
+    def has_lib_js?
+      lib_files.any?
+    end
+
+    def has_manifest?
+      has_file?(MANIFEST_FILENAME)
+    end
+
+    def has_banner?
+      has_file?('assets/banner.png')
+    end
+
+    def build_location_icons_hash(location, product_directory)
+      inactive_png = "icon_#{location}_inactive.png"
+      if has_file?("assets/#{product_directory}icon_#{location}.svg")
+        build_svg_icon_hash(location, product_directory)
+      elsif has_file?("assets/#{product_directory}#{inactive_png}")
+        build_png_icons_hash(location, product_directory)
+      else
+        {}
+      end
+    end
+
+    def build_svg_icon_hash(location, product_directory)
+      cache_busting_param = "?#{Time.now.to_i}" unless @is_cached
+      { 'svg' => "#{product_directory}icon_#{location}.svg#{cache_busting_param}" }
+    end
+
+    def build_png_icons_hash(location, product_directory)
+      inactive_png = "#{product_directory}icon_#{location}_inactive.png"
+      {
+        'inactive' => inactive_png
+      }.tap do |icon_state_hash|
+        %w[active hover].each do |state|
+          specific_png = "#{product_directory}icon_#{location}_#{state}.png"
+          selected_png = has_file?("assets/#{specific_png}") ? specific_png : inactive_png
+          icon_state_hash[state] = selected_png
+        end
+      end
+    end
+
+    def commonjs_modules
+      return {} unless has_lib_js?
+
+      lib_files.each_with_object({}) do |file, modules|
+        name          = file.relative_path.gsub(/^lib\//, '')
+        content       = file.read
+        modules[name] = content
+      end
+    end
+
+    def deep_merge_hash(h, another_h)
+      result_h = h.dup
+      another_h.each do |key, value|
+        result_h[key] = if h.key?(key) && h[key].is_a?(Hash) && value.is_a?(Hash)
+                          deep_merge_hash(h[key], value)
+                        else
+                          value
+                        end
+      end
+      result_h
+    end
+
+    def read_file(path)
+      File.read(path_to(path))
+    end
+
+    def read_json(path, parser_opts = {})
+      file = read_file(path)
+      JSON.parse(read_file(path), parser_opts) unless file.nil?
+    end
+  end
+end