Class: UtilityPalettes::Palettes

Inherits:
Object
  • Object
show all
Defined in:
lib/utility_palettes/palettes.rb

Class Method Summary collapse

Class Method Details

.colourize_values(basic_hash) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/utility_palettes/palettes.rb', line 61

def self.colourize_values(basic_hash)
  colourized_hash = {}

  basic_hash.each do |label, colour|
    begin
      if colour.is_a?(String) && colour.start_with?('$')
        colour_ref_array = [colour]

        # if the colour label begins with $ then it is a reference to a different defined colour, so must be looked up in the main hash
        while colour_ref_array.last.is_a?(String) && colour_ref_array.last.start_with?('$')
          colour_ref = @combined_samples.dig(colour_ref_array.last.slice(1..-1))
          raise UtilityPalettes::Error, "Circular reference detected for colour '#{label}': #{colour_ref_array.join(' -> ')}" if colour_ref_array.include?(colour_ref)

          colour_ref_array << colour_ref
        end

        colourized_hash[label] = ColorConverters::Color.new(colour_ref)
      else
        colourized_hash[label] = ColorConverters::Color.new(colour)
      end

      # TODO
      # provide a name if the label is left blank
      # if label.to_s == '$blank'
      #   hash[colourized_hash[label].name] = hash.delete(label)
      #   puts "Blank colour #{colour} has been given the name: #{colourized_hash[label].name}"
      # end
    rescue UtilityPalettes::Error => e
      warn "Error processing colour #{label}: #{e.message}"
    rescue ColorConverters::InvalidColorError => e
      warn "Error processing colour #{label} with value #{colour}: #{e.message}"
    end
  end

  colourized_hash
end

.format_palette(generated_hash) ⇒ Object 



121
122
123
124
125
126
127
128
129
 
# File 'lib/utility_palettes/palettes.rb', line 121

def self.format_palette(generated_hash)
  configuration = UtilityPalettes.configuration

  generated_hash.transform_keys!(&:to_s)
  generated_hash.transform_keys! { |key| configuration.output_prefix + key } if configuration.output_prefix.present?
  generated_hash.transform_keys! { |key| key + configuration.output_suffix } if configuration.output_suffix.present?

  generated_hash
end

.generate ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/utility_palettes/palettes.rb', line 5

def self.generate
  configuration = UtilityPalettes.configuration

  puts 'Generating utility palettes...'

  default_absolutes = configuration.use_default_absolutes == true ? UtilityPalettes::Defaults.absolutes : {}
  default_relatives = configuration.use_default_relatives == true ? UtilityPalettes::Defaults.relatives : {}
  default_singles = configuration.use_default_singles == true ? UtilityPalettes::Defaults.singles : {}

  puts 'Defined default palettes...'

  user_absolutes = configuration.absolutes
  user_relatives = configuration.relatives
  user_singles = configuration.singles

  puts 'Retrieved user palettes...'

  # merging should mean any user colours will overwrite default colours with the same key names
  combined_absolutes = default_absolutes.merge(user_absolutes)
  combined_relatives = default_relatives.merge(user_relatives)
  combined_singles = {}.merge(default_absolutes, user_absolutes, default_singles, user_singles)

  @combined_samples = combined_absolutes.merge(combined_relatives).merge(combined_singles)

  puts 'Merged palettes...'

  converted_absolutes = self.colourize_values(combined_absolutes)
  converted_relatives = self.colourize_values(combined_relatives)
  converted_singles = self.colourize_values(combined_singles)

  puts 'Converted palettes...'

  generated_absolutes = self.palette_looper(converted_absolutes, 'absolutes')
  generated_relatives = self.palette_looper(converted_relatives, 'relatives')
  generated_singles = converted_singles

  puts 'Generated utility palettes...'

  generated_palettes = {}.merge(generated_absolutes, generated_relatives, generated_singles)
  generated_palettes = self.format_palette(generated_palettes)
  output_palettes = UtilityPalettes::Outputs.generate(generated_palettes)

  filename = configuration.output_filename
  filename += "-#{Time.zone.now.strftime('%Y%m%d-%H%M%S')}" if configuration.output_dated == true

  output_files = configuration.output_files.map(&:strip)

  UtilityPalettes::Outputs.json(filename, output_palettes) if output_files.include?('json')
  UtilityPalettes::Outputs.scss(filename, output_palettes) if output_files.include?('scss')
  UtilityPalettes::Outputs.css(filename, output_palettes) if output_files.include?('css')

  true
end

.palette_looper(colourized_hash, palette_type) ⇒ Object

? Multiple Colour's Palette a function to loop through a map of colours and create absolute or relative palettes for them all and collect this into a single map



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/utility_palettes/palettes.rb', line 103

def self.palette_looper(colourized_hash, palette_type)
  looped_generated_palettes = {}

  colourized_hash.each do |label, base_colour|
    # create a palette for a single colour from the providing mapping
    if palette_type == 'absolutes'
      generated_swatches = UtilityPalettes::Swatch.absolute_generator(label, base_colour)
    elsif palette_type == 'relatives'
      generated_swatches = UtilityPalettes::Swatch.relative_generator(label, base_colour)
    end

    # merge the colours absolute palette into the collective mapping
    looped_generated_palettes.merge!(generated_swatches)
  end

  looped_generated_palettes
end