ezframe 0.0.1 → 0.0.3

data/lib/ezframe/column_type.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+require "date"
 
 module Ezframe
   class TypeBase
-    attr_accessor :attribute, :parent
-    attr_writer :value
+    attr_accessor :attribute, :parent, :error
 
     def self.get_class(key)
       return nil unless key
@@ -25,13 +25,13 @@ module Ezframe
     end
 
     def initialize(attr = nil)
-      @attribute = attr if attr
+      @attribute = attr || {}
     end
 
     def key
-      @attribute[:key]  
-    end  
-    
+      @attribute[:key]
+    end
+
     def label
       return nil if @attribute[:hidden]
       @attribute[:label]
@@ -41,8 +41,8 @@ module Ezframe
       @value
     end
 
-    def view
-      @value
+    def value=(v)
+      @value = v
     end
 
     def db_type
@@ -53,134 +53,295 @@ module Ezframe
       value
     end
 
-    def form
+    def form(opts = {})
       nil
     end
+
+    def form_html(opts = {})
+      form_h = form(opts)
+      return nil unless form_h
+      return Html.convert(form_h)
+    end
+
+    def view(opts = {})
+      return nil if no_view?
+      @value
+    end
+
+    def validate
+      if !@value || @value.empty?
+        if @attribute[:must]
+          @error = "必須項目です。"
+          return @error
+        end
+      end  
+      return nil
+    end
+
+    def no_edit?
+      return ((@attribute[:hidden] || @attribute[:no_edit]) && !@attribute[:force])
+    end
+
+    def no_view?
+      return (@attribute[:hidden] && !@attribute[:force])
+    end
   end
 
-  class StringType < TypeBase
+  class TextType < TypeBase
     def normalize
-      @value.gsub!(/　/, ' ')
+      return unless @value
+      @value = @value.to_s
+      @value.gsub!(/　/, " ")
+      @value.gsub!(/\s+/, " ")
+      @value.strip!
     end
 
-    def form
-      return nil if @attribute[:hidden] && !@attribute[:force]
-      { tag: 'input', type: 'text', name: @attribute[:key], key: @attribute[:key], label: @attribute[:label], value: @value }
+    def value=(v)
+      super(v)
+      normalize
+    end
+
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
+      h = { tag: "input", type: "text", name: @attribute[:key], key: @attribute[:key], label: @attribute[:label], value: @value || "" }
+      h[:size] = @attribute[:size] if @attribute[:size]
+      h
     end
 
     def db_type
-      "string"
+      "text"
     end
   end
 
-  class IntType < StringType
-    def view
-      return nil if @attribute[:hidden]
-      Util.add_comma(@value.to_i)
+  class IntType < TextType
+    def view(opts = {})
+      return nil if no_view? && !opts[:force]
+      return Util.add_comma(@value.to_i)
     end
 
-    def form
-      return nil if @attribute[:hidden]
-      { tag: 'input', type: 'number', key: @attribute[:key], label: @attribute[:label], value: @value }
+    def value=(v)
+      if v.nil?
+        @value = nil
+        return
+      end
+      if v.is_a?(String)
+        v = v.tr("０-９", "0-9").strip
+      end
+      @value = v.to_i
+    end
+
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
+      { tag: "input", type: "number", key: @attribute[:key], label: @attribute[:label], value: @value || "" }
     end
 
     def db_type
       "int"
     end
+
+
   end
 
   class ForeignType < IntType
-    def view
+    def view(opts = {})
+      return nil if no_view? && !opts[:force]
       dataset = @parent.db.dataset[self.type.inner]
       data = dataset.get(id: @value)
-      data[@attribute[:view]]
+      return data[@attribute[:view]]
+    end
+
+    def form
+      return nil
     end
   end
-  
+
   class IdType < IntType
     def label
-      return nil if @attribute[:hidden] && !@attribute[:force]
-      "ID"
+      return nil if no_view?
+      return "ID"
+    end
+
+    def form(opts = {})
+      return nil
     end
   end
 
-  class PasswordType < StringType
-    def form
-      { tag: "input", type: "password", label: @attribute[:label], value: @value}
+  class PasswordType < TextType
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
+      return { tag: "input", type: "password", label: @attribute[:label], value: @value || "" }
     end
 
     def db_value
-      value      
+      return value
     end
   end
 
   class SelectType < TypeBase
-    def form
-      return nil if @attribute[:hidden]
-      { tag: 'select', key: @attribute[:key], label: @attribute[:label], items: @attribute[:items], value: @value }
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
+      # puts "selectType: #{@attribute[:items].inspect}"
+      return { tag: "select", key: @attribute[:key], label: @attribute[:label], items: @attribute[:items], value: @value }
     end
 
     def db_type
