admiral-tools-figma 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db6a98e25fe4de8274065f26dfc4db1808034dfe4b60b80d40c9f99d383729f7
+  data.tar.gz: 8b204394e797d86d8ac6de7ace055ece02631b879b30457cf1ed43aa0e11fe72
+SHA512:
+  metadata.gz: 34fc5807ebeb31cc95e1797e535039dd3aafa58c051b3c628f70a12faf43cbcf869888f3afcad60746a4fd746f9cbd36f377ee2d91a89d6ebc8863a7bbed050b
+  data.tar.gz: 389fc58b3afa3584df804e769e3ccee55823a594300522fe1dc0e1c3f001f2e91d70343bb81da95066dac45e78a823d98af879876611bb926894ddf35049ae64

data/README.md

@@ -0,0 +1 @@
+# admiral-tools-figma

data/admiral-tools-figma.gemspec

@@ -0,0 +1,9 @@
+Gem::Specification.new do |s|
+  s.name        = "admiral-tools-figma"
+  s.authors     = ["Admiral team"]
+  s.version = "0.0.1"
+  s.homepage = "https://github.com/admiral-team"
+  s.description = "The tool to download figma icons"
+  s.files = Dir['**/*']
+  s.summary = "The tool to download figma icons"
+end

data/admiraltools/actions/figma_download_images.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'fastlane/action'
+require_relative '../helper/admiraltools_helper'
+require_relative '../helper/figma/figma_image_downloader/figma_image_downloader'
+
+module Fastlane
+  module Actions
+    class FigmaDownloadImagesAction < Action
+      def self.run(params)
+        image_components_json = params[:image_components]
+        output_folder = params[:output_folder]
+        output_format = params[:output_format]
+        folder_depth = params[:folder_depth]
+        naming_style = params[:naming_style]
+        xcassets_params = params[:xcassets_params]
+        convert_svg_to_vector = params[:convert_svg_to_vector]
+        convert_scales_to_dpi = params[:convert_scales_to_dpi]
+        include_page_name = params[:include_page_name]
+        include_frame_name = params[:include_frame_name]
+
+        image_components = ComponentsList.from_json(image_components_json).components || []
+        downloader = FigmaImageDownloader.new
+
+        image_params = DownloadImageParams.new(
+          image_components: image_components,
+          output_folder: output_folder,
+          folder_depth: folder_depth,
+          output_format: output_format,
+          naming_style: naming_style,
+          xcassets_params: xcassets_params,
+          convert_svg_to_vector: convert_svg_to_vector,
+          convert_scales_to_dpi: convert_scales_to_dpi,
+          include_page_name: include_page_name,
+          include_frame_name: include_frame_name
+        )
+
+        downloader.download_images(params: image_params)
+      end
+
+      def self.description
+        'Figma plugin'
+      end
+
+      def self.authors
+        ['ton252']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        'Figma plugin'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :image_components,
+                                       description: 'Image components json',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :output_folder,
+                                       description: 'Output folder path',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :output_format,
+                                       description: "Output type: #{FigmaImageDownloader::OUTPUT_FORMAT_XCASSETS}, #{FigmaImageDownloader::OUTPUT_FORMAT_RES}, #{FigmaImageDownloader::OUTPUT_FORMAT_RAW}",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :folder_depth,
+                                       description: 'Folder depth',
+                                       optional: true,
+                                       default_value: -1,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :naming_style,
+                                       description: "Image naming style: #{String::FORMAT_STYLE_CAMELCASE}, #{String::FORMAT_STYLE_SNAKECASE}, #{String::FORMAT_STYLE_KEBABCASE}",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :xcassets_params,
+                                       description: 'Xcassets parameters (template_rendering_intent, provides-namespace, preserves_vector_representation)',
+                                       optional: true,
+                                       type: Hash),
+          FastlaneCore::ConfigItem.new(key: :convert_svg_to_vector,
+                                       description: 'Convert svg images to Android vector',
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :convert_scales_to_dpi,
+                                       description: 'Convert scales to dpi',
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :include_page_name,
+                                       description: 'Include page name',
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :include_frame_name,
+                                       description: 'Include page name',
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false)
+        ]
+      end
+
+      def self.is_supported?(_platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/admiraltools/actions/figma_generate_styles.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fastlane/action'
+require_relative '../helper/admiraltools_helper'
+require_relative '../helper/figma/figma_template_generator/figma_template_generator'
+
+module Fastlane
+  module Actions
+    class FigmaGenerateStylesAction < Action
+      def self.run(params)
+        Actions.verify_gem!('liquid')
+
+        styles_json = params[:styles]
+        style_types = params[:style_types]
+        template_file = params[:template_file]
+        output_file = params[:output_file]
+
+        generator = FigmaTemplateGenerator.new
+        styles = StylesList.from_json(styles_json).styles
+
+        generator.generate(
+          styles: styles,
+          style_types: style_types,
+          template_path: template_file,
+          output_path: output_file
+        )
+      end
+
+      def self.description
+        'Figma plugin'
+      end
+
+      def self.authors
+        ['ton252']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        'Figma plugin'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :styles,
+                                       description: 'Figma styles list json',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :template_file,
+                                       description: 'Figma template liquid file path',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :output_file,
+                                       description: 'Figma output styles file path',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :style_types,
+                                       description: 'Figma style type filter [FILL, TEXT, EFFECT, GRID]',
+                                       optional: true,
+                                       type: Array)
+
+        ]
+      end
+
+      def self.is_supported?(_platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/admiraltools/actions/figma_get_image_links.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'fastlane/action'
+require_relative '../helper/admiraltools_helper'
+require_relative '../helper/figma/figma_client/figma_client'
+
+module Fastlane
+  module Actions
+    class FigmaGetImageLinksAction < Action
+      def self.run(params)
+        access_token = params[:access_token]
+        file_key = params[:file_key]
+        name_filter_regex = params[:name_filter_regex]
+        description_filter_regex = params[:description_filter_regex]
+        frame_filter_regex = params[:frame_filter_regex]
+        page_filter_regex = params[:page_filter_regex]
+        components_output_file = params[:output_file]
+        image_format = params[:format]
+        image_scales = params[:scales]
+        svg_include_id = params[:svg_include_id]
+        svg_simplify_stroke = params[:svg_simplify_stroke]
+        use_absolute_bounds = params[:use_absolute_bounds]
+        request_batch = params[:request_batch]
+        scales = ScaleFormatter.new.any_scales_to_scales(image_scales)
+
+        client = FigmaClient.new(access_token: access_token)
+
+        components_list = client.get_full_image_components(
+          file_key: file_key,
+          image_format: image_format,
+          scales: scales,
+          name_filter_regex: name_filter_regex,
+          desc_filter_regex: description_filter_regex,
+          frame_filter_regex: frame_filter_regex,
+          page_filter_regex: page_filter_regex,
+          svg_include_id: svg_include_id,
+          svg_simplify_stroke: svg_simplify_stroke,
+          use_absolute_bounds: use_absolute_bounds,
+          request_batch: request_batch
+        )
+
+        unless components_output_file.nil?
+          File.write_file_json(
+            hash: components_list.to_hash,
+            path: components_output_file,
+            create_directories: true
+          )
+        end
+
+        components_list
+      end
+
+      def self.description
+        'Figma plugin'
+      end
+
+      def self.authors
+        ['ton252']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        'Figma plugin'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :access_token,
+                                       description: 'Figma access token',
+                                       env_name: 'FIGMA_ACCESS_TOKEN',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :file_key,
+                                       env_name: 'FIGMA_FILE_KEY',
+                                       description: 'Figma file key',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :name_filter_regex,
+                                       description: 'Name filter regex',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :description_filter_regex,
+                                       description: 'Description filter regex',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :frame_filter_regex,
+                                       description: 'Frame filter regex',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :page_filter_regex,
+                                       description: 'Page filter regex',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :format,
+                                       description: 'Image output format, can be [jpg png svg pdf]',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :scales,
+                                       description: 'An array of number between 0.01 and 4, the image scaling factor. Example: ["0.5", "1", "2", "3"]',
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :request_batch,
+                                       description: 'Figma max request components batch',
+                                       default_value: 1_000_000,
+                                       optional: true,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :output_file,
+                                       description: 'Figma output component file path',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :svg_include_id,
+                                       description: 'Whether to include id attributes for all SVG elements. Default: false',
+                                       optional: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :svg_simplify_stroke,
+                                       description: 'Whether to simplify inside/outside strokes and use stroke attribute if possible instead of <mask>. Default: true',
+                                       optional: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :use_absolute_bounds,
+                                       description: 'If image use its bounds box',
+                                       default_value: true,
+                                       optional: true,
+                                       type: Boolean)
+        ]
+      end
+
+      def self.is_supported?(_platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/admiraltools/actions/figma_get_styles.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fastlane/action'
+require_relative '../helper/admiraltools_helper'
+require_relative '../helper/figma/figma_client/figma_client'
+
+module Fastlane
+  module Actions
+    class FigmaGetStylesAction < Action
+      def self.run(params)
+        Actions.verify_gem!('liquid')
+
+        access_token = params[:access_token]
+        file_key = params[:file_key]
+        styles_output_file = params[:output_file]
+        style_types = params[:style_types]
+        request_batch = params[:request_batch]
+
+        client = FigmaClient.new(access_token: access_token)
+        styles = client.get_full_styles(file_key: file_key, request_batch: request_batch) || []
+        styles = styles.select { |s| (style_types.nil? || style_types.include?(s.style_type)) }
+        styles_list = StylesList.new(styles: styles)
+
+        unless styles_output_file.nil?
+          File.write_file_json(
+            hash: styles_list.to_hash,
+            path: styles_output_file,
+            create_directories: true
+          )
+        end
+
+        styles_list
+      end
+
+      def self.description
+        'Figma plugin'
+      end
+
+      def self.authors
+        ['ton252']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        'Figma plugin'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :access_token,
+                                       description: 'Figma access token',
+                                       env_name: 'FIGMA_ACCESS_TOKEN',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :file_key,
+                                       env_name: 'FIGMA_FILE_KEY',
+                                       description: 'Figma file key',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :style_types,
+                                       description: 'Figma style type filter [FILL, TEXT, EFFECT, GRID]',
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :request_batch,
+                                       description: 'Figma max request components batch',
+                                       default_value: 1_000_000,
+                                       optional: true,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :output_file,
+                                       description: 'Figma output styles file path',
+                                       optional: true,
+                                       type: String)
+
+        ]
+      end
+
+      def self.is_supported?(_platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/admiraltools/helper/admiraltools_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?('UI')
+
+  module Helper
+    class AdmiraltoolsHelper
+      # class methods that you define here become available in your action
+      # as `Helper::AdmiraltoolsHelper.your_method`
+      #
+      def self.show_message
+        UI.message('Hello from the admiraltools plugin helpers!')
+      end
+    end
+  end
+end

data/admiraltools/helper/figma/figma_client/figma_client.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'json'
+require 'net/http'
+require_relative 'models/models'
+
+class FigmaClient
+  TOKEN_HEADER_NAME = 'X-FIGMA-TOKEN'
+  CONTENT_TYPE_HEADER_NAME = 'Content-Type'
+  CONTENT_TYPE_HEADER_VALUE = 'application/json'
+  BASE_URL_DEFAULT = 'https://api.figma.com/v1'
+
+  def initialize(access_token:, base_url: nil)
+    @access_token = access_token
+    @base_url = base_url || BASE_URL_DEFAULT
+  end
+
+  def get_full_image_components(
+    file_key:,
+    image_format:,
+    scales:,
+    name_filter_regex:,
+    desc_filter_regex: nil,
+    frame_filter_regex: nil,
+    page_filter_regex: nil,
+    request_batch: nil,
+    svg_include_id: nil,
+    svg_simplify_stroke: nil,
+    use_absolute_bounds: nil
+  )
+    converter = FigmaToDomainConverter.new
+    components_result = get_components(file_key: file_key)
+    figma_components = components_result&.meta&.components || []
+    scales = [1.0] if scales.nil? || scales.empty?
+
+    unless name_filter_regex.nil?
+      figma_components = figma_components.select { |c| c.name[Regexp.new(name_filter_regex)] }
+    end
+
+    unless desc_filter_regex.nil?
+      figma_components = figma_components.select { |c| c.description[Regexp.new(desc_filter_regex)] }
+    end
+
+    unless frame_filter_regex.nil?
+      figma_components = figma_components.select { |c| c.containing_frame&.name[Regexp.new(frame_filter_regex)] }
+    end
+
+    unless page_filter_regex.nil?
+      figma_components = figma_components.select { |c| c.containing_frame&.page_name[Regexp.new(page_filter_regex)] }
+    end
+
+    node_ids = figma_components.map(&:node_id)
+    node_id_batches = node_ids.each_slice(request_batch || 1_000_000).to_a
+    image_links_hash = {}
+
+    scales.each do |scale|
+      images_all = {}
+      node_id_batches.each do |batch_node_ids|
+        images = get_images(
+          file_key: file_key,
+          node_ids: batch_node_ids,
+          image_format: image_format,
+          scale: scale,
+          svg_include_id: svg_include_id,
+          svg_simplify_stroke: svg_simplify_stroke,
+          use_absolute_bounds: use_absolute_bounds
+        )&.images || {}
+        images_all.merge!(images)
+      end
+      image_links_hash[scale] = images_all
+    end
+
+    components = converter.fulfill_components(
+      figma_components: figma_components,
+      image_links_hash: image_links_hash,
+      image_format: image_format
+    )
+
+    ComponentsList.new(components: components)
+  end
+
+  def get_components(file_key:)
+    uri = URI.parse("#{@base_url}/files/#{file_key}/components")
+
+    req = create_request(uri)
+    http = create_http_client(uri)
+
+    res = http.start do |h|
+      h.request(req)
+    end
+
+    raise "HTTP Status Code: #{res.code}\n#{res.body}" unless res.is_a?(Net::HTTPSuccess)
+
+    json_data = JSON.parse(res.body)
+    FigmaComponentsStylesResult.from_hash(json_data)
+  end
+
+  def get_images(file_key:, node_ids:, image_format:, scale:, use_absolute_bounds:, svg_include_id:, svg_simplify_stroke:)
+    uri = URI.parse("#{@base_url}/images/#{file_key}")
+    params = {}
+    params['ids'] = node_ids.join(',')
+    params['format'] = image_format unless image_format.nil?
+    params['scale'] = scale unless scale.nil?
+    params['use_absolute_bounds'] = use_absolute_bounds unless use_absolute_bounds.nil?
+    params['svg_include_id'] = svg_include_id unless svg_include_id.nil?
+    params['svg_simplify_stroke'] = svg_simplify_stroke unless svg_simplify_stroke.nil?
+    add_query_parameters(uri: uri, params: params)
+
+    req = create_request(uri)
+    http = create_http_client(uri)
+
+    res = http.start do |h|
+      h.request(req)
+    end
+
+    raise "HTTP Status Code: #{res.code}\n#{res.body}" unless res.is_a?(Net::HTTPSuccess)
+
+    json_data = JSON.parse(res.body)
+    FigmaImagesResult.from_hash(json_data)
+  end
+
+  def get_full_styles(file_key:, request_batch:)
+    converter = FigmaToDomainConverter.new
+    styles_result = get_styles(file_key: file_key)
+    node_ids = (styles_result&.meta&.styles || []).map(&:node_id)
+    node_id_batches = node_ids.each_slice(request_batch || 1_000_000).to_a
+
+    nodes_result = FigmaNodesResult.new(name: nil, nodes: {})
+
+    node_id_batches.each do |batch_node_ids|
+      result = get_nodes(file_key: file_key, node_ids: batch_node_ids, depth: 1)
+      nodes_result.name = result.name
+      nodes_result.nodes.merge!(result.nodes)
+    end
+
+    converter.fulfill_styles(figma_nodes_result: nodes_result, figma_styles_result: styles_result)
+  end
+
+  def get_styles(file_key:)
+    uri = URI.parse("#{@base_url}/files/#{file_key}/styles")
+
+    req = create_request(uri)
+    http = create_http_client(uri)
+
+    res = http.start do |h|
+      h.request(req)
+    end
+
+    raise "HTTP Status Code: #{res.code}\n#{res.body}" unless res.is_a?(Net::HTTPSuccess)
+
+    json_data = JSON.parse(res.body)
+    FigmaComponentsStylesResult.from_hash(json_data)
+  end
+
+  def get_nodes(file_key:, node_ids:, depth: 1)
+    uri = URI.parse("#{@base_url}/files/#{file_key}/nodes")
+    node_ids_string = node_ids.join(',')
+    params = { "ids": node_ids_string, "depth": depth }
+    add_query_parameters(uri: uri, params: params)
+
+    req = create_request(uri)
+    http = create_http_client(uri)
+
+    res = http.start do |h|
+      h.request(req)
+    end
+
+    raise "HTTP Status Code: #{res.code}\n#{res.body}" unless res.is_a?(Net::HTTPSuccess)
+
+    json_data = JSON.parse(res.body)
+    FigmaNodesResult.from_hash(json_data)
+  end
+
+  private
+
+  def add_query_parameters(uri:, params:)
+    uri.query = URI.encode_www_form(URI.decode_www_form(uri.query || '').concat(params.to_a))
+  end
+
+  def create_request(uri)
+    req = Net::HTTP::Get.new(uri.request_uri.to_s)
+    req[CONTENT_TYPE_HEADER_NAME] = CONTENT_TYPE_HEADER_VALUE
+    req[TOKEN_HEADER_NAME] = @access_token
+    req
+  end
+
+  def create_http_client(uri)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http
+  end
+end

data/admiraltools/helper/figma/figma_client/models/api/primitives/figma_color.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class FigmaColor
+  attr_accessor :r, :g, :b, :a
+
+  def initialize(r:, g:, b:, a:)
+    @r = r
+    @g = g
+    @b = b
+    @a = a
+  end
+
+  def self.from_hash(hash)
+    return nil if hash.nil?
+
+    r = hash['r']
+    g = hash['g']
+    b = hash['b']
+    a = hash['a']
+
+    return FigmaColor.new(r: r, g: g, b: b, a: a) if !r.nil? && !g.nil? && !b.nil? && !a.nil?
+
+    nil
+  end
+
+  def to_hash
+    hash = {}
+    hash['r'] = r
+    hash['g'] = g
+    hash['b'] = b
+    hash['a'] = a
+
+    hash
+  end
+end