jekyll_patternbot 0.12.0

data/_plugins/jekyll_patternbot/generators/user_patterns.rb

@@ -0,0 +1,57 @@
+module JekyllPatternbot
+
+  class UserPatternsGenerator < Jekyll::Generator
+    priority :normal
+
+    def initialize(site)
+      @site = site
+    end
+
+    def generate(site)
+      @site = site
+      @site.pages.concat patterns
+    end
+
+    def patterns
+      pats = []
+      PatternbotData[:patterns][:user].each do |pattern, data|
+        pats.concat pattern_pages(pattern, data)
+      end
+      pats
+    end
+
+    def pattern_pages(pattern, data)
+      pages = []
+      if data[:config].key? 'patterns' and not data[:config]['patterns'].nil?
+        data[:config]['patterns'].each do |subpattern, subdata|
+          pages.push to_page pattern, data, subpattern, subdata
+        end
+      end
+      pages
+    end
+
+    def to_page(pattern, data, subpattern, subdata)
+      source_dir = File.expand_path File.expand_path pattern, Config['patternbot']['source']
+      dir = Config['patternbot']['destination'] + '/patterns/' + pattern
+      html = Jekyll::PageWithoutAFile.new(@site, @site.source, dir, "#{subpattern}.html")
+      html.data['layout'] = 'patternbot_pattern_user'
+      html.data['title'] = PatternHelper.title pattern, subpattern, data, subdata
+      html.data['_PatternbotConfig'] = Config.with_indifferent_access
+      html.data['_PatternbotLocale'] = PatternbotLocale.with_indifferent_access
+      html.data['_PatternbotData'] = PatternbotData.with_indifferent_access
+      html.data['_pattern'] = pattern
+      html.data['_pattern_data'] = data.is_a?(Hash) ? data.with_indifferent_access : {}
+      html.data['_subpattern'] = subpattern
+      html.data['_subpattern_data'] = subdata.is_a?(Hash) ? subdata.with_indifferent_access : {}
+
+      unless File.file? File.expand_path "#{subpattern}.html", source_dir
+        PatternbotLogger.fatal "Patternbot cannot find the associated HTML file for the “#{subpattern}” pattern listed inside the “#{pattern}” config.yml file."
+      end
+
+      html.content = JekyllHelper.pattern_tag_with_data(pattern, subpattern, subdata.is_a?(Hash) ? subdata['fields'] : nil)
+      html
+    end
+
+  end
+
+end

data/_plugins/jekyll_patternbot/helpers/color.rb

@@ -0,0 +1,26 @@
+module JekyllPatternbot
+  class ColorHelper
+
+    def self.color(val)
+      the_color = val
+      if (val.match(/^\-\-/) and
+        PatternbotData.key? :css and
+        PatternbotData[:css].key? :theme and
+        PatternbotData[:css][:theme].key? :colors and
+        PatternbotData[:css][:theme][:colors].key? :raw and
+        PatternbotData[:css][:theme][:colors][:raw].key? val)
+        the_color = PatternbotData[:css][:theme][:colors][:raw][val]
+      end
+      if the_color.match? /^rgb/
+        rgb_bits = the_color.gsub(/[^\d,]/, '').split(/\,/)
+        the_color = [rgb_bits[0].to_i, rgb_bits[1].to_i, rgb_bits[2].to_i]
+      end
+      begin
+        return ColorContrastCalc.color_from the_color
+      rescue
+        return ColorContrastCalc.color_from 'black'
+      end
+    end
+
+  end
+end

data/_plugins/jekyll_patternbot/helpers/file.rb

@@ -0,0 +1,17 @@
+module JekyllPatternbot
+  module FileHelper
+
+    def self.strip(path)
+      path.sub "#{Config['patternbot']['source']}/", ''
+    end
+
+    def self.list_dirs(dir)
+      Dir.entries(dir).select { |entry| File.directory? File.join(dir, entry) and !(entry =='.' || entry == '..') }
+    end
+
+    def self.list_files_with_ext(dir, ext)
+      Dir.glob("#{dir}/**/*.#{ext}")
+    end
+
+  end
+end

