ezframe 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ee9abffabef18607104a790bf9c044fd18022c1bb9c325d0b49c3919504da0e
-  data.tar.gz: 7c624b8735e2d081a73c8c5b771abdb3ca0a531a66d1e80ac953c4063dd237ba
+  metadata.gz: 5ab67d7d24a058acd24e2df411c31371b3470d5f448950b226bb6a0073690625
+  data.tar.gz: 9a244d5b2c0265c38cdff614b086a56d29ef0570cc4eb4ae38136d1d34709a76
 SHA512:
-  metadata.gz: abf17a71fad66bdb9776346a155913664b78ebc9dfe4bc2fc94526340238423c7adf593650ed82e5e15ae052ecaa25e38a3a3803a68efa831d5cdf3d46478951
-  data.tar.gz: 4235b2a4e945845797e3cb41f27b675775598b8996952087701ca5ce678ef08abb28b44fb5f9b475a6281e16dd9845d77522824486b23f818ef773ea617e77ef
+  metadata.gz: 0544756cb9b1ff1db515424425bbe2cc0682f6671c51e5e14d4dc1464bdb73f486d5b5cafc471d2e1da8e1a12a19178c8728fb6f6bc3d5ceceaa58c1fd445b9c
+  data.tar.gz: b823cb688787f08e492bc9b2fc2f517bef2e417d64c099f041a4174042ee39e2e5bb6fbb52a0978f9e79a95ef30c9e09eb4780407434f576cb3b06c4b27427cb

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://www.rubygems.org"
+gemspec

data/exe/check_column_yml

@@ -47,7 +47,7 @@ Dir["column/*.yml"].each do |file|
   if dup && dup.length > 0
     puts "#{file}\n#{dup}"
   end
-  yaml = YAML.load_file(file)
+  yaml = YAML.load(File.open(file), symbolize_names: true)
   upper = Object.const_get("Ezframe")
   yaml.each do |column|
     type = column["type"]

data/exe/dbmigrate

@@ -3,108 +3,129 @@
 require "ezframe"
 include Ezframe
 
-class DBInfo
-  class << self
-    def get_db_info(table_name)
-      typ = get_database_type(Config[:database])
-      case typ
-      when "postgresql"
-        return get_info_from_postgres(table_name)
-      when "sqlite"
-        return get_info_from_sqlite(table_name)
-      else
-        raise "unknown database"
+module Ezframe
+  module Model
+    class DBInfo
+      def initialize
+        @db_columns = {}
+        @db_typ = get_database_type(Config[:database])
+        case @db_typ
+        when "postgresql"
+          get_info_from_postgres
+        when "sqlite"
+          get_info_from_sqlite
+        else
+          raise "unknown database system"
+        end
       end
-      return nil
-    end
 
-    def get_info_from_postgres(table_name)
-      dbcol = {}
-      sql = "SELECT column_name,data_type FROM information_schema.columns WHERE table_name = '#{table_name}'"
-      begin
-        data_a = DB.sequel[sql].all
-      rescue
-        return nil
+      def get_db_info(table_name)
+        return @db_columns[table_name.to_sym]
       end
-      # puts data_a
-      data_a.each do |row|
-        dbcol[row[:column_name].to_s.to_sym] = normalize_dbtype(row[:data_type])
+
+      def get_info_from_postgres
+        sql = "SELECT * FROM information_schema.columns"
+        begin
+          data_a = DB.sequel[sql].all
+        rescue => e
+          EzLog.error("get_info_from_postgres: #{e}")
+          return nil
+        end
+        data_a.each do |row|
+          table_name, col_name = row[:table_name], row[:column_name]
+          next if col_name.nil? || table_name.nil?
+          next unless ColumnSets.refer(table_name)
+          @db_columns[table_name.to_sym] ||= {}
+          @db_columns[table_name.to_sym][col_name.to_sym] = normalize_dbtype(row[:data_type])
+        end
       end
