jekyll-uj-powertools 1.6.0 → 1.6.1

data/lib/tags/member.rb

@@ -0,0 +1,204 @@
+# Libraries
+require "jekyll"
+
+module Jekyll
+  class UJMemberTag < Liquid::Tag
+    def initialize(tag_name, markup, tokens)
+      super
+      @markup = markup.strip
+    end
+
+    def render(context)
+      # Parse arguments preserving quotes
+      args = parse_arguments_with_quotes(@markup)
+      member_input = args[0]
+      property_input = args[1] || "'name'"  # Default to name if no property specified
+
+      # Strip quotes from property if present
+      property = property_input.gsub(/^['"]|['"]$/, '')
+
+      # Check if the member input was originally quoted
+      is_quoted = member_input && member_input.match(/^['"]/)
+
+      # Resolve member ID
+      if is_quoted
+        # If quoted, strip quotes and use as literal
+        member_id = member_input.gsub(/^['"]|['"]$/, '')
+      else
+        # Otherwise resolve as variable
+        member_id = resolve_member_id(context, member_input)
+      end
+      return '' unless member_id
+
+      # Find member in site.team collection
+      site = context.registers[:site]
+      member = find_member(site, member_id)
+      return '' unless member
+
+      # Return the requested property
+      case property
+      when 'name'
+        (member.data['member'] && member.data['member']['name']) || ''
+      when 'url'
+        site_url = site.config['url'] || ''
+        site_url + member.url
+      when 'path'
+        member.url
+      when 'image'
+        member_id_clean = member.id.gsub('/team/', '')
+        "/assets/images/team/#{member_id_clean}/profile.jpg"
+      when 'image-tag'
+        # Generate image path
+        member_id_clean = member.id.gsub('/team/', '')
+        image_path = "/assets/images/team/#{member_id_clean}/profile.jpg"
+        
+        # Parse additional options for the image tag
+        image_options = parse_image_options(args[2..-1])
+        
+        # Set default alt text if not provided
+        if !image_options['alt'] && member.data['member'] && member.data['member']['name']
+          image_options['alt'] = member.data['member']['name']
+        end
+        
+        # Build the markup string for uj_image tag
+        image_markup = build_image_markup(image_path, image_options)
+        
+        # Parse and render the uj_image tag using Liquid template
+        template_content = "{% uj_image #{image_markup} %}"
+        template = Liquid::Template.parse(template_content)
+        template.render!(context)
+      else
+        # Try to access any other property dynamically
+        (member.data['member'] && member.data['member'][property]) || member.data[property] || ''
+      end
+    end
+
+    private
+
+    def parse_arguments_with_quotes(markup)
+      # Parse arguments preserving quotes for detection
+      args = []
+      current_arg = ''
+      in_quotes = false
+      quote_char = nil
+      
+      markup.each_char.with_index do |char, i|
+        if !in_quotes && (char == '"' || char == "'")
+          in_quotes = true
+          quote_char = char
+          current_arg += char
+        elsif in_quotes && char == quote_char
+          in_quotes = false
+          current_arg += char
+          quote_char = nil
+        elsif !in_quotes && char == ','
+          args << current_arg.strip
+          current_arg = ''
+        else
+          current_arg += char
+        end
+      end
+      
+      args << current_arg.strip if current_arg.strip.length > 0
+      args
+    end
+    
+    def parse_arguments(markup)
+      # Parse arguments that can be quoted or unquoted
+      args = []
+      current_arg = ''
+      in_quotes = false
+      quote_char = nil
+
+      markup.each_char.with_index do |char, i|
+        if !in_quotes && (char == '"' || char == "'")
+          in_quotes = true
+          quote_char = char
+        elsif in_quotes && char == quote_char
+          in_quotes = false
+          quote_char = nil
+        elsif !in_quotes && char == ','
+          args << current_arg.strip
+          current_arg = ''
+        else
+          current_arg += char
+        end
+      end
+
+      args << current_arg.strip if current_arg.strip.length > 0
+      args
+    end
+
+    def resolve_member_id(context, member_input)
+      if member_input.nil? || member_input.empty?
+        # No input, try default sources
+        page = context['page']
+        return nil unless page
+
+        if page['post'] && page['post']['member']
+          page['post']['member']
+        elsif page['member'] && page['member']['name']
+          page['id']
+        else
+          nil
+        end
+      else
+        # Resolve the variable
+        resolve_variable(context, member_input)
+      end
+    end
+
+    def resolve_variable(context, variable_name)
+      # Handle nested variable access
+      parts = variable_name.split('.')
+      current = context
+
+      parts.each do |part|
+        return nil unless current.respond_to?(:[]) || current.is_a?(Hash)
+        current = current[part]
+        return nil if current.nil?
+      end
+
+      current
+    end
+
+    def find_member(site, member_id)
+      return nil unless site.collections['team']
+
+      site.collections['team'].docs.find do |member|
+        member.id.include?(member_id.to_s)
+      end
+    end
+    
+    def parse_image_options(option_args)
+      options = {}
+      
+      option_args.each do |arg|
+        # Strip quotes if present
+        arg_clean = arg.gsub(/^['"]|['"]$/, '')
+        
+        if arg_clean.include?('=')
+          key, value = arg_clean.split('=', 2)
+          key = key.strip
+          value = value.strip.gsub(/^['"]|['"]$/, '')
+          options[key] = value
+        end
+      end
+      
+      options
+    end
+    
+    def build_image_markup(image_path, options)
+      # Build markup string in the format expected by uj_image tag
+      markup_parts = ["\"#{image_path}\""]
+      
+      options.each do |key, value|
+        markup_parts << "#{key}=\"#{value}\""
+      end
+      
+      markup_parts.join(', ')
+    end
+  end
+end
+
+Liquid::Template.register_tag('uj_member', Jekyll::UJMemberTag)

data/lib/tags/post.rb

@@ -0,0 +1,258 @@
+# Libraries
+require "jekyll"
+
+module Jekyll
+  class UJPostTag < Liquid::Tag
+    def initialize(tag_name, markup, tokens)
+      super
+      @markup = markup.strip
+    end
+
+    def render(context)
+      # Parse arguments
+      args = parse_arguments_with_quotes(@markup)
+      post_input = args[0]
+      property_input = args[1] || "'title'"  # Default to title if no property specified
+
+      # Strip quotes from property if present
+      property = property_input.gsub(/^['"]|['"]$/, '')
+
+      # Check if the post input was originally quoted
+      is_quoted = post_input && post_input.match(/^['"]/)
+
+      # Resolve post ID
+      if is_quoted
+        # If quoted, strip quotes and use as literal
+        post_id = post_input.gsub(/^['"]|['"]$/, '')
+      else
+        # Otherwise resolve as variable
+        post_id = resolve_post_id(context, post_input)
+      end
+      return '' unless post_id
+
+      # Find post in site collections
+      site = context.registers[:site]
+      post = find_post(site, post_id)
+      return '' unless post
+
+      # Return the requested property
+      case property
+      when 'title'
+        post.data['title'] || ''
+      when 'description'
+        post.data['description'] || post.data['excerpt'] || ''
+      when 'url'
+        site_url = site.config['url'] || ''
+        site_url + post.url
+      when 'path'
+        post.url
+      when 'image'
+        # Use the custom post.post.id if available, otherwise fall back to extracting from post.id
+        custom_id = (post.data['post'] && post.data['post']['id']) || post.id.gsub(/^\/(\w+)\//, '')
+        # Extract the slug from the Jekyll post ID
+        post_id_clean = post.id.gsub(/^\/(\w+)\//, '')
+        slug = post_id_clean.gsub(/^\d{4}-\d{2}-\d{2}-/, '')
+        "/assets/images/blog/post-#{custom_id}/#{slug}.jpg"
+      when 'date'
+        post.data['date'] ? post.data['date'].strftime('%Y-%m-%d') : ''
+      when 'author'
+        (post.data['post'] && post.data['post']['author']) || post.data['author'] || ''
+      when 'category'
+        post.data['category'] || post.data['categories']&.first || ''
+      when 'categories'
+        Array(post.data['categories']).join(', ')
+      when 'tags'
+        Array(post.data['tags']).join(', ')
+      when 'id'
+        post.id
+      when 'image-tag'
+        # Generate image path
+        # Use the custom post.post.id if available, otherwise fall back to extracting from post.id
+        custom_id = (post.data['post'] && post.data['post']['id']) || post.id.gsub(/^\/(\w+)\//, '')
+        # Extract the slug from the Jekyll post ID
+        post_id_clean = post.id.gsub(/^\/(\w+)\//, '')
+        slug = post_id_clean.gsub(/^\d{4}-\d{2}-\d{2}-/, '')
+        image_path = "/assets/images/blog/post-#{custom_id}/#{slug}.jpg"
+        
+        # Parse additional options for the image tag
+        image_options = parse_image_options(args[2..-1], context)
+        
+        # Set default alt text if not provided
+        if !image_options['alt']
+          # Try to get the title from post.post.title first, then fall back to post.title
+          default_alt = (post.data['post'] && post.data['post']['title']) || post.data['title']
+          image_options['alt'] = default_alt if default_alt
+        end
+        
+        # Build the markup string for uj_image tag
+        image_markup = build_image_markup(image_path, image_options)
+        
+        # Parse and render the uj_image tag using Liquid template
+        template_content = "{% uj_image #{image_markup} %}"
+        template = Liquid::Template.parse(template_content)
+        template.render!(context)
+      else
+        # Try to access any other property dynamically
+        (post.data['post'] && post.data['post'][property]) || post.data[property] || ''
+      end
+    end
+
+    private
+
+    def parse_arguments_with_quotes(markup)
+      # Parse arguments preserving quotes for detection
+      args = []
+      current_arg = ''
+      in_quotes = false
+      quote_char = nil
+      
+      markup.each_char.with_index do |char, i|
+        if !in_quotes && (char == '"' || char == "'")
+          in_quotes = true
+          quote_char = char
+          current_arg += char
+        elsif in_quotes && char == quote_char
+          in_quotes = false
+          current_arg += char
+          quote_char = nil
+        elsif !in_quotes && char == ','
+          args << current_arg.strip
+          current_arg = ''
+        else
+          current_arg += char
+        end
+      end
+      
+      args << current_arg.strip if current_arg.strip.length > 0
+      args
+    end
+    
+    def parse_arguments(markup)
+      # Parse arguments that can be quoted or unquoted
+      args = []
+      current_arg = ''
+      in_quotes = false
+      quote_char = nil
+
+      markup.each_char.with_index do |char, i|
+        if !in_quotes && (char == '"' || char == "'")
+          in_quotes = true
+          quote_char = char
+        elsif in_quotes && char == quote_char
+          in_quotes = false
+          quote_char = nil
+        elsif !in_quotes && char == ','
+          args << current_arg.strip
+          current_arg = ''
+        else
+          current_arg += char
+        end
+      end
+
+      args << current_arg.strip if current_arg.strip.length > 0
+      args
+    end
+
+    def resolve_post_id(context, post_input)
+      if post_input.nil? || post_input.empty?
+        # No input, use current page if it's a post
+        page = context['page']
+        return nil unless page
+
+        # Check if current page is a post
+        if page['post'] || page['collection'] == 'posts'
+          page['id']
+        else
+          nil
+        end
+      else
+        # Resolve the variable
+        resolve_variable(context, post_input)
+      end
+    end
+
+    def resolve_variable(context, variable_name)
+      # Handle nested variable access
+      parts = variable_name.split('.')
+      current = context
+
+      parts.each do |part|
+        return nil unless current.respond_to?(:[]) || current.is_a?(Hash)
+        current = current[part]
+        return nil if current.nil?
+      end
+
+      current
+    end
+
+    def find_post(site, post_id)
+      post_id_clean = post_id.to_s.strip
+      
+      # Search in posts collection first
+      if site.collections['posts']
+        post = site.collections['posts'].docs.find do |doc|
+          # Check standard ID match
+          doc.id == post_id_clean || 
+          doc.id.include?(post_id_clean) ||
+          # Also check if the post has a custom post.id field that matches
+          (doc.data['post'] && doc.data['post']['id'] == post_id_clean)
+        end
+        return post if post
+      end
+
+      # Search in other collections that might contain posts  
+      site.collections.each do |name, collection|
+        next if name == 'posts'  # Already checked
+
+        post = collection.docs.find do |doc|
+          (doc.id == post_id_clean || 
+           doc.id.include?(post_id_clean) ||
+           # Check custom post.id field
+           (doc.data['post'] && doc.data['post']['id'] == post_id_clean)) && 
+          doc.data['post']
+        end
+        return post if post
+      end
+
+      nil
+    end
+    
+    def parse_image_options(option_args, context)
+      options = {}
+      
+      option_args.each do |arg|
+        if arg.include?('=')
+          key, value = arg.split('=', 2)
+          key = key.strip
+          
+          # Check if the value is quoted (literal) or unquoted (variable)
+          if value.strip.match(/^['"].*['"]$/)
+            # It's a literal string, strip quotes
+            value = value.strip.gsub(/^['"]|['"]$/, '')
+          else
+            # It's a variable, resolve it
+            resolved_value = resolve_variable(context, value.strip)
+            value = resolved_value || value.strip
+          end
+          
+          options[key] = value
+        end
+      end
+      
+      options
+    end
+    
+    def build_image_markup(image_path, options)
+      # Build markup string in the format expected by uj_image tag
+      markup_parts = ["\"#{image_path}\""]
+      
+      options.each do |key, value|
+        markup_parts << "#{key}=\"#{value}\""
+      end
+      
+      markup_parts.join(', ')
+    end
+  end
+end
+
+Liquid::Template.register_tag('uj_post', Jekyll::UJPostTag)

data/lib/tags/readtime.rb

@@ -0,0 +1,73 @@
+# Libraries
+require "jekyll"
+
+module Jekyll
+  class UJReadtimeTag < Liquid::Tag
+    def initialize(tag_name, markup, tokens)
+      super
+      @markup = markup.strip
+    end
+
+    def render(context)
+      # Get the content to analyze
+      content = resolve_content(context)
+      return '1' unless content
+      
+      # Strip HTML tags
+      stripped_content = strip_html(content)
+      
+      # Count words
+      words = count_words(stripped_content)
+      
+      # Calculate readtime (200 words per minute, minimum 1 minute)
+      readtime = (words / 200.0).ceil
+      readtime = 1 if readtime < 1
+      
+      readtime.to_s
+    end
+    
+    private
+    
+    def resolve_content(context)
+      if @markup.empty?
+        # No argument, use page content
+        page = context['page']
+        return nil unless page
+        page['content']
+      else
+        # Resolve the variable name
+        resolve_variable(context, @markup)
+      end
+    end
+    
+    def resolve_variable(context, variable_name)
+      # Handle nested variable access like page.content or include.content
+      parts = variable_name.split('.')
+      current = context
+      
+      parts.each do |part|
+        return nil unless current.respond_to?(:[]) || current.is_a?(Hash)
+        current = current[part]
+        return nil if current.nil?
+      end
+      
+      current
+    end
+    
+    def strip_html(content)
+      # Remove HTML tags
+      content = content.to_s.gsub(/<script.*?<\/script>/m, '')
+      content = content.gsub(/<style.*?<\/style>/m, '')
+      content = content.gsub(/<[^>]+>/, ' ')
+      content = content.gsub(/\s+/, ' ')
+      content.strip
+    end
+    
+    def count_words(text)
+      # Count words (split by whitespace)
+      text.split(/\s+/).length
+    end
+  end
+end
+
+Liquid::Template.register_tag('uj_readtime', Jekyll::UJReadtimeTag)

data/lib/tags/social.rb

@@ -0,0 +1,84 @@
+# Libraries
+require "jekyll"
+
+module Jekyll
+  class UJSocialTag < Liquid::Tag
+    # Social platform URL patterns
+    SOCIAL_URLS = {
+      'facebook' => 'https://facebook.com/%s',
+      'twitter' => 'https://twitter.com/%s',
+      'linkedin' => 'https://linkedin.com/in/%s',
+      'youtube' => 'https://youtube.com/@%s',
+      'instagram' => 'https://instagram.com/%s',
+      'tumblr' => 'https://%s.tumblr.com',
+      'slack' => 'https://%s.slack.com',
+      'discord' => 'https://discord.gg/%s',
+      'github' => 'https://github.com/%s',
+      'dev' => 'https://dev.to/%s',
+      'tiktok' => 'https://tiktok.com/@%s',
+      'twitch' => 'https://twitch.tv/%s',
+      'soundcloud' => 'https://soundcloud.com/%s',
+      'spotify' => 'https://open.spotify.com/user/%s',
+      'mixcloud' => 'https://mixcloud.com/%s'
+    }
+    
+    def initialize(tag_name, markup, tokens)
+      super
+      @markup = markup.strip
+    end
+
+    def render(context)
+      # Parse the platform name (can be quoted or unquoted)
+      platform_input = parse_argument(@markup)
+      
+      # Resolve the platform name (could be a variable or literal string)
+      platform = resolve_variable(context, platform_input)
+      
+      # If it didn't resolve to anything, use the input as a literal string
+      platform = platform_input if platform.nil? || platform.empty?
+      
+      # Get the social handle from page.resolved.socials.{platform}
+      page = context['page']
+      return '' unless page
+      
+      social_handle = page['resolved'] && page['resolved']['socials'] && page['resolved']['socials'][platform]
+      return '' unless social_handle && !social_handle.empty?
+      
+      # Get the URL pattern for this platform
+      url_pattern = SOCIAL_URLS[platform]
+      return '' unless url_pattern
+      
+      # Build the URL
+      url_pattern % social_handle
+    end
+    
+    private
+    
+    def parse_argument(markup)
+      # Remove quotes if present
+      cleaned = markup.strip
+      if (cleaned.start_with?('"') && cleaned.end_with?('"')) ||
+         (cleaned.start_with?("'") && cleaned.end_with?("'"))
+        cleaned[1..-2]
+      else
+        cleaned
+      end
+    end
+    
+    def resolve_variable(context, variable_name)
+      # Handle nested variable access like page.social
+      parts = variable_name.split('.')
+      current = context
+      
+      parts.each do |part|
+        return nil unless current.respond_to?(:[]) || current.is_a?(Hash)
+        current = current[part]
+        return nil if current.nil?
+      end
+      
+      current
+    end
+  end
+end
+
+Liquid::Template.register_tag('uj_social', Jekyll::UJSocialTag)