data/_plugins/jekyll_patternbot/helpers/jekyll.rb

@@ -0,0 +1,60 @@
+module JekyllPatternbot
+  module JekyllHelper
+
+    def self._pattern_data_source_var_name(field)
+      "patternbot_temp_var_#{field['name']}"
+    end
+
+    def self._pattern_assign_tags(fields)
+      assign_tags = []
+      for field in fields
+        unless field['required'] == false
+          if field.key? 'data'
+            assign_tags.push "{% assign #{self._pattern_data_source_var_name(field)}=#{field['data']['source']} %}"
+          end
+        end
+      end
+      assign_tags
+    end
+
+    def self._pattern_include_fields(fields, datasource=false)
+      liquid_fields = []
+      for field in fields
+        unless field['required'] == false
+          if field.key? 'data'
+            if datasource
+              liquid_fields.push "#{field['name']}=#{self._pattern_data_source_var_name(field)}"
+            else
+              liquid_fields.push "#{field['name']}=#{field['data']['type']}"
+            end
+          end
+          if field.key? 'example'
+            liquid_fields.push "#{field['name']}=\"#{field['example']}\""
+          end
+        end
+      end
+      liquid_fields
+    end
+
+    def self._pattern_include(pattern, subpattern, fields)
+      extra_space = ' ' if fields.length > 0
+      "{% pattern #{pattern}/#{subpattern}#{extra_space}#{fields.join(' ')} %}"
+    end
+
+    def self.pattern_tag(pattern, subpattern, fields)
+      liquid_fields = []
+      liquid_fields = self._pattern_include_fields fields if fields
+      self._pattern_include pattern, subpattern, liquid_fields
+    end
+
+    def self.pattern_tag_with_data(pattern, subpattern, fields)
+      liquid_fields = []
+      liquid_fields = self._pattern_include_fields fields, true if fields
+      assign_tags = []
+      assign_tags = self._pattern_assign_tags fields if fields
+      assign_tags.concat [self._pattern_include(pattern, subpattern, liquid_fields)]
+      assign_tags.join
+    end
+
+  end
+end

data/_plugins/jekyll_patternbot/helpers/pattern.rb

@@ -0,0 +1,36 @@
+module JekyllPatternbot
+  module PatternHelper
+
+    def self.slug_to_words(slug)
+      slug.gsub(/[\-_]/, ' ').gsub(/\s+/, ' ')
+    end
+
+    def self.normalize_filename(filename)
+      return filename unless filename
+      if Config['permalink'].match? /pretty/ or not Config['permalink'].match? /\:output_ext/
+        if filename.match? /^index/
+          if filename.match? /\.html/
+            return filename
+          else
+            return "#{filename}.html"
+          end
+        else
+          return "#{filename.sub(/\.html/, '')}/index.html"
+        end
+      end
+      unless filename.match? /\.html/
+        return "#{filename}.html"
+      end
+      filename
+    end
+
+    def self.title(pattern, subpattern, data, subdata)
+      group_title = self.slug_to_words(pattern).unicode_titlecase
+      pattern_title = self.slug_to_words(subpattern).unicode_titlecase
+      group_title = data['title'] if data.is_a?(Hash) and data.key?('title')
+      pattern_title = subdata['title'] if subdata.is_a?(Hash) and subdata.key?('title')
+      "#{pattern_title} · #{group_title}"
+    end
+
+  end
+end

data/_plugins/jekyll_patternbot/hooks/pattern_lib.rb

