ezframe 0.1.1 → 0.2.0

data/lib/ezframe/config.rb

@@ -3,14 +3,27 @@ module Ezframe
     class << self
       attr_accessor :value_h
 
+      def init(dir = "./config")
+        load_files(dir)
+      end
+
       def load_files(dir)
         unless @value_h
-          Dir["#{dir}/*.yml"].each do |file|
-            load_one_file(file)
+          load_dir(dir)
+          rack_env = ENV['RACK_ENV']
+          env_dir = "#{dir}/#{rack_env}"
+          if rack_env && File.directory?(env_dir)
+            load_dir(env_dir)
           end
         end
       end
 
+      def load_dir(dir)
+        Dir["#{dir}/*.yml"].each do |file|
+          load_one_file(file)
+        end
+      end
+
       def load_one_file(filename)
         instr = File.open(filename, &:read)
         if instr.index("\#{")
@@ -19,7 +32,7 @@ module Ezframe
         begin
           yaml = YAML.load(instr)
         rescue
-          mylog("YAML load error: #{filename}")
+          Logger.info("YAML load error: #{filename}")
           return 
         end
         @value_h ||={}
@@ -35,6 +48,10 @@ module Ezframe
         @value_h[k]=v
       end
 
+      def delete(k)
+        @value_h.delete(k) if @value_h[k]
+      end
+
       def inspect
         @value_h.inspect
       end

data/lib/ezframe/controller.rb

@@ -1,46 +1,49 @@
 # frozen_string_literal: true
-require "oj"
-
 module Ezframe
   class Controller
     class << self
       def init
-        Config.load_files("./config")
-        Model.init
+        Config.init
+        ColumnSets.init
+        DB.init
         Message.init
-        Auth.init_warden if defined?(Warden)
+        Auth.init if Config[:auth]
       end
 
       def exec(request, response)
         @request = request
-        model = Model.get_clone
-        @request.env["model"] = model
+        page_instance, method, url_params, class_opts = Route::choose(request)
 
-        mylog("exec: path=#{request.path_info} params=#{request.params}")
-        page_instance, method, url_params = Route::choose(request)
-        mylog "page: #{page_instance.class}, method=#{method}, url_params=#{url_params}"
+        Logger.debug("Controller.exec: path=#{request.path_info}, params=#{request.params}, class=#{page_instance.class}, method=#{method}, url_params=#{url_params}, class_opts=#{class_opts}")
         if !page_instance || page_instance == 404
           file_not_found(response)
           return
         end
         @request.env["url_params"] = url_params
-        warden.authenticate! if page_instance.auth
-        mylog "rack.session.keys=#{request.env['rack.session'].keys}"
+        opt_auth = class_opts[:auth]
+        @session = @request.env['rack.session']
+        if !@session[:user] && Config[:auth] && (!opt_auth || opt_auth != "disable")
+          Logger.debug("authenticate!")
+          warden.authenticate! 
+          Logger.info "Controller.exec: warden.options = #{@request.env['warden.options']}"
+        end
+        # session["in_controller"] = "set in controller"
+        Logger.debug "rack.session.keys=#{@session.keys}" if @session
         page_instance.set_request(@request)
         body = page_instance.send(method)
 
         # 戻り値によるレスポンス生成
         if body.is_a?(Hash) || body.is_a?(Array)
-          # puts  "Controller: body = #{body}"
-          response.body = [ JSON.generate(body) ]
-          # response.body = [ Oj.dump(body) ]
+          # Logger.debug("Controller: body = #{body}")
+          json = JSON.generate(body)
+          response.body = [ json ]
           response['Content-Type'] = 'application/json; charset=utf-8'
         else
           response.body = [ body ]
           response['Content-Type'] = 'text/html; charset=utf-8'
         end
         response.status = 200
-        # puts response.body
+        # Logger.debug("Controller.exec: response.body=#{response.body}")
       end
 
       def file_not_found(response)

data/lib/ezframe/database.rb

@@ -2,61 +2,173 @@
 require "logger"
 
 module Ezframe
