card 1.104.2 → 1.105.1

data/db/test_seed.rb

@@ -1,322 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require "timecop"
-require "active_support/core_ext/numeric/time"
-
-# noinspection RubyResolve
-class SharedData
-  extend Card::Model::SaveHelper
-
-  USERS = [
-    "Joe Admin", "Joe User", "Joe Camel", "Sample User", "No count",
-    "u1", "u2", "u3",
-    "Big Brother", "Optic fan", "Sunglasses fan", "Narcissist"
-  ].freeze
-
-  CARDTYPE_COUNT = 44
-
-  class << self
-    def create_user name, args
-      args[:subcards] = account_args args if args[:email]
-
-      if name == "Joe Admin"
-        super name, args
-      else
-        Card::Auth.with("joe_admin") { super name, args }
-      end
-    end
-
-    def account_args hash
-      { "+*account" => { "+*email" => hash.delete(:email),
-                         "+*password" => hash.delete(:password) || "joe_pass" } }
-    end
-
-    # noinspection RubyResolve
-    def add_test_data
-      Card::Cache.reset_all
-      Card::Env.reset
-      Card::Auth.as_bot
-
-      user_and_role_cards
-
-      # generic, shared attribute card
-      ensure_card "color"
-
-      create "signup alert email+*to", "signups@decko.org"
-      # CREATE A CARD OF EACH TYPE
-
-      no_samples = %w[user sign_up set number mirror_list mirrored_list file image
-                      customized_bootswatch_skin alias]
-      Card::Auth.createable_types.each do |type|
-        next if no_samples.include? type.to_name.key
-
-        create type: type, name: "Sample #{type}"
-      end
-
-      %w[c1 c2 c3].each do |name|
-        create name
-      end
-
-      create_layout_type "lay out", "Greatest {{_main|title: Callahan!; view: labeled}}"
-      create_pointer "stacks", %w[horizontal vertical]
-      create_pointer "stacks+*self+*layout", "lay out"
-      create "horizontal"
-      create_pointer "vertical"
-
-      create_pointer "friends+*right+*default"
-      create_search_type "friends+*right+*content options", '{"type":"User"}'
-
-      create_pointer "joes"
-      create "joes+*self+*input type", "filtered list"
-      create "joes+*self+*content options", ["Joe Admin", "Joe User", "Joe Camel"]
-
-      # cards for rename_test
-      # FIXME: could probably refactor these..
-      [
-        ["Z", "I'm here to be referenced to"],
-        ["A", "Alpha [[Z]]"],
-        ["B", "Beta {{Z}}"],
-        %w[T Theta],
-        ["X", "[[A]] [[A+B]] [[T]]"],
-        ["Y", "{{B}} {{A+B}} {{A}} {{T}}"],
-        ["A+B", "AlphaBeta"],
-        ["A+B+Y+Z", "more letters"],
-        ["Link to unknown", "[[Mister X]]"]
-      ].each do |name, content|
-        create name, content
-      end
-
-      create "One+Two+Three"
-      create "Four+One+Five"
-      create "basicname", "basiccontent"
-
-      cardtype_cards
-
-      # for template stuff
-      Card.create! type_id: Card::CardtypeID, name: "UserForm"
-      create "UserForm+*type+*structure", "{{+name}} {{+age}} {{+description}}"
-
-      Card::Auth.signin "joe_user"
-      create "JoeLater", "test"
-      create "JoeNow", "test"
-
-      Card::Auth.signin Card::WagnBotID
-
-      create_cardtype "Book"
-      create "Book+*type+*structure", "by {{+author}}, design by {{+illustrator}}"
-      create_book "Iliad"
-
-      create_cardtype "Author"
-      create_author "Darles Chickens"
-      create_author "Stam Broker"
-      create_book "Parry Hotter"
-      create_book "50 grades of shy"
-
-      ## --------- Fruit: creatable by anyone but not readable ---
-      Card.create! type: "Cardtype", name: "Fruit"
-      Card.create! name: "Fruit+*type+*create", type: "Pointer", content: "[[Anyone]]"
-      Card.create! name: "Fruit+*type+*read", type: "Pointer",
-                   content: "[[Administrator]]"
-
-      # codenames for card_accessor tests
-      Card.create! name: "*write", codename: :write
-
-      # -------- For toc testing: ------------
-
-      create "OnneHeading", "<h1>This is one heading</h1>\r\n<p>and some text</p>"
-      create "TwwoHeading", "<h1>One Heading</h1>\r\n<p>and some text</p>\r\n"\
-                            "<h2>And a Subheading</h2>\r\n<p>and more text</p>"
-      create "ThreeHeading", "<h1>A Heading</h1>\r\n<p>and text</p>\r\n"\
-                             "<h2>And Subhead</h2>\r\n<p>text</p>\r\n"\
-                             "<h1>And another top Heading</h1>"
-
-      # -------- For history testing: -----------
-      first = create "First", "egg"
-      first.update! content: "chicken"
-      first.update! content: "chick"
-
-      # -------- For rename testing: -----------
-      [
-        ["Blue", ""],
-        ["blue includer 1", "{{Blue}}"],
-        ["blue includer 2", "{{blue|closed;other:stuff}}"],
-        ["blue linker 1", "[[Blue]]"],
-        ["blue linker 2", "[[blue]]"]
-      ].each do |name, content|
-        create name, content
-      end
-      create_cardtype "self aware", "[[/new/{{_self|name}}|new]]"
-
-      notification_cards
-
-      create "42", TEXT
-      create_pointer "items",
-                     content: ["Parry Hotter", "42", "Stam Broker", "First",
-                               "yeti skin+image", "*all+*script+*machine output"]
-    end
-
-    def user_and_role_cards
-      # Card::Auth.instant_account_activation do
-      create_user "Joe Admin", content: "I'm number one", email: "joe@admin.com"
-        create_user "Joe User", content: "I'm number two", email: "joe@user.com"
-        create_user "Joe Camel", content: "Mr. Buttz", email: "joe@camel.com"
-
-        # data for testing users and account requests
-        create_user "No Count", content: "I got no account"
-        create_user "Sample User", email: "sample@user.com", password: "sample_pass"
-      # end
-
-      # noinspection RubyResolve
-      Card["Joe Admin"].fetch(:roles, new: { type_code: "pointer" })
-                       .items = [Card::AdministratorID, Card::SharkID, Card::HelpDeskID]
-
-      Card["Joe User"].fetch(:roles, new: { type_code: "pointer" })
-                      .items = [Card::SharkID]
-
-      create_user "u1", email: "u1@user.com", password: "u1_pass"
-      create_user "u2", email: "u2@user.com", password: "u2_pass"
-      create_user "u3", email: "u3@user.com", password: "u3_pass"
-
-      r1 = create_role "r1"
-      r2 = create_role "r2"
-      r3 = create_role "r3"
-      r4 = create_role "r4"
-
-      Card["u1"].fetch(:roles, new: { type_code: "pointer" }).items = [r1, r2, r3]
-      Card["u2"].fetch(:roles, new: {}).items = [r1, r2, r4]
-      Card["u3"].fetch(:roles, new: {}).items = [r1, r4, Card::AdministratorID]
-    end
-
-    def cardtype_cards
-      # for cql & permissions
-      %w[A+C A+D A+E C+A D+A F+A A+B+C].each { |name| create name }
-      ("A".."F").each do |ch|
-        create "Cardtype #{ch}", type_code: "cardtype",
-                                 codename: "cardtype_#{ch.downcase}"
-      end
-      Card::Codename.reset_cache
-
-      ("a".."f").each do |ch|
-        create "type-#{ch}-card", type_code: "cardtype_#{ch}",
-                                  content: "type_#{ch}_content"
-      end
-
-      create_pointer "Cardtype B+*type+*create", "[[r3]]"
-      create_pointer "Cardtype B+*type+*update", "[[r1]]"
-
-      ## --------- create templated permissions -------------
-      create "Cardtype E+*type+*default"
-    end
-
-    def future_stamp
-      Time.zone.local 2020, 1, 1, 0, 0, 0
-    end
-
-    def notification_cards
-      Timecop.freeze(future_stamp - 1.day) do
-        # fwiw Timecop is apparently limited by ruby Time object,
-        # which goes only to 2037 and back to 1900 or so.
-        #  whereas DateTime can represent all dates.
-
-        followers = {
-          "John" => ["John Following", "All Eyes On Me"],
-          "Sara" => ["Sara Following", "All Eyes On Me", "Optic+*type",
-                     "Google Glass"],
-          "Big Brother" => ["All Eyes on Me", "Look at me+*self", "Optic+*type",
-                            "lens+*right", "Optic+tint+*type plus right",
-                            ["*all", "*created"], ["*all", "*edited"]],
-          "Optic fan" => ["Optic+*type"],
-          "Sunglasses fan" => ["Sunglasses"],
-          "Narcissist" => [["*all", "*created"], ["*all", "*edited"]]
-        }
-
-        followers.each do |name, _follow|
-          create_user name, email: "#{name.parameterize}@user.com",
-                            password: "#{name.parameterize}_pass"
-        end
-
-        create "All Eyes On Me"
-        create "No One Sees Me"
-        create "Look At Me"
-        create_cardtype "Optic"
-        create "Sara Following"
-        create "John Following", "{{+her}}"
-        create "John Following+her"
-        magnifier = create "Magnifier+lens"
-
-        Card::Auth.signin "Narcissist"
-        magnifier.update! content: "zoom in"
-        create_optic "Sunglasses", "{{+tint}}{{+lens}}"
-
-        Card::Auth.signin "Optic fan"
-        create_optic "Google glass", "{{+price}}"
-
-        Card::Auth.signin Card::WagnBotID
-        create "Google glass+*self+*follow_fields", ""
-        create "Sunglasses+*self+*follow_fields",
-               "[[#{:nests.cardname}]]\n[[_self+price]]\n[[_self+producer]]"
-        create "Sunglasses+tint"
-        create "Sunglasses+price"
-
-        followers.each do |name, follow|
-          user = Card[name]
-          follow.each do |f|
-            user.follow(*f)
-          end
-        end
-      end
-
-      # capitalized names so that they don't interfere with checks for the verbs
-      create "Created card", content: "new content"
-      update "Created card", name: "Updated card", content: "changed content",
-                             type: :pointer, skip: :validate_renaming
-      create "Created card", content: "new content"
-      card = create "Deleted card", content: "old content"
-      card.delete
-
-      Card::Auth.with "Joe User" do
-        [
-          ["card with fields", "field 1", "field 2"],
-          ["card with fields and admin fields", "field 1", "admin field 1"],
-          ["admin card with fields and admin fields", "field 1", "admin field 1"],
-          ["admin card with admin fields", "admin field 1", "admin field 2"]
-        ].each do |name, f1, f2|
-          create name,
-                 content: "main content {{+#{f1}}}  {{+#{f2}}}",
-                 subcards: { "+#{f1}" => "content of #{f1}",
-                             "+#{f2}" => "content of #{f2}" }
-        end
-      end
-
-      Card::Auth.as_bot do
-        [
-          ["admin card with fields and admin fields", :self],
-          ["admin card with admin fields", :self],
-          ["admin field 1", :right],
-          ["admin field 2", :right]
-        ].each do |name, rule_set|
-          create [name, rule_set, :read], type: "Pointer", content: "[[Administrator]]"
-        end
-        create ["field 1", :right, :read], type: "Pointer", content: "[[Anyone]]"
-      end
-    end
-  end
-
-  TEXT = <<~TXT.strip_heredoc.freeze
-          Far out in the uncharted backwaters of the unfashionable end of
-          the western spiral arm of the Galaxy lies a small unregarded
-          yellow sun.
-          
-          Orbiting this at a distance of roughly ninety-two million miles
-          is an utterly insignificant little blue green planet whose ape-
-          descended life forms are so amazingly primitive that they still
-          think digital watches are a pretty neat idea.
-          
-          This planet has - or rather had - a problem, which was this: most
-          of the people living on it were unhappy for pretty much of the time.
-          Many solutions were suggested for this problem, but most of these
-          were largely concerned with the movements of small green pieces
-          of paper, which is odd because on the whole it wasn't the small
-          green pieces of paper that were unhappy.
-  TXT
-end

