card 0.0.1 → 1.15.pre

data/db/version_core_cards.txt

@@ -0,0 +1 @@
+20150220134731

data/lib/card.rb

@@ -1,5 +1,48 @@
-require "card/version"
+# -*- encoding : utf-8 -*-
 
-module Card
-  # Your code goes here...
+Object.send :remove_const, :Card if Object.send(:const_defined?, :Card)
+
+class Card < ActiveRecord::Base
+  require_dependency 'card/active_record_ext'
+  require_dependency 'card/codename'
+  require_dependency 'card/query'
+  require_dependency 'card/format'
+  require_dependency 'card/exceptions'
+  require_dependency 'card/auth'
+  require_dependency 'card/log'
+  require_dependency 'card/loader'
+  require_dependency 'card/content'
+  require_dependency 'card/action'
+  require_dependency 'card/act'
+  require_dependency 'card/change'
+  require_dependency 'card/reference'
+
+  has_many :references_from, :class_name => :Reference, :foreign_key => :referee_id
+  has_many :references_to,   :class_name => :Reference, :foreign_key => :referer_id
+  has_many :acts, :order => :id
+  has_many :actions, :order => :id, :conditions=>{:draft => [nil,false]}
+  has_many :drafts, :order=>:id, :conditions=>{:draft=>true}, :class_name=> :Action
+
+  cache_attributes 'name', 'type_id' # review - still worth it in Rails 3?
+
+  cattr_accessor :set_patterns, :error_codes
+  @@set_patterns, @@error_codes = [], {}
+
+  attr_accessor :action, :supercard, :current_act, :current_action, 
+    :comment, :comment_author,    # obviated soon
+    :update_referencers,          # wrong mechanism for this
+    :update_all_users,                  # if the above is wrong then this one too
+    :follower_stash, :remove_rule_stash,
+    :last_action_id_before_edit
+    
+  define_callbacks :approve, :store, :extend
+  
+  before_validation :approve
+  around_save :store
+  after_save :extend
+  
+  TRACKED_FIELDS = %w(name type_id db_content trash)
+
+  ActiveSupport.run_load_hooks(:card, self)
 end
+

data/lib/card/active_record_ext.rb

@@ -0,0 +1,77 @@
+# -*- encoding : utf-8 -*-
+module ActiveRecord
+
+  module ConnectionAdapters
+    class AbstractAdapter
+      def match(string)
+        raise "match not implemented"
+      end
+
+      def cast_types
+        native_database_types.merge custom_cast_types
+      end
+
+      def custom_cast_types
+        {}
+      end
+    end
+
+    class PostgreSQLAdapter
+      def match(string)
+        "~* #{string}"
+      end
+    end
+
+    module MysqlCommon
+      def match(string)
+        "REGEXP #{string}"
+      end
+
+      def custom_cast_types
+        { :string  => { :name=>'char'    },
+          :integer => { :name=>'signed'  },
+          :text    => { :name=>'char'    },
+          :float   => { :name=>'decimal' },
+          :binary  => { :name=>'binary'  }  }
+      end
+    end
+
+    class MysqlAdapter
+      include MysqlCommon
+    end
+
+    class Mysql2Adapter
+      include MysqlCommon
+    end
+
+    class SQLiteAdapter
+      def match(string)
+        "REGEXP #{string}"
+      end
+    end
+  end
+  
+  module Transactions
+    #FIXME!!
+    # the following code is already in Rails 4 (see https://github.com/rails/rails/commit/c8792c7b2ea4f5fe7a5610225433ea8dd8d0f83e)
+    # it allows manual rollbacks in after_save (eg store events) to reset the object correctly
+    #  hopefully we can soon get rid of this code!
+    
+    def with_transaction_returning_status
+      status = nil
+      self.class.transaction do
+        add_to_transaction
+        begin
+          status = yield
+        rescue ActiveRecord::Rollback
+          @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+          status = nil
+        end
+
+        raise ActiveRecord::Rollback unless status
+      end
+      status
+    end
+  end
+  
+end

data/lib/card/auth.rb

