card 1.101.7 → 1.103.2

data/lib/cardio/script_loader.rb

@@ -0,0 +1,53 @@
+require "pathname"
+
+module Cardio
+  # help card executable find ./script/card when called from anywhere within deck
+  module ScriptLoader
+    # modularize for reusing in decko
+    module ClassMethods
+      RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) +
+             RbConfig::CONFIG["EXEEXT"]
+
+      def script
+        File.join("script", "card")
+      end
+
+      def exec!
+        cwd = Dir.pwd
+        return unless continue?
+
+        exec_script
+        recurse cwd
+      rescue SystemCallError
+        # could not chdir, no problem just return
+      end
+
+      def recurse cwd
+        Dir.chdir("..") do
+          # Recurse in a chdir block: if the search fails we want to be sure
+          # the application is generated in the original working directory.
+          exec! unless cwd == Dir.pwd
+        end
+      end
+
+      def exec_script
+        exec RUBY, script, *ARGV if in_application?
+      end
+
+      def continue?
+        in_application? || in_application_subdirectory?
+      end
+
+      def in_application?
+        File.exist?(script)
+      end
+
+      def in_application_subdirectory? path=Pathname.new(Dir.pwd)
+        File.exist?(File.join(path, script)) ||
+          !path.root? && in_application_subdirectory?(path.parent)
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/cardio/seed.rb

@@ -0,0 +1,21 @@
+module Cardio
+  # methods in support of seeding
+  module Seed
+    TABLES = %w[cards card_actions card_acts card_changes card_references
+                schema_migrations schema_migrations_core_cards
+                schema_migrations_deck schema_migrations_deck_cards].freeze
+
+    class << self
+      attr_accessor :path, :test_path, :test_script_path
+
+      def db_path *args
+        parts = [Cardio.gem_root, "db"] + args
+        File.join(*parts)
+      end
+    end
+
+    self.path = db_path "seed", "new"
+    self.test_path = db_path "seed", "test", "fixtures"
+    self.test_script_path = db_path "test_seed.rb"
+  end
+end

data/lib/cardio/utils.rb

@@ -1,39 +1,33 @@
 module Cardio
   # Utilities that may need to be run even when mods are not loaded.
   module Utils
-    def t key, args={}
-      ::I18n.t key, args
-    end
+    class << self
+      def seed_test_db
+        system "env RAILS_ENV=test bundle exec rake db:fixtures:load"
+      end
 
-    def seed_test_db
-      system "env RAILS_ENV=test bundle exec rake db:fixtures:load"
-    end
+      # deletes tmp directory within files directory
+      # It's here because it gets called as part of cache clearing, which sometimes gets
+      # called in a context where card mods are not loaded.
+      # Why does cache clearing need to do this??
+      def delete_tmp_files! id=nil
+        raise "no files directory" unless files_dir
 
-    def database_name
-      @database_name ||= config.database_configuration.dig Rails.env, "database"
-    end
+        delete_tmp_files id
+      rescue StandardError
+        Rails.logger.info "failed to remove tmp files"
+      end
 
-    # deletes tmp directory within files directory
-    # It's here because it gets called as part of cache clearing, which sometimes gets
-    # called in a context where card mods are not loaded.
-    # Why does cache clearing need to do this??
-    def delete_tmp_files! id=nil
-      raise "no files directory" unless files_dir
+      private
 
-      delete_tmp_files id
-    rescue StandardError
-      Rails.logger.info "failed to remove tmp files"
-    end
-
-    private
-
-    def delete_tmp_files id=nil
-      dir = [files_dir, "tmp", id.to_s].compact.join "/"
-      FileUtils.rm_rf dir, secure: true
-    end
+      def delete_tmp_files id=nil
+        dir = [files_dir, "tmp", id.to_s].compact.join "/"
+        FileUtils.rm_rf dir, secure: true
+      end
 
-    def files_dir
-      @files_dir ||= Cardio.paths["files"].existent.first
+      def files_dir
+        @files_dir ||= Cardio.paths["files"].existent.first
+      end
     end
   end
 end

data/lib/generators/deck/USAGE

@@ -0,0 +1,14 @@
+Description:
+    The '<%= banner_command %> new' command creates a new Decko deck with a default
+    directory structure and configuration at the path you specify.
+
+Examples:
+    <%= banner_command %> new poker
+
+    This generates a new deck in a directory named "poker" inside the current working
+    directory.
+
+
+    <%= banner_command %> new ~/Poker/FullHouse
+
+    This generates a new deck in ~/Poker/FullHouse.

data/lib/generators/deck/deck_generator.rb

