yiffspace 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 005aad0fa1bb9ee0b93c116a8ff16ee6b9221393b7218ace6458a0a205edf851
-  data.tar.gz: 3184951a3460ebb9c4b3afc7174f2956789d7a1617b6b6bdf0a8c7567298ab71
+  metadata.gz: b8d498d64c506f7f2c008b8c03aca70d0d51f371805cbd1f6c5c4d9fdb89a453
+  data.tar.gz: c311ba586f4365538d8a0802ad47ab000ea90a76f94d6b9e0642aef233bfcba2
 SHA512:
-  metadata.gz: c3aedc62b4a752a0124e8a41ac8aa013ea5a54cc7f95d5876afda928bcad70e9b13b0744a42cde382dfb2a7d4af3f7d906493971c28f0813d9f24de7ef70fb23
-  data.tar.gz: 0063344df91e5a741fe752be20b1f591b51df35bbc16746a7eb51d155c16b77c8d39824a7a8f0dc7c2f852444c48fe802b84f00ac9a7ab6e34af08c0489b46bc
+  metadata.gz: d463a33bee7f0760dc314e832ad7776a894185ee46590b87f3c49f540a89c521732d28f7b126b6606f03204f013b8230d05d512043130e3b101e2e33e0cf2d68
+  data.tar.gz: 561db6abdedb892c69defa2bc2f2baebf4cdf1f79d1ab194ed45ebc3929eaef6121a70dd0cfec2811f10dadc85688b14ea78e95aece7a59352d04ce3d05d2659

data/lib/generators/yiffspace/fixer/USAGE

