ezframe 0.0.4 → 0.4.0

data/lib/ezframe/materialize.rb

@@ -4,17 +4,16 @@ module Ezframe
   class Materialize
     class << self
       def into_html_header
-
-        css_a = Config[:extra_css_list].map {|file| "<link href=\"#{file}\" rel=\"stylesheet\">\n" }
-        js_a = Config[:extra_js_list].map {|file| "<script src=\"#{file}\"></script>\n" }
+        css_a = Config[:extra_css_list]&.map {|file| "<link href=\"#{file}\" rel=\"stylesheet\">\n" }
+        js_a = Config[:extra_js_list]&.map {|file| "<script src=\"#{file}\"></script>\n" }
 
         css_files = Dir["./asset/css/*.css"]||[]
-        css_a += css_files.map do |file|
+        css_a += css_files.sort.map do |file|
           file.gsub!("./asset", "")
           "<link href=\"#{file}\" rel=\"stylesheet\">\n"
         end
         js_files = Dir["./asset/js/*.js"]||[]
-        js_a += js_files.map do |file|
+        js_a += js_files.sort.map do |file|
           file.gsub!("./asset", "")
           "<script src=\"#{file}\"></script>\n"
         end
@@ -27,19 +26,16 @@ module Ezframe
 
       def convert(ht_h)
         return nil unless ht_h
-        return ht_h if (ht_h.kind_of?(Hash) && ht_h[:final])
+        return ht_h if (ht_h.is_a?(Hash) && ht_h[:final])
         new_h = ht_h.clone
-        if ht_h.kind_of?(Array)
+        if ht_h.is_a?(Array)
           new_h = ht_h.map { |v| convert(v) }
-        elsif ht_h.kind_of?(Hash)
+        elsif ht_h.is_a?(Hash)
           unless ht_h[:tag]
-            mylog("convert: no tag: #{ht_h.inspect}")
+            EzLog.info("convert: no tag: #{ht_h.inspect}")
             return nil
           end
           case ht_h[:tag].to_sym
-#          when :input, :select
-#            new_h = input(ht_h) if "hidden" != ht_h[:type]
-#            return new_h
           when :checkbox
             return checkbox(ht_h)
           when :radio
@@ -58,8 +54,8 @@ module Ezframe
 
       def icon(ht_h)
         new_h = ht_h.clone
-        mylog "[warn] no name attribute for icon ht_h: #{ht_h.inspect}" unless new_h[:name]
-        new_h.add_class("material-icons")
+        EzLog.info "[warn] no name attribute for icon ht_h: #{ht_h.inspect}" unless new_h[:name]
+        new_h.add_class(%w[material-icons align-icon])
         new_h.update({ tag: "i", child: ht_h[:name] })
         new_h.delete(:name)
         return new_h

data/lib/ezframe/message.rb

@@ -0,0 +1,46 @@
+module Ezframe
+  class Message
+    class << self
+      def init
+        load_yaml_files
+      end
+
+      def load_yaml_files(dir = "./message")
+        unless @catalog
+          @catalog = {}
+          Dir["#{dir}/*.yml"].each do |file|
+            load_one_file(file)
+          end
+        end
+      end
+
+      def load_one_file(file)
+        begin
+          yaml = YAML.load(File.open(file), symbolize_names: true)
+        rescue
+          EzLog.info("YAML load error: #{file}")
+          return 
+        end
+        if /([a-z]{2})\.yml$/ =~ file
+          lang = $1
+          @catalog[lang.to_sym] = yaml # .recursively_symbolize_keys
+        end
+      end
+
+      def languages
+        return @catalog.keys
+      end
+
+      def get(key, lang = nil)
+        lang = languages[0] unless lang
+        messages = @catalog[lang]
+        return messages[key.to_sym] if messages
+        return nil
+      end
+
+      def [](key)
+        return get(key)
+      end
+    end
+  end
+end

data/lib/ezframe/page_base.rb

@@ -2,106 +2,94 @@
 
 require "json"
 require "uri"
-
 require_relative "util"
 
 module Ezframe
   class PageBase
-    class << self
-      def decide_route(path_info)
-        default_class = Config[:default_page_class]||"App"
-        default_method = Config[:default_page_method]||"default"
-        path_parts = path_info.split('/').drop(1)
-        case path_parts.length
-        when 0
-          [get_class(default_class), default_method]
-        when 1
-          filename = path_parts[0]
-          if filename.index(".")
-            return nil
-          end
-          klass = get_class(path_parts)
-          if klass
-            return [klass, default_method]
-          else
-            return [get_class(default_class), path_parts[0]]
-          end
-        else
-          klass = get_class(path_parts)
-          if klass
-            [klass, default_method]
-          else
-            method = path_parts.pop
-            klass = get_class(path_parts)
-            [klass, method]
-          end
-        end
-      end
+    attr_accessor :request
 
