card 1.103.3 → 1.104.2

data/lib/cardio/commands.rb

@@ -1,53 +1,59 @@
 require "English"
+require "colorize"
+require "cardio/commands/custom"
 
 module Cardio
-  # manage different types of commands that can be run via bin/card and bin/decko
+  # manage different types of commands that can be run via bin/card (and bin/decko)
   class Commands
+    include Custom
+    
     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
+    class << self
+      attr_accessor :current
 
-      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]
-        }
+      def gem
+        current&.gem
       end
     end
 
-    extend Accessors
+    def map
+      @map ||= {
+        new: { desc: "create a new deck", group: :shark, via: :call },
+        seed: { desc: "populate a database", group: :shark, via: :rake },
+        update: { desc: "run data updates", group: :shark, alias: :u, via: :rake },
+        version: { desc: "#{gem} gem version", group: :shark, alias: :v, via: :call },
+        help: { desc: "show this text", group: :shark, alias: :h, via: :call},
+
+        console: { desc: "start a ruby console", group: :monkey, alias: :c },
+        dbconsole: { desc: "start a database console", group: :monkey, alias: :db },
+        runner: { desc: "run code in app environment", group: :monkey, alias: :r },
+        rspec: { desc: "run rspec tests", group: :monkey, alias: :rs, via: :call },
+        generate: { desc: "generate templated code", group: :monkey, alias: :g },
+        poop: { desc: "export card data to mod yaml", group: :monkey, via: :rake },
+        eat: { desc: "ingest card data from mod yaml", group: :monkey, via: :rake }
+      }
+    end
+
+    # TODO: review the following. see if any work well enough to include
+    #
+    #    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
+    #    jasmine
 
     def initialize args
       @args = args
-      @command = self.class.aliases[args.first] || args.first
+      @command = command_for_key args.first&.to_sym
       ENV["PRY_RESCUE_RAILS"] = "1" if rescue?
       @args.shift unless handler == :rails
+      Commands.current = self
     end
 
-    def rescue?
-      args.delete "--rescue"
-    end
-
-    def handler
-      commands = self.class.commands
-      @handler ||= commands.keys.find { |k| commands[k].include? command }
+    def gem
+      "card"
     end
 
     def run
@@ -56,65 +62,59 @@ module Cardio
         run_rails
       when :rake
         run_rake
-      when :custom
+      when :call
         send "run_#{command}"
-      else
-        unrecognized
+      when :unknown
+        unknown_error
       end
       exit 0
     end
 
-    # runs all commands in "rails" list
-    def run_rails
-      require "rails/commands"
-    end
+    private
 
-    # runs all commands in "rake" list
-    def run_rake
-      require "cardio/commands/rake_command"
-      RakeCommand.new("#{rake_prefix}:#{command}", args).run
-    end
+    def command_for_key key
+      return :help unless key
+      return key if map.key? key
 
-    def rake_prefix
-      "card"
+      map.each { |k, v| return k if v[:alias] == key }
+      @unknown = true
+      key
     end
 
-    # ~~~~~~~~~ CUSTOM COMMANDS ~~~~~~~~~~~~ #
+    def rescue?
+      args.delete "--rescue"
+    end
 
-    def run_help
-      puts File.read(File.expand_path("../commands/USAGE", __FILE__))
+    def config
+      map[command]
     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
+    def handler
+      @handler ||= @unknown ? :unknown : (config[:via] || :rails)
     end
 
-    def run_version
-      require "card/version"
-      puts "Decko #{Card::Version.release}"
+    # runs all commands in "rails" list
+    def run_rails
+      require generator_requirement if command == :generate
+      require "rails/commands"
     end
 
-    def run_rspec
-      require "cardio/commands/rspec_command"
-      RspecCommand.new(args).run
+    def generator_requirement
+      "cardio/generators"
     end
 
-    def run_jasmine
+    # runs all commands in "rake" list
+    def run_rake
       require "cardio/commands/rake_command"
-      RakeCommand.new("spec:javascript", envs: "test").run
+      RakeCommand.new(gem, command, args).run
     end
 
     # ~~~~~~~~~~~~~~~~~~~~~ catch-all -------------- #
 
-    def unrecognized
-      puts "Error: Command not recognized: #{command}"
+    def unknown_error
+      puts "----------------------------------------------\n" \
+           "ERROR: Command not recognized: #{command}\n" \
+           "----------------------------------------------\n".red
       run_help
       exit 1
     end

data/lib/cardio/generators.rb

@@ -2,19 +2,72 @@
 
 require "rails/generators"
 require "rails/generators/active_record"
+require "colorize"
 
 module Cardio
   # for now, this just fulfills zeitwerk expectations. File is here for require calls.
   module Generators