@@ -0,0 +1,57 @@
+module JekyllPatternbot
+  PatternbotLogger = PatternbotConsoleLogger.new
+  PatternbotCache = {}
+  PatternbotData = {
+    :css => {},
+    :logos => false,
+    :icons => false,
+    :patterns => {},
+    :pages => [],
+  }
+
+  Jekyll::Hooks.register :site, :post_read do |site|
+    # File.open('/Users/thomasjbradley/Desktop/patternbot-config.json', 'w') do |f|
+    #   f.write(JSON.pretty_generate(Config))
+    # end
+
+    modulifier = ModulifierParser.new(Config['patternbot']['css']['modulifier'])
+    PatternbotData[:css][:modulifier] = modulifier.exists? ? modulifier.info : {}
+
+    gridifier = GridifierParser.new(Config['patternbot']['css']['gridifier'])
+    PatternbotData[:css][:gridifier] = gridifier.exists? ? gridifier.info : {}
+
+    typografier = TypografierParser.new(Config['patternbot']['css']['typografier'])
+    PatternbotData[:css][:typografier] = typografier.exists? ? typografier.info : {}
+
+    theme = ThemeParser.new(Config['patternbot']['css']['theme'])
+    PatternbotData[:css][:theme] = theme.exists? ? theme.info : {}
+
+    logos = LogosFinder.new(Config['patternbot']['logos'])
+    PatternbotData[:logos] = logos.exists? ? logos.info : {}
+
+    icon_files = IconsFinder.new(Config['patternbot']['icons'])
+    if icon_files.exists?
+      icons = IconsParser.new(Config['patternbot']['icons'], icon_files.info)
+      PatternbotData[:icons] = icons.info
+    else
+      PatternbotData[:icons] = []
+    end
+
+    pattern_files = PatternsFinder.new
+    PatternbotData[:patterns] = {
+      :internal => pattern_files.internal_patterns_info,
+      :user => pattern_files.user_patterns_info,
+    }
+
+    pages = SamplePagesFinder.new
+    PatternbotData[:pages] = pages.info
+
+    brand_processor = BrandProcessor.new.process
+    modules_processor = ModulesProcessor.new.process
+
+    # File.open('/Users/thomasjbradley/Desktop/patternbot.json', 'w') do |f|
+    #   f.write(JSON.pretty_generate(PatternbotData))
+    # end
+  end
+
+end

data/_plugins/jekyll_patternbot/loggers/patternbot.rb

@@ -0,0 +1,24 @@
+module JekyllPatternbot
+  class PatternbotConsoleLogger
+
+    def initialize
+      @logger = Logger.new STDERR
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        "PATTERNBOT — #{datetime}: #{msg}\n"
+      end
+    end
+
+    def fatal(msg)
+      @logger.fatal "⬣ #{msg}".red
+    end
+
+    def warn(msg)
+      @logger.warn "▲ #{msg}".yellow
+    end
+
+    def info(msg)
+      @logger.info "✔ #{msg}".green
+    end
+
+  end
+end

data/_plugins/jekyll_patternbot/parsers/css_color.rb

@@ -0,0 +1,54 @@
+module JekyllPatternbot
+  class CSSColorParser
+
+    def self.base
+      {
+        :primary => [],
+        :secondary => [],
+        :neutral => [],
+        :accent => [],
+        :raw => {},
+      }
+    end
+
+    def self.color
+      {
+        :name => nil,
+        :name_pretty => nil,
+        :raw => nil,
+        :hex => nil,
+        :rgba => nil,
+      }
+    end
+
+    def self.is_color?(dec)
+      !!dec.match(/\-\-color\-/)
+    end
+
+    def self.parse_color(dec, val)
+      parsed_color = ColorHelper::color val
+      color = self.color.clone
+      color[:name] = dec
+      color[:name_pretty] = PatternHelper.slug_to_words(dec.sub(/\-\-color\-/, '')).unicode_titlecase
+      color[:raw] = val
+      color[:hex] = parsed_color.hex.downcase
+      color[:rgba] = "rgba(#{parsed_color.rgb.join(', ')}, 1)"
+      color
+    end
+
+    def self.parse(data)
+      colors = self.base.clone
+      data.each do |dec, val|
+        if self.is_color? dec
+          colors[:primary].push(self.parse_color(dec, val)) if dec.match(/\-\-color\-primary/)
+          colors[:secondary].push(self.parse_color(dec, val)) if dec.match(/\-\-color\-secondary/)
+          colors[:neutral].push(self.parse_color(dec, val)) if dec.match(/\-\-color\-neutral/)
+          colors[:accent].push(self.parse_color(dec, val)) unless dec.match(/\-\-color\-(primary|secondary|neutral)/)
+          colors[:raw][dec] = val
+        end
+      end
+      colors
+    end
+
+  end
+end

