card 1.101.7 → 1.102.0

data/lib/cardio/all.rb

@@ -0,0 +1,16 @@
+require "rails"
+require "cardio"
+require "cardio/mod"
+
+%w[
+  active_record/railtie
+  active_storage/engine
+  action_view/railtie
+  action_mailer/railtie
+  active_job/railtie
+  action_mailbox/engine
+  rails/test_unit/railtie
+  sprockets/railtie
+].each do |railtie|
+  require railtie
+end

data/lib/cardio/application.rb

@@ -0,0 +1,141 @@
+require "cardio/all"
+
+Bundler.require :default, *Rails.groups
+
+# these two have railties and likely need to be loaded before application so they
+# don't override configuration later
+require "haml"
+require "kaminari"
+
+require "bootstrap4-kaminari-views"
+
+module Cardio
+  # handles config and path defaults
+  class Application < Rails::Application
+    def self.card_environment_initializer
+      initializer "card.load_environment_config",
+                  before: :load_environment_config, group: :all do
+        paths["card/config/environments"].existent.each do |environment|
+          require environment
+        end
+      end
+    end
+    card_environment_initializer
+
+    def config
+      @config ||= super.tap do |config|
+        simple_configs config
+        coded_configs config
+      end
+    end
+
+    private
+
+    def simple_configs config
+      config_from_yaml.each_pair do |setting, value|
+        config.send "#{setting}=", *value
+      end
+    end
+
+    # TODO: many of these defaults should be in mods!
+    def config_from_yaml
+      YAML.load_file File.expand_path("defaults.yml", __dir__)
+    end
+
+    def coded_configs config
+      config.autoloader = :zeitwerk
+      config.i18n.enforce_available_locales = true
+      config.read_only = !ENV["DECKO_READ_ONLY"].nil?
+      config.load_strategy = (ENV["REPO_TMPSETS"] || ENV["TMPSETS"] ? :tmp_files : :eval)
+      config.autoload_paths += Dir["#{Cardio.gem_root}/lib"]
+      Paths.new(config).assign
+      Cardio::Mod.each_path do |mod_path|
+        config.autoload_paths += Dir["#{mod_path}/lib"]
+        config.watchable_dirs["#{mod_path}/set"] = %i[rb haml]
+      end
+    end
+
+    class Paths
+      attr_reader :config, :paths
+
+      def initialize config
+        @config = config
+        @paths = config.paths
+      end
+
+      def assign
+        add_tmppaths
+        add_path "mod"        # add card gem's mod path
+        paths["mod"] << "mod" # add deck's mod path
+        paths.add "files"
+
+        add_db_paths
+        add_initializer_paths
+        add_mod_initializer_paths
+        add_gem_environment_path
+
+        paths["app/models"] = []
+        paths["app/mailers"] = []
+        paths["app/controllers"] = []
+      end
+
+      def add_tmppaths
+        %w[set set_pattern].each do |dir|
+          opts = tmppath_opts dir
+          add_path "tmp/#{dir}", opts if opts
+        end
+      end
+
+      def tmppath_opts dir
+        if ENV["REPO_TMPSETS"]
+          { with: "tmpsets/#{dir}" }
+        elsif ENV["TMPSETS"]
+          { root: config.root }
+        end
+      end
+
+      def add_db_paths
+        add_path "db"
+        add_path "db/migrate"
+        add_path "db/migrate_core_cards"
+        add_path "db/migrate_deck", root: config.root, with: "db/migrate"
+        add_path "db/migrate_deck_cards", root: config.root, with: "db/migrate_cards"
+        add_path "db/seeds.rb", with: "db/seeds.rb"
+      end
+
+      def add_initializer_paths
+        add_path "config/initializers", glob: "**/*.rb"
+        add_initializers config.root
+        Cardio::Mod.each_path do |mod_path|
+          add_initializers mod_path, false, "core_initializers"
+        end
+      end
+
+      def add_mod_initializer_paths
+        add_path "mod/config/initializers", glob: "**/*.rb"
+        Cardio::Mod.each_path do |mod_path|
+          add_initializers mod_path, true
+        end
+      end
+
+      def add_initializers base_dir, mod=false, init_dir="initializers"
+        Dir.glob("#{base_dir}/config/#{init_dir}").each do |initializers_dir|
+          path_mark = mod ? "mod/config/initializers" : "config/initializers"
+          paths[path_mark] << initializers_dir
+        end
+      end
+
+      def add_gem_environment_path
+        add_path "card/config/environments",
+                 glob: "#{Rails.env}.rb",
+                 with: "config/environments"
+      end
+
+      def add_path path, options={}
+        root = options.delete(:root) || Cardio.gem_root
+        options[:with] = File.join(root, (options[:with] || path))
+        paths.add path, options
+      end
+    end
+  end
+end