-    # noop
+    # methods shared across Generator bases (which inherit from Rails generator classes)
+    module ClassMethods
+      def source_root path=nil
+        if path
+          @_card_source_root = path
+        else
+          @_card_source_root ||= File.expand_path(
+            "../../generators/#{generator_name}/templates", __FILE__
+          )
+        end
+      end
+
+      # Override Rails default banner (using card/decko for the command name).
+      def banner
+        usage_args = arguments.map(&:usage).join " "
+        text = "\n#{banner_command} generate #{namespace} #{usage_args} [options]".green
+        text.gsub(/\s+/, " ")
+      end
+
+      def banner_command
+        Commands.gem
+      end
+
+      # Override Rails namespace handling so we can put generators in `module Cardio`
+      def namespace name=nil
+        return super if name
+        @namespace ||= super.sub(/cardio:/, "")
+      end
+    end
+    delegate :banner_command, to: :class
   end
 end
 
 module Rails
   # override to hide all the rails generators that don't apply in a card/decko context
   module Generators
-    def self.sorted_groups
-      [["card", %w[mod set migration]]]
+    class << self
+      # TODO: autogenerate
+      def generator_names
+        %i[mod set migration]
+      end
+
+      def help command="generate"
+        caller = Cardio::Commands.gem
+        puts "Usage:"
+        puts "  #{caller} #{command} GENERATOR [args] [options]".green
+        puts
+        puts "General options:"
+        puts "  -h, [--help]     # Print generator's options and usage"
+        puts "  -p, [--pretend]  # Run but do not make any changes"
+        puts "  -f, [--force]    # Overwrite files that already exist"
+        puts "  -s, [--skip]     # Skip files that already exist"
+        puts "  -q, [--quiet]    # Suppress status output"
+        puts
+        puts "Please choose a generator below."
+        puts
+        generator_names.each do |name|
+          puts "  #{name}".light_cyan
+        end
+        puts
+      end
     end
   end
 end

data/lib/cardio/migration/deck_structure.rb

@@ -1,5 +1,7 @@
 # -*- encoding : utf-8 -*-
 
+# ENV["NO_CARD_LOAD"] = "true"
+
 require "cardio/migration"
 
 module Cardio

data/lib/cardio/migration/import/import_data/card_content.rb

@@ -5,7 +5,7 @@ module Cardio
         # handles card content for import
         module CardContent
           def card_content data
-            File.read(content_path(data))
+            File.read content_path(data)
           end
 
           def content_changed? data

data/lib/cardio/migration/import.rb

@@ -64,11 +64,11 @@ module Cardio
       private
 
       def update &block
-        ImportData.update(@data_path, &block)
+        ImportData.update @data_path, &block
       end
 
       def importer
-        @importer ||= ImportData.new(@data_path)
+        @importer ||= ImportData.new @data_path
       end
 
       # Returns an array of hashes with card attributes

data/lib/cardio/migration.rb

@@ -2,7 +2,7 @@
 
 module Cardio
   class Migration < ActiveRecord::Migration[4.2]
-    include Card::Model::SaveHelper
+    include Card::Model::SaveHelper unless ENV["NO_CARD_LOAD"]
     @type = :deck_cards
 
     class << self
@@ -43,12 +43,36 @@ module Cardio
         Schema.assume_migrated_upto_version type
       end
 
+      def assume_current
+        migration_context do |mc|
+          versions = mc.migrations.map(&:version)
+          migrated = mc.get_all_versions
+          mark_as_migrated versions - migrated
+        end
+      end
+
       def data_path filename=nil
         File.join([migration_paths.first, "data", filename].compact)
       end
+
+      private
+
+      def mark_as_migrated versions
+        sql = connection.send :insert_versions_sql, versions
+        connection.execute sql
+      end
+
+      def connection
+        ActiveRecord::Base.connection
+      end
+
+      def migration_context &block
+        Schema.migration_context type, &block
+      end
     end
 
     def contentedly
+      return yield if ENV["NO_CARD_LOAD"]
       Card::Cache.reset_all
       Schema.mode "" do
         Card::Auth.as_bot do
@@ -111,7 +135,7 @@ module Cardio
     end
 
     # Execute this migration in the named direction
-    # copied from ActiveRecord to wrap 'up' in 'contentendly'
+    # copied from ActiveRecord to wrap 'up' in 'contentedly'
     def exec_migration conn, direction
       @connection = conn
       if respond_to?(:change)

data/lib/cardio/mod/class_methods.rb

