scriptorium 0.6.1 → 0.7.2

data/lib/scriptorium/helpers.rb

@@ -18,6 +18,17 @@ Symbol.include(PathSep)
 
 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 }
@@ -25,6 +36,8 @@ module Scriptorium::Helpers
     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
@@ -38,11 +51,21 @@ module Scriptorium::Helpers
     @root/:views/name
   end
 
-  def write_file(file, content)
+  def write_file(file, content, empty: false)
     # Input validation
-    raise CannotWriteFilePathNil if file.nil?
+                raise FilePathNil if file.nil?
+
+        raise FilePathEmpty if file.to_s.strip.empty?
     
-    raise CannotWriteFilePathEmpty 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))
@@ -53,30 +76,30 @@ module Scriptorium::Helpers
         f.puts content
       end
     rescue Errno::ENOSPC => e
-      raise CannotWriteFileDiskFull(file, e.message)
+              raise FileDiskFull(file, e.message)
     rescue Errno::EACCES => e
-      raise CannotWriteFilePermissionDenied(file, e.message)
+              raise FilePermissionDenied(file, e.message)
     rescue Errno::ENOENT => e
-      raise CannotWriteFileDirectoryNotFound(file, e.message)
+              raise FileDirectoryNotFound(file, e.message)
     rescue => e
-      raise CannotWriteFileError(file, e.message)
+      raise WriteFileError(file, e.message)
     end
   end
 
-  def write_file!(file, *lines)
+  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)
+    write_file(file, content, empty: empty)
   end
 
   def make_dir(dir, create_parents = false)
     # Input validation
-    raise CannotCreateDirectoryPathNil if dir.nil?
-    
-    raise CannotCreateDirectoryPathEmpty if dir.to_s.strip.empty?
+        raise DirectoryPathNil if dir.nil?
+
+    raise DirectoryPathEmpty if dir.to_s.strip.empty?
     
     # Create parent directories if requested
     if create_parents
@@ -86,25 +109,25 @@ module Scriptorium::Helpers
       begin
         Dir.mkdir(dir)
       rescue Errno::ENOSPC => e
-        raise CannotCreateDirectoryDiskFull(dir, e.message)
+        raise DirectoryDiskFull(dir, e.message)
       rescue Errno::EACCES => e
-        raise CannotCreateDirectoryPermissionDenied(dir, e.message)
+        raise DirectoryPermissionDenied(dir, e.message)
       rescue Errno::ENOENT => e
-        raise CannotCreateDirectoryParentNotFound(dir, e.message)
+        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 CannotCreateDirectoryError(dir, e.message)
+        raise CreateDirectoryError(dir, e.message)
       end
     end
   end
 
   def system!(command, description = nil)
     # Input validation
-    raise CannotExecuteCommandNil if command.nil?
-    
-    raise CannotExecuteCommandEmpty if command.to_s.strip.empty?
+        raise CommandNil if command.nil?
+
+    raise CommandEmpty if command.to_s.strip.empty?
     
     # Execute command with error handling
     success = system(command)
@@ -119,9 +142,9 @@ module Scriptorium::Helpers
 
   def need(type, path, exception_class = RuntimeError)
     # Input validation
-    raise CannotRequirePathNil(type) if path.nil?
-    
-    raise CannotRequirePathEmpty(type) if path.to_s.strip.empty?
+        raise RequirePathNil(type) if path.nil?
+
+    raise RequirePathEmpty(type) if path.to_s.strip.empty?
     
     # Check if file/directory exists
     exists = case type
@@ -146,9 +169,9 @@ module Scriptorium::Helpers
 
   def read_file(file, options = {})
     # Input validation
-    raise CannotReadFilePathNil if file.nil?
-    
-    raise CannotReadFilePathEmpty if file.to_s.strip.empty?
+        raise ReadFilePathNil if file.nil?
+
+    raise ReadFilePathEmpty if file.to_s.strip.empty?
     
     # Handle missing file with fallback
     if options[:missing_fallback]
@@ -172,12 +195,12 @@ module Scriptorium::Helpers
       if options[:missing_fallback]
         return options[:missing_fallback]
       else
-        raise CannotReadFileNotFound(file, e.message)
+        raise ReadFileNotFound(file, e.message)
       end
     rescue Errno::EACCES => e
-      raise CannotReadFilePermissionDenied(file, e.message)
+              raise ReadFilePermissionDenied(file, e.message)
     rescue => e