-      "string"
+      return "text"
     end
   end
 
   class CheckboxType < TypeBase
-    def form
-      return nil if @attribute[:hidden]
-      { tag: "checkbox", key: @attribute[:key], name: @attribute[:key], value: parent[:id].value, label: @attribute[:label] }
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
+      return { tag: "checkbox", key: @attribute[:key], name: @attribute[:key], value: parent[:id].value, label: @attribute[:label] }
     end
 
     def db_type
-      "int"
+      return "int"
     end
   end
 
-  class DateType < StringType
-    def form
+  class DateType < TextType
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
       h = super
-      h[:type] = 'date' if h
-      h
+      if h
+        #        h[:type] = 'date'
+        h[:type] = "text"
+        h[:class] = "datepicker"
+        h[:value] = value || ""
+      end
+      return h
     end
 
     def db_type
-      "datetime"
+      "date"
+    end
+
+    def value
+      if @value.is_a?(Date) || @value.is_a?(Time)
+        return "%d-%02d-%02d" % [@value.year, @value.mon, @value.mday]
+      end
+      return @value
+    end
+
+    def value=(v)
+      if v.nil?
+        @value = nil
+        return
+      end
+      if v.is_a?(String)
+        if v.strip.empty?
+          @value = nil
+          return
+        end
+        y, m, d = v.split(/[\-\/]/)
+        # puts "date=#{v.inspect}"
+        @value = Date.new(y.to_i, m.to_i, d.to_i)
+        return
+      end
+      if v.is_a?(Date) || v.is_a?(Time)
+        @value = v
+      else
+        mylog "[WARN] illegal value for date type: #{v.inspect}"
+      end
+    end
+
+    def view(opts = {})
+      return nil if no_view? && !opts[:force]
+      if @value.is_a?(Time) || @value.is_a?(Date)
+        return "#{@value.year}/#{@value.mon}/#{@value.mday}"
+      else
+        return @value
+      end
     end
   end
-  
-  class EmailType < StringType
-    def form
-      h = super
-      h[:type] = 'email' if h
-      h
+
+  class TimeType < TextType
+  end
+
+  class DatetimeType < DateType
+    def db_type
+      "timestamp"
     end
   end
 
-  class TelephoneType < StringType
-    def form
+  class BirthdayType < DateType
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
+      prefix = @attribute[:key]
+      now = Time.now
+      year_list = []
+      110.times do |y|
+        year = now.year - y - 10
+        year_list.push [year, "#{year}年 (#{Japanese.convert_wareki(year)})"]
+      end
+      mon_list = (1..12).map { |m| [m, "#{m}月"] }
+      mon_list.unshift([0, "(月)"])
+      mday_list = (1..31).map { |d| [d, "#{d}日"] }
+      mday_list.unshift([0, "(日)"])
+      return [Ht.select(name: "#{prefix}_year", items: year_list),
+              Ht.select(name: "#{prefix}_mon", items: mon_list),
+              Ht.select(name: "#{prefix}_mday", items: mday_list)]
+    end
+  end
+
+  class EmailType < TextType
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
       h = super
