decko 0.0.1 → 0.1

data/lib/decko/generators/decko/templates/spec/javascripts/support/decko_jasmine.yml

@@ -0,0 +1,74 @@
+# path to parent directory of src_files
+# relative path from Rails.root
+# defaults to app/assets/javascripts
+# useless for decko file structure
+src_dir: <%= @cardio_gem_root %>/mod/machines/lib/javascript
+#"app/assets/javascripts"
+
+# path to additional directory of source file that are not part of assets pipeline and need to be included
+# relative path from Rails.root
+# defaults to []
+# include_dir:
+#   - ../mobile_app/public/js
+
+# path to parent directory of css_files
+# relative path from Rails.root
+# defaults to app/assets/stylesheets
+# useless for decko file structure
+css_dir: <%= @cardio_gem_root %>/mod/machines/lib/stylesheets
+
+# list of file expressions to include as source files
+# relative path from src_dir
+src_files:
+ - script_jquery.js
+ - script_tinymce.js
+ - decko_mod.js.coffee
+ - decko_editor.js.coffee
+ - decko_upload.js.coffee
+ - decko_layout.js.coffee
+ - decko_navbox.js.coffee
+ - decko.js.coffee
+ - script_card_menu.js
+ # - jquerymobile.js
+ - jquery-ui.js
+ - jquery.ui.autocomplete.html.js
+ - jquery.autosize.js
+ - jquery.fileupload.js
+ - jquery.iframe-transport.js
+ - jquery_ujs.js
+ - script_ace.js
+ - script_prosemirror.js
+ #- "**/*.{js.coffee,js,coffee}"
+
+# list of file expressions to include as css files
+# relative path from css_dir
+css_files:
+    # - "**/*.{css,scss}"
+# THIS IS IMPORTANT!!!
+include_dir:
+  - <%= @cardio_gem_root %>/mod/machines/lib/javascript
+# path to parent directory of spec_files
+# relative path from Rails.root
+#
+# Alternatively accept an array of directory to include external spec files
+# spec_dir:
+#   - spec/javascripts
+#   - ../engine/spec/javascripts
+#
+# defaults to spec/javascripts
+spec_dir:  <%= @decko_gem_root %>/spec/javascripts
+
+# list of file expressions to include as helpers into spec runner
+# relative path from spec_dir
+helpers:
+  - "helpers/**/*.{js.coffee,js,coffee}"
+
+# list of file expressions to include as specs into spec runner
+# relative path from spec_dir
+spec_files:
+  - "**/*[Ss]pec.{js.coffee,js,coffee}"
+
+# path to directory of temporary files
+# (spec runner and asset cache)
+# defaults to tmp/jasmine
+tmp_dir: "tmp/jasmine"

data/lib/decko/generators/decko/templates/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "decko/mods_spec_helper"

data/lib/decko/mods_spec_helper.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+# require 'codeclimate-test-reporter'
+# CodeClimate::TestReporter.start
+
+require "decko" # only for card_gem_root
+require File.join Decko.card_gem_root, "spec/support/card_spec_loader.rb"
+require File.join Decko.card_gem_root, "spec/support/matchers.rb"
+
+CardSpecLoader.init
+
+CardSpecLoader.prefork do
+  if defined?(Bundler)
+    Bundler.require(:test)
+    # if simplecov is activated in the Gemfile, it has to be required here
+  end
+  #  FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures'
+  CardSpecLoader.rspec_config
+end
+
+CardSpecLoader.each_run do
+  # This code will be run each time you run your specs.
+end
+
+CardSpecLoader.helper

data/lib/decko/response.rb

