skeleton-loader 0.1.0

data/lib/skeleton_loader/configuration.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SkeletonLoader
+  # Configuration class manages settings for the SkeletonLoader gem.
+  class Configuration
+    TEMPLATE_DEFAULTS = {
+      card: { width: 200, count: 3, per_row: 3 },
+      comment: { width: 900, count: 2, per_row: 1 },
+      default: { width: 900, count: 1, per_row: 1 },
+      gallery: { width: 320, count: 3, per_row: 3 },
+      paragraph: { width: 900, count: 1, per_row: 1 },
+      product: { width: 320, count: 3, per_row: 3 },
+      profile: { width: 320, count: 3, per_row: 3 }
+    }.freeze
+
+    attr_reader :scale, :template_paths, :animation_type,
+                :additional_allowed_tags, :additional_allowed_attributes,
+                :additional_allowed_css_properties, :templates
+
+    def initialize
+      reset!
+    end
+
+    # Resets all configuration options to their defaults.
+    def reset!
+      set_general_defaults
+      set_template_defaults
+      set_animation_defaults
+      set_security_defaults
+    end
+
+    def base_options
+      {
+        scale: @scale,
+        animation_type: @animation_type,
+        additional_allowed_tags: @additional_allowed_tags,
+        additional_allowed_attributes: @additional_allowed_attributes,
+        additional_allowed_css_properties: @additional_allowed_css_properties
+      }
+    end
+
+    # Returns the default options for a specific template type
+    def template_defaults_for(type)
+      @templates[type&.to_sym || :default] || @templates[:default]
+    end
+
+    private
+
+    def set_general_defaults
+      @scale = 1.0
+      @template_paths = []
+    end
+
+    def set_template_defaults
+      @templates = TEMPLATE_DEFAULTS.dup
+    end
+
+    def set_animation_defaults
+      @animation_type = "sl-gradient"
+    end
+
+    def set_security_defaults
+      @additional_allowed_tags = []
+      @additional_allowed_attributes = {}
+      @additional_allowed_css_properties = []
+    end
+  end
+end

data/lib/skeleton_loader/engine.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SkeletonLoader
+  # SkeletonLoader::Engine integrates the SkeletonLoader gem with Rails,
+  # configuring asset paths, pre-compiling assets, and including view helpers
+  # in Action View.
+  class Engine < ::Rails::Engine
+    isolate_namespace SkeletonLoader
+
+    initializer "skeleton_loader.assets" do |app|
+      # CSS always through asset pipeline
+      app.config.assets.paths << root.join("app/assets/stylesheets")
+      app.config.assets.precompile += %w[skeleton_loader.css]
+
+      if defined?(Webpacker) || defined?(Shakapacker)
+        # You should use npm package
+      elsif defined?(Importmap::Engine)
+        gem_js_path = root.join("app/assets/javascripts").to_s
+        app.config.assets.paths.reject! { |path| path.to_s == gem_js_path }
+        app.config.assets.paths << root.join("dist")
+        app.config.assets.precompile += %w[skeleton_loader.js]
+      else
+        app.config.assets.paths << root.join("app/assets/javascripts")
+        app.config.assets.precompile += %w[skeleton_loader.js]
+      end
+    end
+
+    initializer "skeleton_loader.view_helpers" do
+      ActiveSupport.on_load(:action_view) { include SkeletonLoader::ViewHelpers }
+    end
+
+    initializer "skeleton_loader.append_routes" do |app|
+      app.routes.prepend do
+        mount SkeletonLoader::Engine, at: "/skeleton_loader", as: "skeleton_loader_engine"
+      end
+    end
+
+    initializer "skeleton_loader.append_migrations" do
+      config.paths["app/controllers"] << File.expand_path("../app/controllers", __dir__)
+    end
+  end
+end

data/lib/skeleton_loader/skeleton_element_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SkeletonLoader
+  #
+  # Generates skeleton loader element
+  #
+  class SkeletonElementGenerator
+    class << self
+      def generate(content_id:, options: {}, context: :view, &block)
+        validate_content_id!(content_id)
+        content = generate_content(options, &block)
+
+        css_class = context == :controller ? "skeleton-loader--client" : "skeleton-loader--server"
+        wrap_content(content, content_id, css_class)
+      end
+
+      private
+
+      def validate_content_id!(content_id)
+        raise SkeletonLoader::Error, "content_id is required" if content_id.blank?
+      end
+
+      def generate_content(options, &block)
+        content = if block_given?
+                    raise Error, "Options cannot be used with a block" unless options.empty?
+
+                    block.call
+                  else
+                    type = options[:type] || "default"
+                    template_path = TemplatePathFinder.find(type)
+                    TemplateRenderer.render(template_path, options)
+                  end
+        # rubocop:disable Rails/OutputSafety
+        # NOTE: The following use of `html_safe` is intentional
+        content.html_safe
+        # rubocop:enable Rails/OutputSafety
+      end
+
+      def wrap_content(content, content_id, css_class)
+        ActionController::Base.helpers.content_tag(
+          :div,
+          content,
+          class: css_class,
+          data: { content_id: content_id }
+        )
+      end
+    end
+  end
+end

data/lib/skeleton_loader/template_path_finder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SkeletonLoader
+  #
+  # This class is responsible for locating a specific template file by type.
+  # It searches through configured paths and defaults to searching in
+  # `app/views/skeleton_loader` within the Rails root directory.
+  # Raises an error if the template is not found.
+  #
+  class TemplatePathFinder
+    def self.find(type)
+      template_name = "_#{type}.html.erb"
+      search_paths = SkeletonLoader.configuration.template_paths +
+                     [Rails.root.join("app/views/skeleton_loader")]
+
+      search_paths.each do |path|
+        full_path = File.join(path, template_name)
+        return full_path if File.exist?(full_path)
+      end
+
+      raise "Template '#{template_name}' not found in any of the specified paths."
+    end
+  end
+end

