decko 0.11.5 → 0.13.0

data/lib/decko/commands/cucumber_command/parser.rb

@@ -3,7 +3,7 @@
 require "optparse"
 
 module Decko
-  module Commands
+  class Commands
     class CucumberCommand
       class Parser < OptionParser
         class Flagger
@@ -34,7 +34,7 @@ module Decko
           super() do |parser|
             parser.banner = "Usage: decko cucumber [DECKO ARGS] -- [CUCUMBER ARGS]\n\n"
             parser.separator "\nDECKO ARGS"
-            opts[:env] = ["RAILS_ROOT=."]
+            opts[:env] = ["RAILS_ROOT=. RAILS_ENV=cucumber"]
             Flagger.new(parser, opts).add_flags
             parse_spring parser, opts
           end

data/lib/decko/engine.rb

@@ -1,55 +1,11 @@
-require "rails/all"
-require "cardio"
-
-# TODO: Move these to modules that use them
-require "htmlentities"
-require "coderay"
-require "haml"
-require "kaminari"
-require "bootstrap4-kaminari-views"
-require "diff/lcs"
-require "builder"
-
-require "decko"
-
 module Decko
   class Engine < ::Rails::Engine
-    paths.add "gem-assets",       with: "rails/assets"
-    paths.add "config/routes.rb", with: "rails/engine-routes.rb"
-    paths.add "lib/tasks", with: "#{::Decko.gem_root}/lib/decko/tasks",
-                           glob: "**/*.rake"
-    paths["lib/tasks"] << "#{::Cardio.gem_root}/lib/card/tasks"
-    paths.add "lib/decko/config/initializers",
-              with: File.join(Decko.gem_root, "lib/decko/config/initializers"),
-              glob: "**/*.rb"
-
-    initializer "decko.engine.load_config_initializers",
-                after: :load_config_initializers do
-      paths["lib/decko/config/initializers"].existent.sort.each do |initializer|
-        load(initializer)
-      end
-    end
-
-    initializer "engine.copy_configs",
-                before: "decko.engine.load_config_initializers" do
-      # this code should all be in Decko somewhere, and it is now, gem-wize
-      # Ideally railties would do this for us; this is needed for both use cases
-      Engine.paths["request_log"]   = Decko.paths["request_log"]
-      Engine.paths["log"]           = Decko.paths["log"]
-      Engine.paths["lib/tasks"]     = Decko.paths["lib/tasks"]
-      Engine.paths["config/routes.rb"] = Decko.paths["config/routes.rb"]
-    end
+    paths.add "config/routes.rb", with: "config/engine_routes.rb"
 
     initializer :connect_on_load do
       ActiveSupport.on_load(:active_record) do
         ActiveRecord::Base.establish_connection(::Rails.env.to_sym)
       end
-      # ActiveSupport.on_load(:after_initialize) do
-      #   # require "card" if Cardio.load_card?
-      #   Card if Cardio.load_card?
-      # rescue ActiveRecord::StatementInvalid => e
-      #  ::Rails.logger.warn "database not available[#{::Rails.env}] #{e}"
-      # end
     end
   end
 end

data/lib/decko/generators.rb

@@ -0,0 +1,17 @@
+# -*- encoding : utf-8 -*-
+
+require "cardio/generators"
+require "cardio/generators/class_methods"
+
+# note: despite the decko file name the base class is Cardio
+module Cardio
+  module Generators
+    # main definition of this module is in card gem
+    module ClassMethods
+      # generator USAGE docs will use "decko" rather than "card" when called with decko
+      def banner_command
+        "decko"
+      end
+    end
+  end
+end

data/lib/decko/mods_spec_helper.rb

@@ -11,7 +11,7 @@ CardSpecLoader.prefork do
     Bundler.require(:test)
     # if simplecov is activated in the Gemfile, it has to be required here
   end
-  #  CARD_TEST_SEED_PATH = File.dirname(__FILE__) + '/../fixtures'
+  #  Cardio::Seed.test_path = File.dirname(__FILE__) + '/../fixtures'
   CardSpecLoader.rspec_config
 end
 

data/lib/decko/railtie.rb