-      def get_class(keys)
-        keys = [keys] if keys.is_a?(String)
-        klass = (%w[Ezframe] + keys.map { |k| k.to_camel }).join("::")
-        mylog "get_class: #{klass}"
-        if Object.const_defined?(klass)
-          return Object.const_get(klass)
-        end
-        return nil
-      end
+    def initialize(request = nil)
+      @class_snake = class_to_snake(self.class)
+      # puts "class_snake = #{@class_snake}"
+      set_request(request) if request
+      init_vars
     end
 
-    attr_accessor :auth
+    def init_vars
+    end
+
+    # Rackのrequestを代入し、関連するインスタンス変数を定義
+    def set_request(request)
+      @request = request
+      @column_set = ColumnSets.get(@class_snake)
+      @dataset = DB.dataset(@class_snake)
+      EzLog.debug "column_set is not defined: #{@class_snake}" unless @column_set
+      @params = parse_query_string(request.env["QUERY_STRING"])
+      @params.update(request.params)
+      # EzLog.info "set_request: params=#{@params.inspect}" if @params.length > 0
+      # @id, @key = @params[:id], @params[:key]
+      @env = @request.env
+      @session = @env["rack.session"]
 
-    def initialize(request = nil, model = nil)
-      @model = model if model
-      if request
-        @request = request
-        @params = parse_query_string(request.env["QUERY_STRING"])
-        @params.update(request.params)
-        mylog "params=#{@params.inspect}" if @params.length > 0
-        @id, @key = @params[:id], @params[:key]
-        @env = @request.env
-        @session = @env["rack.session"]
-        mylog "session = #{@session.inspect}"
-        if request.post?
-          parse_json_body
-          mylog "json=#{@json.inspect}"
+      if %w[POST PUT].include?(request.request_method)
+        body = @request.body.read
+        if request.content_type.index("json")
+          @parsed_body = parse_json_body(body)
+        else
+          @parsed_body = parse_query_string(body)
         end
+        # EzLog.info "parsed_body=#{@parsed_body.inspect}"
+        @event = @parsed_body[:ezevent] || {}
+        @form = @event[:form]
       end
-      @auth = nil
     end
 
-    def parse_query_string(str)
-      query_a = URI::decode_www_form(str)
-      res_h = {}
-      query_a.map { |a| res_h[a[0].to_sym] = a[1] }
-      res_h
+    # routeから基本URLを生成
+    def make_base_url(id = nil)
+      path = Route::get_path(@class_snake)
+      params = @request.env["url_params"] || {}
+      # EzLog.info "make_base_url: params=#{params}"
+      # params[@class_snake.to_sym] = id
+      path_s = path.map do |pa|
+        if pa == @class_snake.to_sym && id
+          "#{pa}/#{id}"
+        elsif params[pa.to_sym]
+          "#{pa}/#{params[pa.to_sym]}"
+        else
+          pa
+        end
+      end.join("/")
+      # EzLog.info "path_s=#{path_s}"
+      return "/#{path_s}"
     end
 
-    def common_page(opts = {})
+    def show_base_template(opts = {})
       args = {
         title: opts[:title],
         body: opts[:body],
         into_html_header: Materialize.into_html_header,
         into_bottom_of_body: Materialize.into_bottom_of_body,
       }
-      Template.fill("template/base.html", args)
+      Template.fill_from_file("template/base.html", args)
     end
 
-    def parse_json_body
-      body = @request.body.read
+    def parse_json_body(body)
       return {} if !body || body.length==0
       begin
-        @json = JSON.parse(body)
+        json = JSON.parse(body, symbolize_names: true)
       rescue => e
-        mylog "ERROR: #{e.class}:#{e.message}\n#{e.backtrace}"
+        EzLog.info "ERROR: #{e.class}:#{e.message}\n#{e.backtrace}"
         return nil
       end
-      @json = @json.recursively_symbolize_keys if @json.is_a?(Hash) || @json.is_a?(Array)
-      return @json
+      return json
+    end
+
+    def session
+      return @request.env['rack.session']
     end
 
     def warden
-      @request.env["warden"]
+      return @request.env["warden"]
     end
 
     def login?
@@ -109,7 +97,7 @@ module Ezframe
     end
 
     def user
-      warden.user
+      return warden.user
     end
   end
 end

data/lib/ezframe/route.rb