data/lib/card/content/truncate.rb

@@ -1,67 +0,0 @@
-class Card
-  class Content
-    # tools for truncating content
-    module Truncate
-      ELLIPSES_HTML = '<span class="closed-content-ellipses">...</span>'.freeze
-
-      def smart_truncate input, words=25
-        return if input.nil?
-
-        truncated, wordstring = truncate input, words
-        # nuke partial tags at end of snippet
-        wordstring.gsub!(/(<[^>]+)$/, "")
-        wordstring = close_tags wordstring
-        wordstring += ELLIPSES_HTML if truncated
-        # wordstring += '...' if wordlist.length > l
-        polish wordstring
-      end
-
-      private
-
-      def truncate input, words
-        wordlist = input.to_s.split
-        l = words.to_i - 1
-        l = 0 if l.negative?
-        truncating = wordlist.length > l
-        wordstring = truncating ? wordlist[0..l].join(" ") : input.to_s
-        [truncating, wordstring]
-      end
-
-      def close_tags wordstring
-        tags = find_tags wordstring
-        tags.each { |t| wordstring += "</#{t}>" }
-        wordstring
-      end
-
-      def polish wordstring
-        wordstring.gsub! %r{</?br[\s/]*>}, " "
-        # Also a hack -- get rid of <br>'s -- they make line view ugly.
-        wordstring.gsub! %r{</?p[^>]*>}, " "
-        ## Also a hack -- get rid of <br>'s -- they make line view ugly.
-        wordstring
-      end
-
-      def find_tags wordstring
-        tags = []
-
-        # match tags with or without self closing (ie. <foo />)
-        wordstring.scan(%r{<([^>\s/]+)[^>]*?>}).each do |t|
-          tags.unshift(t[0])
-        end
-        # match tags with self closing and mark them as closed
-        wordstring.scan(%r{<([^>\s/]+)[^>]*?/>}).each do |t|
-          next unless (x = tags.index(t[0]))
-
-          tags.slice!(x)
-        end
-        # match close tags
-        wordstring.scan(%r{</([^>\s/]+)[^>]*?>}).each do |t|
-          next unless (x = tags.rindex(t[0]))
-
-          tags.slice!(x)
-        end
-        tags
-      end
-    end
-  end
-end