@@ -0,0 +1,181 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  module Auth
+    @@as_card = @@as_id = @@current_id = @@current = @@simulating_setup_need = nil
+
+    NON_CREATEABLE_TYPES = %w{ signup setting set } # NEED API
+    NEED_SETUP_KEY = 'NEED_SETUP'
+
+    #after_save :reset_instance_cache
+
+    class << self
+
+      # Authenticates a user by their login name and unencrypted password.  
+      def authenticate email, password
+        accounted = Auth[ email ]
+        if accounted and account = accounted.account and account.active?
+          if Card.config.no_authentication or password_authenticated?( account, password.strip )
+            accounted.id
+          end
+        end
+      end
+
+      def password_authenticated? account, password
+        account.password == encrypt( password, account.salt )
+      end
+
+
+      # Encrypts some data with the salt.
+      def encrypt password, salt
+        Digest::SHA1.hexdigest "#{salt}--#{password}--"
+      end
+
+      # find accounted by email
+      def [] email
+        Auth.as_bot do
+          Card.search( :right_plus=>[
+            {:id=>Card::AccountID},
+            {:right_plus=>[{:id=>Card::EmailID},{ :content=>email.strip.downcase }]}
+          ]).first
+        end
+      end
+        
+      def signin signin_id
+        self.current_id = signin_id
+        session[:user] = signin_id if session
+      end
+
+      def session
+        Card::Env[:session]
+      end
+
+      def set_current_from_session
+        self.current_id = 
+          if session
+            if card_id=session[:user] and Card.exists? card_id
+              card_id
+            else
+              session[:user] = nil
+            end
+          end
+        current_id
+      end
+
+      def current_id
+        @@current_id ||= Card::AnonymousID
+      end
+
+      def current
+        if @@current && @@current.id == current_id
+          @@current
+        else
+          @@current = Card[current_id]
+        end
+      end
+
+      def current_id= card_id
+        @@current = @@as_id = @@as_card = nil
+        @@current_id = card_id
+      end
+
+      def get_user_id user
+        case user
+        when NilClass;   nil
+        when Card    ;   user.id
+        when Integer ;   user
+        else
+          user = user.to_s
+          Card::Codename[user] or (cd=Card[user] and cd.id)
+        end
+      end
+
+      def as given_user
+        tmp_id, tmp_card = @@as_id, @@as_card
+        @@as_id, @@as_card = get_user_id( given_user ), nil  # we could go ahead and set as_card if given a card...
+
+        @@current_id = @@as_id if @@current_id.nil?
+
+        if block_given?
+          value = yield
+          @@as_id, @@as_card = tmp_id, tmp_card
+          return value
+        else
+          #fail "BLOCK REQUIRED with Card#as"
+        end
+      end
+
+      def as_bot &block
+        as Card::WagnBotID, &block
+      end
+
+      def among? authzed
+        as_card.among? authzed
+      end
+
+      def as_id
+        @@as_id || current_id
+      end
+
+      def as_card
+        if @@as_card and @@as_card.id == as_id
+          @@as_card
+        else
+          @@as_card = Card[as_id]
+        end
+      end
+
+      def signed_in?
+        current_id != Card::AnonymousID
+      end
+
+      def needs_setup?
+        test = Card.cache.read NEED_SETUP_KEY
+        !test.nil? ? test : begin
+          @@simulating_setup_need or Card.cache.write( NEED_SETUP_KEY, (account_count < 3) ) # 3, because
+        end
+      end
+    
+      def simulate_setup_need! mode=true
+        @@simulating_setup_need = mode
+        Card.cache.write NEED_SETUP_KEY, nil
+      end
+    
+
+      def always_ok?
+        #warn Rails.logger.warn("aok? #{as_id}, #{as_id&&Card[as_id].id}")
+        return false unless usr_id = as_id
+        return true if usr_id == Card::WagnBotID #cannot disable
+
+        always = Card.cache.read('ALWAYS') || {}
+        #warn(Rails.logger.warn "Auth.always_ok? #{usr_id}")
+        if always[usr_id].nil?
+          always = always.dup if always.frozen?
+          always[usr_id] = !!Card[usr_id].all_roles.detect{|r|r==Card::AdministratorID}
+          #warn(Rails.logger.warn "update always hash #{always[usr_id]}, #{always.inspect}")
+          Card.cache.write 'ALWAYS', always
+        end
+        #warn Rails.logger.warn("aok? #{usr_id}, #{always[usr_id]}")
+        always[usr_id]
+      end
+      # PERMISSIONS
+
+
+      def createable_types
+        type_names = Auth.as_bot do
+          Card.search :type=>Card::CardtypeID, :return=>:name, :not => { :codename => ['in'] + NON_CREATEABLE_TYPES }
+        end
+        type_names.reject do |name|
+          !Card.new( :type=>name ).ok? :create
+        end.sort
+      end
+
+      private
+  
+      def account_count
+        as_bot { Card.count_by_wql :right=>Card[:account].name }
+      end
+
+    end
+  end
+end

data/lib/card/cache.rb

