jekyll-uj-powertools 1.5.2 → 1.6.1

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)

data/lib/tags/translation_url.rb

@@ -0,0 +1,154 @@
+# Libraries
+require "jekyll"
+
+module Jekyll
+  class UJTranslationUrlTag < Liquid::Tag
+    def initialize(tag_name, markup, tokens)
+      super
+      @markup = markup.strip
+    end
+
+    def render(context)
+      # Parse arguments that can be quoted or unquoted
+      parts = parse_arguments(@markup)
+      
+      # Return root if no arguments
+      return '/' if parts.empty? || parts[0].nil?
+      
+      language_code_input = parts[0]
+      url_path_input = parts[1] || '/'
+
+      # Resolve language code (literal or variable)
+      language_code = resolve_argument_value(context, language_code_input)
+      # Resolve URL path (literal or variable)  
+      url_path = resolve_argument_value(context, url_path_input)
+
+      # Get site and translation config from context
+      site = context.registers[:site]
+      return '/' unless site
+
+      translation_config = site.config['translation'] || {}
+      default_language = translation_config['default'] || 'en'
+      available_languages = translation_config['languages'] || [default_language]
+      
+      # Validate that the requested language is available
+      unless available_languages.include?(language_code)
+        # Fall back to default language if requested language is not available
+        language_code = default_language
+      end
+      
+      # Normalize the URL path
+      normalized_path = normalize_path(url_path)
+      
+      # Generate the language-specific URL
+      generate_language_url(language_code, normalized_path, default_language)
+    end
+
+    private
+
+    def parse_arguments(markup)
+      # Parse arguments that can be quoted or unquoted
+      # Examples: 'es', '/pricing'  OR  language, page.canonical.path  OR  'es', page.url
+      args = []
+      current_arg = ''
+      in_quotes = false
+      quote_char = nil
+
+      markup.each_char.with_index do |char, i|
+        if !in_quotes && (char == '"' || char == "'")
+          # Start of quoted string - include the quote in the arg
+          in_quotes = true
+          quote_char = char
+          current_arg += char
+        elsif in_quotes && char == quote_char
+          # End of quoted string - include the quote in the arg
+          current_arg += char
+          in_quotes = false
+          quote_char = nil
+        elsif !in_quotes && char == ','
+          # Argument separator
+          args << current_arg.strip
+          current_arg = ''
+        else
+          # Regular character
+          current_arg += char
+        end
+      end
+
+      # Add the last argument
+      args << current_arg.strip if current_arg.strip.length > 0
+
+      args
+    end
+
+    def resolve_argument_value(context, argument_input)
+      return '' if argument_input.nil? || argument_input.empty?
+
+      # Check if the argument was originally quoted (literal string)
+      is_quoted = argument_input.match(/^['"].*['"]$/)
+
+      # If quoted, remove quotes and use as literal. Otherwise, try to resolve as variable
+      if is_quoted
+        # Remove quotes from literal string
+        resolved_value = argument_input[1..-2]
+      else
+        # Try to resolve as a variable
+        resolved_value = resolve_variable(context, argument_input)
+        # If variable resolved to nil, return empty string
+        return '' if resolved_value.nil?
+        # If it didn't resolve to a string, use the resolved value
+        resolved_value = resolved_value.to_s if resolved_value
+      end
+
+      resolved_value.to_s
+    end
+
+    def resolve_variable(context, variable_name)
+      parts = variable_name.split('.')
+      current = context
+
+      parts.each do |part|
+        if current.respond_to?(:[])
+          current = current[part]
+        elsif current.respond_to?(:key?) && current.key?(part)
+          current = current[part]
+        else
+          return nil
+        end
+        return nil if current.nil?
+      end
+
+      current
+    end
+
+    def normalize_path(path)
+      return '' if path.nil? || path.empty?
+      
+      # Remove leading slash for processing
+      clean_path = path.start_with?('/') ? path[1..-1] : path
+      
+      # Handle empty path (home page)
+      return '' if clean_path.empty?
+      
+      clean_path
+    end
+
+    def generate_language_url(language_code, normalized_path, default_language)
+      # If it's the default language, return the original path
+      if language_code == default_language
+        return normalized_path.empty? ? '/' : "/#{normalized_path}"
+      end
+
+      # For non-default languages, prefix with language code
+      if normalized_path.empty?
+        # Home page: /es
+        "/#{language_code}"
+      else
+        # Other pages: /es/pricing
+        "/#{language_code}/#{normalized_path}"
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('uj_translation_url', Jekyll::UJTranslationUrlTag)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-uj-powertools
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.1
 platform: ruby
 authors:
 - ITW Creative Works
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-16 00:00:00.000000000 Z
+date: 2025-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -72,6 +72,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -102,8 +116,19 @@ files:
 - lib/filters/main.rb
 - lib/generators/inject-properties.rb
 - lib/hooks/inject-properties.rb
+- lib/hooks/markdown-images.rb
 - lib/jekyll-uj-powertools.rb
-- lib/tags/ifistruthy.rb
+- lib/tags/fake_comments.rb
+- lib/tags/icon.rb
+- lib/tags/iffalsy.rb
+- lib/tags/iftruthy.rb
+- lib/tags/image.rb
+- lib/tags/language.rb
+- lib/tags/member.rb
+- lib/tags/post.rb
+- lib/tags/readtime.rb
+- lib/tags/social.rb
+- lib/tags/translation_url.rb
 homepage: https://github.com/itw-creative-works/jekyll-uj-powertools
 licenses:
 - MIT