@@ -0,0 +1,102 @@
+module Decko
+  # methods for managing decko responses
+  module Response
+    private
+
+    def card_redirect url
+      url = card_url url # make sure we have absolute url
+      if Card::Env.ajax?
+        # lets client reset window location
+        # (not just receive redirected response)
+        # formerly used 303 response, but that gave IE the fits
+        render json: { redirect: url }
+      else
+        redirect_to url
+      end
+    end
+
+    def deliver format, result, status
+      if format == :file && status == 200
+        send_file(*result)
+      elsif status == 302
+        card_redirect result
+      else
+        args = { text: result, status: status }
+        args[:content_type] = "text/text" if format == :file
+        render args
+      end
+    end
+
+    def reset_card new_card
+      @card = new_card
+      update_params_for_success
+      @card.select_action_by_params params
+    end
+
+    def update_params_for_success
+      success = Card::Env.success
+      if success.soft_redirect?
+        self.params = success.params
+      else
+        # need tests. insure we get slot, main...
+        params.merge! success.params
+      end
+    end
+
+    def send_deprecated_asset
+      filename = [params[:filename], params[:format]].join(".")
+      # for security, block relative paths
+      raise Decko::BadAddress if filename.include? "../"
+      path = Decko::Engine.paths["gem-assets"].existent.first
+      send_file File.join(path, filename), x_sendfile: true
+    end
+
+    def format_from_params
+      return :file if params[:explicit_file]
+      format = request.parameters[:format]
+      # unknown format
+      return :file unless Card::Format.registered.member?(format)
+      format.to_sym
+    end
+
+    def interpret_id id
+      case id
+      when "*previous" then return card_redirect(Card::Env.previous_location)
+      when nil         then determine_id
+      else                  validate_id_encoding id
+      end
+    end
+
+    def determine_id
+      case
+      when prompt_setup?
+        prepare_setup_card!
+      when params[:card] && params[:card][:name]
+        params[:card][:name]
+      when Card::Format.tagged(params[:view], :unknown_ok)
+        ""
+      else
+        Card.global_setting(:home) || "Home"
+      end
+    end
+
+    def prompt_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
+
+    def validate_id_encoding id
+      # we should find the place where we produce these bad urls
+      id.valid_encoding? ? id : id.force_encoding("ISO-8859-1").encode("UTF-8")
+    end
+
+    def use_draft?
+      params[:edit_draft] && card.drafts.present?
+    end
+  end
+end

data/lib/decko/script_decko_loader.rb

@@ -0,0 +1,31 @@
+require "pathname"
+
+module Decko
+  module ScriptDeckoLoader
+    RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) +
+           RbConfig::CONFIG["EXEEXT"]
+    SCRIPT_DECKO = File.join("script", "decko")
+
+    def self.exec_script_decko!
+      cwd = Dir.pwd
+      return unless in_decko_application? || in_decko_application_subdirectory?
+      exec RUBY, SCRIPT_DECKO, *ARGV if in_decko_application?
+      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_script_decko! unless cwd == Dir.pwd
+      end
+    rescue SystemCallError
+      # could not chdir, no problem just return
+    end
+
+    def self.in_decko_application?
+      File.exist?(SCRIPT_DECKO)
+    end
+
+    def self.in_decko_application_subdirectory? path=Pathname.new(Dir.pwd)
+      File.exist?(File.join(path, SCRIPT_DECKO)) ||
+        !path.root? && in_decko_application_subdirectory?(path.parent)
+    end
+  end
+end

data/lib/decko/tasks/cucumber.rake

@@ -0,0 +1,65 @@
+# IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a
+# newer version of cucumber-rails. Consider adding your own code to a new file
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# 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
+$LOAD_PATH.unshift(File.dirname(vendored_cucumber_bin) + "/../lib") unless vendored_cucumber_bin.nil?
+
+begin
+  require "cucumber/rake/task"
+
+  namespace :cucumber do
+    Cucumber::Rake::Task.new({ ok: "db:test:prepare" }, "Run features that should pass") do |t|
+      t.binary = vendored_cucumber_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" }, "Run features that are being worked on") do |t|
+      t.binary = vendored_cucumber_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" }, "Record failing features and run only them if any exist") do |t|
+      t.binary = vendored_cucumber_bin
+      t.fork = true # You may get faster startup if you set this to false
+      t.profile = "rerun"
+    end
+
+    desc "Run all features"
+    task all: [:ok, :wip]
+
+    task :statsetup do
+      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") # hack!  should be elsewhere
+    end
+  end
+  desc "Alias for cucumber:ok"
+  task cucumber: "cucumber:ok"
+
+  task default: :cucumber
+
+  task features: :cucumber do
+    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
+  end
+
+  task stats: "cucumber:statsetup"
+rescue LoadError
+  desc "cucumber rake task not available (cucumber not installed)"
+  task :cucumber do
+    abort "Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin"
+  end
+end
+
+end

