gfdnavi 1.3.0.0

data/app/models/function.rb

@@ -0,0 +1,75 @@
+class Function < NodeEntityAbstract
+  has_many :function_outputs, :order => :position, :dependent => :destroy
+  has_many :function_arguments, :order => :position, :dependent => :destroy
+
+  validates_presence_of :nvars, :script
+
+  before_save :check_name
+  after_update :update_yml
+  after_save :update_yml
+
+  def get_script
+    result = ""
+    function_arguments.length.times{|i|
+      arg = function_arguments[i]
+      result += " arg#{i} = arg#{i}.#{to_type(arg.name)}\n"
+    }
+    result += script
+    return result
+  end
+
+  protected
+
+  def check_name
+    func = Function.find(:first, :conditions=>["name=?",node.name],:user=>:all)
+    if func && func != self
+      errors.add("name", "must be uniq")
+      return false
+    end
+  end
+
+  def update_yml
+    return if default
+    h = Hash.new
+    h[:name] = self.name
+    h[:description] = self.description
+    h[:nvars] = self.nvars
+    h[:script] = self.script
+    ary = Array.new
+    function_arguments.each{|fa|
+      h2 = Hash.new
+      h2[:description] = fa.description
+      h2[:value_type] = fa.value_type.name
+      h2[:default] = fa.default
+      ary.push h2
+    }
+    h[:arguments] = ary if ary.length > 0
+    ary = Array.new
+    function_outputs.each{|fo|
+      h2 = Hash.new
+      h2[:name] = fo.name
+      h2[:subscript] = fo.subscript
+      h2[:description] = fo.description
+      ary.push h2
+    }
+    h[:outputs] = ary if ary.length > 0
+    yml = node.add_prefix(self.path)+".yml"
+    File.open(yml,"w"){|file|
+      file.print h.to_yaml
+    }
+  end
+
+  def to_type(type)
+    case type.value_type
+    when "int"
+      "to_i"
+    when "float"
+      "to_f"
+    when "string"
+      "to_s"
+    else
+      raise "argument type of function is invalid"
+    end
+  end
+
+end

data/app/models/function_argument.rb

@@ -0,0 +1,6 @@
+class FunctionArgument < ActiveRecord::Base
+  belongs_to :function
+  belongs_to :value_type
+  acts_as_list :scope => :function
+  validates_presence_of :value_type_id
+end

data/app/models/function_output.rb

@@ -0,0 +1,4 @@
+class FunctionOutput < ActiveRecord::Base
+  belongs_to :function
+  acts_as_list :scope => :function
+end

data/app/models/group.rb

