decko 0.11.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bb1203eba43f58959d97efbfb758f1381d7db1ac7816d73cb5dfa033dc6643b
-  data.tar.gz: 496f2f2b1d9552f716379e9d25e6ebf24085993e4030ff656d717e7f9cd68b14
+  metadata.gz: 8bb3b3da3fa9c6e8e1fe97ee9ab4fa406b7c3dcb5850db324c1404ac378de442
+  data.tar.gz: 4878e14c56ef66cc61cc376aa6c6f0a2cdbc9c0dc7e6b4d4308b140f8b688c91
 SHA512:
-  metadata.gz: 6ced715eed9b7f6c0956598955021106a396a1beb82cac21762ddcf9f69aefc6f94121945e20e6d1a434237cf3dddee35f75b474510e11bf6ebfa63ee51570a2
-  data.tar.gz: bf9643036097f1475b8aab433419b20f27a46a85d4dd1fb4397ffd207a4fee607265cb32d8839cd2473e74db97ec63ecb263acd15c0746679a3f584fd5482a99
+  metadata.gz: afbfc8a1b33c3e00f4734fb89c25c02abdadb6fb50e9b31b1056409123ccd9237a23069332ef1aea8f0c8f1372a6e47408e9deef742b123c817bffb08c48d736
+  data.tar.gz: a8a564f378ecbbb8ac75f0087f2f5e9daa93fd000962ded9e90779caf09fe9c6dcd543c150ea3a35dfcd03b05050c9a0b58782070c0a49d2016033bf14e8a60a

data/bin/decko

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
 
-git_path = File.expand_path("../../../.git", __FILE__)
+git_path = File.expand_path("../../.git", __dir__)
 
 if File.exist?(git_path)
-  railties_path = File.expand_path("../../lib", __FILE__)
+  railties_path = File.expand_path("../lib", __dir__)
   $LOAD_PATH.unshift(railties_path)
 end
 require "decko/cli"

data/lib/card_controller.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+
+# Decko's only controller.
+class CardController < ActionController::Base
+  include Mark
+  include Rest
+  include Response
+  include Errors
+  extend Errors::Rescue
+
+  # NOTE: including Card::Env::Location triggers card loading, which triggers mod loading,
+  # which can include initializers that add to the CardController class.
+  # It's important that it come *after* the modules above, so that mod modules
+  # can override them.
+  include ::Card::Env::Location
+
+  layout nil
+  attr_reader :card
+
+  before_action :setup, except: [:asset]
+  before_action :authenticate, except: [:asset]
+  before_action :load_mark, only: [:read]
+  before_action :load_card, except: [:asset]
+  before_action :load_action, only: [:read]
+  before_action :refresh_card, only: %i[create update delete]
+
+  rescue_from_class(*Card::Error::UserError.user_error_classes)
+  rescue_from_class StandardError if rescue_all?
+end

data/{rails/controllers → lib}/card_controller/errors.rb

@@ -1,21 +1,23 @@
 # Decko's only controller.
 class CardController
-  class << self
-    def rescue_from_class *klasses
-      klasses.each do |klass|
-        rescue_from(klass) { |exception| handle_exception exception }
+  # controller error handling
+  module Errors
+    # controller class method to handle top-level error rescuing
+    module Rescue
+      def rescue_from_class *klasses
+        klasses.each do |klass|
+          rescue_from(klass) { |exception| handle_exception exception }
+        end
       end
-    end
 
-    def rescue_all?
-      Cardio.config.rescue_all_in_controller
+      def rescue_all?
+        Cardio.config.rescue_all_in_controller
+      end
     end
-  end
 
-  # controller error handling
-  module Errors
     def handle_exception exception
       raise exception if debug_exception?(exception)
+
       @card ||= Card.new
       error = Card::Error.report exception, card
       show error.class.view, error.class.status_code
@@ -29,7 +31,4 @@ class CardController
         Card[:debugger]&.content =~ /on/  # && !Card::Env.ajax?
     end
   end
-
-  rescue_from_class(*Card::Error::UserError.user_error_classes)
-  rescue_from_class StandardError if rescue_all?
 end

data/lib/card_controller/mark.rb