-      h[:type] = 'tel' if h
-      h
+      h[:type] = "email" if h
+      return h
+    end
+
+    def normalize
+      return unless @value
+      @value = NKF.nkf('-w -Z4', @value)
+    end
+
+    def validate
+      super
+      return @error if @error
+      if email_format?
+        @error = "形式が正しくありません"
+        return @error
+      end
+      return nil
+    end
+
+    def email_format?
+      return nil unless @value
+      return @value =~ /^[a-zA-Z0-9.!\#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
     end
   end
 
-  class JpnameType < StringType
+  class TelType < TextType
+    def validate
+      super
+      return @error if @error
+      unless /^0\d{9,10}$/ =~ @value
+        @error = "形式が正しくありません"
+        return @error
+      end
+    end
   end
 
-  class JpnameKanaType < StringType
-    def set(val)
-      val = val.tr('ァ-ン', 'ぁ-ん')
-      super(val)
+  class JpnameType < TextType
+  end
+
+  class JpnameKanaType < TextType
+    def normalize
+      return unless @value
+      super
+      @value.tr!("ァ-ン", "ぁ-ん")
     end
 
     def validation
       unless /^[ぁ-ん ]+$/ =~ @value
-        'ひらがなのみで入力してください。'
+        "ひらがなのみで入力してください。"
       end
     end
   end
 
-  # 
   class PrefectureType < SelectType
     def initialize(attr)
       super(attr)
@@ -195,26 +356,28 @@ module Ezframe
       @pref_a.each_with_index { |p, i| @pref_h[i] = p }
     end
 
-    def form
+    def form(opts = {})
+      return nil if no_edit? && !opts[:force]
       h = super
       h[:items] = @pref_h
-      h
+      return h
     end
 
     def view
-      @pref_h[@value.to_i]
+      return @pref_h[@value.to_i]
     end
   end
 
   # Japanese Zipcode type column
-  class ZipcodeType < StringType
-    def view
+  class ZipcodeType < TextType
+    def view(opts = {})
+      return nil if no_view? && !opts[:force]
       return "" unless @value
-      @value.to_s.gsub(/(\d{3})(\d{4})/) { "#{$1}-#{$2}" }
+      return @value.to_s.gsub(/(\d{3})(\d{4})/) { "#{$1}-#{$2}" }
     end
 
     def db_type
-      "string"
+      return "text"
     end
   end
 end

data/lib/ezframe/config.rb

@@ -28,6 +28,10 @@ module Ezframe
         @value_h||={}
         @value_h[k]=v
       end
+
+      def inspect
+        @value_h.inspect
+      end
     end
   end
 end

data/lib/ezframe/controller.rb

@@ -9,22 +9,33 @@ module Ezframe
         Model.init
         model = Model.get_clone
         Auth.init_warden
-        Auth.model = model
+        @request.env["model"] = model
+        # Auth.model = model
 
         mylog("exec: path=#{request.path_info} params=#{request.params}")
         klass, method = PageBase::decide_route(request.path_info)
-        mylog "klass=#{klass}, method=#{method}"
+        unless klass
+          response.status = 404
+          response['Content-Type'] = 'text/html; charset=utf-8'
+          response.body = [ Html.convert(Ht.p("file not found")) ]
+          return
+        end
+        method = "default" if !method || method=="undefined"
         page = klass.new(request, model)
         if request.post?
           method_full_name = "public_#{method}_post"
         else
           method_full_name = "public_#{method}_page"
         end
-        warden.authenticate! if page.auth
+        if page.auth
+          warden.authenticate! 
+        end
         # request.env["rack.session"]["kamatest"]="usable"
-        mylog "method: #{klass}.#{method_full_name}"
-        mylog "rack.session.id=#{request.env['rack.session'].id}"
+        # mylog "method: #{klass}.#{method_full_name}"
+        #mylog "rack.session.id=#{request.env['rack.session'].id}"
         mylog "rack.session.keys=#{request.env['rack.session'].keys}"
+        #mylog "warden=#{request.env['warden'].inspect}"
+        mylog "klass=#{klass}, method=#{method_full_name}"
         body = if page.respond_to?(method_full_name)
                     page.send(method_full_name)
                   else
@@ -41,11 +52,10 @@ module Ezframe
         response.status = 200
       end
 
-
-      def file_not_found(response)
-        response.body = ['path not found']
-        response.status = 404
-      end
+#      def file_not_found(response)
+#        response.body = ['path not found']
+#        response.status = 404
+#      end
 
       def warden
         @request.env["warden"]

data/lib/ezframe/database.rb

@@ -5,13 +5,15 @@ module Ezframe
   class Database
     attr_accessor :sequel
 
-    def initialize(dbfile = "db/devel.sqlite")
+    def initialize(dbfile = nil)
       @dbfile = dbfile
       connect
     end  
 
     def connect
-      @sequel = Sequel.connect("sqlite://#{@dbfile}", loggers: [Logger.new($stdout)])
+      @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)
@@ -26,8 +28,13 @@ module Ezframe
       %w[id created_at updated_at].each do |key|
         dbtype_h.delete(key.to_sym)
       end
+      puts "create_table: #{table_name}"
       @sequel.create_table(table_name) do 
-        primary_key :id, auto_increment: true
+#        if @dbfile.index("postgresql")
+          serial :id
+#        else
+          #primary_key :id, auto_increment: true
+        #end
         dbtype_h.each do |key, dbtype|
           column(key, dbtype)
         end

data/lib/ezframe/ht.rb

