madmin-static_models 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 50348135ce76b0e9c74e3fc26c2d0cf99af7a371ccfa1cfc0d5aa1e8b25d6f84
+  data.tar.gz: 7a45e2cf576dbf07bbf285c749cd0af4c57ce186090f80f6b17e8ed22f8dd3e8
+SHA512:
+  metadata.gz: c7ac57164d43bb5d708d788b8838ccbce6dea8a3b0e0379df90869b620700a1fb2a0b7072e099849f570427abe1d50fdb16aa931eb1c7ccb508bb87a32922ddb
+  data.tar.gz: '072779c79e1ce89a000ddfbf7b5e86bb07f957f3da64bb5af81f1f8a1c7cd6063548d9047583e5f1c44ea26b6fdaac273b231c26dc16c70c44c1b0ce7153454c'

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 0.1.0
+
+- Initial release: ActiveHash adapter (covers ActiveHash, ActiveYaml, ActiveJson and ActiveFile models), read-only resources, in-memory search/sort/pagination, generator support, and an adapter API for other static backends.
+- Requires madmin >= 2.6 (extension load hooks and seams).

data/README.md

@@ -0,0 +1,94 @@
+# Madmin Static Models
+
+Browse read-only, in-memory models in your [Madmin](https://github.com/excid3/madmin) admin.
+
+Supports [active_hash](https://github.com/active-hash/active_hash) models out of the box — `ActiveHash::Base`, `ActiveYaml::Base`, `ActiveJson::Base` and `ActiveFile::Base` — with an adapter layer for adding other static backends (e.g. frozen_record) later.
+
+Static resources get:
+
+- Index, show, search, sorting and pagination — all done in memory, no SQL
+- Automatic read-only behavior: no new/edit/delete links, write actions redirect away
+- Generator support: `rails g madmin:install` and `rails g madmin:resource` pick up static models
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "madmin-static_models"
+```
+
+Requires madmin >= 2.6.
+
+## Usage
+
+Define a static model:
+
+```ruby
+class Country < ActiveHash::Base
+  fields :name, :code
+
+  self.data = [
+    {id: 1, name: "United States", code: "US"},
+    {id: 2, name: "Canada", code: "CA"}
+  ]
+end
+```
+
+Generate its admin resource (or write it by hand):
+
+```bash
+rails g madmin:resource Country
+```
+
+```ruby
+class CountryResource < Madmin::Resource
+  attribute :id, form: false
+  attribute :name
+  attribute :code
+end
+```
+
+That's it — the resource shows up in Madmin like any other, minus the write actions.
+
+## How it works
+
+The gem attaches to Madmin through its `ActiveSupport` load hooks (`:madmin_resource`, `:madmin_resource_controller`) and prepends small modules that answer differently for static models and call `super` for everything else:
+
+- `Resource.readonly?` returns true, which makes Madmin hide write links and block write actions
+- `Resource.model_column_names` comes from the adapter instead of the database
+- Pagination, sorting and search run over plain arrays in memory
+- `show_path`/`edit_path` are built manually since static records don't support polymorphic routing
+
+## Adding a backend
+
+An adapter is a class with three methods. Register it and matching models are treated as static:
+
+```ruby
+class FrozenRecordAdapter < Madmin::StaticModels::Adapter
+  def self.handles?(model)
+    model < ::FrozenRecord::Base
+  end
+
+  def self.column_names(model)
+    [model.primary_key.to_s, *model.attributes].uniq
+  end
+
+  def self.models
+    ::FrozenRecord::Base.descendants
+  end
+end
+
+Madmin::StaticModels.register(FrozenRecordAdapter)
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+## License
+
+MIT

data/lib/madmin/static_models/adapter.rb

@@ -0,0 +1,25 @@
+module Madmin
+  module StaticModels
+    # Base class for static model backends. An adapter declares which model
+    # classes it manages and how to introspect them. Register one with:
+    #
+    #   Madmin::StaticModels.register(MyAdapter)
+    class Adapter
+      # True if this adapter manages the given model class.
+      def self.handles?(model)
+        false
+      end
+
+      # Ordered attribute names (strings) for the model, primary key first.
+      def self.column_names(model)
+        []
+      end
+
+      # All model classes managed by this adapter that are currently loaded.
+      # Used by the install generator to create resources.
+      def self.models
+        []
+      end
+    end
+  end
+end

data/lib/madmin/static_models/adapters/active_hash.rb

@@ -0,0 +1,27 @@
+module Madmin
+  module StaticModels
+    module Adapters
+      # Backend for active_hash models. Covers ActiveHash::Base and its
+      # subclasses, which includes ActiveYaml::Base, ActiveJSON::Base and
+      # ActiveFile::Base.
+      class ActiveHash < Adapter
+        # Abstract base classes shipped by the active_hash gem itself.
+        BASE_CLASSES = %w[ActiveHash::Base ActiveFile::Base ActiveYaml::Base ActiveJson::Base ActiveJSON::Base]
+
+        def self.handles?(model)
+          model < ::ActiveHash::Base
+        end
+
+        def self.column_names(model)
+          ([model.primary_key.to_s] + model.field_names.map(&:to_s)).uniq
+        end
+
+        def self.models
+          ObjectSpace.each_object(::ActiveHash::Base.singleton_class).reject do |model|
+            model.name.nil? || BASE_CLASSES.include?(model.name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/madmin/static_models/controller_extension.rb

@@ -0,0 +1,59 @@
+module Madmin
+  module StaticModels
+    # Prepended to Madmin::ResourceController.
+    module ControllerExtension
+      private
+
+      def scoped_resources
+        return super unless StaticModels.static_model?(resource.model)
+
+        resources = resource.model.send(valid_scope)
+        resources = Madmin::Search.new(resources, resource, search_term).run
+
+        return resources if sort_column.blank?
+
+        sort_static(resources, sort_column, sort_direction)
+      end
+
+      def paginate_collection(collection)
+        return super unless StaticModels.static_model?(resource.model)
+
+        paginate_static(collection)
+      end
+
+      def paginate_static(collection)
+        records = collection.to_a
+
+        # Pagy >= 43 paginates plain arrays natively, with the request context
+        # that its nav helpers need.
+        return pagy(records) if defined?(Pagy::Method) && is_a?(Pagy::Method)
+
+        # Older pagy: build the pager by hand.
+        page = [params[:page].to_i, 1].max
+        defaults = Pagy::DEFAULT || {}
+        limit = (params[:limit] || defaults[:limit] || defaults[:items] || 20).to_i
+        pager = begin
+          Pagy.new(count: records.size, page: page, limit: limit)
+        rescue ArgumentError
+          Pagy.new(count: records.size, page: page, items: limit)
+        end
+        per_page = pager.respond_to?(:limit) ? pager.limit : pager.items
+        [pager, records.slice(pager.offset, per_page) || []]
+      end
+
+      def sort_static(collection, column, direction)
+        records = collection.to_a.sort do |a, b|
+          a_value = a.public_send(column) if a.respond_to?(column)
+          b_value = b.public_send(column) if b.respond_to?(column)
+          if a_value.nil? || b_value.nil?
+            # Sort records without a value last
+            (a_value.nil? ? 1 : 0) <=> (b_value.nil? ? 1 : 0)
+          else
+            (a_value <=> b_value) || (a_value.to_s <=> b_value.to_s)
+          end
+        end
+        (direction.to_s == "desc") ? records.reverse : records
+      end
+    end
+  end
+end

data/lib/madmin/static_models/generator_extensions.rb

@@ -0,0 +1,44 @@
+require "rails/generators"
+require "generators/madmin/install/install_generator"
+require "generators/madmin/resource/resource_generator"
+
+module Madmin
+  module StaticModels
+    module InstallGeneratorExtension
+      def generate_resources
+        generateable_models.each do |model|
+          if StaticModels.static_model?(model) || model.table_exists?
+            call_generator "madmin:resource", model.to_s
+          else
+            puts "Skipping #{model} because database table does not exist"
+          end
+        end
+      end
+
+      private
+
+      def generateable_models
+        static = StaticModels.adapters.flat_map(&:models).reject { |model| model.name.nil? }
+        super.to_a + static
+      end
+    end
+
+    module ResourceGeneratorExtension
+      private
+
+      def options_for_attribute(name)
+        adapter = StaticModels.adapter_for(model)
+        return super unless adapter
+
+        if name == model.primary_key.to_s
+          {form: false}
+        elsif !adapter.column_names(model).include?(name)
+          {index: false}
+        end
+      end
+    end
+  end
+end
+
+Madmin::Generators::InstallGenerator.prepend Madmin::StaticModels::InstallGeneratorExtension
+Madmin::Generators::ResourceGenerator.prepend Madmin::StaticModels::ResourceGeneratorExtension

data/lib/madmin/static_models/railtie.rb

@@ -0,0 +1,34 @@
+module Madmin
+  module StaticModels
+    class Railtie < ::Rails::Railtie
+      initializer "madmin.static_models" do |app|
+        # Madmin::ResourceController is reloadable, so patch it lazily via
+        # madmin's load hook whenever it (re)loads.
+        ActiveSupport.on_load(:madmin_resource_controller) do
+          prepend Madmin::StaticModels::ControllerExtension
+        end
+
+        ActiveSupport.on_load(:madmin_resource) do
+          singleton_class.prepend Madmin::StaticModels::ResourceExtension
+        end
+
+        # Plain lib classes; referencing them triggers madmin's autoload.
+        Madmin::Search.prepend Madmin::StaticModels::SearchExtension
+        Madmin::ResourceBuilder.prepend Madmin::StaticModels::ResourceBuilderExtension
+
+        app.config.after_initialize do
+          unless Madmin::Resource.singleton_class.include?(Madmin::StaticModels::ResourceExtension)
+            # The :madmin_resource load hook never fired, so this madmin
+            # predates the extension seams (readonly?, model_column_names,
+            # paginate_collection) that this gem builds on.
+            warn "madmin-static_models requires madmin >= 2.6 (extension load hooks and seams)."
+          end
+        end
+      end
+
+      generators do
+        require "madmin/static_models/generator_extensions"
+      end
+    end
+  end
+end

data/lib/madmin/static_models/resource_builder_extension.rb

@@ -0,0 +1,11 @@
+module Madmin
+  module StaticModels
+    # Prepended to Madmin::ResourceBuilder.
+    module ResourceBuilderExtension
+      def attributes
+        adapter = StaticModels.adapter_for(model)
+        adapter ? adapter.column_names(model) : super
+      end
+    end
+  end
+end

data/lib/madmin/static_models/resource_extension.rb

@@ -0,0 +1,41 @@
+module Madmin
+  module StaticModels
+    # Prepended to Madmin::Resource's singleton class.
+    module ResourceExtension
+      def readonly?
+        StaticModels.static_model?(model) || super
+      end
+
+      def model_column_names
+        adapter = StaticModels.adapter_for(model)
+        adapter ? adapter.column_names(model) : super
+      end
+
+      # Static records can't be passed to polymorphic_path (no #becomes,
+      # not backed by ActiveModel routing), so build the paths by hand.
+      def show_path(record)
+        return super unless StaticModels.static_model?(model)
+
+        "#{index_path}/#{record.id}"
+      end
+
+      def edit_path(record)
+        return super unless StaticModels.static_model?(model)
+
+        "#{index_path}/#{record.id}/edit"
+      end
+
+      def infer_type(name)
+        return super unless StaticModels.static_model?(model)
+
+        if model_column_names.include?(name.to_s)
+          :string
+        elsif model.respond_to?(:reflect_on_association) && (association = model.reflect_on_association(name))
+          type_for_association(association)
+        else
+          :string
+        end
+      end
+    end
+  end
+end

data/lib/madmin/static_models/search_extension.rb

@@ -0,0 +1,25 @@
+module Madmin
+  module StaticModels
+    # Prepended to Madmin::Search. Static models have no SQL backend, so
+    # search filters records in memory instead.
+    module SearchExtension
+      def run
+        return super unless StaticModels.static_model?(@resource.model)
+        return @scoped_resource.all if query.blank?
+
+        static_search(@scoped_resource)
+      end
+
+      private
+
+      def static_search(resources)
+        pattern = Regexp.new(Regexp.escape(query), Regexp::IGNORECASE)
+        fields = search_attributes.flat_map { |attribute| searchable_fields(attribute) }
+        matched = resources.all.select do |record|
+          fields.any? { |field| record.respond_to?(field) && record.public_send(field).to_s.match?(pattern) }
+        end
+        resources.respond_to?(:where) ? resources.where(id: matched.map(&:id)) : matched
+      end
+    end
+  end
+end

data/lib/madmin/static_models/version.rb

@@ -0,0 +1,5 @@
+module Madmin
+  module StaticModels
+    VERSION = "0.1.0"
+  end
+end

data/lib/madmin/static_models.rb

@@ -0,0 +1,39 @@
+require "madmin"
+require "active_hash"
+
+require "madmin/static_models/version"
+require "madmin/static_models/adapter"
+require "madmin/static_models/adapters/active_hash"
+require "madmin/static_models/resource_extension"
+require "madmin/static_models/resource_builder_extension"
+require "madmin/static_models/controller_extension"
+require "madmin/static_models/search_extension"
+require "madmin/static_models/railtie"
+
+module Madmin
+  module StaticModels
+    class << self
+      def adapters
+        @adapters ||= []
+      end
+
+      def register(adapter)
+        adapters << adapter unless adapters.include?(adapter)
+      end
+
+      # Returns the adapter that manages this model class, or nil for
+      # regular (ActiveRecord) models.
+      def adapter_for(model)
+        return nil unless model.is_a?(Class)
+
+        adapters.find { |adapter| adapter.handles?(model) }
+      end
+
+      def static_model?(model)
+        !adapter_for(model).nil?
+      end
+    end
+  end
+end
+
+Madmin::StaticModels.register(Madmin::StaticModels::Adapters::ActiveHash)

data/lib/madmin-static_models.rb

@@ -0,0 +1 @@
+require "madmin/static_models"

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: madmin-static_models
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anthony Veaudry
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: madmin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: active_hash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Browse read-only, in-memory models like ActiveHash and ActiveYaml in
+  your Madmin admin, with an adapter layer for adding other static backends.
+email:
+- anthony@veaudry.pro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/madmin-static_models.rb
+- lib/madmin/static_models.rb
+- lib/madmin/static_models/adapter.rb
+- lib/madmin/static_models/adapters/active_hash.rb
+- lib/madmin/static_models/controller_extension.rb
+- lib/madmin/static_models/generator_extensions.rb
+- lib/madmin/static_models/railtie.rb
+- lib/madmin/static_models/resource_builder_extension.rb
+- lib/madmin/static_models/resource_extension.rb
+- lib/madmin/static_models/search_extension.rb
+- lib/madmin/static_models/version.rb
+homepage: https://github.com/anthony0030/madmin-static_models
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Static model support (ActiveHash, ActiveYaml, ...) for Madmin
+test_files: []