data/_plugins/jekyll_patternbot/parsers/css_font.rb

@@ -0,0 +1,109 @@
+module JekyllPatternbot
+  class CSSFontParser
+
+    def self.base
+      {
+        :primary => false,
+        :secondary => false,
+        :accent => [],
+      }
+    end
+
+    def self.font
+      {
+        :name => nil,
+        :name_pretty => nil,
+        :css_name => nil,
+        :raw => nil,
+        :var => nil,
+        :weights => nil,
+      }
+    end
+
+    def self.font_weight
+      {
+        :css_name => nil,
+        :weight => 'normal',
+        :has_normal => false,
+        :has_italic => false,
+      }
+    end
+
+    def self.is_font?(dec)
+      !!dec.match(/\-\-font\-/)
+    end
+
+    def self.normalize_font_weight(font_weight)
+      font_weight_digits = font_weight.gsub /[^\d]/, ''
+      return 'normal' if font_weight_digits == '400'
+      return 'bold' if font_weight_digits == '700'
+    end
+
+    def self.rule_sets_to_weights(rulesets)
+      weights = {}
+      rulesets.each do |ruleset|
+        font_family = ruleset.get_value('font-family').gsub(/['";]/, '')
+        font_family_slug = font_family.to_slug.normalize.to_s
+        weights[font_family_slug] = {} unless weights.key? font_family_slug
+        font_weight = self.normalize_font_weight ruleset.get_value 'font-weight'
+        weights[font_family_slug][font_weight] = self.font_weight.clone unless weights[font_family_slug].key? font_weight
+        weights[font_family_slug][font_weight][:weight] = font_weight
+        weights[font_family_slug][font_weight][:css_name] = ruleset.get_value('font-family').gsub(/\;/, '').strip
+        weights[font_family_slug][font_weight][:has_normal] = true if ruleset.get_value('font-style').match /normal/ or ruleset.get_value('font-style').nil?
+        weights[font_family_slug][font_weight][:has_italic] = true if ruleset.get_value('font-style').match /italic/
+      end
+      weights
+    end
+
+    def self.parse_font_file(font_url)
+      if font_url
+        parser = CssParser::Parser.new
+        parser.load_uri!(font_url)
+        font_face_rulesets = parser.find_by_selector('@font-face').map { |rules| CssParser::RuleSet.new(nil, rules) }
+        return nil unless font_face_rulesets
+        return self.rule_sets_to_weights font_face_rulesets
+      else
+        return false
+      end
+    end
+
+    def self.parse_font(dec, val, available_weights)
+      font_family = val.match(/[^\,\;]*/)[0].gsub(/['"]/, '')
+      font_family_slug = font_family.to_slug.normalize.to_s
+      font = self.font.clone
+      font[:name] = font_family_slug
+      font[:name_pretty] = font_family
+      font[:raw] = val
+      font[:var] = dec
+      if available_weights and available_weights.key? font_family_slug
+        font[:weights] = available_weights[font_family_slug]
+        font[:css_name] = available_weights[font_family_slug].values[0][:css_name]
+      end
+      font
+    end
+
+    def self.parse(font_url, data)
+      unless PatternbotCache.key?(font_url)
+        if font_url != false
+          PatternbotLogger.warn("Patternbot downloaded CSS for fonts from the remote URL: #{font_url}")
+        end
+        fonts = self.base.clone
+        available_weights = self.parse_font_file(font_url)
+        data.each do |dec, val|
+          if self.is_font? dec
+            fonts[:primary] = self.parse_font(dec, val, available_weights) if dec.match(/\-\-font\-primary/)
+            fonts[:secondary] = self.parse_font(dec, val, available_weights) if dec.match(/\-\-font\-secondary/)
+            fonts[:accent].push self.parse_font(dec, val, available_weights) unless dec.match(/\-\-font\-(primary|secondary)/)
+          end
+        end
+        PatternbotCache[font_url] = fonts
+      else
+        if font_url != false
+          PatternbotLogger.info("Patternbot used a cached version of the font CSS originally located at: #{font_url}")
+        end
+      end
+      PatternbotCache[font_url]
+    end
+
+  end
+end