@@ -0,0 +1,66 @@
+class CardController
+  # methods for interpretation of card marks requested
+  module Mark
+    private
+
+    def load_mark
+      params[:mark] = interpret_mark params[:mark]
+    end
+
+    def interpret_mark mark
+      case mark
+      when "*previous"
+        # Why support this? It's only needed in Success, right? Deprecate?
+        hard_redirect Card::Env.previous_location
+      when nil
+        implicit_mark
+      else
+        explicit_mark mark
+      end
+    end
+
+    def explicit_mark mark
+      # we should find the place where we produce these bad urls
+      mark.valid_encoding? ? mark : mark.force_encoding("ISO-8859-1").encode("UTF-8")
+    end
+
+    def implicit_mark
+      case
+      when initial_setup
+        ""
+      when (name = mark_from_card_hash)
+        name
+      when view_does_not_require_name?
+        ""
+      else
+        home_mark
+      end
+    end
+
+    def home_mark
+      Card::Rule.global_setting(:home) || "Home"
+    end
+
+    def view_does_not_require_name?
+      return false unless (view = params[:view]&.to_sym)
+
+      Card::Set::Format::AbstractFormat::ViewOpts.unknown_ok[view]
+    end
+
+    def mark_from_card_hash
+      params.dig :card, :name
+    end
+
+    # alters params
+    def initial_setup
+      return unless Card::Auth.needs_setup? && Card::Env.html?
+
+      prepare_setup_card!
+    end
+
+    def prepare_setup_card!
+      params[:card] = { type_id: Card.default_accounted_type_id }
+      params[:view] = "setup"
+    end
+  end
+end

data/lib/{decko → card_controller}/response.rb

@@ -1,4 +1,4 @@
-module Decko
+class CardController
   # methods for managing decko responses
   module Response
     def response_format
@@ -72,13 +72,8 @@ module Decko
 
     def require_card_for_soft_redirect!
       return if card.is_a? Card
-      raise Card::Error, "tried to do soft redirect without a card"
-    end
 
-    # (obviously) deprecated
-    def send_deprecated_asset
-      filename = [params[:mark], params[:format]].compact.join(".")
-      send_file asset_file_path(filename), x_sendfile: true
+      raise Card::Error, "tried to do soft redirect without a card"
     end
 
     def asset_file_path filename
@@ -107,64 +102,13 @@ module Decko
     end
 
     def format_name_from_params
-      if explicit_file_format?       then :file
-      elsif params[:format].present? then params[:format].to_sym
-      else                                request.format.to_sym
-      end
+      return :file if explicit_file_format?
+
+      (params[:format].present? ? params[:format] : request.format).to_sym
     end
 
     def explicit_file_format?
       params[:explicit_file] || !Card::Format.registered.member?(request.format)
     end
-
-    def interpret_mark mark
-      case mark
-      when "*previous"
-        # Why support this? It's only needed in Success, right? Deprecate?
-        return hard_redirect(Card::Env.previous_location)
-      when nil
-        implicit_mark
-      else
-        explicit_mark mark
-      end
-    end
-
-    def explicit_mark mark
-      # we should find the place where we produce these bad urls
-      mark.valid_encoding? ? mark : mark.force_encoding("ISO-8859-1").encode("UTF-8")
-    end
-
-    def implicit_mark
-      case
-      when initial_setup                    then ""
-      when (name = params.dig :card, :name) then name
-      when view_does_not_require_name?      then ""
-      else                                       home_mark
-      end
-    end
-
-    def home_mark
-      Card::Rule.global_setting(:home) || "Home"
-    end
-
-    def view_does_not_require_name?
-      return false unless (view = params[:view]&.to_sym)
-      Card::Set::Format::AbstractFormat::ViewOpts.unknown_ok[view]
-    end
-
-    # alters params
-    def initial_setup
-      return unless initial_setup?
-      prepare_setup_card!
-    end
-
-    def initial_setup?
-      Card::Auth.needs_setup? && Card::Env.html?
-    end
-
-    def prepare_setup_card!
-      params[:card] = { type_id: Card.default_accounted_type_id }
-      params[:view] = "setup"
-    end
   end
 end

data/lib/card_controller/rest.rb

@@ -0,0 +1,105 @@
+class CardController
+  # RESTful action methods for card
+  module Rest
+    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    #  PUBLIC METHODS
+
+    def create
+      handle { card.save! }
+    end
+
+    def read
+      show
+    end
+
+    def update
+      card.new_card? ? create : handle { card.update! params[:card]&.to_unsafe_h }
+    end
+
+    def delete
+      handle { card.delete! }
+    end
+
+    # @deprecated
+    def asset
+      body = "Decko installation error: missing asset symlinks"
+      Rails.logger.info "#{body}.\n  >>> Try `rake decko:update_assets_symlink`"
+      render body: body, status: 404
+    end
+
+    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    #  PRIVATE METHODS
+
+    private
+
+    def setup
+      Card::Machine.refresh_script_and_style unless params[:explicit_file]
+      Card::Cache.renew
+      Card::Env.reset controller: self
+    end
+
+    def authenticate
+      Card::Auth.signin_with params
+    end
+
+    def load_card
+      @card = Card.uri_fetch params
+      raise Card::Error::NotFound unless card
+
+      record_as_main
+    end
+
+    def load_action
+      card.select_action_by_params params
+      return unless params[:edit_draft] && card.drafts.present?
+
+      card.content = card.last_draft_content
+    end
+
+    # TODO: refactor this away this when new layout handling is ready
+    def record_as_main
+      Card::Env[:main_name] = params[:main] || card&.name || ""
+    end
+
+    def refresh_card
+      @card = card.refresh
+    end
+
+    # ----------( HELPER METHODS ) -------------
+
+    def handle
+      Card::Env.success card.name
+      yield ? cud_success : raise(Card::Error::UserError)
+    end
+
+    # successful create, update, or delete act
+    def cud_success
+      success = Card::Env.success.in_context card.name
+      if success.reload?
+        reload # instruct JSON to reload
+      else
+        redirect_cud_success success
+      end
+    end
+
+    def show view=nil, status=200
+      card.action = :read
+      format = load_format status
+      result = render_page format, view
+      status = format.error_status || status
+      respond format, result, status
+    end
+
+    def render_page format, view
+      view ||= view_from_params
+      card.act do
+        format.page self, view, Card::Env.slot_opts
+      end
+    end
+
+    def view_from_params
+      %i[view v].each { |k| return params[k] if params[k].present? }
+      nil
+    end
+  end
+end