@@ -0,0 +1,153 @@
+class Group < ActiveRecord::Base
+
+  MAX_GROUP_NO = 64
+
+  belongs_to :owner, :class_name => "User", :foreign_key => "owner_id"
+#  has_many :members, :through => :group_members, :source => :user, :order => :login
+#  has_many :group_members, :dependent => :destroy
+
+  after_save :save_file
+
+  before_validation_on_create :set_id
+  validates_presence_of :name, :owner_id
+  validates_uniqueness_of :name, :on => :create
+  validates_inclusion_of :id, :in=>1..MAX_GROUP_NO, :on => :create
+
+  def bit_mask
+    1 << (id-1)
+  end
+
+  def self.bit_mask_for(*groups)
+    ids = Array.new
+    groups.each do |g|
+      case g
+      when Integer
+        id = g
+        ids.push(id) if id>1 and id<MAX_GROUP_NO
+      when Group
+        ids.push(g.id)
+      when String
+        if (gr=Group.find_by_name(g))  # substitution, not ==
+          ids.push(gr.id)
+        end
+      else
+        raise ArgumentError, "Unsupported kind of object : #{g.inspect}"
+      end
+    end
+    bitmask = 0
+    ids.each{|id| bitmask |= (1 << (id-1))}
+    bitmask
+  end
+
+  def members
+    User.find(:all, :conditions => ["(groups & ?) != 0",bit_mask])
+  end
+
+  def self.find_by_bit_flag(groups)
+    ids = Array.new
+    (1..MAX_GROUP_NO).each do |i| 
+      ids.push(i) if ( groups % 2 == 1 )
+      groups = groups >> 1
+    end
+    if ids.length == 0
+      []
+    elsif ids.length == 1
+      [self.find(ids[0])]
+    else
+      self.find(*ids)
+    end
+  end
+
+  # * users (Array of User) : members to add
+  #
+  def add_members(users)
+    bm = bit_mask
+    User.transaction do
+      users.each do |usr|
+	if String === usr
+          usr = User.find(:first,:conditions=>["login=?",un=usr])
+          unless usr
+            return [false, "No such a usr #{un}"]
+          end
+        end
+	usr.groups = ( usr.groups | bm )
+	usr.save!
+      end
+    end
+    return [true, "add members successed"]
+  end
+
+  alias members= add_members
+
+  def add_member(user)
+    add_members([user])
+  end
+
+  def del_members(users)
+    mask = ~bit_mask
+    User.transaction do
+      users.each do |usr|
+	unless User === usr
+          usr = User.find(:first,:conditions=>["login=?",un=usr])
+          unless usr
+            return [false, "No such a usr #{un}"]
+          end
+        end
+	usr.groups = ( usr.groups & mask )
+	usr.save!
+      end
+    end
+    return [true, "delete member successed"]
+  end
+
+  def del_member(user)
+    del_members([user])
+  end
+
+  def before_destroy
+    mask = ~bit_mask
+    User.update_all("groups = groups & #{mask}")
+    Node.update_all("rgroups = rgroups & #{mask}")
+    Node.update_all("wgroups = wgroups & #{mask}")
+    true
+  end
+
+  def set_id
+    min_id = ((1..MAX_GROUP_NO).to_a - Group.find(:all).collect{|g| g.id})[0]
+    if min_id.nil?
+      raise("Exceeded max group num (#{MAX_GROUP_NO}). Delete one or more.") 
+    end
+    self.id = min_id
+    true
+  end
+
+  def save_file
+    fname = File.join(RAILS_ROOT,"db","group.yml")
+    if File.exist?(fname)
+      yml = YAML.load(File.read(fname))
+      File.rename(fname, fname+"."+Time.now.strftime("%Y%m%d%H%M%S"))
+      unless Hash === yml
+        raise "data is invalid"
+      end
+    else
+      yml = Hash.new
+    end
+    hash = Hash.new
+    self.class.column_names.each{|name|
+      hash[name] = self[name]
+    }
+    yml[self.name] = hash
+    File.open(fname,"w"){|file| file.print yml.to_yaml}
+  end
+
+
+#  def create_or_update  # called in save and save!
+#    Group.transaction do
+#      super
+#      bit_flag = 2**(id-1)
+#      STDERR.puts '@@@@@@',bit_flag
+#      nil
+#    end
+#  end
+
+end

data/app/models/image.rb

@@ -0,0 +1,20 @@
+class Image < NodeEntityAbstract
+
+  def content_type
+    case name
+    when /\.png$/i
+      'image/png'
+    when /\.jpeg$|\.jpg$/i
+      'image/jpeg'
+    when /\.gif$/i
+      'image/gif'
+    when /\.tiff?$/i
+      'image/tiff'
+    when /\.xwd?$/i
+      'image/xwindowdump'
+    else
+      raise "#{name} Not a image file or unsupported image type (which can be easily extended. Contact the gfdnavi developpers.)"
+    end
+  end
+
+end

data/app/models/keyword_attribute.rb