@@ -0,0 +1,112 @@
+module Cardio
+  class Mod
+    # class methods for Cardio::Mod
+    module ClassMethods
+      def load
+        return if ENV["CARD_MODS"] == "none"
+
+        if Card.take
+          Loader.load_mods
+        else
+          Rails.logger.warn "empty database"
+        end
+      end
+
+      # @return an array of Rails::Path objects
+      def dirs
+        @dirs ||= Mod::Dirs.new Cardio.paths["mod"].existent
+      end
+
+      def fetch mod_name
+        dirs.fetch_mod mod_name
+      end
+
+      def normalize_name name
+        name.to_s.sub(/^card-mod-/, "")
+      end
+
+      def missing
+        Card.search(type: :mod).reject { |mod_card| fetch mod_card.modname }
+      end
+
+      def ensure_uninstalled
+        missing.each do |mod_card|
+          Card::Auth.as_bot do
+            Card[:all, :style].drop_item mod_card
+            delete_auto_installed_cards mod_card
+          end
+        end
+      end
+
+      def ensure_installed
+        Card::Cache.reset_all
+        puts "installing card mods".green
+        Cardio.mods.each(&:ensure)
+        Card::Assets.refresh_assets force: true
+      end
+
+      def dependencies name, nickname=true
+        return unless (spec = gem_spec name, nickname)
+
+        deps = spec&.dependencies || []
+        dep_names = deps.map { |dep| dependencies dep.name, false }
+        (dep_names << spec).flatten.compact.uniq
+      end
+
+      def each_path &block
+        each_simple_path(&block)
+        each_gem_path(&block)
+      end
+
+      # @return [Hash] in the form{ modname(String) => Gem::Specification }
+      def gem_specs
+        Bundler.definition.specs.each_with_object({}) do |gem_spec, h|
+          h[gem_spec.name] = gem_spec if gem_spec? gem_spec
+        end
+      end
+
+      private
+
+      # it would be nice if this were easier...
+      def delete_auto_installed_cards mod_card
+        auto_installed_cards(mod_card).each do |card|
+          card.codename = nil
+          card.delete!
+        end
+      end
+
+      def auto_installed_cards mod_card
+        [mod_card].tap do |cards|
+          mod_card.each_descendant do |card|
+            cards.unshift card
+          end
+        end
+      end
+
+      def gem_spec name, nickname=true
+        name = "card-mod-#{name}" if nickname && !name.match?(/^card-mod/)
+        spec = Gem::Specification.stubs_for(name)&.first
+        gem_spec?(spec) ? spec : nil
+      end
+
+      def each_simple_path &block
+        Cardio.paths["mod"].each do |mods_path|
+          Dir.glob("#{mods_path}/*").each(&block)
+        end
+      end
+
+      def each_gem_path
+        gem_specs.each_value do |spec|
+          yield spec.full_gem_path
+        end
+      end
+
+      # @return [True/False]
+      def gem_spec? spec
+        return unless spec
+
+        spec.name.match?(/^card-mod-/) || spec.metadata["card-mod"].present?
+      end
+    end
+  end
+end

data/lib/cardio/mod/dirs.rb

@@ -97,6 +97,13 @@ module Cardio
         fetch_mod(mod_name)&.path
       end
 
+      def subpaths *subdirs
+        @mods.each_with_object({}) do |mod, hash|
+          path = mod.subpath(*subdirs)
+          hash[mod.name] = path if path
+        end
+      end
+
       def fetch_mod mod_name
         @mods_by_name[Mod.normalize_name(mod_name)]
       end
@@ -129,12 +136,15 @@ module Cardio
         end
       end
 
-      def each_public_path
-        @mods.each do |mod|
-          path = mod.public_path
-          next unless Dir.exist? path
+      def each_subpath *subdirs
+        subpaths(*subdirs).each do |mod_name, subpath|
+          yield mod_name, subpath
+        end
+      end
 
-          yield mod.name, path
+      def load_from_gemfile
+        Cardio::Mod.gem_specs.each do |mod_name, mod_spec|
+          add_gem_mod mod_name, mod_spec.full_gem_path
         end
       end
 
@@ -154,12 +164,6 @@ module Cardio
           add_mod filename unless filename.match?(/^\./)
         end
       end
-
-      def load_from_gemfile
-        Cardio::Mod.gem_specs.each do |mod_name, mod_spec|
-          add_gem_mod mod_name, mod_spec.full_gem_path
-        end
-      end
     end
   end
 end

data/lib/cardio/mod/eat/edibles.rb

