rawfeed 0.3.1 → 1.0.0

data/exe/rawfeed

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "pathname"
+
+# Try to find the gem by running it via exe/directly.
+begin
+  exe_path = Pathname.new(__FILE__).realpath
+  gem_root = exe_path.parent.parent
+  lib_dir = gem_root.join("lib")
+
+  if lib_dir.directory? && !$LOAD_PATH.include?(lib_dir.to_s)
+    $LOAD_PATH.unshift(lib_dir.to_s)
+  end
+rescue StandardError
+  # Simple fallback if realpath fails.
+  $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+end
+
+begin
+  require "rawfeed"
+  require "rawfeed/command/cli"
+rescue LoadError => e
+  warn "Error: Could not load 'rawfeed' gem logic. (#{e.message})"
+  warn "If you are developing locally, run with: bundle exec exe/rawfeed"
+  exit 1
+end
+
+Rawfeed::CLI.run(ARGV)

data/index.md

@@ -0,0 +1,15 @@
+---
+layout: home
+author: "William C. Canin"
+text_center: true
+published: true
+permalink: / # do not change
+---
+
+Hello, Welcome to rawfeed!
+
+This is the space for your presentation. Do it right! 😃
+
+This is the **rawfeed** theme for [Jekyll](https://jekyllrb.com){:target="\_blank"}, feel free to modify it.
+
+You can see more customization details in [rawfeed doc](https://rawfeed.github.io/rawfeed-jekyll){:target="\_blank"}.

data/lib/rawfeed/build/cleaner.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "colorize"
+
+module Rawfeed
+  module Build
+    class Cleaner
+      JEKYLL_CACHE_PATHS = [
+        ".jekyll-metadata",
+        ".jekyll-cache",
+        "_site"
+      ].freeze
+
+      PROJECT_PATHS = [
+        ".jekyll-metadata",
+        ".jekyll-cache",
+        "_site"
+      ].freeze
+
+      def self.clean_jekyll_cache
+        puts "Cleaning Jekyll cache...".yellow
+        deleted_paths = []
+
+        JEKYLL_CACHE_PATHS.each do |path|
+          if File.exist?(path) || Dir.exist?(path)
+            FileUtils.rm_rf(path)
+            deleted_paths << path
+          end
+        end
+
+        if deleted_paths.any?
+          puts "Items successfully removed:".green
+          deleted_paths.each { |path| puts "  - #{path}" }
+        else
+          puts "No items to clean."
+        end
+      end
+
+      def self.clean_project
+        puts "Cleaning up project directories and files...".yellow
+        deleted_paths = []
+
+        PROJECT_PATHS.each do |path|
+          if File.exist?(path) || Dir.exist?(path)
+            FileUtils.rm_rf(path)
+            deleted_paths << path
+          end
+        end
+
+        if deleted_paths.any?
+          puts "Items successfully removed:".green
+          deleted_paths.each { |path| puts "  - #{path}" }
+        else
+          puts "No items to clean."
+        end
+      end
+    end
+  end
+end

data/lib/rawfeed/build/image_minifier.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "colorize"
+require "fileutils"
+
+module Rawfeed
+  module Build
+    class ImageMinifier
+      BUILD_DIR = "_site"
+      IMAGE_FORMATS = %w[jpg jpeg png].freeze
+      QUALITY_JPEG = 75
+      QUALITY_WEBP = 75
+      QUALITY_AVIF = 50
+
+      def self.shell_escape(path)
+        "'#{path.to_s.gsub("'", "'\\\\''")}'"
+      end
+
+      def self.minify_images
+        begin
+          require "mini_magick"
+        rescue LoadError
+          # mini_magick is optional, but let user know they need it OR ImageMagick
+        end
+
+        # Check if ImageMagick is installed
+        begin
+          system("identify -version > /dev/null 2>&1")
+          unless $?.success?
+            raise "ImageMagick not found"
+          end
+        rescue => e
+          puts "[!] Error: ImageMagick is not installed or not found in PATH".red
+          puts "".red
+          if RUBY_PLATFORM.include?("linux")
+            if File.exist?("/etc/arch-release")
+              puts "    Arch Linux: sudo pacman -S imagemagick".yellow
+            else
+              puts "    Ubuntu/Debian: sudo apt-get install imagemagick".yellow
+            end
+          elsif RUBY_PLATFORM.include?("darwin")
+            puts "    macOS: brew install imagemagick".yellow
+          elsif RUBY_PLATFORM.include?("mingw") || RUBY_PLATFORM.include?("mswin")
+            puts "    Windows: https://imagemagick.org/script/download.php".yellow
+          else
+            puts "    See: https://imagemagick.org/script/download.php".yellow
+          end
+          exit 1
+        end
+
+        puts "Minifying images...".yellow
+
+        image_files = Dir.glob("#{BUILD_DIR}/assets/images/**/*.{jpg,jpeg,png}", File::FNM_CASEFOLD)
+
+        if image_files.empty?
+          puts "No images found."
+          return
+        end
+
+        puts "Found #{image_files.length} images\n".cyan
+
+        total_before = 0
+        total_after = 0
+        successful = 0
+        failed = 0
+
+        image_files.each do |file|
+          begin
+            before_size = File.size(file)
+            total_before += before_size
+
+            # Get file info
+            dir = File.dirname(file)
+            basename = File.basename(file, File.extname(file))
+
+            # Process with ImageMagick convert command
+            # Use 'magick convert' for ImageMagick 7+, fallback to 'convert' for older versions
+            converter = system("magick --version > /dev/null 2>&1") ? "magick convert" : "convert"
+
+            # 1. Compress original to JPEG
+            temp_jpeg = "#{file}.temp.jpg"
+            cmd_jpeg = "#{converter} #{shell_escape(file)} -quality #{QUALITY_JPEG} -strip #{shell_escape(temp_jpeg)} 2>/dev/null"
+            system(cmd_jpeg)
+
+            if File.exist?(temp_jpeg) && File.size(temp_jpeg) > 0
+              FileUtils.mv(temp_jpeg, file)
+              jpeg_size = File.size(file)
+              total_after += jpeg_size
+              successful += 1
+
+              # Create WebP version
+              webp_path = File.join(dir, "#{basename}.webp")
+              cmd_webp = "#{converter} #{shell_escape(file)} -quality #{QUALITY_WEBP} #{shell_escape(webp_path)} 2>/dev/null"
+              system(cmd_webp)
+
+              # Create AVIF version
+              avif_path = File.join(dir, "#{basename}.avif")
+              cmd_avif = "#{converter} #{shell_escape(file)} -quality #{QUALITY_AVIF} #{shell_escape(avif_path)} 2>/dev/null"
+              system(cmd_avif)
+
+              # Display progress
+              human_before = format_bytes(before_size)
+              human_after = format_bytes(jpeg_size)
+              puts "  #{green_checkmark} #{file} #{neutral("(#{human_before} → #{human_after})")}"
+            else
+              failed += 1
+              FileUtils.rm(temp_jpeg) if File.exist?(temp_jpeg)
+              puts "  #{red_x} #{file} #{red("(Failed to convert)")}"
+            end
+          rescue => e
+            failed += 1
+            puts "  #{red_x} #{file} #{red("(#{e.message}")}\n"
+          end
+        end
+
+        # Display summary
+        if successful > 0
+          saved = total_before - total_after
+          human_before = format_bytes(total_before)
+          human_after = format_bytes(total_after)
+          human_saved = format_bytes(saved)
+
+          puts ""
+          puts "Images optimized: #{human_before} → #{human_after} (saved #{human_saved})".bold.green
+          puts "  Successful: #{successful}, Failed: #{failed}".cyan if failed > 0
+          puts ""
+        elsif failed > 0
+          puts ""
+          puts "No images were processed (#{failed} failed)".red
+          puts ""
+        end
+      end
+
+      private
+
+      def self.format_bytes(bytes)
+        if bytes >= 1_000_000
+          "#{(bytes.to_f / 1_000_000).round(2)}MB"
+        elsif bytes >= 1_000
+          "#{(bytes.to_f / 1_000).round(2)}KB"
+        else
+          "#{bytes}B"
+        end
+      end
+
+      def self.green_checkmark
+        "✔".green
+      end
+
+      def self.red_x
+        "✗".red
+      end
+
+      def self.neutral(text)
+        text
+      end
+
+      def self.red(text)
+        text.red
+      end
+    end
+  end
+end

data/lib/rawfeed/build/minifier.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "colorize"
+require_relative "image_minifier"
+
+module Rawfeed
+  module Build
+    class Minifier
+      BUILD_DIR = "_site"
+
+      def self.minify_javascript
+        begin
+          require "uglifier"
+        rescue LoadError
+          puts "[!] Error: uglifier gem is required for minify feature".red
+          puts "    Install it with: gem install uglifier".yellow
+          puts "    Or add to your Gemfile: gem 'uglifier', '~> 4.2.0'".yellow
+          exit 1
+        end
+
+        puts "Minifying JavaScript files...".yellow
+        js_files = Dir.glob("#{BUILD_DIR}/assets/js/**/*.js")
+
+        if js_files.empty?
+          puts "No JavaScript files found."
+          return
+        end
+
+        begin
+          js_files.each do |file|
+            content = File.read(file)
+            minified = Uglifier.compile(content, harmony: true)
+            File.write(file, minified)
+          end
+          puts "JavaScript minified successfully!".green
+        rescue => e
+          puts "Error minifying JavaScript: #{e.message}".red
+          raise
+        end
+      end
+
+      def self.minify_html
+        puts "Minifying HTML files...".yellow
+        html_files = Dir.glob("#{BUILD_DIR}/**/*.html")
+
+        if html_files.empty?
+          puts "No HTML files found."
+          return
+        end
+
+        begin
+          html_files.each do |file|
+            content = File.read(file)
+            # Simple HTML minification: remove comments, collapse whitespace
+            # Preserves whitespace inside <pre>, <code>, <textarea>, <svg>
+            minified = content
+              .gsub(/<!--.*?-->/m, "")
+              .gsub(/(<(pre|code|textarea|svg)\b[^>]*>.*?<\/\2>)|(\s+)/mi) { $1 || " " }
+              .strip
+            File.write(file, minified)
+          end
+          puts "HTML minified successfully!".green
+        rescue => e
+          puts "Error minifying HTML: #{e.message}".red
+          raise
+        end
+      end
+
+      def self.minify_all
+        puts "Starting minify process...".cyan
+        begin
+          minify_javascript
+          minify_html
+          minify_images
+          puts "\n Minify completed successfully!\n".bold.green
+        rescue => e
+          puts "\n An error occurred during minify.\n".bold.red
+          puts e.message.red
+          exit 1
+        end
+      end
+
+      def self.minify_images
+        ImageMinifier.minify_images
+      end
+    end
+  end
+end
+

data/lib/rawfeed/build.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "build/minifier"
+require_relative "build/cleaner"
+
+module Rawfeed
+  module Build
+  end
+end

data/lib/rawfeed/command/backup.rb

@@ -0,0 +1,124 @@
+require "rawfeed/root"
+require "fileutils"
+require "time"
+require "colorize"
+
+module Rawfeed
+  class Backup
+    DEFAULT_FOLDERS = %w[assets pub .vscode _posts _pages _data].freeze
+    STATIC_FILES = %w[_config.yml index.md robots.txt CNAME].freeze
+    DYNAMIC_EXTENSIONS = %w[.sh .py .rb .bat .ps1].freeze
+    GOOGLE_PATTERN = /^google.*\.html$/.freeze
+
+    def self.site(*args)
+      project_root = "."
+      gemspec_path = File.join(project_root, "rawfeed.gemspec")
+
+      if File.exist?(gemspec_path)
+        puts "[!] Not allowed to create backup from gem source directory (rawfeed.gemspec found)".red
+        exit 1
+      end
+
+      options = parse_options(args)
+      destination = options[:destination] || project_root
+      append_paths = options[:append] || []
+
+      unless Dir.exist?(destination)
+        puts "[!] Destination directory does not exist: #{destination}".red
+        exit 1
+      end
+
+      backup_filename = "backup-#{Time.now.strftime('%Y-%m-%d_%H-%M-%S')}.zip"
+      backup_path = File.join(destination, backup_filename)
+
+      begin
+        create_backup(project_root, backup_path, append_paths)
+        puts "[✓] Backup created successfully: #{backup_path}".green
+      rescue StandardError => e
+        puts "[!] Error creating backup: #{e.message}".red
+        exit 1
+      end
+    end
+
+    private
+
+    def self.parse_options(args)
+      options = { destination: nil, append: [] }
+      i = 0
+
+      while i < args.length
+        case args[i]
+        when "--destination", "-d"
+          options[:destination] = args[i + 1]
+          i += 2
+        when "--append", "-a"
+          options[:append] << args[i + 1]
+          i += 2
+        else
+          i += 1
+        end
+      end
+
+      options
+    end
+
+    def self.create_backup(project_root, backup_path, append_paths)
+      require "zip"
+      Zip::File.open(backup_path, Zip::File::CREATE) do |zipfile|
+        # Add default folders
+        DEFAULT_FOLDERS.each do |folder|
+          folder_path = File.join(project_root, folder)
+          add_folder_to_zip(zipfile, folder_path, folder) if Dir.exist?(folder_path)
+        end
+
+        # Add static files
+        STATIC_FILES.each do |file|
+          file_path = File.join(project_root, file)
+          add_file_to_zip(zipfile, file_path, file) if File.exist?(file_path)
+        end
+
+        # Add dynamic files
+        add_dynamic_files_to_zip(zipfile, project_root)
+
+        # Add append paths
+        append_paths.each do |path|
+          full_path = File.join(project_root, path)
+          if File.directory?(full_path)
+            add_folder_to_zip(zipfile, full_path, path)
+          elsif File.exist?(full_path)
+            add_file_to_zip(zipfile, full_path, path)
+          else
+            puts "[!] Warning: Path not found: #{path}".yellow
+          end
+        end
+      end
+    end
+
+    def self.add_dynamic_files_to_zip(zipfile, project_root)
+      Dir.glob(File.join(project_root, "*")).each do |path|
+        next unless File.file?(path)
+
+        basename = File.basename(path)
+        ext = File.extname(path)
+
+        # Check if it's a dynamic file (has one of the extensions or matches google*.html)
+        if DYNAMIC_EXTENSIONS.include?(ext) || GOOGLE_PATTERN.match?(basename)
+          add_file_to_zip(zipfile, path, basename)
+        end
+      end
+    end
+
+    def self.add_folder_to_zip(zipfile, folder_path, zip_path)
+      Dir.glob(File.join(folder_path, "**/**")).each do |file|
+        next if File.directory?(file)
+
+        relative_path = File.join(zip_path, file.sub(Regexp.escape(folder_path), "").sub(/^\//, ""))
+        zipfile.add(relative_path, file)
+      end
+    end
+
+    def self.add_file_to_zip(zipfile, file_path, zip_path)
+      zipfile.add(zip_path, file_path)
+    end
+  end
+end

data/lib/rawfeed/command/cli.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require "colorize"
+require_relative "tools"
+
+module Rawfeed
+  # Command Line Interface (CLI) entry point for rawfeed-jekyll.
+  # This class handles routing of commands passed from the "rawfeed" executable.
+  class CLI
+    # Parses and executes the CLI command.
+    # Exits the application if invalid commands are provided.
+    #
+    # @param args [Array<String>] The arguments passed from the shell.
+    # @return [void]
+    def self.run(args)
+      if args.empty?
+        puts "Use: rawfeed help"
+        exit 1
+      end
+
+      first_arg = args.shift
+
+      # Internal tools
+      if %w[minify clean help new install build serve backup].include?(first_arg)
+        case first_arg
+        when "minify"
+          Rawfeed::Tools.minify
+        when "clean"
+          Rawfeed::Tools.clean(*args)
+        when "help"
+          Rawfeed::Tools.help
+        when "new"
+          site_path = args.shift || "my-site"
+          Rawfeed::Installer.create_new_site(site_path, *args)
+        when "install"
+          Rawfeed::Tools.install
+        when "build"
+          Rawfeed::Tools.build(*args)
+        when "serve"
+          Rawfeed::Tools.serve(*args)
+        when "backup"
+          Rawfeed::Backup.site(*args)
+        end
+        return
+      end
+
+      # Separate namespace and task for the main commands.
+      namespace, task = first_arg.split(":")
+
+      case namespace
+      when "create"
+        case task
+        when "draft" then Rawfeed::Draft.draft_create(*args)
+        when "pixel" then Rawfeed::Pixel.pixel_create(*args)
+        when "page"  then Rawfeed::Page.page_create(*args)
+        else
+          puts "Unknown create task: #{task}"
+        end
+      when "restore"
+        case task
+          when "donate" then Rawfeed::Donate.restore_page
+          when "contact" then Rawfeed::Contact.restore_page
+          when "licenses" then Rawfeed::Licenses.restore_page
+          when "resume" then Rawfeed::Resume.restore_page
+        else
+          puts "Unknown restore task: #{task}"
+        end
+      when "list"
+        case task
+        when "posts" then Rawfeed::PostList.display
+        else
+          puts "Unknown list task: #{task}"
+        end
+      when "home"
+        case task
+        when "about" then Rawfeed::Layout.home_about(true)
+        when "blog"  then Rawfeed::Layout.home_blog
+        else
+          puts "Unknown home task: #{task}"
+        end
+      when "post"
+        case task
+        when "draft" then Rawfeed::Post.post(*args)
+        else
+          puts "Unknown post task: #{task}"
+        end
+      when "blog"
+        case task
+        when "enable"  then
+          Rawfeed::Layout.blog_index(true)
+          Rawfeed::Layout.tags_index(true)
+          Rawfeed::Layout::change_yml("defaults", "published", true, "_posts")
+          Rawfeed::Layout.change_yml("pagination", "enabled", true)
+        when "disable" then
+          Rawfeed::Layout.blog_index(false)
+          Rawfeed::Layout.tags_index(false)
+          Rawfeed::Layout::change_yml("defaults", "published", false, "_posts")
+          Rawfeed::Layout.change_yml("pagination", "enabled", false)
+        else
+          puts "Unknown blog task: #{task}"
+        end
+      when "pixels"
+        case task
+        when "enable"  then Rawfeed::Layout.pixels_index(true)
+        when "disable" then Rawfeed::Layout.pixels_index(false)
+        else
+          puts "Unknown pixels task: #{task}"
+        end
+      else
+        puts "Unknown namespace or command: #{namespace || first_arg}"
+        puts "Use:"
+        puts "  rawfeed help"
+      end
+    end
+  end
+end