-  class Database
-    attr_accessor :sequel
-
-    def initialize(dbfile = nil)
-      @dbfile = dbfile
-      connect
-    end  
-
-    def connect
-      @dbfile ||= ENV["EZFRAME_DB"] || Config[:database] || "sqlite://db/devel.sqlite"
-      # puts "Database.connect: dbfile=#{@dbfile}"
-      @sequel = Sequel.connect(@dbfile, loggers: [Logger.new($stdout)])
-    end  
-
-    def exec(sql)
-      @sequel.run(sql)  
-    end  
-
-    def dataset(table_name)
-      @sequel[table_name.to_sym]  
-    end
-  
-    def create_table(table_name, dbtype_h)
-      %w[id created_at updated_at].each do |key|
-        dbtype_h.delete(key.to_sym)
-      end
-      # puts "create_table: #{table_name}"
-      if @dbfile.index("postgres")
-        @sequel.create_table(table_name) do 
-          primary_key :id, identity: true
-          dbtype_h.each do |key, dbtype|
-            column(key, dbtype)
+  class DB
+    class << self
+      attr_accessor :sequel, :pool
+
+      def init(dbfile = nil, opts = {})
+        @dbfile = dbfile || ENV["EZFRAME_DB"] || Config[:database]
+        if Config[:use_connection_pool] || opts[:use_connection_pool]
+          @pool = Sequel::ConnectionPool(max_connections: 10) do
+            Sequel.connect(@dbfile, loggers: [Logger])
           end