@@ -0,0 +1,27 @@
+module Decko
+  # decko configuration (also see cardio/railtie)
+  class Railtie < Rails::Railtie
+    config.assets.enabled = false
+    # config.assets.version = "1.0" # does the version matter if not enabled??
+
+    config.before_configuration do |app|
+      gem_root = Decko.gem_root
+      app.config.tap do |c|
+        c.allow_concurrency = false
+        c.filter_parameters += [:password]
+        c.autoload_paths += Dir["#{gem_root}/lib"]
+
+        c.paths.tap do |p|
+          p["lib/tasks"].unshift "#{gem_root}/lib/decko/tasks"
+
+          p["config/environments"].unshift "#{gem_root}/config/environments"
+          p["config/initializers"].unshift "#{gem_root}/config/initializers"
+
+          unless p["config/routes.rb"].existent.present?
+            p["config/routes.rb"] << "#{gem_root}/config/application_routes.rb"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decko/script_decko_loader.rb

@@ -1,46 +1,13 @@
 require "pathname"
 
+require "cardio/script_loader"
+
 module Decko
   module ScriptDeckoLoader
-    RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) +
-           RbConfig::CONFIG["EXEEXT"]
-    SCRIPT_DECKO = File.join("script", "decko")
-
-    class << self
-      def exec!
-        cwd = Dir.pwd
-        return unless continue?
-
-        exec_decko_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_decko_script
-        exec RUBY, SCRIPT_DECKO, *ARGV if in_application?
-      end
-
-      def continue?
-        in_application? || in_application_subdirectory?
-      end
-
-      def in_application?
-        File.exist?(SCRIPT_DECKO)
-      end
+    extend Cardio::ScriptLoader::ClassMethods
 
-      def in_application_subdirectory? path=Pathname.new(Dir.pwd)
-        File.exist?(File.join(path, SCRIPT_DECKO)) ||
-          !path.root? && in_application_subdirectory?(path.parent)
-      end
+    def self.script
+      File.join("script", "decko")
     end
   end
 end

data/lib/decko/tasks/cucumber.rake

@@ -5,35 +5,32 @@
 # files.
 
 unless ARGV.any? { |a| a =~ /^gems/ } # Don't load anything when running the gems:* tasks
-  vendored_cucumber_bin =
-    Dir["#{Rails.root}/vendor/{gems,plugins}/cucumber*/bin/cucumber"].first
-  unless vendored_cucumber_bin.nil?
-    $LOAD_PATH.unshift("#{File.dirname(vendored_cucumber_bin)}/../lib")
-  end
+  vendor_bin = Dir["#{Rails.root}/vendor/{gems,plugins}/cucumber*/bin/cucumber"].first
+  $LOAD_PATH.unshift(File.dirname(vendor_bin) + "/../lib") unless vendor_bin.nil?
 
   begin
     require "cucumber/rake/task"
 
     namespace :cucumber do