data/lib/decko.rb

@@ -1,23 +1,9 @@
-
 module Decko
-  DECKO_GEM_ROOT = File.expand_path("../..", __FILE__)
+  DECKO_GEM_ROOT = File.expand_path("..", __dir__)
 
   class << self
-    def root
-      Rails.root
-    end
-
-    def application
-      Rails.application
-    end
-
-    def config
-      application.config
-    end
-
-    def paths
-      application.paths
-    end
+    delegate :application, :root, to: :Rails
+    delegate :config, :paths, to: :application
 
     def gem_root
       DECKO_GEM_ROOT

data/lib/decko/all.rb

@@ -1 +1,3 @@
+# backwards compatibility for old decks that require decko/all
+
 require "decko/application"

data/lib/decko/application.rb

@@ -1,16 +1,20 @@
 # -*- encoding : utf-8 -*-
 
-require "decko/engine"
-require_relative "config/initializers/sedate_parser"
+require "action_controller/railtie"
+require "cardio/application"
 
-Bundler.require :default, *Rails.groups
+# require_relative "config/initializers/sedate_parser"
 
 module Decko
-  class Application < Rails::Application
-    initializer :load_decko_environment_config,
+  # The application class from which all decko applications inherit
+  class Application < Cardio::Application
+    require "decko/engine"
+
+    card_environment_initializer
+
+    initializer "decko.load_environment_config",
                 before: :load_environment_config, group: :all do
-      add_path paths, "lib/decko/config/environments", glob: "#{Rails.env}.rb"
-      paths["lib/decko/config/environments"].existent.each do |environment|
+      paths["decko/config/environments"].existent.each do |environment|
         require environment
       end
     end
@@ -24,36 +28,9 @@ module Decko
       end
     end
 
-    def add_path paths, path, options={}
-      root = options.delete(:root) || Decko.gem_root
-      options[:with] = File.join(root, (options[:with] || path))
-      paths.add path, options
-    end
-
     def config
-      @config ||= begin
-        config = super
-
-        Cardio.set_config config
-
-        # any config settings below:
-        # (a) do not apply to Card used outside of a Decko context
-        # (b) cannot be overridden in a deck's application.rb, but
-        # (c) CAN be overridden in an environment file
-
-        # therefore, in general, they should be restricted to settings that
-        # (1) are specific to the web environment, and
-        # (2) should not be overridden
-        # ..and we should address (c) above!
-
-        # general card settings (overridable and not) should be in cardio.rb
-        # overridable decko-specific settings don't have a place yet
-        # but should probably follow the cardio pattern.
-
+      @config ||= super.tap do |config|
         # config.load_defaults "6.0"
-        config.autoloader = :zeitwerk
-        config.load_default = "6.0"
-        config.i18n.enforce_available_locales = true
         # config.active_record.raise_in_transactional_callbacks = true
 
         config.allow_concurrency = false
@@ -61,30 +38,22 @@ module Decko
         config.assets.version = "1.0"
 
         config.filter_parameters += [:password]
-
-        # Rails.autoloaders.log!
-        Rails.autoloaders.main.ignore(File.join(Cardio.gem_root, "lib/card/seed_consts.rb"))
-        config
+        config.autoload_paths += Dir["#{Decko.gem_root}/lib"]
+        decko_path_defaults config.paths
       end
     end
 
-    def paths
-      @paths ||= begin
-        paths = super
-        Cardio.set_paths paths
-
-        paths.add "files"
+    private
 
-        paths["app/models"] = []
-        paths["app/mailers"] = []
+    def decko_path_defaults paths
+      paths.add "decko/config/environments",
+                with: File.join(Decko.gem_root, "config/environments"),
+                glob: "#{Rails.env}.rb"
 
-        unless paths["config/routes.rb"].existent.present?
-          add_path paths, "config/routes.rb",
-                   with: "rails/application-routes.rb"
-        end
+      return if paths["config/routes.rb"].existent.present?
 
-        paths
-      end
+      paths.add "config/routes.rb",
+                with: File.join(Decko.gem_root, "rails/application-routes.rb")
     end
   end
 end