-      raise CannotReadFileError(file, e.message)
+              raise ReadFileError(file, e.message)
     end
   end
 
@@ -207,6 +230,8 @@ module Scriptorium::Helpers
   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
@@ -225,7 +250,11 @@ module Scriptorium::Helpers
   end
   
   def ymdhms
-    Time.now.strftime("%Y-%m-%d-%H-%M-%S")
+    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
@@ -243,16 +272,14 @@ module Scriptorium::Helpers
     lines.each {|line| line.gsub!(/ *#.*$/, "") }
     entries = []
   
-    # Determine the root name
-    first_line = lines.shift
-    root = first_line.strip.sub(/\/$/, "") # remove trailing slash
-    root_path = File.join(base, root)
-    make_dir(root_path) unless File.exist?(root_path)
-  
-    # Prepare stack starting from root
-    stack = [root_path]
+    # 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 the remaining lines
+    # Parse all lines as structure
     lines.each do |line|
       if (i = line.index(/ [a-zA-Z0-9_.]/))
         name = line[(i + 1)..-1]
@@ -301,6 +328,17 @@ module Scriptorium::Helpers
     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)
@@ -310,32 +348,82 @@ module Scriptorium::Helpers
     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
-      if File.exist?("dev_assets/#{name}")
-        return "dev_assets/#{name}"
-      elsif File.exist?("assets/#{name}")
-        return "assets/#{name}"
-      else
-        raise AssetNotFound(name)
-      end
+      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)
-      if File.exist?("assets/#{name}")
-        return "assets/#{name}"
-      end
+      # Check user assets first (highest priority) - recursively
+      user_asset = find_asset("assets", name)
+      return user_asset if user_asset
       
-      # Then check gem assets (fallback)
+      # Then check gem assets (fallback) - recursively
       begin
         gem_spec = Gem.loaded_specs['scriptorium']
         if gem_spec
-          gem_asset_path = "#{gem_spec.full_gem_path}/assets/#{name}"
-          if File.exist?(gem_asset_path)
-            return gem_asset_path
-          end
+          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
@@ -385,43 +473,41 @@ module Scriptorium::Helpers
 
   def list_gem_assets
     assets = []
-    begin
-      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
+    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
-    rescue => e
-      # If gem lookup fails, return empty array
     end
     assets.sort
+  rescue => e
+    # If gem lookup fails, return empty array
+    []
   end
 
   def copy_gem_asset_to_user(asset_name, target_dir = "assets")
-    begin
-      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
+    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
-    rescue => e
-      # If gem lookup fails, return nil
     end
     nil
+  rescue => e
+    # If gem lookup fails, return nil
+    nil
   end
 
   # Clipboard helper methods
@@ -471,5 +557,119 @@ module Scriptorium::Helpers
       nil
     end
   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

data/lib/scriptorium/post.rb

@@ -22,10 +22,10 @@ class Scriptorium::Post
     end
 
     private def validate_initialization(repo, num)
-      raise CannotCreatePostRepoNil if repo.nil?
-      raise CannotCreatePostNumNil if num.nil?
-      raise CannotCreatePostNumEmpty if num.to_s.strip.empty?
-      raise CannotCreatePostNumInvalid(num) unless num.to_s.match?(/^\d+$/)
+      raise PostRepoNil if repo.nil?
+      raise PostNumNil if num.nil?
+      raise PostNumEmpty if num.to_s.strip.empty?
+      raise PostNumInvalid(num) unless num.to_s.match?(/^\d+$/)
     end
   
     def dir
@@ -33,16 +33,40 @@ class Scriptorium::Post
     end
   
     def meta_file
-      # Check if post is in deleted directory (with underscore prefix)
-      deleted_meta = @repo.root/:posts/"_#{@num}"/"meta.txt"
-      return deleted_meta if File.exist?(deleted_meta)
+      # Check what directory actually exists
+      normal_dir = @repo.root/:posts/@num
+      deleted_dir = @repo.root/:posts/"_#{@num}"
       
-      # Otherwise use normal directory
-      @repo.root/:posts/@num/"meta.txt"
+      if Dir.exist?(normal_dir)
+        # Normal post directory exists
+        normal_dir/"meta.txt"
+      elsif Dir.exist?(deleted_dir)
+        # Deleted post directory exists
+        deleted_dir/"meta.txt"
+      else
+        # Neither exists - post never existed
+        raise "Post directory for #{@num} not found"
+      end
     end