@@ -0,0 +1,140 @@
+require "rails/generators/app_base"
+
+module Cardio
+  module Generators
+    module Deck
+      # Create new Decks (Decko Applications)
+      class DeckGenerator < Rails::Generators::AppBase
+        require "cardio/generators/rails_overrides"
+        require "cardio/generators/deck_helper"
+
+        include RailsOverrides
+        include DeckHelper
+
+        source_root File.expand_path("templates", __dir__)
+
+        # All but the first aliases should be considered deprecated
+        class_option "monkey",
+                     type: :boolean, aliases: %w[-M --mod-dev],
+                     default: false, group: :runtime,
+                     desc: "Prepare deck for monkey (mod developer)"
+
+        class_option "platypus",
+                     type: :boolean, aliases: %w[-P --core-dev -c],
+                     default: false, group: :runtime,
+                     desc: "Prepare deck for platypus (core development)"
+
+        class_option "repo-path",
+                     type: :string, aliases: %w[-R -g --gem-path],
+                     default: "", group: :runtime,
+                     desc: "Path to local decko repository " \
+                           "(Default, use env DECKO_REPO_PATH)"
+
+        class_option :database,
+                     type: :string, aliases: %w[-D -d], default: "mysql",
+                     desc: "Preconfigure for selected database " \
+                           "(options: #{DATABASES.join('/')})"
+
+        class_option "interactive",
+                     type: :boolean, aliases: %w[-I -i], default: false, group: :runtime,
+                     desc: "Prompt with dynamic installation options"
+
+        public_task :set_default_accessors!
+        public_task :create_root
+
+        def self.banner
+          "decko new #{arguments.map(&:usage).join(' ')} [options]"
+        end
+
+        # Generator works its way through each public method below
+
+        def core_files
+          erb_template "config.ru"
+          erb_template "Gemfile"
+          erb_template "Rakefile"
+
+          # return unless platypus?
+          #
+          # erb_template "cypress.json"
+          # template "package.json"
+        end
+
+        def empty_dirs
+          %w[mod log files tmp].each { |dirname| empty_directory_with_keep_file dirname }
+        end
+
+        def dotfiles
+          copy_file "pryrc", ".pryrc"
+          copy_file "gitignore", ".gitignore"
+          template "rspec.erb", ".rspec"
+          template "simplecov.rb.erb", ".simplecov"
+        end
+
+        def config
+          inside "config" do
+            erb_template "application.rb"
+            erb_template "routes.rb"
+            erb_template "environment.rb"
+            erb_template "boot.rb"
+
+            template "databases/#{options[:database]}.yml", "database.yml"
+            template "cucumber.yml"
+            template "storage.yml"
+            template "puma.rb"
+            # template "initializers/cypress.rb" if platypus?
+          end
+        end
+
+        def public
+          inside "public" do
+            template "robots.txt"
+            inside("files") { template "htaccess", ".htaccess" }
+          end
+        end
+
+        def spring
+          inside("bin") { erb_template "spring" }
+        end
+
+        def script
+          directory("script") { |content| "#{shebang}\n" + content }
+          chmod "script", 0o755 & ~File.umask, verbose: false
+        end
+
+        def spec
+          inside "spec" do
+            if platypus?
+              jasmine_yml :decko
+            else
+              jasmine_yml :deck
+              template "spec_helper.rb"
+            end
+          end
+        end
+
+        public_task :run_bundle
+
+        def seed_data
+          if options["interactive"]
+            Interactive.new(destination_root, (monkey? || platypus?)).run
+          else
+            puts "Now:
+      1. Run `cd #{File.basename(destination_root)}` to enter your new deck directory
+      2. Run `decko seed` to seed your database (see config/database.yml).
+      3. Run `decko server` to start your server"
+          end
+        end
+
+        protected
+
+        def database_gemfile_entry
+          return [] if options[:skip_active_record]
+
+          gem_name, gem_version = gem_for_database
+          msg = "Use #{options[:database]} as the database for Active Record"
+          GemfileEntry.version gem_name, gem_version, msg
+        end
+      end
+    end
+  end
+end

data/lib/generators/deck/deck_generator/interactive.rb

