gfdnavi 1.3.0.0

data/lib/file_gfdnavi.rb

@@ -0,0 +1,38 @@
+class File
+  DIR_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-."
+
+  class << self
+
+=begin
+    alias :_rename :rename
+    private :_rename
+    def rename(from, to)
+      raise("cannot move file from #{from} to #{to}: file #{to} already exists.") if File.exist?(to)
+      _rename(from,to)
+    end
+=end
+
+    def temp_name(path, suffix = nil, length = 32, count = 0)
+      path += "/" unless path[-1..-1] == "/"
+      #  name = [Digest::MD5.digest(salt)].pack("m").gsub!(/+/,"_").gsub!(/\n/,"").gsub!(/=/,"")
+      name = ""
+      max = DIR_CHARS.length
+      length.times{|i|
+        r = rand(max)
+        name += DIR_CHARS[r..r]
+      }
+      name = path + name
+      name += suffix if suffix
+      if File.exist?(name)
+        if count < 10
+          return temp_name(path, suffix, length, count+1)
+        else
+          raise "cannot create temporary path name"
+        end
+      end
+      return name
+    end
+
+  end
+end
+

data/lib/gphys_gfdnavi.rb

@@ -0,0 +1,81 @@
+# Extension of GPhys class for Gfdnavi
+
+require "numru/gphys"
+
+module NumRu
+  class GPhys
+
+    # == Parameters @@read_size_limit_1 and @@read_size_limit_2
+    # 
+    # By default, both are nil, so no restriction is made
+    # on the size of data to read in onto run-time memory.
+    # To limit it, set these parameters explicitly by calling 
+    # the class methods read_size_limit_1= and/or read_size_limit_2=.
+    # 
+    # It's up to the programmer how to use the
+    # two limits. It's OK to use only one of them.
+    # If both are set, it is recommended to set as
+    # @@read_size_limit_2 > @@read_size_limit_1, because
+    # of the order of judgements (the former is evaluated first).
+
+    @@read_size_limit_1 = nil   # e.g., 2000000
+    @@read_size_limit_2 = nil   # e.g., 10000000
+
+
+    class Read_Size_Limit_2_Exceeded < StandardError
+    end
+
+    class Read_Size_Limit_1_Exceeded < StandardError
+    end
+
+    # class method definitions:
+    class << self
+
+      alias :__new__ :new
+
+      # Limit the size of data to read in with GPhys#val.
+      # This is implemented by defining singletone method
+      # for the VArray that represent the main data array.
+      # (Note that no restriction is made for coordinate varaibles,
+      # which is practically unnecessary.)
+      def new(*argv)
+	gp = __new__(*argv)
+	data = gp.data
+	def data.val
+	  if @@read_size_limit_2 && length > @@read_size_limit_2
+	    raise Read_Size_Limit_2_Exceeded, "Exceeded the maximum array size to read in (length=#{@@read_size_limit_2}). Reduce the size by using the 'axes' window, and try again. (Or perhaps you may get around the error by programming with GPhys::each_along_dims.)"
+	  elsif @@read_size_limit_1 && length > @@read_size_limit_1
+	    raise Read_Size_Limit_1_Exceeded, "Exceeded the maximum array size to read in (length=#{@@read_size_limit_1}). Reduce the size by using the 'axes' window, and try again. (Or perhaps you may get around the error by programming with GPhys::each_along_dims.)"
+	  end
+	  super
+	end
+	gp
+      end
+
+      # Set internal parameter @@read_size_limit_1
+      def read_size_limit_1= (limit)
+	return if limit.nil?
+	raise(ArgumentError,"Expect an integer") if !limit.is_a?(Integer)
+	@@read_size_limit_1 = limit
+      end
+
+      # Set internal parameter @@read_size_limit_2 
+      def read_size_limit_2= (limit)
+	return if limit.nil?
+	raise(ArgumentError,"Expect an integer") if !limit.is_a?(Integer)
+	@@read_size_limit_2 = limit
+      end
+
+      def read_size_limit_1
+	@@read_size_limit_1
+      end
+
+      def read_size_limit_2
+	@@read_size_limit_1
+      end
+
+    end
+
+  end
+end
+

data/lib/localdir.rb