@@ -0,0 +1,167 @@
+# HTMLを中間表現としてのハッシュであるhthashを生成するためのクラス
+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 }
+          else
+            h = opts.dup
+          end
+        else
+          mylog("wrap_tag: unknown type: #{opts.inspect}")
+          return nil
+        end
+        h[:tag] ||= __callee__.to_s
+        raise "no tag" if h[:tag] == "wrap_tag"
+        return h
+      end
+
+      alias_method :script, :wrap_tag
+
+      alias_method :h1, :wrap_tag
+      alias_method :h2, :wrap_tag
+      alias_method :h3, :wrap_tag
+      alias_method :h4, :wrap_tag
+      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 :div, :wrap_tag
+      alias_method :span, :wrap_tag
+      alias_method :i, :wrap_tag
+      alias_method :strong, :wrap_tag
+      alias_method :ul, :wrap_tag
+      alias_method :ol, :wrap_tag
+      alias_method :li, :wrap_tag
+      alias_method :table, :wrap_tag
+      alias_method :thead, :wrap_tag
+      alias_method :tbody, :wrap_tag
+      alias_method :tr, :wrap_tag
+      alias_method :th, :wrap_tag
+      alias_method :td, :wrap_tag
+      alias_method :img, :wrap_tag
+      alias_method :a, :wrap_tag
+      alias_method :form, :wrap_tag
+      alias_method :input, :wrap_tag
+      alias_method :select, :wrap_tag
+      alias_method :textarea, :wrap_tag
+      alias_method :label, :wrap_tag
+      alias_method :fieldset, :wrap_tag
+      alias_method :nav, :wrap_tag
+      alias_method :footer, :wrap_tag
+
+      alias_method :small, :wrap_tag
+
+      alias_method :checkbox, :wrap_tag
+      alias_method :radio, :wrap_tag
+
+      # materialize用のiconメソッド
+      # 引数が文字列だったら、それをname属性とする
+      def icon(arg)
+        if arg.is_a?(Hash)
+          h = arg.clone
+          h[:tag] = "icon"
+          return wrap_tag(h)
+        elsif arg.is_a?(String)
+          return { tag: "icon", name: arg }
+        end
+      end
+
+      # buttonタグにはデフォルトでtype=button属性を付ける
+      def button(arg)
+        arg[:tag] = "button"
+        unless arg[:type]
+          arg[:type] = "button"
+        end
+        wrap_tag(arg)
+      end
+
+      def multi_div(class_a, child)
+        class_a.reverse.each do |klass|
+          child = Ht.div(class: klass, child: child)
+        end
+        return child
+      end
+    end
+
+    # 配列を<UL><OL>要素に変換するためのクラス
+    class List < Array
+      attr_accessor :tag
+      def to_h(opts = {})
+        return nil if self.empty?
+        child = self.map do |elem|
+          { tag: "li", child: elem }
+        end
+        h = { tag: @tag, child: child }
+        h.update(opts)
+        return h
+      end
+    end
+
+    # 配列を<UL>要素に変換するためのクラス
+    class Ul < List
+      def to_h(opts = {})
+        @tag = "ul"
+        return super(opts)
+      end
+    end
+
+    # 配列を<OL>要素に変換するためのクラス
+    class Ol < List
+      def to_h(opts = {})
+        @tag = "ol"
+        return super(opts)
+      end
+    end
+
+    # テーブルを生成するためのクラス
+    # @matrix ... テーブルの内容となる二次元配列
+    # @header ... テーブルの先頭に付ける項目名の配列
+    # @class_a ... <table><tr><td>の各ノードにそれぞれ設定したいclass属性を配列として定義
+    class Table
+      attr_accessor :class_a, :header, :matrix
+
+      def initialize(matrix = nil)
+        set(matrix) if matrix
+        @matrix ||= []
+      end
+
+      def set(matrix)
+        @matrix = matrix
+      end
+
+      def add_row(row)
+        @matrix.push(row)
+      end
+
+      def to_h
+        table_class, tr_class, td_class = @class_a
+        max_col = 0
+        @matrix.each { |row| max_col = row.length if max_col < row.length }
+        tr_a = @matrix.map do |row|
+          add_attr = nil
+          add_attr = { colspan: max_col - row.length + 1 } if row.length < max_col
+          td_a = row.map do |v| 
+            td = Ht.td(child: v) 
+            td.add_class(td_class) if td_class
+            td
+          end
+          td_a[0].update(add_attr) if add_attr
+          tr = Ht.tr(class: tr_class, child: td_a)
+          tr.add_class(tr_class) if tr_class
+          tr
+        end
+        tr_a.unshift( Ht.thead(child: Ht.tr(child: @header.map {|v| Ht.th(child: v) }) )) if @header
+        tb = Ht.table(child: tr_a)
+        tb.add_class(table_class) if table_class
+        tb
+      end
+    end
+  end
+end