@@ -0,0 +1,120 @@
+module Decko
+  module Generators
+    module Deck
+      class DeckGenerator
+        # Guides through the decko deck installation with an interactive menu
+        # Offers the possibilitiy to
+        #  - edit database config
+        #  - edit application.rb
+        #  - seed database
+        #  - run server
+        class Interactive
+          def initialize destination_root, dev=false
+            @dev = dev
+            @destination_root = destination_root
+          end
+
+          def run
+            require config_path("application") # need this for Rails.env
+            @menu = ActiveSupport::OrderedHash.new
+            add_config_options
+            add_seed_options
+            add_exit_option
+            while (answer = ask(build_menu)) != "x"
+              if @menu.key? answer
+                @menu[answer][:code].call
+              else
+                puts "invalid choice"
+              end
+            end
+          end
+
+          private
+
+          def dev_options?
+            @dev
+          end
+
+          def config_path file
+            File.join destination_root, "config", file
+          end
+
+          def bundle_exec command, opts={}
+            rails_env = "RAILS_ENV=#{opts[:rails_env]}" if opts[:rails_env]
+            system "cd #{destination_root} && #{rails_env} bundle exec #{command}"
+          end
+
+          def build_menu
+            lines = ["What would you like to do next?"]
+            lines += @menu.map { |key, v|  build_option key, v[:desc], v[:command] }
+            lines << "[#{@menu.keys.join}]"
+            "\n#{lines.join("\n")}\n"
+          end
+
+          def build_option key, desc, command
+            command &&= "#{' ' * (65 - desc.size)}[#{command}]"
+            "  #{key} - #{desc}#{command}"
+          end
+
+          def add_config_options
+            @menu["d"] = {
+              desc: "edit database configuration file",
+              command: "nano config/database.yml",
+              code: proc { system "nano #{config_path 'database.yml'}" }
+            }
+            @menu["c"] = {
+              desc: "configure Decko (e.g. email settings)",
+              command: "nano config/application.rb",
+              code: proc { system "nano #{config_path 'application.rb'}" }
+            }
+          end
+
+          def add_seed_options
+            add_common_seed_option
+            add_seed_all_option
+          end
+
+          def add_common_seed_option
+            @menu["s"] = {
+              desc: "seed #{Rails.env}#{' and test' if dev_options?} database",
+              command: "decko seed",
+              code: proc do
+                bundle_exec "rake decko:seed"
+                bundle_exec "rake decko:seed", rails_env: "test" if dev_options?
+                add_after_seed_options
+              end
+            }
+          end
+
+          def add_seed_all_option
+            @menu["a"] = {
+              desc: "seed all databases (production, development, and test)",
+              command: "decko seed --all",
+              code: proc do
+                %w[production development test].each do |env|
+                  bundle_exec "rake decko:seed", rails_env: env
+                end
+                add_after_seed_options
+              end
+            }
+          end
+
+          def add_exit_option
+            @menu["x"] = {
+              desc: "exit (run 'decko seed' to complete the installation later)"
+            }
+          end
+
+          def add_after_seed_options
+            @menu["x"][:desc] = "exit"
+            @menu["r"] = {
+              desc: "run decko server",
+              command: "decko server",
+              code: proc { bundle_exec "decko server" }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/deck/templates/Gemfile.erb

@@ -0,0 +1,56 @@
+source "http://rubygems.org"
+
+gem "decko"<%= repo_path_constraint %>
+<%= %(gem "card", require: false#{repo_path_constraint}) if repo_path.present? %>
+
+# DATABASE
+# Decko currently supports MySQL (best tested), PostgreSQL (well tested), and SQLite
+# (not well tested).
+gem <%= database_gem_and_version %>
+
+
+# WEBSERVER
+# To run a simple deck at localhost:3000, you can use thin (recommended), unicorn,
+# or (Rails" default) Webrick
+gem "thin"
+# gem "unicorn"
+
+
+# CARD MODS
+# The easiest way to change card behaviors is with card mods. To install a mod:
+#
+#   1. add `gem "card-mod-MODNAME"` below
+#   2. run `bundle update` to install the code
+#   3. run `decko update` to make any needed changes to your deck
+#
+# The "defaults" includes a lot of functionality that is needed in standard decks.
+gem "card-mod-defaults"<%= repo_path_constraint :mod %>
+
+
+# BACKGROUND
+# A background gem is needed to run tasks like sending notifications in a background
+# process.
+# See https://github.com/decko-commons/decko/tree/master/card-mod-delayed_job
+# for additional configuration details.
+<%= "# " if shark? %>gem "card-mod-delayed_job"<%= repo_path_constraint :mod %>
+
+
+# MONKEYS
+# You can also create your own mods. Mod developers (or "Monkeys") will want some
+# additional gems to support development and testing.
+<%= "# " if shark? %>gem "card-mod-monkey", group: :development<%= repo_path_constraint :mod %>
+<%= "# " if shark? %>gem "decko-rspec", group: :test<%= repo_path_constraint :support %>
+<%= "# " if shark? %>gem "decko-cucumber", group: :cucumber<%= repo_path_constraint :support %>
+<%= "# " if shark? %>gem "decko-cypress", group: :cypress<%= repo_path_constraint :support %>
+<%= "# " if shark? %>gem "decko-profile", group: :profile<%= repo_path_constraint :support %>
+<%= "# " if shark? || !spring_install? %>gem "decko-spring"<%= repo_path_constraint :support %>
+
+<% if platypus? %>
+# PLATYPUSES
+# This mod is strongly recommended for platypuses – coders working on the decko core
+gem "card-mod-platypus"<%= repo_path_constraint :mod %>
+<% end %>
+
+# The following allows simple (non-gem) mods to specify gems via a Gemfile.
+# You may need to alter this code if you move such mods to an unconventional location.
+Dir.glob("mod/**/Gemfile").each { |gemfile| instance_eval File.read(gemfile) }