scriptorium 0.0.3 → 0.7.2

data/lib/scriptorium/helpers.rb

@@ -0,0 +1,675 @@
+# Path magic
+
+module PathSep
+  def /(right)
+    s1 = self.to_s.dup
+    s2 = right.to_s.dup
+    s1 << "/" unless s1.end_with?("/") || s2.start_with?("/")
+    path = s1 + s2
+    path.gsub!("//", "/")
+    path
+  end
+end
+
+String.include(PathSep)
+Symbol.include(PathSep)
+
+## Helpers
+
+module Scriptorium::Helpers
+  include Scriptorium::Exceptions
+  
+  # Post comparison for sorting (uses post.date which handles fallback)
+  def post_compare(a, b)
+    # Primary sort: date (newest first)
+    date_compare = b.date <=> a.date
+    return date_compare unless date_compare == 0
+    
+    # Secondary sort: post number (ascending) for stable ordering when dates are identical
+    a.num <=> b.num
+  end
+  
+  def getvars(file)
+    lines = read_file(file, lines: true)
+    lines.map! {|line| line.sub(/# .*$/, "").strip }
+    lines.reject! {|line| line.empty? }
+    vhash = Hash.new("")
+    lines.each do |line|
+      var, val = line.split(" ", 2)
+      # Fix: treat nil values as empty strings
+      val = "" if val.nil?
+      vhash[var.to_sym] = val
+    end
+    vhash
+  end
+
+  def d4(num)
+    "%04d" % num
+  end
+
+  def view_dir(name)
+    @root/:views/name
+  end
+
+  def write_file(file, content, empty: false)
+    # Input validation
+                raise FilePathNil if file.nil?
+
+        raise FilePathEmpty if file.to_s.strip.empty?
+    
+    # Handle empty content if empty: true is specified
+    if empty && (content.nil? || content.to_s.strip.empty?)
+      # If file exists, do nothing; if it doesn't exist, touch it
+      unless File.exist?(file)
+        FileUtils.mkdir_p(File.dirname(file))
+        FileUtils.touch(file)
+      end
+      return
+    end
+    
+    # Ensure parent directory exists
+    FileUtils.mkdir_p(File.dirname(file))
+    
+    # Write the file with error handling
+    begin
+      File.open(file, "w") do |f|
+        f.puts content
+      end
+    rescue Errno::ENOSPC => e
+              raise FileDiskFull(file, e.message)
+    rescue Errno::EACCES => e
+              raise FilePermissionDenied(file, e.message)
+    rescue Errno::ENOENT => e
+              raise FileDirectoryNotFound(file, e.message)
+    rescue => e
+      raise WriteFileError(file, e.message)
+    end
+  end
+
+  def write_file!(file, *lines, empty: false)
+    # Convert nil values to empty strings for proper joining
+    processed_lines = lines.map { |line| line.nil? ? "" : line.to_s }
+    content = processed_lines.join("\n")
+    # Always add a newline at the end to ensure there's an empty line
+    content += "\n"
+    write_file(file, content, empty: empty)
+  end
+
+  def make_dir(dir, create_parents = false)
+    # Input validation
+        raise DirectoryPathNil if dir.nil?
+
+    raise DirectoryPathEmpty if dir.to_s.strip.empty?
+    
+    # Create parent directories if requested
+    if create_parents
+      FileUtils.mkdir_p(dir)
+    else
+      # Create single directory with error handling
+      begin
+        Dir.mkdir(dir)
+      rescue Errno::ENOSPC => e
+        raise DirectoryDiskFull(dir, e.message)
+      rescue Errno::EACCES => e
+        raise DirectoryPermissionDenied(dir, e.message)
+      rescue Errno::ENOENT => e
+        raise DirectoryParentNotFound(dir, e.message)
+      rescue Errno::EEXIST => e
+        # Directory already exists - this is usually not an error
+        # But we could make this configurable if needed
+      rescue => e
+        raise CreateDirectoryError(dir, e.message)
+      end
+    end
+  end
+
+  def system!(command, description = nil)
+    # Input validation
+        raise CommandNil if command.nil?
+
+    raise CommandEmpty if command.to_s.strip.empty?
+    
+    # Execute command with error handling
+    success = system(command)
+    
+    unless success
+      desc = description ? " (#{description})" : ""
+      raise CommandFailedWithDesc(desc, command)
+    end
+    
+    success
+  end
+
+  def need(type, path, exception_class = RuntimeError)
+    # Input validation
+        raise RequirePathNil(type) if path.nil?
+
+    raise RequirePathEmpty(type) if path.to_s.strip.empty?
+    
+    # Check if file/directory exists
+    exists = case type
+             when :file
+               File.exist?(path)
+             when :dir
+               Dir.exist?(path)
+             else
+               raise InvalidType(type)
+             end
+    
+    unless exists
+      raise RequiredFileNotFound(type, path) if exception_class == RuntimeError
+      
+      # Exception class - try to call it as a method first, then as constructor
+      raise exception_class.call(path) if exception_class.respond_to?(:call)
+      raise exception_class.new(path)
+    end
+    
+    path
+  end
+
+  def read_file(file, options = {})
+    # Input validation
+        raise ReadFilePathNil if file.nil?
+
+    raise ReadFilePathEmpty if file.to_s.strip.empty?
+    
+    # Handle missing file with fallback
+    if options[:missing_fallback]
+      return options[:missing_fallback] unless File.exist?(file)
+    end
+    
+    # Read the file with error handling
+    begin
+      if options[:lines]
+        # Read as lines
+        if options[:chomp]
+          File.readlines(file, chomp: true)
+        else
+          File.readlines(file)
+        end
+      else
+        # Read as content
+        File.read(file)
+      end
+    rescue Errno::ENOENT => e
+      if options[:missing_fallback]
+        return options[:missing_fallback]
+      else
+        raise ReadFileNotFound(file, e.message)
+      end
+    rescue Errno::EACCES => e
+              raise ReadFilePermissionDenied(file, e.message)
+    rescue => e
+              raise ReadFileError(file, e.message)
+    end
+  end
+
+
+
+  def change_config(file_path, target_key, new_value)
+    pattern = /
+      ^(?<leading>\s*#{Regexp.escape(target_key)}\s+)  # key and spacing
+      (?<old_value>[^\#]*?)                            # value (non-greedy up to comment)
+      (?<trailing>\s*)                                 # trailing space
+      (?<comment>\#.*)?$                               # optional comment
+    /x
+  
+    lines = read_file(file_path, lines: true)
+    updated_lines = lines.map do |line|
+      if match = pattern.match(line)
+        leading  = match[:leading]
+        trailing = match[:trailing]
+        comment  = match[:comment] || ''
+        "#{leading}#{new_value}#{trailing}#{comment}\n"
+      else
+        line
+      end
+    end
+  
+    write_file(file_path, updated_lines.join)
+  end
+  
+  def slugify(id, title)
+    return "#{d4(id)}-untitled" if title.nil? || title.strip.empty?
+    
+    slug = title.downcase.strip
+               .gsub(/[^a-z0-9\s_-]/, '')  # remove punctuation
+               .gsub(/[\s_-]+/, '-')       # replace spaces and underscores with hyphen
+               .gsub(/^-+|-+$/, '')        # trim leading/trailing hyphens
+    "#{d4(id)}-#{slug}"
+  end
+
+  def clean_slugify(title)
+    return "title-is-missing" if title.nil?
+    
+    slug = title.downcase.strip
+               .gsub(/[^a-z0-9\s_-]/, '')  # remove punctuation
+               .gsub(/[\s_-]+/, '-')       # replace spaces and underscores with hyphen
+               .gsub(/^-+|-+$/, '')        # trim leading/trailing hyphens
+    slug
+  end
+  
+  def ymdhms
+    Time.now.strftime("%Y-%m-%d %H:%M:%S")
+  end
+  
+  def ymdhms_filename
+    Time.now.strftime("%Y%m%d-%H%M%S")
+  end
+
+  def see_file(file)   # Really from TestHelpers
+    puts "----- File: #{file}"
+    system!("cat #{file}", "displaying file contents")
+    puts "-----"
+  end
+
+  def see(label, var)
+    puts "#{label} = \n<<<\n#{var}\n>>>"
+  end
+
+  def make_tree(base, text)
+    lines = text.split("\n").map(&:chomp)
+    lines.each {|line| line.gsub!(/ *#.*$/, "") }
+    entries = []
+  
+    # Always throw away the first line (for backward compatibility)
+    lines.shift
+    
+    # Create the base directory and start stack there
+    make_dir(base) unless File.exist?(base)
+    stack = [base]
+  
+    # Parse all lines as structure
+    lines.each do |line|
+      if (i = line.index(/ [a-zA-Z0-9_.]/))
+        name = line[(i + 1)..-1]
+        level = i / 4
+      else
+        name = line.strip
+        level = 0
+      end
+      entries << [level, name]
+    end
+  
+    entries.each do |level, name|
+      stack = stack[0..level]
+      full_path = File.join(stack.last, name)
+  
+      if name.end_with?("/")
+        make_dir(full_path) unless File.exist?(full_path)
+        stack << full_path
+      else
+        write_file(full_path, "Empty file generated at #{Time.now}")
+      end
+    end
+  end            
+
+  def substitute(obj, text)
+    vars = obj.is_a?(Hash) ? obj : obj.vars
+    text % vars
+  end
+
+  def escape_html(str)
+    str.gsub(/&/, '&amp;')
+       .gsub(/</, '&lt;')
+       .gsub(/>/, '&gt;')
+       .gsub(/"/, '&quot;')
+       .gsub(/'/, '&#39;')
+  end
+  
+  def read_commented_file(file_path)
+    return [] unless File.exist?(file_path)
+    lines = read_file(file_path, lines: true)  # Read file and remove newline characters
+    lines.reject! do |line|    # Remove empty lines and comments
+      line.strip.empty? || line.strip.start_with?("#")
+    end
+    lines.map! do |line|       # Strip trailing comments + preceding spaces
+      line.sub(/# .*$/, "").strip  
+    end
+    lines  # Return cleaned lines
+  end
+
+  def parse_commented_file(file_path)
+    config = {}
+    read_commented_file(file_path).each do |line|
+      if line.include?(' ')
+        key, value = line.split(/\s+/, 2)
+        config[key] = config[key.to_sym] = value
+      end
+    end
+    config
+  end
+      
+  def cf_time(t1, t2)
+    t1 = t1.split(/- :/, 6)
+    t2 = t2.split(/- :/, 6)
+    t1 = Time.new(*t1)
+    t2 = Time.new(*t2)
+    t1 <=> t2
+  end
+
+  # Post state management helpers
+  
+  def read_post_state_file(file_path)
+    return [] unless File.exist?(file_path)
+    content = read_file(file_path)
+    return [] if content.strip.empty?
+    content.lines.map { |line| line.strip.to_i }.reject { |id| id == 0 }
+  end
+  
+  def write_post_state_file(file_path, post_ids)
+    if post_ids.empty?
+      # Write empty file (empty = all posts are in that state)
+      # For state files, empty means "all posts are in this state", so we need to clear the file
+      write_file(file_path, "")
+    else
+      content = post_ids.sort.uniq.join("\n") + "\n"
+      write_file(file_path, content)
+    end
+  end
+  
+  def add_post_to_state_file(file_path, post_id)
+    post_ids = read_post_state_file(file_path)
+    post_ids << post_id unless post_ids.include?(post_id)
+    write_post_state_file(file_path, post_ids)
+  end
+  
+  def remove_post_from_state_file(file_path, post_id)
+    post_ids = read_post_state_file(file_path)
+    post_ids.delete(post_id)
+    write_post_state_file(file_path, post_ids)
+  end
+  
+  def post_in_state_file?(file_path, post_id)
+    post_ids = read_post_state_file(file_path)
+    post_ids.include?(post_id)
+  end
+
+  # Helper method to find asset recursively in a directory
+  def find_asset(base_dir, asset_name)
+    # First try exact path
+    exact_path = "#{base_dir}/#{asset_name}"
+    return exact_path if File.exist?(exact_path)
+    
+    # Then search recursively
+    Dir.glob("#{base_dir}/**/*").each do |file|
+      next unless File.file?(file)
+      next unless File.basename(file) == File.basename(asset_name)
+      return file
+    end
+    
+    nil
+  end
+
+  def get_asset_path(name)
+    if Scriptorium::Repo.testing
+      # Development/testing: Check dev_assets first, then local assets
+      dev_asset = find_asset("dev_assets", name)
+      return dev_asset if dev_asset
+      
+      local_asset = find_asset("assets", name)
+      return local_asset if local_asset
+      
+      raise AssetNotFound(name)
+    else  # Production
+      # Production: Check user assets first, then gem assets
+      
+      # Check user assets first (highest priority) - recursively
+      user_asset = find_asset("assets", name)
+      return user_asset if user_asset
+      
+      # Then check gem assets (fallback) - recursively
+      begin
+        gem_spec = Gem.loaded_specs['scriptorium']
+        if gem_spec
+          gem_asset = find_asset("#{gem_spec.full_gem_path}/assets", name)
+          return gem_asset if gem_asset
+        end
+      rescue => e
+        # If gem lookup fails, continue without gem assets
+      end
+      
+      # Asset not found
+      raise AssetNotFound(name)
+    end
+  end
+
+  def generate_missing_asset_svg(filename, width: 200, height: 150)
+    # Truncate filename if too long for display
+    display_name = filename.length > 20 ? filename[0..16] + "..." : filename
+    
+    # Generate SVG with broken image icon and filename
+    svg = <<~SVG
+      <svg width="#{width}" height="#{height}" xmlns="http://www.w3.org/2000/svg">
+        <!-- Background -->
+        <rect fill="#f8f9fa" stroke="#ddd" stroke-width="1" width="#{width}" height="#{height}" rx="4"/>
+        
+        <!-- Broken image icon -->
+        <g transform="translate(#{width/2}, #{height/2 - 20})">
+          <!-- Image frame -->
+          <rect x="-15" y="-10" width="30" height="20" fill="none" stroke="#999" stroke-width="1"/>
+          <!-- Broken corner -->
+          <path d="M 15 -10 L 25 -20 M 15 -10 L 25 0" stroke="#999" stroke-width="1" fill="none"/>
+          <!-- Image icon -->
+          <rect x="-12" y="-7" width="24" height="14" fill="#e9ecef"/>
+          <circle cx="-5" cy="-2" r="2" fill="#999"/>
+          <polygon points="-8,8 -2,2 2,6 8,0" fill="#999"/>
+        </g>
+        
+        <!-- Filename -->
+        <text x="#{width/2}" y="#{height/2 + 15}" text-anchor="middle" fill="#666" font-family="Arial, sans-serif" font-size="11">
+          #{escape_html(display_name)}
+        </text>
+        
+        <!-- "Asset not found" message -->
+        <text x="#{width/2}" y="#{height/2 + 30}" text-anchor="middle" fill="#999" font-family="Arial, sans-serif" font-size="9">
+          Asset not found
+        </text>
+      </svg>
+    SVG
+    
+    svg.strip
+  end
+
+  def list_gem_assets
+    assets = []
+    gem_spec = Gem.loaded_specs['scriptorium']
+    if gem_spec
+      gem_assets_dir = "#{gem_spec.full_gem_path}/assets"
+      if Dir.exist?(gem_assets_dir)
+        Dir.glob("#{gem_assets_dir}/**/*").each do |file|
+          next unless File.file?(file)
+          relative_path = file.sub("#{gem_assets_dir}/", "")
+          assets << relative_path
+        end
+      end
+    end
+    assets.sort
+  rescue => e
+    # If gem lookup fails, return empty array
+    []
+  end
+
+  def copy_gem_asset_to_user(asset_name, target_dir = "assets")
+    gem_spec = Gem.loaded_specs['scriptorium']
+    if gem_spec
+      gem_asset_path = "#{gem_spec.full_gem_path}/assets/#{asset_name}"
+      if File.exist?(gem_asset_path)
+        # Create target directory if it doesn't exist
+        FileUtils.mkdir_p(target_dir) unless Dir.exist?(target_dir)
+        
+        # Copy the asset
+        target_path = "#{target_dir}/#{File.basename(asset_name)}"
+        FileUtils.cp(gem_asset_path, target_path)
+        return target_path
+      end
+    end
+    nil
+  rescue => e
+    # If gem lookup fails, return nil
+    nil
+  end
+
+  # Clipboard helper methods
+  def copy_to_clipboard(text)
+    begin
+      require 'clipboard'
+      Clipboard.copy(text)
+      true
+    rescue LoadError => e
+      # Fallback to system commands if clipboard gem not available
+      case RbConfig::CONFIG['host_os']
+      when /darwin/     # macOS
+        system("echo '#{text}' | pbcopy")
+      when /linux/      # Linux
+        system("echo '#{text}' | xclip -selection clipboard")
+      when /mswin|mingw|cygwin/  # Windows
+        system("echo '#{text}' | clip")
+      else
+        puts "Clipboard not supported on this OS"
+        false
+      end
+    rescue => e
+      puts "Failed to copy to clipboard: #{e.message}"
+      false
+    end
+  end
+
+  def get_from_clipboard
+    begin
+      require 'clipboard'
+      Clipboard.paste
+    rescue LoadError => e
+      # Fallback to system commands if clipboard gem not available
+      case RbConfig::CONFIG['host_os']
+      when /darwin/     # macOS
+        `pbpaste`
+      when /linux/      # Linux
+        `xclip -selection clipboard -o`
+      when /mswin|mingw|cygwin/  # Windows
+        `powershell -command "Get-Clipboard"`
+      else
+        puts "Clipboard not supported on this OS"
+        nil
+      end
+    rescue => e
+      puts "Failed to read from clipboard: #{e.message}"
+      nil
+    end
+  end
+
+  def tty(str)
+    File.open('/dev/tty', 'w') { |f| f.puts str }
+  end
+
+  def format_date(format, day = Time.now.to_date)
+    # Handle nil dates
+    return format if day.nil?
+    
+    # Handle string dates by parsing them
+    if day.is_a?(String)
+      begin
+        day = Date.parse(day)
+      rescue Date::Error
+        return format # Return original format if date is invalid
+      end
+    end
+    
+    # Parse the format string and replace tokens
+    result = format.dup
+    
+    # Month name vs number
+    result.gsub!(/\bmonth\b/, day.strftime("%B"))
+    result.gsub!(/\bmm\b/, day.strftime("%m"))
+    
+    # Day ordinal vs number - use smart padding
+    result.gsub!(/\bday\b/, ordinalize(day.day))
+    result.gsub!(/\bdd\b/) { smart_pad_day(day.day, result, $~.offset(0)[0]) }
+    
+    # Year formats
+    result.gsub!(/\byyyy\b/, day.strftime("%Y"))
+    result.gsub!(/\byy\b/, day.strftime("%y"))
+    
+    # Line breaks - handle spaces around break
+    result.gsub!(/\s+break\s+/, "<br>")
+    result.gsub!(/\s+break\b/, "<br>")
+    result.gsub!(/\bbreak\s+/, "<br>")
+    result.gsub!(/\bbreak\b/, "<br>")
+    
+    result
+  end
+
+  private
+
+  def smart_pad_day(day, format_string, position)
+    # Look at the context around the dd token to determine padding
+    before = format_string[0...position]
+    after = format_string[position + 2..-1] || ""
+    
+    # Check if we should pad based on context
+    should_pad = false
+    
+    # Rule 1: Initial number followed immediately by punctuation
+    if position == 0 && after.match?(/^[^a-zA-Z\s]/)
+      should_pad = true
+    end
+    
+    # Rule 2: Number enclosed in punctuation (before and after)
+    if before.match?(/[^a-zA-Z\s]$/) && after.match?(/^[^a-zA-Z\s]/)
+      should_pad = true
+    end
+    
+    # Rule 3: Terminal number preceded by punctuation
+    if after.empty? && before.match?(/[^a-zA-Z\s]$/)
+      should_pad = true
+    end
+    
+    # Rule 4: Middle number with spaces - don't pad
+    if before.match?(/\s$/) || after.match?(/^\s/)
+      should_pad = false
+    end
+    
+    should_pad ? day.to_s.rjust(2, '0') : day.to_s
+  end
+
+  def ordinalize(number)
+    case number % 100
+    when 11, 12, 13
+      "#{number}th"
+    else
+      case number % 10
+      when 1 then "#{number}st"
+      when 2 then "#{number}nd"
+      when 3 then "#{number}rd"
+      else "#{number}th"
+      end
+    end
+  end
+
+  def support_file(relative_path)
+    # Get the path to support files, handling both dev and gem environments
+    begin
+      gem_spec = Gem.loaded_specs['scriptorium']
+      if gem_spec
+        # Production: use gem path
+        "#{gem_spec.full_gem_path}/lib/scriptorium/support/#{relative_path}"
+      else
+        # Development: use project root (not current working directory)
+        project_root = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+        File.expand_path("lib/scriptorium/support/#{relative_path}", project_root)
+      end
+    rescue => e
+      # Fallback to development path if gem lookup fails
+      project_root = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+      File.expand_path("lib/scriptorium/support/#{relative_path}", project_root)
+    end
+  end
+
+  def support_data(relative_path)
+    read_file(support_file(relative_path))
+  end
+
+  def copy_support_file(relative_path, target_path)
+    FileUtils.cp(support_file(relative_path), target_path)
+  end
+end