@@ -0,0 +1,92 @@
+module Cardio
+  class Mod
+    class Eat
+      # item handling for Mod::Eat (importables)
+      module Edibles
+        # list of card attribute hashes
+        # @return [Array <Hash>]
+        def edibles
+          mods_with_data.map { |mod| mod_edibles mod }.flatten
+        end
+
+        private
+
+        # if mod is specified, consider only that mod
+        # @return [Array <Cardio::Mod>]
+        def mods_with_data
+          paths = Mod.dirs.subpaths "data"
+          mod_names = @mod ? ensure_mod_data_path(paths) : paths.keys
+          mod_names.map { |mod_name| Mod.fetch mod_name }
+        end
+
+        def ensure_mod_data_path paths
+          return [@mod] if paths[@mod]
+
+          raise "no data directory found for mod #{@mod}".red
+        end
+
+        # @return [Array <Hash>]
+        def mod_edibles mod
+          environments.map { |env| items_for_environment mod, env }.compact
+        end
+
+        def items_for_environment mod, env
+          return unless (items = items_from_yaml mod, env)
+
+          items = items.map do |item|
+            item.is_a?(String) ? items_from_yaml(mod, env, item) : item
+          end.flatten.compact
+          interpret_items mod, items
+        end
+
+        def interpret_items mod, items
+          each_card_hash(items) { |hash| handle_attachments mod, hash }
+        end
+
+        def items_from_yaml mod, env, filename=nil
+          source = "#{env}#{'/' if filename.present?}#{filename}.yml"
+          return unless (path = mod.subpath "data", source)
+
+          YAML.load_file path
+        end
+
+        # for processing that needs to happen on all cards, including fields
+        def each_card_hash items
+          items.each do |item|
+            yield item
+            item[:subfields]&.values&.each { |val| yield val if val.is_a? Hash }
+          end
+          items
+        end
+
+        def handle_attachments mod, hash
+          each_attachment hash do |key, filename|
+            hash[key] = mod_file mod, filename
+            hash[:mod] = mod.name if hash[:storage_type] == :coded
+          end
+        end
+
+        def each_attachment hash
+          attachment_keys.each { |key| yield key, hash[key] if hash.key? key }
+        end
+
+        def mod_file mod, filename
+          File.open mod.subpath("data/files", filename)
+        end
+
+        def attachment_keys
+          @attachment_keys ||= Card.uploaders.keys
+        end
+
+        # @return [Array <Symbol>]
+        # holarchical. each includes the previous
+        # production = [:production],
+        # development = [:production, :development], etc.
+        def environments
+          index = DATA_ENVIRONMENTS.index(@env&.to_sym || Rails.env.to_sym) || -1
+          DATA_ENVIRONMENTS[0..index]
+        end
+      end
+    end
+  end
+end

data/lib/cardio/mod/eat.rb

@@ -0,0 +1,81 @@
+require "timecop"
+
+require "pry"
+
+DATA_ENVIRONMENTS = %i[production development test].freeze
+ENV["STORE_CODED_FILES"] = "true"
+
+module Cardio
+  class Mod
+    # import data from data directory of mods
+    # (list of card attributes)
+    # https://docs.google.com/document/d/13K_ynFwfpHwc3t5gnLeAkZJZHco1wK063nJNYwU8qfc/edit#
+    class Eat
+      include Card::Model::SaveHelper
+      include Edibles
+
+      def initialize mod: nil, env: nil, user: nil, verbose: nil
+        @mod = mod
+        @env = env
+        @user_id = user&.card_id
+        @verbose = !verbose.nil?
+      end
+
+      def up
+        Card::Cache.reset_all
+        Card::Mailer.perform_deliveries = false
+        Card::Auth.as_bot do
+          edibles.each do |edible|
+            track edible do
+              current_user edible.delete(:user)
+              time_machine edible.delete(:time) do
+                ensure_card edible
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def track edible
+        rescuing edible do
+          # puts "eat: #{edible}" if @verbose
+          card = yield
+          puts "eaten: #{card.name}".green # if @verbose
+        end
+      end
+
+      def rescuing edible
+        yield
+      rescue StandardError => e
+        # binding.pry
+        puts edible
+        puts e.message.red
+        puts e.backtrace.join("\n") if @verbose
+      end
+
+      def current_user item_user
+        Card::Auth.current_id = item_user&.card_id || @user_id || Card::WagnBotID
+      end
+
+      def time_machine value, &block
+        return yield unless value.present?
+
+        Timecop.freeze Time.at(time_integer(value)), &block
+      end
+
+      def time_integer value
+        case value
+        when /^[+-]\d+$/
+          # plus or minus an integer (safe to eval)
+          eval "#{Time.now.to_i} #{value}", binding, __FILE__, __LINE__
+        when Integer
+          value
+        else
+          raise TypeError, "invalid time value: #{value}. accepts int, +int, and -int"
+        end
+      end
+    end
+  end
+end