data/lib/cardio/cli.rb

@@ -0,0 +1,11 @@
+require "rbconfig"
+require "cardio/script_loader"
+
+# If we are inside a Decko application this method performs an exec and thus
+# the rest of this script is not run.
+Cardio::ScriptLoader.exec!
+
+require "rails/ruby_version_check"
+Signal.trap("INT") { exit(1) }
+
+require "cardio/commands/application"

data/lib/cardio/commands.rb

@@ -0,0 +1,124 @@
+require "English"
+
+module Cardio
+  # manage different types of commands that can be run via bin/card and bin/decko
+  class Commands
+    attr_reader :command, :args
+
+    # class methods for commands
+    # (basically simulates cattr_reader, which isn't available here)
+    module Accessors
+      def aliases
+        @aliases ||= {
+          "rs" => "rspec",
+          "jm" => "jasmine",
+          "g"  => "generate",
+          "d"  => "destroy",
+          "c"  => "console",
+          "db" => "dbconsole",
+          "r"  => "runner",
+          "v"  => "version",
+          "h"  => "help"
+        }
+      end
+
+      def commands
+        @commands ||= {
+          rails:  %w[generate destroy plugin benchmarker profiler
+                     console dbconsole application runner],
+          rake:   %w[seed reseed load update],
+          custom: %w[new rspec jasmine version help]
+        }
+      end
+    end
+
+    extend Accessors
+
+    def initialize args
+      @args = args
+      @command = self.class.aliases[args.first] || args.first
+      ENV["PRY_RESCUE_RAILS"] = "1" if rescue?
+      @args.shift unless handler == :rails
+    end
+
+    def rescue?
+      args.delete "--rescue"
+    end
+
+    def handler
+      commands = self.class.commands
+      @handler ||= commands.keys.find { |k| commands[k].include? command }
+    end
+
+    def run
+      case handler
+      when :rails
+        run_rails
+      when :rake
+        run_rake
+      when :custom
+        send "run_#{command}"
+      else
+        unrecognized
+      end
+      exit 0
+    end
+
+    # runs all commands in "rails" list
+    def run_rails
+      require "rails/commands"
+    end
+
+    # runs all commands in "rake" list
+    def run_rake
+      require "cardio/commands/rake_command"
+      RakeCommand.new("#{rake_prefix}:#{command}", args).run
+    end
+
+    def rake_prefix
+      "card"
+    end
+
+    # ~~~~~~~~~ CUSTOM COMMANDS ~~~~~~~~~~~~ #
+
+    def run_help
+      puts File.read(File.expand_path("../commands/USAGE", __FILE__))
+    end
+
+    def run_new
+      if ["-h", "--help"].include? args.first
+        require "cardio/commands/application"
+      else
+        puts "Can't initialize a new deck within the directory of another, " \
+         "please change to a non-deck directory first.\n"
+        puts "Type 'decko' for help."
+        exit 1
+      end
+    end
+
+    def run_version
+      require "card/version"
+      puts "Decko #{Card::Version.release}"
+    end
+
+    def run_rspec
+      require "cardio/commands/rspec_command"
+      RspecCommand.new(args).run
+    end
+
+    def run_jasmine
+      require "cardio/commands/rake_command"
+      RakeCommand.new("spec:javascript", envs: "test").run
+    end
+
+    # ~~~~~~~~~~~~~~~~~~~~~ catch-all -------------- #
+
+    def unrecognized
+      puts "Error: Command not recognized: #{command}"
+      run_help
+      exit 1
+    end
+
+    new(ARGV).run unless ENV["CARDIO_COMMANDS"] == "NO_RUN"
+  end
+end

data/lib/cardio/commands/USAGE