@@ -0,0 +1,179 @@
+require "narray"
+
+class KeywordAttribute < ActiveRecord::Base
+  belongs_to :node
+  validates_presence_of :name
+  after_create :set_title_in_node
+  after_update :set_title_in_node
+
+  ### // standard name space -->
+
+  StdName = {
+    'title' => ['title','subject','long_name','standard_name','name'],
+    'description' => ['description'],
+    'who' => ['creator','maintainer'],
+    'information_url' => [{:conditions => "name = 'information_url' OR ( (name = 'reference' OR name = 'references' ) AND value LIKE 'http://%' ) OR name = 'url'", :order => 'name'}]  # order: information_url > reference% > url
+  }
+
+  def self.find_by_stdname(name)
+    if aliases=StdName[name]        # substitution, not ==
+      strs = Array.new
+      has = Array.new
+      aliases.each do |expr|
+        case expr
+        when String
+          strs.push expr
+        when Hash
+          has.push expr
+        else
+          raise "[BUG] Unsupported expression type #{expr.class}"
+        end
+      end
+      if strs.length > 0
+        if ar = find(:first, :conditions => strs.collect{|st| "name='#{st}'"}.join(" OR "))
+          return ar
+        end
+      end
+      if has.length > 0
+        has.each{|ha|
+          if ar = find(:first, ha)
+            return ar
+          end
+        }
+      end
+    end
+    nil
+  end
+
+  def self.find_by_stdname_or_name(name)
+    find_by_stdname(name) || find(:first,:conditions=>["name=?",name])
+  end
+
+  ### <-- standard name space //
+
+  ### // support numerical (NArray) attribute values with num_value -->
+
+  def value= (v)
+    case v
+    when String
+      super(v)
+    when NArray
+      raise "Supported typecodes are 1 digit" if v.typecode>=10
+            # Currently (narray-0.5), it never happens since typecode<= 8
+      self.num_value= v.typecode.to_s + v.hton.to_s
+    else
+      raise ArgumentError, "Unsupported class for a keyword value: #{v.class} (name=#{name})"
+    end
+    v
+  end
+
+  def value
+    if (buf=num_value) && buf != "NULL"               # substitution into buf, not ==
+      v=NArray.to_na(buf[1..-1],buf[0..0].to_i).ntoh  # typecode is one-digit
+    else
+      v=super
+    end
+    v
+  end
+
+  def self.format_value_search(val, mode=:equal, name="")
+    name += "." unless name==""
+    allowed = [:equal, :like]
+    if !allowed.include?(mode)
+      raise ArgumentError,"2nd arg must be one of #{allowed.inspect}"
+    end
+    case val
+    when String
+      case mode
+      when :like
+        "#{name}value LIKE '%#{val}%'"
+      when :equal
+        "#{name}value = '#{val}'"
+      else
+        raise "Unsupported mode  #{mode.inspect}"
+      end
+    when Numeric
+      if val.is_a?(Integer)
+        tcrange = 1..5    # check all integer- and float-types
+      elsif val.is_a?(Float)
+        tcrange = 4..5    # check float-types
+      else
+        raise "Unsupported Numeric type  #{val.class}"
+      end
+      case mode
+      when :like
+        exprs = []
+        for tc in tcrange
+          str = NArray.new(tc,1).fill!(val).hton.to_s
+          if connection.adapter_name=="SQLite"
+            str.gsub!(/\000/,'%00')
+            wild_chr = "*"
+            operator = "GLOB"
+          else
+            str = str.gsub(/_/,'\_').gsub(/%/,'\%')
+            wild_chr = "%"
+            operator = "LIKE BINARY"
+          end
+          exprs.push( "#{name}num_value #{operator} '#{tc.to_s}#{wild_chr}#{str}#{wild_chr}'")
+        end
+        exprs.join(' OR ')
+      when :equal
+        exprs = []
+        for tc in tcrange
+          str = NArray.new(tc,1).fill!(val).hton.to_s
+
+          str.gsub!(/\000/,'%00') if connection.adapter_name=="SQLite"
+          exprs.push( "#{name}num_value = '" + tc.to_s + str  + "'")
+
+        end
+        exprs.join(' OR ')
+      else
+        raise "Unsupported mode  #{mode.inspect}"
+      end
+    when NArray
+      # :like are treated as :equal here
+      str = val.hton.to_s
+      str.gsub!(/\000/,'%00') if connection.adapter_name=="SQLite"
+      "#{name}num_value = '" + val.typecode.to_s + str + "'"
+    end
+  end
+
+  ### <-- support numerical (NArray) attribute values with num_value //
+
+
+  alias _node node
+  def node(reload=false, hash={})
+    if u = hash[:user]
+      return Node.find(node_id, :user=>u)
+    else
+      return _node(reload)
+    end
+  end
+
+
+  def to_xml(opt)
+    opt = opt.dup.update(:except => [:id, :node_id, :value, :num_value])
+    super(opt) do |xml|
+      xml.value self.value
+    end
+  end
+
+
+  protected
+  def set_title_in_node
+    nod = self.node(false,:user=>:all)
+    if StdName["title"].include? self.name
+      unless nod.title && nod.title != "NULL"
+        nod.title = self.value
+        nod.save!
+      end
+    elsif StdName["description"].include? self.name
+      unless nod.description && nod.description != "NULL"
+        nod.description = self.value
+        nod.save!
+      end
+    end
+  end
+
+
+end

