ezframe 0.0.4 → 0.4.0

data/exe/check_column_yml

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+#codnig: utf-8
+
+=begin
+
+  column/*.ymlのチェックをする。
+
+=end
+require "ezframe"
+
+# https://stackoverflow.com/questions/4911105/in-ruby-how-to-be-warned-of-duplicate-keys-in-hashes-when-loading-a-yaml-docume
+def duplicate_keys(file_or_content)
+  yaml = file_or_content.is_a?(File) ? file_or_content.read : file_or_content
+  duplicate_keys = []
+
+  validator = ->(node, parent_path) do
+    if node.is_a?(Psych::Nodes::Mapping)
+      children = node.children.each_slice(2) # In a Mapping, every other child is the key node, the other is the value node.
+      duplicates = children.map { |key_node, _value_node| key_node }.group_by(&:value).select { |_value, nodes| nodes.size > 1 }
+
+      duplicates.each do |key, nodes|
+        duplicate_key = {
+          file: (file_or_content.path if file_or_content.is_a?(File)),
+          key: parent_path + [key],
+          occurrences: nodes.map { |occurrence| "line: #{occurrence.start_line + 1}" },
+        }.compact
+
+        duplicate_keys << duplicate_key
+      end
+
+      children.each { |key_node, value_node| validator.call(value_node, parent_path + [key_node ? key_node.value : nil].compact) }
+    else
+      node.children.to_a.each { |child| validator.call(child, parent_path) }
+    end
+  end
+
+  ast = Psych.parse_stream(yaml)
+  validator.call(ast, [])
+
+  duplicate_keys
+end
+
+Ezframe::Config.init
+Dir["column/*.yml"].each do |file|
+  instr = File.read(file)
+  dup = duplicate_keys(instr)
+  if dup && dup.length > 0
+    puts "#{file}\n#{dup}"
+  end
+  yaml = YAML.load(File.open(file), symbolize_names: true)
+  upper = Object.const_get("Ezframe")
+  yaml.each do |column|
+    type = column["type"]
+    unless type
+      puts "#{file}: type is not defined: key=#{column['key']}"
+      next
+    end
+    klass = "Ezframe::#{type.to_camel}Type"
+    unless upper.const_defined?(klass)
+      puts "#{file}: unknown type: key=#{column['key']}, type=#{type}"
+    end
+  end
+end
+

data/exe/console

@@ -10,5 +10,5 @@ require "ezframe"
 # require "pry"
 # Pry.start
 
-require "irb"
-IRB.start(__FILE__)
+require "pry"
+Pry.start(__FILE__)

data/exe/{create_table.rb → create_table}

@@ -6,7 +6,10 @@ $:.push("lib")
 require 'ezframe'
 require 'sequel'
 
-Ezframe::Config.load_files("config")
-Ezframe::Model.init
-model = Ezframe::Model.get_clone
-model.create_tables
+include Ezframe
+
+Config.init
+DB.init
+ColumnSets.init
+
+ColumnSets.create_tables

data/exe/dbmigrate

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+#coding: utf-8
+require "ezframe"
+include Ezframe
+
+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
+
+      def get_db_info(table_name)
+        return @db_columns[table_name.to_sym]
+      end
+
+      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
+
+      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)
+        # EzLog.debug("parse_create_sql: #{sql}")
+        if sql =~ /CREATE TABLE \`(\w+)\` \(/i
+          table_name = $1
+        else
+          return
+        end
+        @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
+
+      def get_database_type(config)
+        return config.split("://")[0]
+      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 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 = 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;")
+            unless change_type(table, column.key, new_type)
+              # 失敗したときは名前を変更してカラム追加
+              rename_column(table_name, column.key, "#{column.key}_bak")
+              add_column(table, column.key, new_type)
+            end
+            set_default(column)
+          end
+        end
+      end
+
+      # カラム追加
+      def add_column(table_name, key, typ)
+        begin
+          exec_sql("ALTER TABLE #{table_name} ADD #{key} #{typ};")
+        rescue => e
+          EzLog.error("change_type: error: #{e.class}:#{e}:#{e.backtrace}")
+          return nil
+        end
+        return true
+      end
+
+      # カラムの型変更
+      def change_type(table_name, key, typ)
+        begin
+          exec_sql("ALTER TABLE #{table_name} ALTER #{key} TYPE #{typ};")
+        rescue => e
+          EzLog.error("change_type: error: #{e.class}:#{e}:#{e.backtrace}")
+          return nil
+        end
+        return true
+      end
+
+      # カラムの名前変更
+      def rename_column(table_name, old_key, new_key)
+        begin
+          exec_sql("ALTER TABLE #{table_name} RENAME #{old_key} TO #{new_key};")
+        rescue => e
+          EzLog.error("rename_column: error: #{e.class}:#{e}:#{e.backtrace}")
+          return nil
+        end
+        return true
+      end
+    end
+  end
+end
+
+Config.init
+DB.init
+ColumnSets.init
+dbinfo = Model::DBInfo.new
+
+ColumnSets.each do |table_name, column_set|
+  dbinfo.check_diff(column_set)
+end

data/exe/html2ruby

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+#coding: utf-8
+=begin
+
+  HTMLから、hthash生成するrubyプログラムを生成する
+
+=end
+require "nokogiri"
+
+class Html2Ruby
+  def show_leaves(node, depth=0)
+    res = []
+    indent = "  "*depth
+    node.children.each do |child|
+      next if child.name == "comment"
+      if child.name == "text" 
+        if child.content.strip.empty?
+          next
+        else
+          res.push "#{indent}\"#{child.content}\""
+        end
+      else
+        attrs = child.attributes.map do |k, v| 
+          if k.index("-")
+            key_s = "\"#{k}\""
+          else
+            key_s = k
+            if k == "class"
+              if v =~/\s/
+                cls_a = v.split(/\s+/)
+                v = "%w[#{cls_a.join(' ')}]"
+              end
+            end
+          end
+          "#{key_s}: \"#{v}\"" 
+        end
+        descendant = show_leaves(child, depth+1)
+        if descendant && descendant.strip.length > 10
+          attrs.push("child: \n#{descendant}\n")
+          res.push "#{indent}Ht.#{child.name}(#{attrs.join(', ')}#{indent})"
+        else
+          res.push "#{indent}Ht.#{child.name}(#{attrs.join(', ')})"
+        end
+      end
+    end
+    if res.length > 1
+      res_s = res.join(",\n")
+      return "[ #{res_s} ]"
+    else
+      return res[0]
+    end
+  end
+
+  def show_all(file)
+    doc = Nokogiri::HTML(File.open(file))
+    puts show_leaves(doc.root)
+  end
+end
+
+node = Html2Ruby.new
+node.show_all(ARGV[0])

data/ezframe.gemspec

@@ -30,13 +30,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "minitest", '~> 5.13.0'
-  spec.add_development_dependency "nokogiri", '~> 1.10.7'
-  spec.add_development_dependency "rack-test", '~> 1.1.0'
+  spec.add_development_dependency "bundler", '>= 1.16'
+  spec.add_development_dependency "minitest", '>= 5.13.0'
+  spec.add_development_dependency "nokogiri", '>= 1.10.7'
+  spec.add_development_dependency "rack-test", '>= 1.1.0'
+  spec.add_development_dependency "pry", '>= 0.12.2'
 
-  spec.add_runtime_dependency "rake", "~> 13.0"
-  spec.add_runtime_dependency 'rack', '~> 2.0.7'
-  spec.add_runtime_dependency 'sequel', '~> 5.27.0'
-  spec.add_runtime_dependency 'sqlite3', '~> 1.4.0'
+  spec.add_runtime_dependency "rake", '>= 13.0'
+  spec.add_runtime_dependency 'rack', '>= 2.0.6'
+  spec.add_runtime_dependency 'sequel', '>= 5.27.0'
+  spec.add_runtime_dependency 'sqlite3', '>= 1.4.0'
+  spec.add_runtime_dependency 'bcrypt', '>= 3.1.13'
 end

data/lib/ezframe.rb

@@ -4,9 +4,12 @@ require 'yaml'
 require "sequel"
 require "json"
 require "nkf"
+require "date"
+require "bcrypt"
 
 require_relative 'ezframe/version'
 require_relative 'ezframe/util'
+require_relative 'ezframe/ezlog'
 require_relative 'ezframe/config'
 require_relative 'ezframe/controller'
 require_relative 'ezframe/japanese_utils'
@@ -16,14 +19,17 @@ require_relative 'ezframe/database'
 require_relative 'ezframe/ht'
 require_relative 'ezframe/html'
 require_relative 'ezframe/materialize'
-require_relative 'ezframe/model'
-require_relative 'ezframe/page_kit'
 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'
 require_relative 'ezframe/auth.rb'
-require_relative 'ezframe/editor.rb'
 require_relative 'ezframe/loader'
+require_relative 'ezframe/route'
 
 
 

data/lib/ezframe/auth.rb

@@ -1,71 +1,90 @@
 module Ezframe
   class Auth
     class << self
-      attr_accessor :model, :user
+      attr_accessor :user
 
-      def init_warden
+      def init
         Warden::Manager.serialize_into_session do |auth|
-          mylog "serialize_into: #{auth.inspect}"
+          # EzLog.info "serialize_into: #{auth.inspect}"
           auth.user[:id]
         end
         Warden::Manager.serialize_from_session do |account|
-          mylog "serialize_from: account = #{account}"
-          inst = Auth.get(env['model'], account)
-          mylog "inst = #{inst.inspect}"
+          # EzLog.info "serialize_from: account = #{account}"
+          inst = Auth.get(account)
+          # EzLog.info "inst = #{inst.inspect}"
           inst
         end
         Warden::Strategies.add(:mystrategy) do
           def valid?
-            # mylog "valid?"
+            # EzLog.info "valid?"
             params["account"] || params["password"]
           end
 
           def authenticate!
-            mylog "authenticate!: #{params}"
+            EzLog.info "mystrategy.authenticate!: user=#{user}, params=#{params}"
             if Auth.authenticate(env, params["account"], params["password"])
-              success!(Auth.get(env['model'], params["account"]))
+              EzLog.info "mystrategy.authenticate!: success: user=#{user}"
+              success!(Auth.get(params["account"]))
             else
-              env['x-rack.flash'].error = 'ユーザーが登録されていないか、パスワードが違っています。'
-              fail!("authenticate failure")
+              EzLog.info "mystrategy.authenticate!: failed: user=#{user}"
+              fail!(Message[:login_failure])
             end
           end
         end 
       end
 
-      def get(model, account)
-        new(model, account)
+      def get(account)
+        new(account)
       end
 
       def authenticate(env, account, pass)
-        model = env["model"]
-        raise "model is not initialized" unless model
-        @user = model.db.dataset(:user).where(account: account).first
-        if @user
-          mylog "Auth: authenticate: user=#{@user.inspect}"
+        return nil if !pass || pass.strip.empty?
+        EzLog.debug("Auth.self.authenticate: account=#{account}, pass=#{pass}")
+        auth_conf = Config[:auth]
+        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
-          mylog "authenticate: this user does not exist: #{account}"
+          EzLog.info "Auth.self.authenticate: this user does not exist: #{account}"
           return nil
         end
-        mylog "env=#{env.inspect}"
-        env['rack.session'][:user] = @user[:id]
-        password = @user[:password]
-        @user.delete(:password)
-
-        return nil if !pass || !password
-        !!(password == 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
 
-    attr_accessor :account, :password, :model, :user, :id
+    attr_accessor :account, :password, :user, :id
 
-    def initialize(model, account)
+    def initialize(account)
       self.account = account
-      @user = model.db.dataset(:user).where(Sequel.or(account: account, id: account)).first
+      auth_conf = Config[:auth]
+      dataset = DB.dataset(auth_conf[:table])
+      if account.is_a?(Integer)
+        @user = dataset.where(id: account).first
+      else
+        @user = dataset.where(auth_conf[:user].to_sym => account).first
+      end
       unless @user
-        mylog "Auth.initialize: This user does not exist: #{account}"
+        EzLog.error "Auth.initialize: This user does not exist: #{account}"
+        return
       end
-      self.password = @user[:password]
+      self.password = @user[auth_conf[:password].to_sym]
       @user.delete(:password)
     end
+
+    def inspect
+      "account=#{@account}, user=#{@user}, id=#{@id}"
+    end
   end
 end