data/lib/skeleton_loader/template_renderer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SkeletonLoader
+  #
+  # This class handles rendering templates for skeleton loaders. It retrieves
+  # template files and prepares them for display as placeholders.
+  #
+  class TemplateRenderer
+    def self.render(template_path, options = {})
+      new(template_path, options).render
+    end
+
+    def initialize(template_path, options = {})
+      @template_path = template_path
+      @options = merge_options(options)
+
+      # Dynamically set instance variables for template rendering
+      @options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def render
+      template_content = File.read(@template_path)
+      erb = ERB.new(template_content)
+      erb.result(binding)
+    rescue StandardError => e
+      raise "Error rendering template at #{@template_path}: #{e.message}"
+    end
+
+    private
+
+    def merge_options(options)
+      config = SkeletonLoader.configuration
+
+      config.base_options
+            .merge(config.template_defaults_for(options[:type]))
+            .merge(options)
+    end
+  end
+end

data/lib/skeleton_loader/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SkeletonLoader
+  VERSION = "0.1.0"
+end

data/lib/skeleton_loader/view_helpers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SkeletonLoader
+  # Provides helper methods for rendering skeleton loaders in views.
+  module ViewHelpers
+    def skeleton_loader(content_id:, **options, &block)
+      SkeletonElementGenerator.generate(content_id: content_id, options: options, &block)
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    private
+
+    def handle_error(error)
+      Rails.logger.error "Error in skeleton_loader helper: #{error.message}"
+      raise
+    end
+  end
+end

data/lib/skeleton_loader.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "skeleton_loader/version"
+require "skeleton_loader/configuration"
+require "skeleton_loader/view_helpers"
+require "skeleton_loader/template_path_finder"
+require "skeleton_loader/template_renderer"
+require "skeleton_loader/skeleton_element_generator"
+require "skeleton_loader/engine"
+
+require "action_view"
+#
+# This module serves as the entry point for the SkeletonLoader gem, which provides
+# configurable skeleton loaders for Rails views. It includes configuration methods,
+# custom error handling, and auto-loading for key classes and helpers.
+#
+# Usage:
+# Configure by calling `SkeletonLoader.configure` and provide settings, such as
+# template paths. SkeletonLoader provides view helpers and uses ActionView for
+# generating HTML components for skeleton loaders.
+#
+module SkeletonLoader
+  class Error < StandardError; end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration) if block_given?
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+end

data/lib/tasks/skeleton_loader_tasks.rake

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+namespace :skeleton_loader do
+  desc "Build JavaScript for all targets"
+  task build_js: :environment do
+    # Run webpack build
+    system("yarn build")
+
+    # Ensure assets/javascripts exists
+    FileUtils.mkdir_p("app/assets/javascripts")
+
+    # Copy webpack build to asset pipeline
+    FileUtils.cp(
+      "dist/skeleton-loader.js",
+      "app/assets/javascripts/skeleton_loader.js"
+    )
+
+    puts "✓ Built successfully!"
+    puts "  → Source: app/javascript/"
+    puts "  → NPM build: dist/skeleton-loader.js"
+    puts "  → Asset Pipeline: app/assets/javascripts/skeleton_loader.js"
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: skeleton-loader
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Emad Rahimi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-12-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: Provides customizable, responsive skeleton loaders for Rails views.
+email:
+- 121079771+ersync@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- app/assets/javascripts/skeleton_loader.js
+- app/assets/javascripts/skeleton_loader.js.LICENSE.txt
+- app/assets/stylesheets/skeleton_loader.css
+- app/controllers/skeleton_loader/skeleton_loader_controller.rb
+- app/javascript/client_skeleton_loader.js
+- app/javascript/server_skeleton_loader.js
+- app/javascript/skeleton_loader.js
+- config/routes.rb
+- lib/generators/skeleton_loader/add_templates_generator.rb
+- lib/generators/skeleton_loader/reset_templates_generator.rb
+- lib/generators/skeleton_loader/templates/_card.html.erb
+- lib/generators/skeleton_loader/templates/_comment.html.erb
+- lib/generators/skeleton_loader/templates/_default.html.erb
+- lib/generators/skeleton_loader/templates/_gallery.html.erb
+- lib/generators/skeleton_loader/templates/_paragraph.html.erb
+- lib/generators/skeleton_loader/templates/_product.html.erb
+- lib/generators/skeleton_loader/templates/_profile.html.erb
+- lib/skeleton-loader.rb
+- lib/skeleton_loader.rb
+- lib/skeleton_loader/configuration.rb
+- lib/skeleton_loader/engine.rb
+- lib/skeleton_loader/skeleton_element_generator.rb
+- lib/skeleton_loader/template_path_finder.rb
+- lib/skeleton_loader/template_renderer.rb
+- lib/skeleton_loader/version.rb
+- lib/skeleton_loader/view_helpers.rb
+- lib/tasks/skeleton_loader_tasks.rake
+homepage: https://github.com/ersync/skeleton-loader
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ersync/skeleton-loader
+  source_code_uri: https://github.com/ersync/skeleton-loader
+  changelog_uri: https://github.com/ersync/skeleton-loader/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: A Ruby on Rails gem for skeleton loading screens.
+test_files: []