@@ -0,0 +1,28 @@
+  Usage: decko COMMAND [ARGS]
+
+  The most common decko commands are:
+   new         Create a new Decko deck. "decko new my_deck" creates a
+               new deck called MyDeck in "./my_deck"
+   seed        Create and seed the database specified in config/database.yml
+
+   server      Start the Rails server (short-cut alias: "s")
+   console     Start the Rails console (short-cut alias: "c")
+   dbconsole   Start a console for the database specified in config/database.yml
+               (short-cut alias: "db")
+
+  For core developers
+   cucumber     Run cucumber features (short-cut alias: "cc")
+   rspec        Run rspec tests (short-cut alias: "rs")
+   update       Run card migrations
+   load         Load bootstrap data into database
+
+  In addition to those, there are the standard rails commands:
+   generate     Generate new code (short-cut alias: "g")
+   application  Generate the Rails application code
+   destroy      Undo code generated with "generate" (short-cut alias: "d")
+   benchmarker  See how fast a piece of code runs
+   profiler     Get profile information from a piece of code
+   plugin       Install a plugin
+   runner       Run a piece of code in the application environment (short-cut alias: "r")
+
+  All commands can be run with -h (or --help) for more information.

data/lib/cardio/commands/application.rb

@@ -0,0 +1,10 @@
+require "rails/generators"
+require File.expand_path("../../../generators/deck/deck_generator", __FILE__)
+
+if ARGV.first != "new"
+  ARGV[0] = "--help"
+else
+  ARGV.shift
+end
+
+Cardio::Generators::Deck::DeckGenerator.start

data/lib/cardio/commands/command.rb

@@ -0,0 +1,27 @@
+module Cardio
+  class Commands
+    # shared handling of commands splitting cardio and original args with "--"
+    class Command
+      def run
+        puts command
+        exit_with_child_status command
+      end
+
+      def exit_with_child_status command
+        command += " 2>&1"
+        exit $CHILD_STATUS.exitstatus unless system command
+      end
+
+      # split special cardio args and original command args separated by '--'
+      def split_args args
+        before_split = true
+        cardio_args, command_args =
+          args.partition do |a|
+            before_split = (a == "--" ? false : before_split)
+          end
+        command_args.shift
+        [cardio_args, command_args]
+      end
+    end
+  end
+end

data/lib/cardio/commands/rake_command.rb

@@ -0,0 +1,43 @@
+require File.expand_path("command", __dir__)
+# require "pry"
+
+module Cardio
+  class Commands
+    # enhance standard rake command with some decko/card -specific options
+    class RakeCommand < Command
+      def initialize rake_task, args={}
+        @task = rake_task
+        opts = {}
+        if args.is_a? Array
+          Parser.new(rake_task, opts).parse!(args)
+        else
+          opts = args
+        end
+        @envs = Array(opts[:envs])
+      end
+
+      def run
+        commands.each do |cmd|
+          puts cmd
+          # exit_with_child_status cmd
+
+          result = `#{cmd}`
+          process = $CHILD_STATUS
+          puts result
+          exit process.exitstatus unless process.success?
+        end
+      end
+
+      def commands
+        task_cmd = "bundle exec rake #{@task}"
+        return [task_cmd] if !@envs || @envs.empty?
+
+        @envs.map do |env|
+          "env RAILS_ENV=#{env} #{task_cmd}"
+        end
+      end
+    end
+  end
+end
+
+require File.expand_path("rake_command/parser", __dir__)

data/lib/cardio/commands/rake_command/parser.rb

@@ -0,0 +1,50 @@
+# -*- encoding : utf-8 -*-
+
+require "optparse"
+
+module Cardio
+  class Commands
+    class RakeCommand
+      # parse decko/card -specific options for rake
+      class Parser < OptionParser
+        ONS = {
+          production: {
+            desc: "production database (default)"
+          },
+          test: {},
+          development: {},
+          all: {
+            desc: "production, test, and development database",
+            envs: %w[production development test]
+          }
+        }.freeze
+
+        def initialize command, opts
+          super() do |parser|
+            parser.banner = "Usage: decko #{command} [options]\n\n" \
+                            "Run decko:#{command} task on the production "\
+                            " database specified in config/database.yml\n\n"
+            parser_ons parser, command do |env_array|
+              opts[:envs] = env_array
+            end
+          end
+        end
+
+        def parser_ons parser, command
+          ONS.each do |env, vals|
+            parser.on(*parser_on_opts(env, command, vals[:desc])) do
+              yield (vals[:envs] || [env.to_s])
+            end
+          end
+        end
+
+        def parser_on_opts env, command, desc
+          main = "--#{env}"
+          short = "-#{env.to_s[0]}"
+          desc ||= "#{env} database"
+          [main, short, "#{command} #{desc}"]
+        end
+      end
+    end
+  end
+end