data/lib/card/director/card_methods.rb

@@ -1,45 +0,0 @@
-class Card
-  class Director
-    module CardMethods
-      attr_writer :director
-
-      delegate :validation_phase, :storage_phase, :integration_phase,
-               :validation_phase_callback?, :integration_phase_callback?, to: :director
-
-      def director
-        @director ||= Director.fetch self
-      end
-
-      def prepare_for_phases
-        reset_patterns
-        include_set_modules
-      end
-
-      def identify_action
-        @action =
-          if trash && trash_changed?
-            :delete
-          elsif new_card?
-            :create
-          else
-            :update
-          end
-      end
-
-      def restore_changes_information
-        # restores changes for integration phase
-        # (rails cleared them in an after_create/after_update hook which is
-        #  executed before the integration phase)
-        return unless saved_changes.present?
-
-        @mutations_from_database = mutations_before_last_save
-      end
-
-      def clear_action_specific_attributes
-        self.class.action_specific_attributes.each do |attr|
-          instance_variable_set "@#{attr}", nil
-        end
-      end
-    end
-  end
-end

data/lib/card/file_card_creator/abstract_file_card/migration_file.rb

@@ -1,50 +0,0 @@
-class Card
-  class FileCardCreator
-    class AbstractFileCard
-      # Module that provides #create_migration_file method for classes that
-      # inherit from AbstractFileCard.
-      # It uses the decko generator to create the migration.
-      module MigrationFile
-        def create_migration_file
-          puts "creating migration file...".yellow
-          migration_out = `#{migrate_command}`
-          return if migration_out.include?("conflict")
-
-          migration_file_name = migration_out[/db.*/]
-          write_at migration_file_name, 5, indented_migration_content # 5 is line no.
-        end
-
-        private
-
-        def migrate_command
-          cmd = "bundle exec decko generate card:migration add_#{@codename}"
-          cmd += " --force" if @force
-          cmd
-        end
-
-        def indented_migration_content
-          migration_file_content.lines.map do |line|
-            " " * 4 + line
-          end.join
-        end
-
-        def migration_file_content
-          indent = " " * category.to_s.size
-          <<-RUBY.strip_heredoc
-            add_#{category} "#{remove_prefix @name}",
-                #{indent} type_id: #{type_id},
-                #{indent} to: "#{rule_card_name}"
-          RUBY
-        end
-
-        def remove_prefix name
-          name.sub(/^(?:#{category}):?_?\s*/, "")
-        end
-
-        def type_id
-          "Card::#{type_codename.to_s.camelcase}ID"
-        end
-      end
-    end
-  end
-end

data/lib/card/file_card_creator/abstract_file_card/ruby_file.rb

@@ -1,30 +0,0 @@
-class Card
-  class FileCardCreator
-    class AbstractFileCard
-      # Module that provides #create_ruby_file method for a classes that
-      # inherit from AbstractFileCard.
-      # The default location for the ruby file is set/self.
-      module RubyFile
-        def create_ruby_file
-          write_to_mod(ruby_file_dir, ruby_file_name) do |f|
-            f.puts ruby_file_content
-          end
-        end
-
-        private
-
-        def ruby_file_dir
-          File.join "set", "self"
-        end
-
-        def ruby_file_name
-          "#{@codename}.rb"
-        end
-
-        def ruby_file_content
-          "include_set Abstract::CodeFile"
-        end
-      end
-    end
-  end
-end

data/lib/card/file_card_creator/abstract_file_card/source_file.rb

@@ -1,36 +0,0 @@
-class Card
-  class FileCardCreator
-    class AbstractFileCard
-      # Module that provides #create_source_file method for a classes that
-      # inherit from AbstractFileCard
-      module SourceFile
-        def create_source_file
-          write_to_mod source_file_dir, source_file_name do |f|
-            f.puts source_file_content
-          end
-        end
-
-        private
-
-        def source_file_content
-          card = Card.fetch(@name)
-          if card
-            card.content
-          else
-            color_puts "warning:", :yellow,
-                       "Card '#{@name}' doesn't exist. Creating empty source file ..."
-            ""
-          end
-        end
-
-        def source_file_name
-          "#{@codename}.#{source_file_ext}"
-        end
-
-        def source_file_ext
-          @type
-        end
-      end
-    end
-  end
-end

data/lib/card/file_card_creator/abstract_file_card.rb

@@ -1,44 +0,0 @@
-class Card
-  class FileCardCreator
-    # A template class for generating cards that are linked to source files.
-    class AbstractFileCard
-      include OutputHelper
-      include SourceFile
-      include MigrationFile
-      include RubyFile
-
-      class << self
-        attr_reader :supported_types, :category
-        attr_accessor :default_rule_name
-
-        def valid_type? type
-          supported_types.include? type.to_sym
-        end
-      end
-
-      def initialize mod, name, type, codename: nil, force: false
-        @mod = mod
-        @type = type.to_sym
-        @name = name
-        @force = force
-        @codename = codename || name.underscore.tr(" ", "_")
-      end
-
-      def create
-        create_source_file
-        create_ruby_file
-        create_migration_file
-      end
-
-      def category
-        self.class.category
-      end
-
-      private
-
-      def rule_card_name
-        self.class.default_rule_name
-      end
-    end
-  end
-end

data/lib/card/file_card_creator/haml_card.rb

@@ -1,42 +0,0 @@
-require "html2haml"
-
-class Card
-  class FileCardCreator
-    # Convert a card with html db content to a card with hard-coded haml.
-    # It generates three files:
-    #   1. a migration file that creates a card with codename
-    #   2. a haml file with the converted html
-    #   3. a ruby file (=code rule)that ties the haml file to the card
-    class HamlCard < AbstractFileCard
-      @supported_types = %i[haml]
-      @category = :haml
-
-      private
-
-      def type_codename
-        @type_codename ||= :html
-      end
-
-      def source_file_dir
-        File.join "template", "self"
-      end
-
-      def source_file_content
-        html = super()
-        Html2haml::HTML.new(html).render
-      end
-
-      def migration_file_content
-        <<-RUBY.strip_heredoc
-          ensure_card "#{@name}",
-                      type_id: #{type_id},
-                      codename: "#{@codename}"
-        RUBY
-      end
-
-      def ruby_file_content
-        "include_set Abstract::HamlFile"
-      end
-    end
-  end
-end

data/lib/card/file_card_creator/output_helper.rb

@@ -1,53 +0,0 @@
-class Card
-  class FileCardCreator
-    # Helper methods to write to files and the console.
-    module OutputHelper
-      def write_to_mod rel_dir, filename, &block
-        dir = File.join "mod", @mod, rel_dir
-        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
-
-        path = File.join dir, filename
-        log_file_action path do
-          File.open(path, "w", &block)
-        end
-      end
-
-      def log_file_action path, &block
-        if File.exist?(path) && !@force
-          log_file_exists path
-        else
-          execute_and_log_file_action path, &block
-        end
-      end
-
-      def execute_and_log_file_action path
-        status = File.exist?(path) ? "overridden" : "created"
-        yield
-        color_puts status, :green, path
-      end
-
-      def log_file_exists path
-        color_puts "file exists (use 'force=true' to override)", :yellow, path
-      end
-
-      # insert content into a file at a given line number
-      def write_at fname, at_line, sdat
-        open(fname, "r+") do |f|
-          (at_line - 1).times do # read up to the line you want to write after
-            f.readline
-          end
-          pos = f.pos # save your position in the file
-          rest = f.read # save the rest of the file
-          f.seek pos # go back to the old position
-          f.puts sdat # write new data & rest of file
-          f.puts rest
-          color_puts "created", :green, fname
-        end
-      end
-
-      def color_puts colored_text, color, text=""
-        puts "#{colored_text.send(color.to_s)} #{text}"
-      end
-    end
-  end
-end