data/lib/decko/tasks/db.rake

@@ -0,0 +1,55 @@
+require "rake"
+
+# This code lets us redefine existing Rake tasks, which is extremely
+# handy for modifying existing Rails rake tasks.
+# Credit for the original snippet of code goes to Jeremy Kemper
+# http://pastie.caboo.se/9620
+unless Rake::TaskManager.methods.include?(:redefine_task)
+  module Rake
+    module TaskManager
+      def redefine_task task_class, args, &block
+        task_name, arg_names, deps = resolve_args(args)
+        task_name = task_class.scope_name(@scope, task_name)
+        deps = [deps] unless deps.respond_to?(:to_ary)
+        deps = deps.map(&:to_s)
+        task = @tasks[task_name.to_s] = task_class.new(task_name, self)
+        task.application = self
+        @last_comment = nil
+        task.enhance(deps, &block)
+        task
+      end
+    end
+    class Task
+      class << self
+        def redefine_task args, &block
+          Rake.application.redefine_task(self, [args], &block)
+        end
+      end
+    end
+  end
+end
+
+namespace :db do
+  namespace :fixtures do
+    desc "Load fixtures into the current environment's database.  Load specific fixtures using FIXTURES=x,y"
+    task load: :environment do
+      require "active_record/fixtures"
+      fixture_path = File.join(Cardio.gem_root, "db", "seed", "test", "fixtures")
+      ActiveRecord::Base.establish_connection(::Rails.env.to_sym)
+      (ENV["FIXTURES"] ? ENV["FIXTURES"].split(/,/) : Dir.glob(File.join(fixture_path, "*.{yml,csv}"))).each do |fixture_file|
+        ActiveRecord::FixtureSet.create_fixtures(fixture_path, File.basename(fixture_file, ".*"))
+      end
+    end
+  end
+
+  namespace :test do
+    desc "Prepare the test database and load the schema"
+    Rake::Task.redefine_task(prepare: :environment) do
+      if ENV["RELOAD_TEST_DATA"] == "true" || ENV["RUN_CODE_RUN"]
+        puts `env RAILS_ENV=test rake decko:seed`
+      else
+        puts "skipping loading test data.  to force, run `env RELOAD_TEST_DATA=true rake db:test:prepare`"
+      end
+    end
+  end
+end

data/lib/decko/tasks/decko.rake