@@ -0,0 +1,40 @@
+Description:
+    Generates a new one-time fix script tracked by YiffSpace::FixTracker.
+
+Example:
+    bin/rails generate yiffspace:fixer fixer_name
+
+    This will create:
+        db/fixes/<id>_fixer_name.rb
+
+    bin/rails generate yiffspace:fixer fixer_name --steps 2
+
+    This will create:
+        db/fixes/<id>_1_fixer_name.rb
+        db/fixes/<id>_2_fixer_name.rb
+
+    A host app can define named templates, auto-discovered from db/fixer_templates/*.rb (see
+    YiffSpace::FixerTemplate and YiffSpace.config.fixer_templates_path) - no registration needed,
+    just define a subclass. Each `step` block's return value becomes that step's file content:
+
+        # db/fixer_templates/elasticsearch_template.rb
+        class ElasticsearchTemplate < YiffSpace::FixerTemplate
+          short("e")
+
+          step { "# add the elasticsearch index\n" }
+          step { "# backfill the elasticsearch data\n" }
+        end
+
+    bin/rails generate yiffspace:fixer fixer_name --template elasticsearch
+    bin/rails generate yiffspace:fixer fixer_name -t elasticsearch
+    bin/rails generate yiffspace:fixer fixer_name -e
+
+    All three create the 2 steps above; `short` is optional - a template is always reachable via
+    --template/-t, the shortname flag is just a convenience.
+
+    A host app can also register a preset with just a step count (no per-step content - every
+    step falls back to the generic fixer.rb template) directly in an initializer instead:
+
+        YiffSpace.configure do |config|
+          config.fixer_templates.register(:legacy, steps: 3)
+        end

data/lib/generators/yiffspace/fixer/fixer_generator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Yiffspace
+  # Scaffolds a new db/fixes/*.rb script for YiffSpace::FixTracker (see `rake fixes:list`).
+  #
+  # `--steps N` splits the fix into N ordered steps sharing an id, each one a copy of the generic
+  # fixer.rb template. A host app can instead define a YiffSpace::FixerTemplate subclass (see that
+  # class) to control both the step count and each step's file content, auto-discovered from
+  # YiffSpace.config.fixer_templates_path - reachable here with `--template <name>`/`-t <name>`,
+  # or with the template's own shortname flag if it registered one (e.g. `-e`).
+  class FixerGenerator < Rails::Generators::NamedBase
+    source_root(File.expand_path("templates", __dir__))
+    # No short alias - -s/-f/-p/-q are already claimed by Rails::Generators::Base's own runtime
+    # options (--skip/--force/--pretend/--quiet), and Thor silently lets the last-defined
+    # class_option win a collision instead of erroring.
+    class_option(:steps, type: :numeric, default: 1,
+                          desc: "Split the fix into N ordered steps sharing an id, e.g. 12_1_name.rb, 12_2_name.rb")
+    class_option(:template, type: :string, default: nil, aliases: ["-t"],
+                             desc: "Use a fixer template registered with YiffSpace.config.fixer_templates")
+
+    YiffSpace.config.fixer_templates.each do |template|
+      next unless template.short
+
+      class_option(template.name.to_sym, type: :boolean, default: false, aliases: ["-#{template.short}"],
+                                          desc: "Shortcut for --template #{template.name}")
+    end
+
+    def create_fixer
+      content_blocks = resolve_content_blocks
+
+      id = Dir[File.join(destination_root, "db/fixes/*.rb")].map { |f| File.basename(f, ".rb").split("_").first.to_i }.max.to_i + 1
+
+      if content_blocks.size == 1
+        create_fixer_file("db/fixes/#{id}_#{file_name}.rb", content_blocks.first)
+      else
+        content_blocks.each_with_index { |block, index| create_fixer_file("db/fixes/#{id}_#{index + 1}_#{file_name}.rb", block) }
+      end
+    end
+
+    private
+
+    # One entry per step - a block returning that step's file content, or nil to fall back to
+    # copying the generic fixer.rb template (a plain --steps N, or a manually
+    # YiffSpace.config.fixer_templates.register'd template, has no per-step content).
+    def resolve_content_blocks
+      template = resolve_template
+      return template.content_blocks if template
+
+      Array.new(steps_from_flag)
+    end
+
+    def resolve_template
+      name = template_name
+      return nil if name.nil?
+
+      template = YiffSpace.config.fixer_templates[name]
+      raise(Thor::Error, "no fixer template named #{name.inspect} is registered") unless template
+
+      template
+    end
+
+    # The template chosen via `--template <name>`, or via a registered template's own shortname
+    # flag (e.g. `-e` for a template registered with `short: "e"`) - nil if neither was passed.
+    def template_name
+      return options["template"] if options["template"]
+
+      YiffSpace.config.fixer_templates.find { |template| template.short && options[template.name] }&.name
+    end
+
+    def steps_from_flag
+      steps = options["steps"].to_i
+      raise(Thor::Error, "--steps must be at least 1") if steps < 1
+
+      steps
+    end
+
+    def create_fixer_file(path, content_block)
+      if content_block
+        create_file(path, content_block.call)
+        chmod(path, "+x")
+      else
+        copy_file("fixer.rb", path, mode: :preserve)
+      end
+    end
+  end
+end

data/lib/generators/yiffspace/fixer/templates/fixer.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config", "environment")))

data/lib/generators/yiffspace/install/fixes_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Yiffspace
+  module Install
+    # Installs YiffSpace::FixTracker into a host app: `bin/rails generate yiffspace:install:fixes`
+    # copies the `fixes` tracking table migration. Run `bin/rails db:migrate` afterwards.
+    class FixesGenerator < Rails::Generators::Base
+      include(Rails::Generators::Migration)
+
+      source_root(File.expand_path("templates", __dir__))
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Migration.next_migration_number(current_migration_number(dirname) + 1)
+      end
+
+      def create_migration_file
+        migration_template("create_fixes.rb.erb", "db/migrate/create_fixes.rb")
+      end
+    end
+  end
+end

data/lib/generators/yiffspace/install/templates/create_fixes.rb.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Tracks which db/fixes/*.rb scripts have been applied, the same way schema_migrations tracks
+# migrations - see YiffSpace::FixTracker and `rake fixes:migrate`/`rake fixes:list`.
+#
+# `id` is the fix's own leading number (e.g. 12, 23), not a surrogate key, so it isn't unique on
+# its own - a fix can be split into ordered sub-steps (12_1, 12_2, ...) that share an id and are
+# distinguished by `index`. `index` is null for fixes with no subtype.
+class CreateFixes < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    create_table(:fixes, id: false) do |t|
+      t.integer(:id, null: false) # not a surrogate key, this is the fix's own leading number
+      t.integer(:index)
+    end
+
+    add_index(:fixes, %i[id index], unique: true, nulls_not_distinct: true)
+  end
+end

data/lib/tasks/fixes.rake

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Keep structure.sql's fixes rows in sync with the database on every schema dump, the same way
+# ActiveRecord keeps schema_migrations rows in sync - not just when `fixes:migrate` runs.
+Rake::Task["db:schema:dump"].enhance do
+  YiffSpace::FixTracker.dump_structure_sql!
+end
+
+namespace(:fixes) do
+  desc("List available fix scripts in db/fixes, marking which have already been applied")
+  task(list: :environment) do
+    applied = YiffSpace::FixTracker.applied
+    YiffSpace::FixTracker.all_fixes.each do |name|
+      puts("#{applied.include?(YiffSpace::FixTracker.key_for(name)) ? '[x]' : '[ ]'} #{name}")
+    end
+  end
+
+  desc("Run a fix script from db/fixes by id or name, e.g. `rake fixes:run[1]` - re-runs even if already recorded as applied")
+  task(:run, [:name] => :environment) do |_task, args|
+    name = args[:name].to_s.delete_suffix(".rb")
+    abort("Usage: rake fixes:run[id_or_name] (see `rake fixes:list`)") if name.blank?
+
+    candidates = Dir["db/fixes/*.rb"]
+    exact = candidates.find { |path| File.basename(path, ".rb") == name }
+    matches = exact ? [exact] : candidates.select { |path| File.basename(path, ".rb").start_with?("#{name}_") || File.basename(path, ".rb").include?(name) }
+
+    if matches.empty?
+      abort("No fix matches \"#{name}\". Run `rake fixes:list` to see available fixes.")
+    elsif matches.size > 1
+      abort("Multiple fixes match \"#{name}\", be more specific:\n#{matches.map { |m| "  #{File.basename(m, '.rb')}" }.join("\n")}")
+    end
+
+    puts("Running #{File.basename(matches.first, '.rb')}...")
+    name = YiffSpace::FixTracker.run!(matches.first)
+    puts("Recorded #{name} as applied")
+  end
+
+  desc("Apply all fix scripts not yet recorded as applied, in order, then dump the schema like db:migrate does")
+  task(migrate: :environment) do
+    pending = YiffSpace::FixTracker.pending
+
+    if pending.empty?
+      puts("No pending fixes.")
+    else
+      pending.each do |name|
+        puts("Running #{name}...")
+        YiffSpace::FixTracker.run!(YiffSpace::FixTracker.fix_path(name))
+        puts("Recorded #{name} as applied")
+      end
+    end
+
+    Rake::Task["db:_dump"].invoke
+  end
+
+  desc("Record all of the current fixes as having been applied")
+  task(load: :environment) do
+    list = YiffSpace::FixTracker.all_fixes.map { YiffSpace::FixTracker.key_for(it) }
+    existing = ActiveRecord::Base.connection.select_all('SELECT id, "index" FROM fixes ORDER BY id, "index"').rows
+    list.reject! { |id, index| existing.any? { |e| e[0] == id && e[1] == index } }
+    unless list.empty?
+      values = list.map { |id, index| "(#{id}, #{index.nil? ? 'NULL' : index})" }.join(", ")
+      ActiveRecord::Base.connection.execute(%(INSERT INTO fixes (id, "index") VALUES #{values}))
+    end
+    puts("Loaded #{list.length} #{'fix'.pluralize(list.length)}")
+  end
+end

data/lib/yiffspace/configuration/fixer_templates.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  class Configuration
+    # Named presets for `bin/rails generate yiffspace:fixer`, so `--template <name>` (or a
+    # registered shortname flag) can stand in for `--steps N`. Populated two ways:
+    #
+    # - Automatically, from YiffSpace::FixerTemplate subclasses found in
+    #   YiffSpace.config.fixer_templates_path (the common case - see FixerTemplate).
+    # - Manually, via #register, for a preset that just needs a step count and no per-step
+    #   content (every step falls back to the generic fixer.rb template).
+    #
+    # See YiffSpace::Configuration#fixer_templates and Yiffspace::FixerGenerator.
+    class FixerTemplates
+      include(Enumerable)
+
+      Template = Struct.new(:name, :short, :content_blocks, keyword_init: true) do
+        def steps
+          content_blocks.size
+        end
+      end
+
+      # -t is yiffspace:fixer's own --template flag; -f/-p/-q/-s are Rails::Generators::Base's
+      # built-in runtime options (--force/--pretend/--quiet/--skip).
+      RESERVED_SHORTS = %w[t f p q s].freeze
+
+      def initialize
+        @templates = {}
+        @discovered = false
+      end
+
+      # short is optional - a template is always reachable via `--template <name>`, a shortname
+      # flag (e.g. `-e`) is just a convenient alias for it.
+      def register(name, steps:, short: nil)
+        raise(ArgumentError, "steps must be a positive integer, got #{steps.inspect}") unless steps.is_a?(Integer) && steps.positive?
+
+        add(name.to_s, short: short, content_blocks: Array.new(steps))
+      end
+
+      def [](name)
+        discover!
+        @templates[name.to_s]
+      end
+
+      def each(&)
+        discover!
+        @templates.each_value(&)
+      end
+
+      private
+
+      def add(name, short:, content_blocks:)
+        raise(ArgumentError, "a fixer template named #{name.inspect} is already registered") if @templates.key?(name)
+
+        short = short.to_s.delete_prefix("-") if short
+        if short
+          raise(ArgumentError, "\"-#{short}\" is reserved by yiffspace:fixer's own options") if RESERVED_SHORTS.include?(short)
+
+          existing = @templates.values.find { |template| template.short == short }
+          raise(ArgumentError, "\"-#{short}\" is already registered to the #{existing.name.inspect} fixer template") if existing
+        end
+
+        @templates[name] = Template.new(name: name, short: short, content_blocks: content_blocks)
+      end
+
+      # Scans YiffSpace.config.fixer_templates_path for YiffSpace::FixerTemplate subclasses and
+      # registers each one - runs once, the first time a template is looked up (#[] or #each),
+      # so it sees whatever the host app registered manually beforehand.
+      def discover!
+        return if @discovered
+
+        @discovered = true
+        path = YiffSpace.config.fixer_templates_path
+        return unless path && Dir.exist?(path)
+
+        before = FixerTemplate.subclasses
+        Dir[File.join(path, "*.rb")].each { |file| require(file) }
+
+        (FixerTemplate.subclasses - before).each do |klass|
+          raise(ArgumentError, "#{klass.name} has no step blocks - add at least one `step { ... }`") if klass.steps.empty?
+
+          add(klass.template_name, short: klass.short, content_blocks: klass.steps)
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/configuration.rb

@@ -112,5 +112,19 @@ module YiffSpace
     def images
       @images ||= Images.new
     end
+
+    # Named `--steps` presets for `bin/rails generate yiffspace:fixer`. See
+    # YiffSpace::Configuration::FixerTemplates.
+    def fixer_templates
+      @fixer_templates ||= FixerTemplates.new
+    end
+
+    # Directory scanned for YiffSpace::FixerTemplate subclasses (see FixerTemplate) - defaults to
+    # db/fixer_templates in the host app.
+    attr_writer(:fixer_templates_path)
+
+    def fixer_templates_path
+      @fixer_templates_path ||= Rails.root.join("db/fixer_templates")
+    end
   end
 end

data/lib/yiffspace/fix_tracker.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  # Tracks which db/fixes/*.rb scripts a host app has applied, in a `fixes` table (see
+  # db/migrate/*_create_fixes.rb) the same way ActiveRecord's own schema_migrations table
+  # tracks migrations. Used by the `fixes:*` rake tasks (lib/tasks/fixes.rake).
+  module FixTracker
+    module_function
+
+    def fix_path(name)
+      Rails.root.glob("db/fixes/#{name}.rb").first
+    end
+
+    # db/fixes filenames are "<id>_description.rb", occasionally "<id>_<index>_description.rb"
+    # (e.g. 1_1_..., 1_2_...) for a handful of fixes split into ordered steps - the `fixes`
+    # table mirrors this as an (id, index) pair, with index null for fixes with no subtype.
+    def key_for(name)
+      id, maybe_index = name.split("_", 3)
+      index = maybe_index =~ /\A\d+\z/ ? maybe_index.to_i : nil
+      [id.to_i, index]
+    end
+
+    # Sort on the (id, index) parts, not the filename string, so 12 doesn't sort before 2_2.
+    def sort_key(name)
+      id, index = key_for(name)
+      [id, index || 0]
+    end
+
+    # Only numbered one-time fixes are tracked/auto-applied - a host app's db/fixes may also hold
+    # reusable on-demand maintenance scripts that aren't meant to run automatically as part of
+    # `fixes:migrate`. Those stay reachable via `fixes:run[name]`.
+    def all_fixes
+      Rails.root.glob("db/fixes/*.rb").map { |path| File.basename(path, ".rb") }.grep(/\A\d/).sort_by { |name| sort_key(name) }
+    end
+
+    def applied
+      ActiveRecord::Base.connection.select_rows('SELECT id, "index" FROM fixes').to_set
+    end
+
+    def applied?(name)
+      id, index = key_for(name)
+      conn = ActiveRecord::Base.connection
+      index_clause = index.nil? ? '"index" IS NULL' : %("index" = #{index})
+      conn.select_value("SELECT 1 FROM fixes WHERE id = #{id} AND #{index_clause}").present?
+    end
+
+    def pending
+      applied_keys = applied
+      all_fixes.reject { |name| applied_keys.include?(key_for(name)) }
+    end
+
+    def record!(name)
+      id, index = key_for(name)
+      conn = ActiveRecord::Base.connection
+      conn.execute(<<~SQL.squish)
+        INSERT INTO fixes (id, "index") VALUES (#{id}, #{index || 'NULL'})
+        ON CONFLICT (id, "index") DO NOTHING
+      SQL
+    end
+
+    def run!(path)
+      name = File.basename(path, ".rb")
+      load(File.expand_path(path))
+      record!(name)
+      name
+    end
+
+    # Mirrors how ActiveRecord appends `INSERT INTO "schema_migrations"` to structure.sql after
+    # a schema dump (see Connection#dump_schema_versions) - appends the currently-applied fixes
+    # the same way, so loading structure.sql into a fresh database marks them applied too instead
+    # of leaving `fixes:migrate` to re-run every historical fix. Hooked into `db:schema:dump` in
+    # lib/tasks/fixes.rake, so it runs on every schema dump, not just `fixes:migrate`.
+    def dump_structure_sql!
+      db_config = ActiveRecord::Base.connection_db_config
+      return unless db_config.schema_format == :sql
+
+      filename = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(db_config)
+      return unless filename && File.exist?(filename)
+
+      conn = ActiveRecord::Base.connection
+      return unless conn.table_exists?(:fixes)
+
+      rows = conn.select_rows('SELECT id, "index" FROM fixes ORDER BY id DESC, "index" DESC NULLS LAST')
+      return if rows.empty?
+
+      values = rows.map { |id, index| "(#{id}, #{index || 'NULL'})" }.join(",\n")
+      File.open(filename, "a") do |f|
+        f.puts(<<~TEXT)
+          INSERT INTO "fixes" (id, "index") VALUES
+          #{values};
+        TEXT
+      end
+    end
+  end
+end

data/lib/yiffspace/fixer_template.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  # Base class for a `bin/rails generate yiffspace:fixer` template, auto-discovered from *.rb
+  # files in YiffSpace.config.fixer_templates_path (default db/fixer_templates) - no explicit
+  # registration needed, just define a subclass:
+  #
+  #   class ElasticsearchTemplate < YiffSpace::FixerTemplate
+  #     short("e")
+  #
+  #     step { "..." }
+  #     step { "..." }
+  #   end
+  #
+  # The template's name comes from the class name with a trailing "Template" dropped and
+  # kebab-cased (ElasticsearchTemplate -> "elasticsearch", OpenSearchTemplate -> "open-search"),
+  # reachable as `--template <name>` (see Yiffspace::FixerGenerator). Its step count is the
+  # number of `step` blocks - each one's return value becomes that step's fix file content,
+  # instead of the generic fixer.rb template a plain `--steps N` copies for every step.
+  class FixerTemplate
+    class << self
+      # Optional - a template is always reachable via `--template <name>`, a registered
+      # shortname flag (e.g. `-e`) is just a convenient alias for it.
+      def short(value = nil)
+        @short = value.to_s.delete_prefix("-") unless value.nil?
+        @short
+      end
+
+      def step(&block)
+        raise(ArgumentError, "#{name}.step requires a block") unless block
+
+        steps << block
+      end
+
+      def steps
+        @steps ||= []
+      end
+
+      def template_name
+        name.demodulize.delete_suffix("Template").underscore.dasherize
+      end
+    end
+  end
+end

data/lib/yiffspace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module YiffSpace
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/lib/yiffspace.rb

@@ -21,6 +21,7 @@ loader.inflector.inflect({ "postgresql" => "PostgreSQL", "yiffspace" => "YiffSpa
 loader.ignore("#{__dir__}/yiffspace/core_ext")
 loader.ignore("#{__dir__}/yiffspace/include")
 loader.ignore("#{__dir__}/yiffspace/engine.rb")
+loader.ignore("#{__dir__}/generators")
 loader.setup
 
 # Require the engine eagerly so it registers with Rails before the host app's

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: yiffspace
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Donovan_DMC
 bindir: bin
 cert_chain: []
-date: 2026-08-21 00:00:00.000000000 Z
+date: 2026-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abbrev
@@ -97,6 +97,12 @@ files:
 - app/models/yiff_space/application_record.rb
 - app/views/layouts/yiff_space/application.html.erb
 - app/views/yiff_space/error.html.erb
+- lib/generators/yiffspace/fixer/USAGE
+- lib/generators/yiffspace/fixer/fixer_generator.rb
+- lib/generators/yiffspace/fixer/templates/fixer.rb
+- lib/generators/yiffspace/install/fixes_generator.rb
+- lib/generators/yiffspace/install/templates/create_fixes.rb.erb
+- lib/tasks/fixes.rake
 - lib/yiffspace.rb
 - lib/yiffspace/concerns/active_record_extensions.rb
 - lib/yiffspace/concerns/api_methods.rb
@@ -112,6 +118,7 @@ files:
 - lib/yiffspace/concerns/user_resolvable_methods.rb
 - lib/yiffspace/config_builder.rb
 - lib/yiffspace/configuration.rb
+- lib/yiffspace/configuration/fixer_templates.rb
 - lib/yiffspace/configuration/images.rb
 - lib/yiffspace/core_ext/active_record/all.rb
 - lib/yiffspace/core_ext/active_record/cross_join_lateral.rb
@@ -151,6 +158,8 @@ files:
 - lib/yiffspace/extensions/object/to_b.rb
 - lib/yiffspace/extensions/object/truthy_falsy.rb
 - lib/yiffspace/extensions/string/sql.rb
+- lib/yiffspace/fix_tracker.rb
+- lib/yiffspace/fixer_template.rb
 - lib/yiffspace/images.rb
 - lib/yiffspace/images/avatar.rb
 - lib/yiffspace/images/avatar/base.rb