@@ -0,0 +1,199 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+
+  ActiveSupport::Cache::FileStore.class_eval do
+    # escape special symbols \*"<>| additionaly to :?.
+    # All of them not allowed to use in ms windows file system
+    def real_file_path(name)
+      name = name.gsub('%','%25').gsub('?','%3F').gsub(':','%3A')
+      name = name.gsub('\\','%5C').gsub('*','%2A').gsub('"','%22')
+      name = name.gsub('<','%3C').gsub('>','%3E').gsub('|','%7C')
+      '%s/%s.cache' % [@cache_path, name ]
+    end
+  end
+
+  class Cache
+
+    TEST_ENVS = %w{test cucumber}
+    @@prepopulating     = TEST_ENVS.include? Rails.env
+    @@using_rails_cache = TEST_ENVS.include? Rails.env
+    @@cache_by_class    = {}
+
+    cattr_reader :cache_by_class
+
+    class << self
+      def [] klass
+        raise "nil klass" if klass.nil?
+        cache_by_class[klass] ||= new :class=>klass, :store=>(@@using_rails_cache ? nil : Cardio.cache)
+      end
+
+      def renew
+        cache_by_class.keys do |klass|
+          if klass.cache
+            cache_by_class[klass].system_prefix = system_prefix(klass)
+          else
+            raise "renewing nil cache: #{klass}"
+          end
+        end
+        reset_local
+      end
+
+      def prefix_root
+        @@prefix_root ||= ( cfg = Cardio.config and cfg = cfg.database_configuration and
+                            cfg[Rails.env]['database'] )
+      end
+
+      def system_prefix klass
+        "#{ prefix_root }/#{ klass }"
+      end
+
+      def restore klass=nil
+        reset_local
+        prepopulate
+      end
+
+      def generate_cache_id
+        ((Time.now.to_f * 100).to_i).to_s + ('a'..'z').to_a[rand(26)] + ('a'..'z').to_a[rand(26)]
+      end
+
+      def reset_global
+        cache_by_class.each do |klass, cache|
+          cache.reset hard=true
+        end
+        Card::Codename.reset_cache
+        Cardio.delete_tmp_files
+      end
+
+      def reset_local
+        cache_by_class.each do |cc, cache|
+          if Card::Cache===cache
+            cache.reset_local
+          else warn "reset class #{cc}, #{cache.class} #{caller[0..8]*"\n"} ???" end
+        end
+      end
+
+      private
+
+      def prepopulate
+        if @@prepopulating
+          @@rule_cache      ||= Card.rule_cache
+          @@read_rule_cache ||= Card.read_rule_cache
+          @@user_ids_cache  ||= Card.user_ids_cache
+          @@rule_keys_cache ||= Card.rule_keys_cache
+          Card.cache.write_local 'RULES', @@rule_cache
+          Card.cache.write_local 'READRULES', @@read_rule_cache
+          Card.cache.write_local 'USER_IDS', @@user_ids_cache
+          Card.cache.write_local 'RULE_KEYS', @@rule_keys_cache
+        end
+      end
+
+
+
+    end
+
+    attr_reader :prefix, :store, :klass
+    attr_accessor :local
+
+    def initialize opts={}
+      #warn "new cache #{opts.inspect}"
+      @klass = opts[:class]
+      @store = opts[:store]
+      @local = Hash.new
+      self.system_prefix = opts[:prefix] || self.class.system_prefix(opts[:class])
+      cache_by_class[klass] = self
+    end
+    
+
+    def system_prefix= system_prefix
+      @system_prefix = system_prefix
+      if @store.nil?
+        @prefix = system_prefix + self.class.generate_cache_id + "/"
+      else
+        @system_prefix += '/' unless @system_prefix[-1] == '/'
+        @cache_id = @store.fetch(@system_prefix + "cache_id") do
+          self.class.generate_cache_id
+        end
+        @prefix = @system_prefix + @cache_id + "/"
+      end
+    end
+
+    def read key
+      if @local.has_key? key
+        read_local key
+      elsif @store
+        write_local key, @store.read(@prefix + key)
+      end
+    end
+    
+    def read_local key
+      @local[key]
+    end
+    
+    def write_variable key, variable, value
+      key = @prefix + key
+      if @store and object = @store.read(key)
+        object.instance_variable_set "@#{ variable }", value
+        @store.write key, object
+      end
+      value
+    end
+
+    def write key, value
+      @store.write(@prefix + key, value) if @store
+      write_local key, value
+    end
+
+    def write_local key, value
+      @local[key] = value
+    end
+
+    def fetch key, &block
+      fetch_local key do
+        if @store
+          @store.fetch(@prefix + key, &block)
+        else
+          block.call
+        end
+      end
+    end
+    
+    def fetch_local key
+      read_local key or write_local key, yield
+    end
+
+    def delete key
+      @store.delete(@prefix + key) if @store
+      @local.delete key
+    end
+
+    def dump
+      p "dumping local...."
+      @local.each do |k, v|
+        p "#{k} --> #{v.inspect[0..30]}"
+      end
+    end
+
+    def reset hard=false
+      reset_local
+      @cache_id = self.class.generate_cache_id
+      if @store
+        if hard
+          begin
+            @store.clear
+          rescue => e
+            Rails.logger.debug "Problem clearing cache: #{e.message}"
+          end
+        else
+          @store.write @system_prefix + "cache_id", @cache_id
+        end
+      end
+      @prefix = @system_prefix + @cache_id + "/"
+    end
+    
+    def reset_local
+      @local = {}
+    end
+  end
+end
+