@@ -0,0 +1,126 @@
+module Ezframe
+  class Route
+    class << self
+      def choose(request, route_h = nil)
+        path_parts = request.path_info.split("/").drop(1)
+        route_h ||= Config[:route].deep_dup
+        unless route_h
+          raise "Config[:route] is not defined. It should be defined in config/route.yml"
+        end
+        # puts  "config=#{Config[:route]}, route_h=#{route_h}"
+        args = {}
+        opts = {}
+        class_a = []
+        # p path_parts
+        if path_parts.empty?
+          root_conf = route_h[:/]
+          # p root_conf
+          if root_conf
+            klass = get_class(root_conf[:class])
+            return [ klass.new, make_method_name("default", request.request_method) ]
+          end
+          return [ 404 ]
+        end
+        # URLを解析して、クラスの決定とIDの取得を行う
+        while path_parts.length > 0
+          part = path_parts.shift
+          # break if part.empty?
+          # EzLog.info "part=#{part}, route_h=#{route_h.inspect}"
+          if route_h.has_key?(part.to_sym)
+            # EzLog.info "has_route: #{part}"
+            class_a.push(part)
+            if path_parts[0].to_i > 0
+              args[part.to_sym] = val = path_parts.shift
+              # EzLog.info "value: part=#{part}, val=#{val}"
+            end
+            route_h = route_h[part.to_sym]
+            break if route_h.nil?
+            opts = {}
+            route_h.keys.compact.each do |rkey|
+              if rkey =~ /option_(\w+)/
+                opt_key = $1
+                opts[opt_key.to_sym] = route_h[rkey]
+              end
+            end
+          else
+            # routeに無ければ、メソッドを探す
+            # EzLog.info "no_route: #{part}"
+            klass = get_class(class_a[-1])
+            return [ 404 ] unless klass
+            instance = klass.new
+            method_name = make_method_name(part, request.request_method)
+            if instance.respond_to?(method_name)
+              return [instance, method_name, args, opts]
+            else
+              EzLog.info "undefined method: #{klass}.#{method_name}: full path=#{request.path_info}"
+            end
+          end
+        end
+        # 最後にメソッド名が無い場合はpublic_default_#{method}を実行。
+        #puts "class_a=#{class_a}"
+        klass = get_class(class_a[-1])
+        return [404] unless klass
+        if path_parts.length > 0
+          part = path_parts.shift
+        else
+          part = "default"
+        end
+        method_name = make_method_name(part, request.request_method)
+        #EzLog.info "method_name=#{method_name}"
+        instance = klass.new
+        if instance.respond_to?(method_name)
+          return [instance, method_name, args, opts]
+        end
+        return [ 404 ]
+      end
+
+      # ページクラスの階層を辿る
+      def get_path(class_snake, route_h = nil)
+        route_h = Config[:route] unless route_h
+        # EzLog.info "get_path: route_h=#{route_h}"
+        @get_path_found_it = nil
+        route =_scan_route(class_snake, route_h.deep_dup) 
+        return route.reverse if route
+        return nil
+      end
+
+      # targetに対応する名称のクラスまでの経路を返す
+      def _scan_route(target, route_h)
+        if route_h.keys.include?(target.to_sym)
+          @get_path_found_it = true
+          return [ target ]
+        else
+          route_h.each do |k, v|
+            next if k.to_s =~ /^option_/
+            if v.is_a?(Hash)
+              a = _scan_route(target, v)
+              if @get_path_found_it
+                a.push(k)
+                return a
+              end
+            end
+          end
+        end
+        return nil
+      end
+
+      def make_method_name(base_name, method = "get")
+        return ["public", base_name, method.downcase].join("_")
+      end
+
+      def get_class(keys)
+        # EzLog.info "get_class: #{keys.inspect}"
+        return nil unless keys
+        keys = [ keys ] if keys.is_a?(String)
+        klass = (%w[Ezframe] + keys.map { |k| k.to_s.to_camel }).join("::")
+        # EzLog.info "get_class: #{klass}"
+        if Object.const_defined?(klass)
+          return Object.const_get(klass)
+        else
+          raise "get_class: undefined class: #{klass}"
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/ezframe/server.rb

@@ -2,14 +2,25 @@
 
 module Ezframe
   class Server
-    def self.call(env)
+    def initialize
+      Controller.init
+    end
+
+    def call(env)
       req = Rack::Request.new(env)
       res = Rack::Response.new
-      Boot.exec(req, res)
-      if res.body.empty?
-        raise "no body in response"
+      begin
+        Controller.exec(req, res)
+      rescue => e
+        EzLog.error("Controller.exec: exception: #{e.message}:\n#{e.backtrace}")
+        res.status = 500
+        res.headers["Content-Type"] = "text/plain"
+        res.body = [ "Internal server error" ]
       end
-      res.finish
+#      if res.body.empty?
+#        raise "no body in response"
+#      end
+      return res.finish
     end
   end
 end

data/lib/ezframe/single_page_editor.rb

@@ -0,0 +1,22 @@
+require_relative "editor_common"
+require_relative "single_page_kit"
+
+module Ezframe
+  # ページ遷移無しでデータを編集する仕組み
+  class SinglePageEditor < PageBase
+    include EditorCommon
+    include PageKit::Default
+    include PageKit::Index
+    include PageKit::Edit
+    include PageKit::Detail
+    include PageKit::Delete
+
+    def init_vars
+      super
+      @sort_key = :id
+      @event = @parsed_body[:ezevent] if @parsed_body
+      @dom_id = { create: "create-area", edit: "edit-area", index: "index-area", detail: "detail-area"}
+      # @show_delete_button = nil
+    end
+  end
+end