-      Cucumber::Rake::Task.new({ ok: "db:test:prepare" },
+      Cucumber::Rake::Task.new({ ok: "test:prepare" },
                                "Run features that should pass") do |t|
-        t.binary = vendored_cucumber_bin # If nil, the gem's binary is used.
+        t.binary = vendor_bin # If nil, the gem's binary is used.
         t.fork = true # You may get faster startup if you set this to false
         t.profile = "default"
       end
 
-      Cucumber::Rake::Task.new({ wip: "db:test:prepare" },
+      Cucumber::Rake::Task.new({ wip: "test:prepare" },
                                "Run features that are being worked on") do |t|
-        t.binary = vendored_cucumber_bin
+        t.binary = vendor_bin
         t.fork = true # You may get faster startup if you set this to false
         t.profile = "wip"
       end
 
       Cucumber::Rake::Task.new(
-        { rerun: "db:test:prepare" },
+        { rerun: "test:prepare" },
         "Record failing features and run only them if any exist"
       ) do |t|
-        t.binary = vendored_cucumber_bin
+        t.binary = vendor_bin
         t.fork = true # You may get faster startup if you set this to false
         t.profile = "rerun"
       end
@@ -45,7 +42,17 @@ unless ARGV.any? { |a| a =~ /^gems/ } # Don't load anything when running the gem
         require "rails/code_statistics"
         ::STATS_DIRECTORIES << %w[Cucumber\ features features] if File.exist?("features")
         ::CodeStatistics::TEST_TYPES << "Cucumber features" if File.exist?("features")
-        ::STATS_DIRECTORIES << %w[Mods mods] if File.exist?("mods")
+      end
+
+      task :annotations_setup do
+        Rails.application.configure do
+          if config.respond_to?(:annotations)
+            config.annotations.directories << "features"
+            config.annotations.register_extensions("feature") do |tag|
+              /#\s*(#{tag}):?\s*(.*)$/
+            end
+          end
+        end
       end
     end
     desc "Alias for cucumber:ok"
@@ -54,14 +61,17 @@ unless ARGV.any? { |a| a =~ /^gems/ } # Don't load anything when running the gem
     task default: :cucumber
 
     task features: :cucumber do
-      warn "*** The 'features' task is deprecated. See rake -T cucumber ***"
+      STDERR.puts "*** The 'features' task is deprecated. See rake -T cucumber ***"
     end
 
-    # In case we don't have ActiveRecord, append a no-op task that we can depend upon.
-    task "db:test:prepare" do
+    # In case we don't have the generic Rails test:prepare hook,
+    # append a no-op task that we can depend upon.
+    task "test:prepare" do
     end
 
     task stats: "cucumber:statsetup"
+
+    task notes: "cucumber:annotations_setup"
   rescue LoadError
     desc "cucumber rake task not available (cucumber not installed)"
     task :cucumber do
@@ -69,5 +79,4 @@ unless ARGV.any? { |a| a =~ /^gems/ } # Don't load anything when running the gem
             "Be sure to install cucumber as a gem or plugin"
     end
   end
-
 end

data/lib/decko/tasks/decko.rake

@@ -1,6 +1,5 @@
 require "decko/application"
 require_relative "alias"
-require "card/seed_consts"
 
 CARD_TASKS =
   [
@@ -41,7 +40,7 @@ decko_namespace = namespace :decko do
     conn = ActiveRecord::Base.connection
 
     puts "delete all data in bootstrap tables"
-    CARD_SEED_TABLES.each do |table|
+    Cardio::Seed::TABLES.each do |table|
       conn.delete "delete from #{table}"
     end
   end
@@ -71,7 +70,7 @@ decko_namespace = namespace :decko do
     end
 
     puts "set symlink for assets"
-    decko_namespace["update_assets_symlink"].invoke
+    decko_namespace["card:mod:symlink"].invoke
   end
 
   desc "reset with an empty tmp directory"
@@ -95,38 +94,19 @@ decko_namespace = namespace :decko do
       decko_namespace["migrate"].invoke
       decko_namespace["reset_tmp"].invoke
       Card::Cache.reset_all
-      decko_namespace["update_assets_symlink"].invoke
+      Rake::Task["card:mod:install"].invoke
+      Rake::Task["card:mod:symlink"].invoke
     end
   end
 
-  desc "set symlink for assets"
-  task update_assets_symlink: :environment do
-    prepped_asset_path do |assets_path|
-      Cardio::Mod.dirs.each_assets_path do |mod, target|
-        link = File.join assets_path, mod
-        FileUtils.rm_rf link
-        FileUtils.ln_s target, link, force: true
-      end
-    end
-  end
-
-  def prepped_asset_path
-    return if Rails.root.to_s == Decko.gem_root # inside decko gem
-
-    assets_path = File.join Rails.public_path, "assets"
-    if File.symlink?(assets_path) || !File.directory?(assets_path)
-      FileUtils.rm_rf assets_path
-      FileUtils.mkdir assets_path
-    end
-    yield assets_path
-  end
-
+  alias_task "mod:symlink", "card:mod:symlink"
+  alias_task "mod:install", "card:mod:install"
   alias_task :migrate, "card:migrate"
 
   desc "insert existing card migrations into schema_migrations_cards to avoid re-migrating"
   task :assume_card_migrations do
     require "decko/engine"
-    Cardio.assume_migrated_upto_version :core_cards
+    Cardio::Schema.assume_migrated_upto_version :core_cards
   end
 
   def seed with_cache_reset: true
@@ -143,7 +123,6 @@ decko_namespace = namespace :decko do
     Rake::Task["db:create"].invoke
 
     puts "loading schema"
-
     Rake::Task["db:schema:load"].invoke
 
     load_task = "decko:load"

data/lib/decko/tasks/decko/benchmark.rake

@@ -0,0 +1,38 @@
+require "colorize"
+require "benchmark"
+
+namespace :decko do
+  namespace :benchmark do
+    desc "measure time for script generation"
+    task machines: :environment do
+      Benchmark.bm do |x|
+        regenerate x, :style
+        regenerate x, :script
+      end
+    end
+  end
+end
+
+def regenerate benchmarker, all_field
+  Card::Auth.as_bot do
+    card = Card[:all, all_field]
+    Card::Machine.reset_all
+
+    card.machine_input_card.extended_item_cards.each do |i_card|
+      puts i_card
+      i_card.expire_machine_cache
+    end
+
+    %w[machine_output machine_cache].each do |code|
+      Card.search(right: { codename: code }).each(&:delete)
+    end
+
+    Card::Cache.reset_all
+
+    benchmarker.report(all_field) do
+      card.update_machine_output
+      # regenerate_machine_output
+    end
+    # puts Card[:all,  all_field, :machine_output].attachment.read
+  end
+end

data/lib/decko/tasks/decko/docs.rake

@@ -16,7 +16,7 @@ namespace :decko do
 
     # run yardoc command, which generates the docs content in the repo root
     #
-    # If you run this while decko is a gem, you could get some funky docs in
+    # If you run this while using decko as a built gem, you could get some funky docs in
     # your gems directory...
     task :yardoc do
       doc_dir = File.expand_path "..", Decko.gem_root

data/lib/decko/tasks/decko/seed.rake

@@ -1,10 +1,12 @@
+require "cardio/seed"
+
 namespace :decko do
   namespace :seed do
     desc "reseed, migrate, re-clean, and re-dump"
     task update: :environment do
       ENV["STAMP_MIGRATIONS"] = "true"
       ENV["GENERATE_FIXTURES"] = "true"
-      %w[reseed update seed:clean seed:supplement seed:dump].each do |task|
+      %w[reseed update mod:install seed:clean seed:supplement seed:dump].each do |task|
         Rake::Task["decko:#{task}"].invoke
       end
     end
@@ -45,7 +47,7 @@ namespace :decko do
 
     def clean_machines
       puts "clean machines"
-      Card.reset_all_machines
+      Card::Machine.reset_all
       reseed_machine_output
       clean_inputs_and_outputs
     end
@@ -55,6 +57,9 @@ namespace :decko do
         puts "coding machine output for #{name}"
         Card[name].make_machine_output_coded
       end
+      Card.search(type_id: Card::ModScriptAssetsID) do |card|
+        card.make_machine_output_coded true
+      end
     end
 
     def clean_inputs_and_outputs
@@ -70,13 +75,17 @@ namespace :decko do
     end
 
     def reserved_output? name
-      (machine_seed_names.member? name.left_name.key) &&
+      machine_seed_member?(name) &&
         (name.right_name.key == :machine_output.cardname.key)
     end
 
+    def machine_seed_member? name
+      machine_seed_names.member?(name.left_name.key) || name.match(/^mod:/)
+    end
+
     def machine_seed_names
       @machine_seed_names ||=
-        [%i[all script], %i[all style], [:script_html5shiv_printshiv]].map do |name|
+        [%i[all style], [:script_html5shiv_printshiv]].map do |name|
           Card::Name[*name]
         end
     end
@@ -119,14 +128,14 @@ namespace :decko do
     def add_test_data
       return unless Rails.env == "test"
 
-      load CARD_TEST_SEED_SCRIPT_PATH
+      load Cardio::Seed.test_script_path
       SharedData.add_test_data
     end
 
     desc "dump db to bootstrap fixtures"
     task dump: :environment do
       Card::Cache.reset_all
-      CARD_SEED_TABLES.each do |table|
+      Cardio::Seed::TABLES.each do |table|
         i = "000"
         write_seed_file table do
           yamlize_records table do |record, hash|
@@ -137,7 +146,7 @@ namespace :decko do
     end
 
     def write_seed_file table
-      path = Rails.env == "test" ? CARD_TEST_SEED_PATH : CARD_SEED_PATH
+      path = Rails.env == "test" ? Cardio::Seed.test_path : Cardio::Seed.path
       filename = File.join path, "#{table}.yml"
       File.open filename, "w" do |file|
         file.write yield