data/app/models/knowledge.rb

@@ -0,0 +1,94 @@
+class Knowledge < NodeEntityAbstract
+
+  has_many :knowledge_figures, :dependent => :destroy
+
+#  validates_length_of :title, :within => 0..400
+  validates_length_of :textbody, :within => 0..100000
+  validates_length_of :description, :within => 0..4000
+  validates_format_of :category, :with => /^[a-zA-Z0-9_]+$/, :message => "you can only use alphabets and numbers and underscore to Category."
+  
+  #<< class methods >>
+
+  class << self
+    def read_parameters_of_knowledge_document(path, user)
+      knowledge = Knowledge.find(:first, :conditions => ["path=?", path], :user => user)
+      comments = Knowledge.find(:all, :conditions => ["comment_on = ?" ,knowledge.node_id])
+      knowledge_figures = KnowledgeFigure.find(:all, :conditions => ["knowledge_id=?", knowledge.id]) # not find -> return []
+
+      # = �G�̃p�X�Ƒ傫��
+      #   * �G�̃p�X��nodes�e�[�u����path���擾
+      #   * �G�̑傫����images�e�[�u����vizshot���擾
+      image_paths = Array.new
+      image_widths = Array.new
+      image_heights = Array.new
+      caption_widths = Array.new
+      caption_heights = Array.new
+      knowledge_figures.each do |kf|
+        unless (image = Image.find(kf.image_id, :user => user))
+          raise "Figure is not found.\n"
+        else
+          image_paths << image.path
+          vizshot_yaml = image.vizshot
+          begin
+            vizshot = YAML.load(vizshot_yaml)
+            if (image_size = vizshot.get_size)
+              image_widths << image_size[0]
+              image_heights << image_size[1]
+              caption_widths << (image_size[0] * 0.8).to_i
+              caption_heights << (image_size[1] * 0.8).to_i
+            else
+              # vizshot���畜���ł��Ȃ������Ƃ���normal�T�C�Y��K�p����
+              image_widths << 554
+              image_heights << 554
+              caption_widths << 440
+              caption_heights << 440
+            end
+          rescue
+            # vizshot�������Ƃ���normal�T�C�Y��K�p����
+            image_widths << 250
+            image_heights << 254
+            caption_widths << 440
+            caption_heights << 440
+          end
+        end
+      end
+      return knowledge, knowledge_figures, comments, image_paths, image_widths, image_heights, caption_widths, caption_heights
+    end
+    
+    # == �V���ȃR�����g�ɑ΂��ăR�����g�ԍ�������U��
+    def new_comment_number_from_parent_document(parent_knowledge_node_id, user)
+      comments = Knowledge.find(:all, :conditions => ["comment_on = ? AND comment_number IS NOT NULL", parent_knowledge_node_id], :user => user)
+      if comments.length > 0
+        comments.collect! {|comment|
+          comment = comment.comment_number
+        }
+        comment_number = comments.max + 1
+      else
+        comment_number = 1
+      end
+    end
+    
+    # OpenID�̐ړ��ɂ‚� http:// �� https:// �A�܂������ɂ‚� / ����菜��
+    def remove_scheme(user)
+      if user.internal_user
+        user.login
+      else
+        username_in_path = user.login
+        case username_in_path
+        when /^http:\/\/(.+)/, /^https:\/\/(.+)/
+          username_in_path = $1
+        end
+        
+        case username_in_path
+        when /(.+)\/$/
+          username_in_path = $1
+        end
+        return username_in_path
+      end
+    end
+    
+  end
+end
+
+
+