@@ -0,0 +1,110 @@
+require 'numru/gphys'
+
+module NumRu
+  class LocalDir
+
+    def initialize(path)
+      @dir = Dir.new(path)
+    end
+
+    class << self
+      alias open new
+
+=begin
+      def open(path)
+        file = File.open(path)
+        if block_given?
+          yield(file)
+          file.close
+          nil
+        else
+          file
+        end
+      end
+=end
+    end
+
+    def path
+      @dir.path
+    end
+
+    def name
+      File.basename(path)
+    end
+
+    def entries
+      @dir.entries
+    end
+
+    def each_dir
+      @dir.each do |name|
+	path = File.join(self.path,name)
+	if name!='.' && name!='..' && File.directory?(path)
+	  dir = self.class.new(path)
+          mtime = File.mtime(path)
+	  yield(dir, mtime)
+	end
+      end
+      nil
+    end
+
+    def each_gphys_file
+      @dir.each do |name|
+	path = File.join(self.path,name)
+        if (File.file?(path) || (/nus$/=~path&&File.directory?(path))) && (klass=GPhys::IO.file2file_class(path))
+#          file = klass.open(path)
+          mtime = File.mtime(path)
+          size = File.size(path)
+#          yield(file, mtime, size)
+          yield(path, mtime, size, klass)
+        end
+      end
+      nil
+    end
+
+    # name_pattern : regexp to limit by name
+    #
+    def each_file(name_pattern = nil)
+      @dir.each do |name|
+        path = File.join(self.path,name)
+        if File.file?(path) and 
+                 (name_pattern.nil? or name_pattern =~ name)
+          yield(path, File.mtime(path), File.size(path) )
+        end
+      end
+    end
+
+=begin
+    def plain_file_paths
+      if @plain_file_paths.nil? 
+        @plain_file_paths = Array.new
+        @dir.each do |name|
+          path = File.join(self.path,name)
+          if File.file?(path) && GPhys::IO.file2file_class(path).nil?
+            @plain_file_paths.push(path)
+          end
+        end
+      end
+      @plain_file_paths 
+    end
+=end
+
+  end
+end
+
+if $0 == __FILE__
+  include NumRu
+  dir = LocalDir.open(File.expand_path(File.dirname(__FILE__)+'/../public/data/samples/reanalysis'))
+  dir.each_dir do |d, mtime|
+    p d.path, mtime
+    d.each_gphys_file do |file, mtime,size|
+      p file.path,mtime,size,GPhys::IO.var_names_except_coordinates(file)
+      file.close
+    end
+  end
+  pat = Regexp.union(/readme$/i, /\.yml$/)
+  dir.each_file(pat) do |path, mtime, size|
+    print "  **** #{path} #{mtime} #{size}\n"
+    open(path){|f| print f.gets}
+  end
+end

data/lib/login_system.rb

@@ -0,0 +1,110 @@
+require_dependency "user"
+
+module LoginSystem
+
+  protected
+
+  # overwrite this if you want to restrict access to only a few actions
+  # or if you want to check if the user has the correct rights
+  # example:
+  #
+  #  # only allow nonbobs
+  #  def authorize?(user)
+  #    user.login != "bob"
+  #  end
+  def authorize?(user)
+     true
+  end
+
+  # overwrite this method if you only want to protect certain actions of the controller
+  # example:
+  #
+  #  # don't protect the login and the about method
+  #  def protect?(action)
+  #    if ['action', 'about'].include?(action)
+  #       return false
+  #    else
+  #       return true
+  #    end
+  #  end
+  def protect?(action)
+    true
+  end
+
+  # login_required filter. add
+  #
+  #   before_filter :login_required
+  #
+  # if the controller should be under any rights management.
+  # for finer access control you can overwrite
+  #
+  #   def authorize?(user)
+  #
+  def login_required
+
+    if not protect?(action_name)
+      return true
+    end
+    if session[:user] and authorize?(session[:user])
+      return true
+    end
+
+    # store current location so that we can
+    # come back after the user logged in
+    store_location
+
+    # call overwriteable reaction to unauthorized access
+    access_denied
+    return false
+  end
+  
+  # == internal_login filter.
+  # using as follows in controllers.
+  #    before_filter :internal_login_required
+  def internal_login_required
+    if not protect?(action_name)
+      return true
+    end
+    if session[:user] and authorize?(session[:user])
+      user = (login=session[:user]) && User.find_by_login(login)
+      if user.internal_user
+        return true
+      end
+    end
+
+    # store current location so that we can
+    # come back after the user logged in
+    store_location
+
+    # call overwriteable reaction to unauthorized access
+    access_denied
+    return false
+  end
+  
+
+  # overwrite if you want to have special behavior in case the user is not authorized
+  # to access the current operation.
+  # the default action is to redirect to the login screen
+  # example use :
+  # a popup window might just close itself for instance
+  def access_denied
+    redirect_to :controller=>"/user", :action =>"login"
+  end
+
+  # store current uri in  the session.
+  # we can return to this location by calling return_location
+  def store_location
+    session['return-to'] = request.request_uri
+  end
+
+  # move to the last store_location call or to the passed default one
+  def redirect_back_or_default(default)
+    if session['return-to'].nil?
+      redirect_to default
+    else
+      redirect_to session['return-to']
+      session['return-to'] = nil
+    end
+  end
+
+end