-  
-
 
+    def validate_metadata_consistency
+      return unless File.exist?(meta_file)
+      
+      normal_dir = @repo.root/:posts/@num
+      deleted_dir = @repo.root/:posts/"_#{@num}"
+      metadata_deleted = meta["post.deleted"] == "true"
+      
+      if Dir.exist?(normal_dir) && metadata_deleted
+        raise "Inconsistency: Post #{@num} has normal directory but metadata shows deleted=true"
+      elsif Dir.exist?(deleted_dir) && !metadata_deleted
+        raise "Inconsistency: Post #{@num} has deleted directory but metadata shows deleted=false"
+      end
+    end
+  
+    def blurb_text
+      meta["post.blurb"]
+    end
+    
     def blurb
       meta["post.blurb"]
     end
@@ -58,6 +82,14 @@ class Scriptorium::Post
     def pubdate
       meta["post.pubdate"]
     end
+    
+    def created
+      meta["post.created"]
+    end
+    
+    def date
+      pubdate || created
+    end
 
     def set_pubdate(ymd, seconds: 0)
       check_invariants
@@ -80,12 +112,12 @@ class Scriptorium::Post
     end
 
     private def validate_date_format(date)
-      raise CannotSetPubdateYmdNil if date.nil?
-      raise CannotSetPubdateYmdEmpty if date.to_s.strip.empty?
-      raise CannotSetPubdateInvalidFormat(date) unless date.to_s.match?(/^\d{4}-\d{2}-\d{2}$/)
+      raise PubdateYmdNil if date.nil?
+      raise PubdateYmdEmpty if date.to_s.strip.empty?
+      raise PubdateInvalidFormat(date) unless date.to_s.match?(/^\d{4}-\d{2}-\d{2}$/)
     end
 
-    private def update_pubdate_metadata(time)
+    def update_pubdate_metadata(time)
       meta["post.pubdate"] = time.strftime("%Y-%m-%d %H:%M:%S") 
       meta["post.pubdate.month"] = time.strftime("%B") 
       meta["post.pubdate.day"] = time.strftime("%e") 
@@ -123,8 +155,25 @@ class Scriptorium::Post
       meta["post.tags"]
     end
 
+    def tags_array
+      tags_str = meta["post.tags"]
+      return [] if tags_str.nil? || tags_str.strip.empty?
+      tags_str.strip.split(/,\s*/)
+    end
+
     def deleted
-      meta["post.deleted"] == "true"
+      # Check what directory actually exists
+      normal_dir = @repo.root/:posts/@num
+      deleted_dir = @repo.root/:posts/"_#{@num}"
+      
+      if Dir.exist?(deleted_dir)
+        true
+      elsif Dir.exist?(normal_dir)
+        false
+      else
+        # Neither exists - post never existed
+        raise "Post directory for #{@num} not found"
+      end
     end
 
     def deleted=(value)
@@ -144,9 +193,10 @@ class Scriptorium::Post
     end
 
     # New class method to read metadata and initialize the Post
-    def self.read(repo, num)
+    def self.read(repo, num, deleted: false)
       post = new(repo, num)
       post.load_metadata
+      post.validate_metadata_consistency
       post
     end
   
@@ -159,6 +209,20 @@ class Scriptorium::Post
       return @vars if defined?(@vars)
       @vars = Hash.new("")
       meta.each_pair {|k,v| @vars[k.to_sym] = v }
+      
+      # Add computed date components for template access
+      date_value = pubdate || created
+      if date_value
+        begin
+          date_obj = Date.parse(date_value)
+          @vars[:"post.pubdate.month"] = date_obj.strftime("%B")
+          @vars[:"post.pubdate.day"] = date_obj.strftime("%e").strip
+          @vars[:"post.pubdate.year"] = date_obj.strftime("%Y")
+        rescue Date::Error
+          # If date is invalid, leave the computed fields empty
+        end
+      end
+      
       @vars
     end
 

data/lib/scriptorium/reddit.rb

@@ -3,7 +3,7 @@ require 'redd'
 require_relative 'exceptions'
 require_relative 'helpers'
 
-module Scriptorium
+class Scriptorium
   class Reddit
     include Scriptorium::Exceptions
     include Scriptorium::Helpers