@@ -0,0 +1,170 @@
+require "decko/application"
+
+DECKO_SEED_TABLES = %w( cards card_actions card_acts card_changes
+                       card_references ).freeze
+DECKO_SEED_PATH = File.join(
+  ENV["DECKO_SEED_REPO_PATH"] || [Cardio.gem_root, "db", "seed"], "new"
+)
+
+namespace :decko do
+  desc "create a decko database from scratch, load initial data"
+  task :seed do
+    ENV["SCHEMA"] ||= "#{Cardio.gem_root}/db/schema.rb"
+    puts "dropping"
+    # FIXME: this should be an option, but should not happen on standard
+    # creates!
+    begin
+      Rake::Task["db:drop"].invoke
+    rescue
+      puts "not dropped"
+    end
+
+    puts "creating"
+    Rake::Task["db:create"].invoke
+
+    puts "loading schema"
+    Rake::Task["db:schema:load"].invoke
+
+    Rake::Task["decko:load"].invoke
+  end
+
+  desc "clear and load fixtures with existing tables"
+  task reseed: :environment do
+    ENV["SCHEMA"] ||= "#{Cardio.gem_root}/db/schema.rb"
+
+    Rake::Task["decko:clear"].invoke
+
+    Rake::Task["decko:load"].invoke
+  end
+
+  desc "empty the card tables"
+  task :clear do
+    conn = ActiveRecord::Base.connection
+
+    puts "delete all data in bootstrap tables"
+    DECKO_SEED_TABLES.each do |table|
+      conn.delete "delete from #{table}"
+    end
+  end
+
+  desc "Load bootstrap data into database"
+  task :load do
+    require "decko/engine"
+    puts "update card_migrations"
+    Rake::Task["decko:assume_card_migrations"].invoke
+
+    if Rails.env == "test" && !ENV["GENERATE_FIXTURES"]
+      puts "loading test fixtures"
+      Rake::Task["db:fixtures:load"].invoke
+    else
+      puts "loading bootstrap"
+      Rake::Task["decko:bootstrap:load"].invoke
+    end
+
+    puts "set symlink for assets"
+    Rake::Task["decko:update_assets_symlink"].invoke
+
+    puts "reset cache"
+    system "bundle exec rake decko:reset_cache" # needs loaded environment
+  end
+
+  desc "update decko gems and database"
+  task :update do
+    ENV["NO_RAILS_CACHE"] = "true"
+    # system 'bundle update'
+    if Wagn.paths["tmp"].existent
+      FileUtils.rm_rf Wagn.paths["tmp"].first, secure: true
+    end
+    Dir.mkdir Wagn.paths["tmp"].first
+    Rake::Task["decko:migrate"].invoke
+    # FIXME: remove tmp dir / clear cache
+    puts "set symlink for assets"
+    Rake::Task["decko:update_assets_symlink"].invoke
+  end
+
+  desc "reset cache"
+  task reset_cache: :environment do
+    Card::Cache.reset_all
+    Card.reset_all_machines
+  end
+
+  desc "set symlink for assets"
+  task :update_assets_symlink do
+    assets_path = File.join(Rails.public_path, "assets")
+    if Rails.root.to_s != Wagn.gem_root && !File.exist?(assets_path)
+      FileUtils.rm assets_path if File.symlink? assets_path
+      FileUtils.ln_s(Decko::Engine.paths["gem-assets"].first, assets_path)
+    end
+  end
+
+  desc "migrate structure and cards"
+  task migrate: :environment do
+    ENV["NO_RAILS_CACHE"] = "true"
+    ENV["SCHEMA"] ||= "#{Cardio.gem_root}/db/schema.rb"
+
+    stamp = ENV["STAMP_MIGRATIONS"]
+
+    puts "migrating structure"
+    Rake::Task["decko:migrate:structure"].invoke
+    Rake::Task["decko:migrate:stamp"].invoke :structure if stamp
+
+    puts "migrating core cards"
+    Card::Cache.reset_all
+    # not invoke because we don't want to reload environment
+    Rake::Task["decko:migrate:core_cards"].execute
+    if stamp
+      Rake::Task["decko:migrate:stamp"].reenable
+      Rake::Task["decko:migrate:stamp"].invoke :core_cards
+    end
+
+    puts "migrating deck cards"
+    # not invoke because we don't want to reload environment
+    Rake::Task["decko:migrate:deck_cards"].execute
+    if stamp
+      Rake::Task["decko:migrate:stamp"].reenable
+      Rake::Task["decko:migrate:stamp"].invoke :deck_cards
+    end
+
+    Card::Cache.reset_all
+  end
+
+  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
+  end
+
+  namespace :emergency do
+    task rescue_watchers: :environment do
+      follower_hash = Hash.new { |h, v| h[v] = [] }
+
+      Card.where("right_id" => 219).each do |watcher_list|
+        watcher_list.include_set_modules
+        next unless watcher_list.left
+        watching = watcher_list.left.name
+        watcher_list.item_names.each do |user|
+          follower_hash[user] << watching
+        end
+      end
+
+      Card.search(right: { codename: "following" }).each do |following|
+        Card::Auth.as_bot do
+          following.update_attributes! content: ""
+        end
+      end
+
+      follower_hash.each do |user, items|
+        next unless (card = Card.fetch(user)) && card.account
+        Card::Auth.as(user) do
+          following = card.fetch trait: "following", new: {}
+          following.items = items
+        end
+      end
+    end
+  end
+end
+
+def version
+  ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+end