data/lib/multibytes.rb

@@ -0,0 +1,20 @@
+# = Handling of multi-byte characters (or Japanese).
+#
+# Assume that $KCONV has been set appropriately
+
+class String
+
+  # see http://www.ruby-lang.org/ja/man/ chapter 10 (method jleft)
+  def jleft_w_dots(len)
+    len0 = self.length
+    if len0 <= len
+      self.dup
+    else
+      str = self[0,len]
+      str[-1,1] = '' if /.\z/ !~ str
+      str[-1,1] = '' if /.\z/ !~ str  # don't know why, but needed two times
+      str + '..'
+    end
+  end
+
+end

data/lib/narray_yaml.rb

@@ -0,0 +1,58 @@
+require "yaml"
+require "narray"
+
+$__yaml_new__ =  Class.method_defined?("yaml_as")
+$__yaml_domain__ = "ruby.yaml.org,2002"
+$__yaml_type__ = "narray"
+
+
+class NArray
+
+  if $__yaml_new__
+
+    yaml_as "tag:#{$__yaml_domain__}:#{$__yaml_type__}"
+    def NArray.yaml_new( klass, tag, val )
+      na = NArray.new(val["typecode"], *val["shape"])
+      na[true] = val["ary"]
+      na
+    end
+    def to_yaml(opts={})
+      YAML::quick_emit( object_id, opts ) do |out|
+        out.map( taguri, to_yaml_style ) do |map|
+          map.add( "typecode", typecode )
+          map.add( "shape", shape )
+          map.add( "ary", to_a.flatten )
+        end
+      end
+    end
+
+  else
+
+    def is_complex_yaml?
+      true
+    end
+    def to_yaml_type
+      "!#{$__yaml_domain__}/#{$__yaml_type__}"
+    end
+    def to_yaml( opts = {} )
+      YAML::quick_emit( object_id, opts ) { |out|
+        out.map( to_yaml_type ) { |map|
+          map.add( "typecode", typecode )
+          map.add( "shape", shape )
+          map.add( "ary", to_a.flatten )
+        }
+      }
+    end
+
+  end
+end
+
+unless $__yaml_new__
+  YAML.add_domain_type( $__yaml_domain__, /^#{$__yaml_type__}/ ) { |type, val|
+    na = NArray.new(val["typecode"], *val["shape"])
+    na[true] = val["ary"]
+    na
+  }
+end
+
+$__yaml_new__ = nil

data/lib/no_rdb_base.rb

@@ -0,0 +1,40 @@
+module ActiveRecord #:nodoc:
+  class NoRdbBase < Base
+    class << self # Class methods
+      %w(find exists?
+         create update delete destroy update_all destroy_all
+         count_by_sql
+         table_exists?
+         construct_finder_sql
+         add_order! add_limit! add_lock! add_joins! add_conditions! type_condition
+         determine_finder determine_deprecated_finder determine_instantiator extract_attribute_names_from_match
+         attribute_condition expand_id_conditions
+         sanitize_sql sanitize_sql_hash sanitize_sql_array sanitize_conditions
+         validate_find_options
+      ).each{|name|
+        undef_method(name) if instance_methods.include?(name)
+      }
+
+      def connection
+        raise "this is NoRdbBase class. No connection exists"
+      end
+
+      def push_column(column)
+        @columns ||= Array.new
+        @columns.push column
+      end
+
+      def columns
+        @columns
+      end
+
+    end
+
+    %w(save save! destroy reload create_or_update update create
+       interpolate_sql
+    ).each{|name|
+      undef_method(name) if self.instance_methods.include?(name)
+    }
+
+  end
+end