-      return dbcol
-    end
 
-    def get_info_from_sqlite(table_name)
-      sql = "SELECT * from sqlite_master WHERE name = '#{table_name}';"
-      data = DB.sequel[sql].first
-      return nil unless data
-      sql = data[:sql]
-      return parse_create_sql(sql)
-    end
+      def get_info_from_sqlite
+        sql = "SELECT * from sqlite_master;"
+        data_a = DB.sequel[sql].all
+        return nil unless data_a
+        data_a.each do |data|
+          sql = data[:sql]
+          parse_create_sql(sql)
+        end
+      end
 
-    def parse_create_sql(sql)
-      sql.gsub(/CREATE TABLE \`\w+\` \(/, "")
-      column_a = sql.split(", ")
-      dbcol = {}
-      column_a.each do |line|
-        if line =~ /\`(\w+)\`\s(\w+)/
-          colkey, dbtype = $1, $2
-          dbcol[colkey.to_sym] = dbtype
+      def parse_create_sql(sql)
+        sql.gsub(/CREATE TABLE \`(\w+)\` \(/i, "")
+        table_name = $1
+        @db_columns[table_name.to_sym] ||= {}
+        column_a = sql.split(", ")
+        column_a.each do |line|
+          if line =~ /\`(\w+)\`\s(\w+)/
+            colkey, dbtype = $1, $2
+            @db_columns[table_name.to_sym][colkey.to_sym] = dbtype
+          end
         end
       end
-      return dbcol
-    end
 
-    def get_database_type(config)
-      return config.split("://")[0]
-    end
-  end
-end
+      def get_database_type(config)
+        return config.split("://")[0]
+      end
 
-def exec_sql(sql)
-  begin
-    DB.sequel.run(sql)
-  rescue => exception
-    p exception
-  end
-end
+      def exec_sql(sql)
+        begin
+          DB.sequel.run(sql)
+        rescue => e
+          EzLog.error("dbmigrate: exec_sql: #{e}")
+        end
+      end
 
-def normalize_dbtype(dbtype)
-  return nil unless dbtype
-  return "int" if dbtype == "integer"
-  return "timestamp" if dbtype.index("timestamp")
-  return dbtype
-end
+      def normalize_dbtype(dbtype)
+        return nil unless dbtype
+        return "int" if dbtype == "integer"
+        return "timestamp" if dbtype.index("timestamp")
+        return dbtype
+      end
 
-def set_default(column)
-  default_value = column.attribute[:default]
-  if default_value
-    unless %w[int].include?(column.db_type)
-      default_value = "'#{default_value}'"
-    end
-    exec_sql("ALTER TABLE #{column.parent.name} ALTER #{column.key} SET DEFAULT #{default_value}")
-  end
-end
+      def set_default(column)
+        default_value = column.attribute[:default]
+        if default_value
+          unless %w[int].include?(column.db_type)
+            default_value = "'#{default_value}'"
+          end
+          exec_sql("ALTER TABLE #{column.parent.name} ALTER #{column.key} SET DEFAULT #{default_value}")
+        end
+      end
 
-def check_diff(column_set)
-  table_name = column_set.name
-  dbcols = DBInfo.get_db_info(table_name)
-  unless dbcols
-    ColumnSets.create_one_table(table_name, ColumnSets.get(table_name.to_sym))
-    return
-  end
-  column_set.each do |column|
-    next if %w[id updated_at created_at].include?(column.key.to_s)
-    dbtype = dbcols[column.key]
-    new_type = column.db_type
-    unless dbtype
-      exec_sql("ALTER TABLE #{table_name} ADD #{column.key} #{new_type};")
-      set_default(column)
-      next
-    end
-    if dbtype != new_type
-      exec_sql("ALTER TABLE #{table_name} ALTER COLUMN #{column.key} DROP DEFAULT;")
-      exec_sql("ALTER TABLE #{table_name} ALTER #{column.key} TYPE #{new_type};")
-      set_default(column)
+      def check_diff(column_set)
+        table_name = column_set.name
+        dbcols = get_db_info(table_name)
+        unless dbcols
+          ColumnSets.create_one_table(table_name, ColumnSets.get(table_name.to_sym))
+          return
+        end
+        column_set.each do |column|
+          next if %w[id updated_at created_at deleted_at].include?(column.key.to_s)
+          dbtype = dbcols[column.key]
+          new_type = column.db_type
+          if !new_type || new_type.empty?
+            EzLog.error("check_diff: no db_type: table=#{table_name}:key=#{column.key}")
+            next
+          end
+          unless dbtype
+            exec_sql("ALTER TABLE #{table_name} ADD #{column.key} #{new_type};")
+            set_default(column)
+            next
+          end
+          if dbtype != new_type
+            exec_sql("ALTER TABLE #{table_name} ALTER COLUMN #{column.key} DROP DEFAULT;")
+            begin
+              exec_sql("ALTER TABLE #{table_name} ALTER #{column.key} TYPE #{new_type};")
+            rescue => e
+              EzLog.error("alter column type error: #{e.class}:#{e}:#{e.backtrace}")
+              back_key = "#{column.key}_bak"
+              exec_sql("ALTER TABLE #{table_name} RENAME #{column.key} TO #{back_key};")
+            end
+            set_default(column)
+          end
+        end
+        # exec_sql("ALTER TABLE #{table_name} add COLUMN deleted_at timestamp;")
+      end
     end
   end
 end
@@ -112,7 +133,8 @@ end
 Config.init
 DB.init
 ColumnSets.init
+dbinfo = Model::DBInfo.new
 
 ColumnSets.each do |table_name, column_set|
-  check_diff(column_set)
+  dbinfo.check_diff(column_set)
 end

data/lib/ezframe.rb

@@ -5,10 +5,11 @@ require "sequel"
 require "json"
 require "nkf"
 require "date"
+require "bcrypt"
 
 require_relative 'ezframe/version'
 require_relative 'ezframe/util'
-require_relative 'ezframe/logger'
+require_relative 'ezframe/ezlog'
 require_relative 'ezframe/config'
 require_relative 'ezframe/controller'
 require_relative 'ezframe/japanese_utils'
@@ -19,6 +20,10 @@ require_relative 'ezframe/ht'
 require_relative 'ezframe/html'
 require_relative 'ezframe/materialize'
 require_relative 'ezframe/page_base'
+require_relative 'ezframe/editor_common'
+require_relative 'ezframe/main_editor'
+require_relative 'ezframe/sub_editor'
+require_relative 'ezframe/single_page_editor'
 require_relative 'ezframe/template'
 require_relative 'ezframe/server'
 require_relative 'ezframe/message'

data/lib/ezframe/auth.rb

@@ -5,26 +5,28 @@ module Ezframe
 
       def init
         Warden::Manager.serialize_into_session do |auth|
-          # Logger.info "serialize_into: #{auth.inspect}"
+          # EzLog.info "serialize_into: #{auth.inspect}"
           auth.user[:id]
         end
         Warden::Manager.serialize_from_session do |account|
-          # Logger.info "serialize_from: account = #{account}"
+          # EzLog.info "serialize_from: account = #{account}"
           inst = Auth.get(account)
-          # Logger.info "inst = #{inst.inspect}"
+          # EzLog.info "inst = #{inst.inspect}"
           inst
         end
         Warden::Strategies.add(:mystrategy) do
           def valid?
-            # Logger.info "valid?"
+            # EzLog.info "valid?"
             params["account"] || params["password"]
           end
 
           def authenticate!
-            Logger.info "Auth.authenticate: #{params}"
+            EzLog.info "mystrategy.authenticate!: user=#{user}, params=#{params}"
             if Auth.authenticate(env, params["account"], params["password"])
+              EzLog.info "mystrategy.authenticate!: success: user=#{user}"
               success!(Auth.get(params["account"]))
             else
+              EzLog.info "mystrategy.authenticate!: failed: user=#{user}"
               fail!(Message[:login_failure])
             end
           end
@@ -36,26 +38,29 @@ module Ezframe
       end
 
       def authenticate(env, account, pass)
-        Logger.debug("authenticate: #{env}")
+        return nil if !pass || pass.strip.empty?
+        EzLog.debug("Auth.self.authenticate: account=#{account}, pass=#{pass}")
         auth_conf = Config[:auth]
-        @user = DB.dataset(auth_conf[:table]).where(auth_conf[:user].to_sym => account ).first
-        if @user
-          Logger.info "Auth: authenticate"
+        user_data = DB.dataset(auth_conf[:table]).where(auth_conf[:user].to_sym => account ).first
+        if user_data
+          EzLog.info "Auth: self.authenticate: has user: #{@user}"
         else
-          Logger.info "authenticate: this user does not exist: #{account}"
+          EzLog.info "Auth.self.authenticate: this user does not exist: #{account}"
           return nil
         end
-        # Logger.info "env=#{env.inspect}"
-        env['rack.session'][:user] = @user[:id]
-        password = @user[auth_conf[:password].to_sym]
-        Logger.debug("@user=#{@user}")
-        bcrypt = BCrypt::Password.new(password)
-        @user.delete(:password)
-
-        return nil if !pass || pass.strip.empty? || !password || password.strip.empty?
-        # 生パスワード比較
-        # !!(password == pass)
-        return bcrypt == pass
+        db_pass = user_data[auth_conf[:password].to_sym]
+        user_data.delete(:password)
+        return nil if !db_pass || db_pass.strip.length < 8
+        bcrypt = BCrypt::Password.new(db_pass)
+        if bcrypt == pass
+          env['rack.session'][:user] = user_data[:id]
+          @user = user_data
+          EzLog.debug("Auth.self.authenticate: success: password match!")
+          return true
+        else
+          EzLog.debug("Auth.self.authenticate: failure: password mismatch")
+        end
+        return nil
       end
     end
 
@@ -71,11 +76,15 @@ module Ezframe
         @user = dataset.where(auth_conf[:user].to_sym => account).first
       end
       unless @user
-        Logger.error "Auth.initialize: This user does not exist: #{account}"
+        EzLog.error "Auth.initialize: This user does not exist: #{account}"
         return
       end
       self.password = @user[auth_conf[:password].to_sym]
       @user.delete(:password)
     end
+
+    def inspect
+      "account=#{@account}, user=#{@user}, id=#{@id}"
+    end
   end
 end

data/lib/ezframe/column_set.rb

@@ -19,12 +19,12 @@ module Ezframe
 
       def load_one_file(filename)
         colset_name = $1 if filename =~ /(\w+).ya?ml$/
-        yaml = YAML.load_file(filename)
+        yaml = YAML.load(File.open(filename), symbolize_names: true)
         if yaml.length == 0
-          Logger.error("[ERROR] columns file is empty: #{filename}")
+          EzLog.error("[ERROR] columns file is empty: #{filename}")
           return
         end
-        column_info = yaml.recursively_symbolize_keys
+        column_info = yaml # .recursively_symbolize_keys
         # puts "load_one_file: filename=#{filename} column_info=#{column_info.inspect}"
         add(colset_name, column_info)
       end
@@ -59,13 +59,14 @@ module Ezframe
       end
 
       def each
-        @colset_h.each { |k, v| yield(k, v) }
+        @colset_h.each {|k, v| yield(k, v) }
       end
 
       def inspect
-        @colset_h.each do |name, colset|
-          "[#{name}]:#{colset.inspect}"
-        end
+        return @colset_h.map do |name, colset|
+          # "[#{name}]:#{colset.inspect}"
+          "[#{name}]:\n"
+        end.join
       end
 
       def create_tables
@@ -73,14 +74,14 @@ module Ezframe
           begin
             create_one_table(table_name, column_set)
           rescue => e
-            Logger.error("create_tables: #{e.inspect}\n#{$@.inspect}")
+            EzLog.error("create_tables: #{e.inspect}\n#{$@.inspect}")
           end
         end
       end
 
       def create_one_table(table_name, column_set)
         col_h = column_set.get_hash(:db_type)
-        Logger.info "create_one_table: col_h=#{col_h.inspect}"
+        EzLog.info "create_one_table: col_h=#{col_h.inspect}"
         DB.create_table(table_name, col_h)
       end
 
@@ -102,7 +103,7 @@ module Ezframe
               if @colset_h[key]
                 foreign_table = key
               else
-                Logger.error "There is no related table: #{key}"
+                EzLog.error "There is no related table: #{key}"
                 next
               end
             end
@@ -166,13 +167,13 @@ module Ezframe
         elsif @default_table
           colset_key, col_key =  @default_table, colset_key
         else
-          Logger.error "ColumnSetCollection.get: illegal arguments: #{colset_key}, #{col_key}"
+          EzLog.error "ColumnSetCollection.get: illegal arguments: #{colset_key}, #{col_key}"
           return nil
         end
       end
       colset = @colset_h[colset_key.to_sym]
       return nil unless colset
-      # Logger.debug("Collection.get: colset_key=#{colset_key}, col_key=#{col_key}, value=#{colset[col_key].value}")
+      # EzLog.debug("Collection.get: colset_key=#{colset_key}, col_key=#{col_key}, value=#{colset[col_key].value}")
       return colset[col_key]
     end
 
@@ -182,7 +183,7 @@ module Ezframe
   end
 
   class ColumnSet
-    attr_accessor :name, :parent, :edit_keys, :view_keys
+    attr_accessor :name, :parent # , :edit_keys, :view_keys
 
     def initialize(parent: nil, name: nil, columns: nil)
       @parent = parent
@@ -201,6 +202,14 @@ module Ezframe
       @columns.keys
     end
 
+    def edit_keys
+      @columns.keys.select {|k| !@columns[k].no_edit? }
+    end
+
+    def view_keys
+      @columns.keys.select {|k| !@columns[k].no_view? }
+    end
+
     # 配列を初期化する
     def set(attr_a)
       @columns[:id] = IdType.new(key: "id", label: "ID", hidden: true)
@@ -217,6 +226,7 @@ module Ezframe
       end
       @columns[:created_at] = DatetimeType.new(type: "datetime", key: "created_at", label: "生成日時", hidden: true)
       @columns[:updated_at] = DatetimeType.new(type: "datetime", key: "updated_at", label: "更新日時", hidden: true)
+      @columns[:deleted_at] = DatetimeType.new(type: "datetime", key: "deleted_at", label: "削除日時", hidden: true)
       @columns.values.each { |col| col.parent = self }
       return @columns
     end
@@ -228,18 +238,27 @@ module Ezframe
     def set_from_db(id)
       data = dataset.where(id: id).first
       return nil unless data
-      self.values = data
+      self.set_values(data, from_db: true)
       return data
     end
 
+    def set_from_form(form, key_suffix: nil)
+      self.set_values(form)
+    end
+
     # データベースに新規に値を登録する
-    def create(value_h)
-      self.set_values(value_h)
+    def create(value_h, from_db: nil, key_suffix: nil)
+      if from_db
+        self.set_values(value_h, from_db: true, key_suffix: key_suffix)
+      else
+        self.set_values(value_h, key_suffix: key_suffix)
+      end
       db_value_h = self.get_hash(:db_value)
-      Logger.debug("column_set.create: #{db_value_h}")
+      EzLog.debug("column_set.create: #{db_value_h}")
       db_value_h.delete(:id)
       db_value_h[:updated_at] = Time.now
       db_value_h[:created_at] = Time.now
+      EzLog.debug("create: sql=#{dataset.insert_sql(db_value_h)}")
       return dataset.insert(db_value_h)
     end
 
@@ -249,50 +268,57 @@ module Ezframe
       updated_values = {}
       @columns.each do |colkey, column|
         next if column.no_edit?
-        if column.multi_inputs?
+        if column.respond_to?(:form_to_value)
           new_value = column.form_to_value(value_h)
         else
           new_value = value_h[colkey]
         end
-        prev_value = column.value
+        prev_value = column.db_value
         column.value = new_value
+        # EzLog.debug("key=#{colkey}, pre_value=#{prev_value}, new_value=#{column.db_value}")
         if column.respond_to?("value_equal?")
-          unless column.value_equal?(prev_value, column.value)
-            updated_values[colkey] = column.set_for_db(value)
+          unless column.value_equal?(prev_value, column.db_value)
+            updated_values[colkey] = column.db_value
           end
-        elsif prev_value != column.value
-          updated_values[colkey] = column.value
+        elsif prev_value != column.db_value
+          updated_values[colkey] = column.db_value
         end
       end
       if updated_values.length > 0
         updated_values[:updated_at] = Time.now
-        # puts dataset.where(id: id).update_sql(updated_values)
+        sql = dataset.where(id: id).update_sql(updated_values)
+        EzLog.debug("update: sql=#{sql}")
         dataset.where(id: id).update(updated_values)
       end
     end
 
-    def values=(value_h)
-      clear
-      set_values(value_h)
+    # 各カラムに値を格納する
+    def set_values(value_h, from_db: nil, key_suffix: nil)
+      self.clear
+      merge_values(value_h, from_db: from_db, key_suffix: key_suffix)
     end
 
-    # 各カラムに値を格納する
-    def set_values(value_h)
-      return unless value_h
+    def merge_values(value_h, from_db: nil, key_suffix: nil)
+      return self unless value_h
       @columns.keys.each do |key|
-        next if key.nil? || key.to_s.empty?
+        next if key.to_s.empty?
+        target_key = key
+        target_key = "#{key}#{key_suffix}" if key_suffix
         column = @columns[key.to_sym]
-        next unless column
-        if column.respond_to?(:form_to_value) && !value_h.has_key?(key)
-          val = column.form_to_value(value_h)
+        if !from_db && column.respond_to?(:form_to_value) # && !value_h.has_key?(key)
+          val = column.form_to_value(value_h, target_key: target_key)
         else
-          val = value_h[key]
+          val = value_h[target_key.to_sym] || value_h[key]
         end
         column.value = val
       end
       return self
     end
 
+    def values=(value_h)
+      set_values(value_h)
+    end
+
     # 各カラムのバリデーション
     # 戻り値は[ 正規化した値, エラーシンボル(Messageのキーと紐づく) ]を値として、
     # カラムキーをキーとするハッシュ
@@ -354,7 +380,7 @@ module Ezframe
         return @edit_keys.map do |key|
                  col = @columns[key.to_sym]
                  unless col
-                   Logger.info "[ERROR] @edit_keys has unknown column:name=#{@name}:key=#{key}"
+                   EzLog.info "[ERROR] @edit_keys has unknown column:name=#{@name}:key=#{key}"
                    next
                  end
                  col.form
@@ -369,7 +395,7 @@ module Ezframe
         return @view_keys.map do |key|
                  col = @columns[key.to_sym]
                  unless col
-                   Logger.info "[ERROR] @view_keys has unknown column:name=#{@name}:key=#{key}"
+                   EzLog.info "[ERROR] @view_keys has unknown column:name=#{@name}:key=#{key}"
                    next
                  end
                  col.view