-          column(:created_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
-          column(:updated_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
-        end
-      else
-        @sequel.create_table(table_name) do 
-          primary_key :id, auto_increment: true
-          dbtype_h.each do |key, dbtype|
-            column(key, dbtype)
+        else
+          connect(@dbfile)
+        end
+      end
+
+      def connect(dbfile = nil)
+        dbfile ||= @dbfile
+        @sequel = Sequel.connect(dbfile, loggers: [Logger])
+        return @sequel
+      end
+
+      def disconnect
+        @sequel.disconnect
+      end
+
+      def get_conn
+        if @pool
+          @pool.hold {|conn| return conn }
+        else
+          @sequel
+        end
+      end
+
+      def exec(sql, first: nil)
+        conn = get_conn
+        if first
+          return conn[sql].first
+        else
+          return conn[sql].all
+        end
+      end
+
+      def run(sql)
+        conn = get_conn
+        conn.run(sql)
+      end
+
+      def dataset(table_name)
+        @sequel[table_name.to_sym]
+      end
+
+      class JointHash < Hash
+        def initialize(default_table, values = {})
+          @default_table = default_table
+          self.update(values)
+        end
+
+        def []=(key, value)
+          super(key.to_s, value)
+        end
+
+        def [](key)
+          key = key.to_s
+          return fetch(key) if has_key?(key)
+          alt_key = "#{@default_table}.#{key}"
+          return fetch(alt_key) if has_key?(alt_key)
+          return nil
+        end
+      end
+
+      # テーブルを連結して、全てのデータを返す。
+      def get_join_table(structure, opts = {})
+        col_h = {}
+        reverse_col_h = {}
+        query_a = []
+        table_a = []
+        prefix="_x_"
+        structure[:column_list].each_with_index do |k, i|
+          key = "#{prefix}#{i+1}"
+          col_h[k.to_sym] = key.to_sym
+          reverse_col_h[key.to_sym] = k
+          query_a.push "#{k} AS #{key}"
+        end
+        tables = structure[:tables].clone
+        join_cond = structure[:join_condition]
+        tb = tables.shift
+        table_part = [ tb ]
+        tables.each do |table|
+          cond = join_cond[table.to_sym]
+          if cond
+            table_part.push " LEFT JOIN #{table} ON #{cond}"
+          else
+            table_part.push " LEFT JOIN #{table} ON #{tb}.#{table} = #{table}.id"
+          end
+        end
+        sql = "SELECT #{query_a.join(', ')} FROM #{table_part.join(' ')}"
+        sql += " WHERE #{opts[:where]}" if opts[:where]
+        sql += " ORDER BY #{opts[:order]}" if opts[:order]
+        sql += " LIMIT #{opts[:limit]}" if opts[:limit]
+        data_a = self.exec(sql)
+        res_a = []
+        data_a.each do |data|
+          new_data = JointHash.new(tb)
+          data.each do |k, v|
+            orig_key = reverse_col_h[k.to_sym]
+            next unless orig_key
+            new_data[orig_key] = v
           end
-          column(:created_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
-          column(:updated_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
+          res_a.push(new_data)
         end
+        return res_a
+      end
+
+      # テーブル生成
+      def create_table(table_name, dbtype_h)
+        %w[id created_at updated_at].each do |key|
+          dbtype_h.delete(key.to_sym)
+        end
+        # puts "create_table: #{table_name}"
+        if @dbfile.index("postgres")
+          @sequel.create_table(table_name) do
+            primary_key :id, identity: true
+            dbtype_h.each do |key, dbtype|
+              column(key, dbtype)
+            end
+            column(:created_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
+            column(:updated_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
+          end
+        else
+          @sequel.create_table(table_name) do
+            primary_key :id, auto_increment: true
+            dbtype_h.each do |key, dbtype|
+              column(key, dbtype)
+            end
+            column(:created_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
+            column(:updated_at, :timestamp, default: Sequel::CURRENT_TIMESTAMP)
+          end
+        end
+      end
+
+      def insert(table_name, val_h)
+        dataset(table_name).insert(val_h)
+      end
+
+      def update(dataset, val_h)
+        val_h.update({ updated_at: Time.now() })
+        dataset.update(val_h)
       end
-    end
-    
-    def insert(table_name, val_h)
-      dataset(table_name).insert(val_h)
     end
 
-    def update(dataset, val_h)
-      val_h.update({ updated_at: Time.now() })
-      dataset.update(val_h)
-    end  
+    class Cache
+      class << self
+
+        def [](table)
+          @store ||= {}
+          dataset = DB.dataset(table.to_sym)
+          # Logger.debug("DB::Cache: #{table}")
+          unless @store[table.to_sym]
+            data_a = dataset.all
+            h = {}
+            data_a.each {|data| h[data[:id]] = data }
+            @store[table.to_sym] = h
+          end
+          # Logger.debug(@store[table.to_sym])
+          return @store[table.to_sym]
+        end
+      end
+    end
   end
 end

data/lib/ezframe/editor.rb

@@ -84,7 +84,7 @@ module Ezframe
       table = []
       matrix = @column_set.map do |column|
         form = column.form
-        table.push Ht.p([ Ht.small_text(column.label), form ]) if form
+        table.push Ht.p([ Ht.small(column.label), form ]) if form
       end
       send_button = Ht.button(child: Message[:edit_finish_button_label], class: %w[btn], event: "on=click:url=#{make_base_url(@id)}/#{command}:with=form") 
       table.push(send_button)
@@ -94,7 +94,7 @@ module Ezframe
     #--------------------------------------------------------------------------------------------------------
     # 検索
     def public_search_post
-      mylog "public_search_post: #{@parsed_body.inspect}"
+      Logger.info "public_search_post: #{@parsed_body.inspect}"
       sch_keys = @search_keys || @column_set.keys
       word = @params["word"]
       pattern = "%#{word}%"
@@ -107,7 +107,7 @@ module Ezframe
 
     # 詳細表示
     def show_detail_page
-      mylog "show_detail_page: #{@request.params.inspect}"
+      Logger.info "show_detail_page: #{@request.params.inspect}"
       id = get_id(@class_snake)
       unless @column_set.set_from_db(id)
         return show_message_page("no data", "data is not defined: #{id}")
@@ -128,7 +128,7 @@ module Ezframe
           edit_btn = edit_button(column)
           edit_btn[:event] = "on=click:branch=edit_column:key=#{column.key}" if edit_btn
         end
-        table.push(Ht.p(class: %w[hover-button-box], child: [ Ht.small_text(column.label), column.view, edit_btn ].compact))
+        table.push(Ht.p(class: %w[hover-button-box], child: [ Ht.small(column.label), column.view, edit_btn ].compact))
       end
       unless @column_edit_mode
         edit_btn = Ht.button(class: %w[btn], child: [ Ht.icon("edit"), Message[:edit_button_label] ], event: "on=click:url=#{make_base_url(@id)}/edit")
@@ -146,7 +146,7 @@ module Ezframe
       class_name ||= @class_snake
       params = @request.env['url_params']
       return nil unless params
-      # mylog "get_id: #{params.inspect}, #{class_name}"
+      # Logger.info "get_id: #{params.inspect}, #{class_name}"
       return params[class_name.to_sym]
     end
 
@@ -159,13 +159,13 @@ module Ezframe
     # ラベル付きで1カラムのviewを表示
     def show_label_view(key)
       col = @column_set[key]
-      Ht.span([Ht.small_text(col.label), col.view(force: true)])
+      Ht.span([Ht.small(col.label), col.view(force: true)])
     end
 
     # ラベル付きで1カラムのformを表示
     def show_label_edit(key)
       col = @column_set[key]
-      Ht.span([Ht.small_text(col.label), col.form(force: true)])
+      Ht.span([Ht.small(col.label), col.form(force: true)])
     end
 
     # エラーページの表示

data/lib/ezframe/ht.rb

@@ -3,17 +3,18 @@ module Ezframe
   module Ht
     class << self
       # メソッド名の名前のタグのhthashを生成
-      def wrap_tag(opts = {})
-        if opts.is_a?(String) || opts.is_a?(Array)
-          h = { child: opts }
-        elsif opts.is_a?(Hash)
-          if opts[:tag] && !__callee__.to_s.index("wrap_tag")
-            h = { child: opts }
+      def wrap_tag(ht_h = {})
+        return nil unless ht_h
+        if ht_h.is_a?(String) || ht_h.is_a?(Array)
+          h = { child: ht_h }
+        elsif ht_h.is_a?(Hash)
+          if ht_h[:tag] && !__callee__.to_s.index("wrap_tag")
+            h = { child: ht_h }
           else
-            h = opts.dup
+            h = ht_h.dup
           end
         else
-          mylog("wrap_tag: unknown type: #{opts.inspect}")
+          Logger.info("[WARN] wrap_tag: unknown type: #{ht_h.inspect}")
           return nil
         end
         h[:tag] ||= __callee__.to_s
@@ -21,6 +22,13 @@ module Ezframe
         return h
       end
 
+      def single_tag(ht_h = {})
+        ht_h[:tag] ||= __callee__.to_s
+        raise "no tag" if ht_h[:tag] == "wrap_tag"
+        raise "has child: #{ht_h.inspect}" if ht_h[:child]
+        return ht_h
+      end
+
       alias_method :script, :wrap_tag
 
       alias_method :h1, :wrap_tag
@@ -30,8 +38,8 @@ module Ezframe
       alias_method :h5, :wrap_tag
       alias_method :h6, :wrap_tag
       alias_method :p, :wrap_tag
-      alias_method :br, :wrap_tag
-      alias_method :hr, :wrap_tag
+      alias_method :br, :single_tag
+      alias_method :hr, :single_tag
       alias_method :div, :wrap_tag
       alias_method :span, :wrap_tag
       alias_method :i, :wrap_tag
@@ -45,10 +53,10 @@ module Ezframe
       alias_method :tr, :wrap_tag
       alias_method :th, :wrap_tag
       alias_method :td, :wrap_tag
-      alias_method :img, :wrap_tag
+      alias_method :img, :single_tag
       alias_method :a, :wrap_tag
       alias_method :form, :wrap_tag
-      alias_method :input, :wrap_tag
+      alias_method :input, :single_tag
       alias_method :select, :wrap_tag
       alias_method :textarea, :wrap_tag
       alias_method :label, :wrap_tag
@@ -58,6 +66,7 @@ module Ezframe
 
       alias_method :small, :wrap_tag
       alias_method :pre, :wrap_tag
+      alias_method :iframe, :wrap_tag
 
       alias_method :checkbox, :wrap_tag
       alias_method :radio, :wrap_tag
@@ -90,10 +99,6 @@ module Ezframe
         return child
       end
 
-      def small_text(text)
-        return small(class: %w[teal-text], child: text)
-      end
-
       def search(ht_h, opts)
         @found ||= []
         if ht_h.is_a?(Hash)