ezframe 0.0.1

data/lib/ezframe/column_type.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Ezframe
+  class TypeBase
+    attr_accessor :attribute, :parent
+    attr_writer :value
+
+    def self.get_class(key)
+      return nil unless key
+      upper = Object.const_get("Ezframe")
+      key_camel = "#{key}_type".to_camel
+      # puts "get_class: #{key_camel}"
+      # puts "const_get: #{upper.const_get(key_camel).inspect}"
+      if upper.const_defined?(key_camel)
+        return upper.const_get(key_camel)
+      end
+      return nil
+    end
+
+    def self.type_name
+      if /::(\w*)Type/ =~ to_s
+        return $1.to_s.to_snake
+      end
+      to_s.to_snake
+    end
+
+    def initialize(attr = nil)
+      @attribute = attr if attr
+    end
+
+    def key
+      @attribute[:key]  
+    end  
+    
+    def label
+      return nil if @attribute[:hidden]
+      @attribute[:label]
+    end
+
+    def value(_situation = nil)
+      @value
+    end
+
+    def view
+      @value
+    end
+
+    def db_type
+      nil
+    end
+
+    def db_value
+      value
+    end
+
+    def form
+      nil
+    end
+  end
+
+  class StringType < TypeBase
+    def normalize
+      @value.gsub!(/　/, ' ')
+    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 }
+    end
+
+    def db_type
+      "string"
+    end
+  end
+
+  class IntType < StringType
+    def view
+      return nil if @attribute[:hidden]
+      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 }
+    end
+
+    def db_type
+      "int"
+    end
+  end
+
+  class ForeignType < IntType
+    def view
+      dataset = @parent.db.dataset[self.type.inner]
+      data = dataset.get(id: @value)
+      data[@attribute[:view]]
+    end
+  end
+  
+  class IdType < IntType
+    def label
+      return nil if @attribute[:hidden] && !@attribute[:force]
+      "ID"
+    end
+  end
+
+  class PasswordType < StringType
+    def form
+      { tag: "input", type: "password", label: @attribute[:label], value: @value}
+    end
+
+    def db_value
+      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 }
+    end
+
+    def db_type
+      "string"
+    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] }
+    end
+
+    def db_type
+      "int"
+    end
+  end
+
+  class DateType < StringType
+    def form
+      h = super
+      h[:type] = 'date' if h
+      h
+    end
+
+    def db_type
+      "datetime"
+    end
+  end
+  
+  class EmailType < StringType
+    def form
+      h = super
+      h[:type] = 'email' if h
+      h
+    end
+  end
+
+  class TelephoneType < StringType
+    def form
+      h = super
+      h[:type] = 'tel' if h
+      h
+    end
+  end
+
+  class JpnameType < StringType
+  end
+
+  class JpnameKanaType < StringType
+    def set(val)
+      val = val.tr('ァ-ン', 'ぁ-ん')
+      super(val)
+    end
+
+    def validation
+      unless /^[ぁ-ん ]+$/ =~ @value
+        'ひらがなのみで入力してください。'
+      end
+    end
+  end
+
+  # 
+  class PrefectureType < SelectType
+    def initialize(attr)
+      super(attr)
+      @pref_a = %w[選択してください 北海道 青森県 岩手県 宮城県 秋田県 山形県 福島県
+                   茨城県 栃木県 群馬県 埼玉県 千葉県 東京都 神奈川県
+                   新潟県 富山県 石川県 福井県 山梨県 長野県 岐阜県 静岡県 愛知県
+                   三重県 滋賀県 京都府 大阪府 兵庫県 奈良県 和歌山県
+                   鳥取県 島根県 岡山県 広島県 山口県
+                   徳島県 香川県 愛媛県 高知県
+                   福岡県 佐賀県 長崎県 熊本県 大分県 宮崎県 鹿児島県 沖縄県]
+      @pref_h = {}
+      @pref_a.each_with_index { |p, i| @pref_h[i] = p }
+    end
+
+    def form
+      h = super
+      h[:items] = @pref_h
+      h
+    end
+
+    def view
+      @pref_h[@value.to_i]
+    end
+  end
+
+  # Japanese Zipcode type column
+  class ZipcodeType < StringType
+    def view
+      return "" unless @value
+      @value.to_s.gsub(/(\d{3})(\d{4})/) { "#{$1}-#{$2}" }
+    end
+
+    def db_type
+      "string"
+    end
+  end
+end

data/lib/ezframe/config.rb

@@ -0,0 +1,33 @@
+module Ezframe
+  class Config
+    class << self
+      attr_accessor :value_h
+
+      def load_files(dir)
+        Dir["#{dir}/*.yml"].each do |file|
+          load_one_file(file)
+        end
+      end
+
+      def load_one_file(filename)
+        begin
+          yaml = YAML.load_file(filename)
+        rescue
+          mylog("YAML load error: #{filename}")
+          return 
+        end
+        @value_h ||={}
+        @value_h.update(yaml.recursively_symbolize_keys) if yaml.length>0
+      end
+
+      def [](k)
+        @value_h[k] if @value_h
+      end
+
+      def []=(k, v)
+        @value_h||={}
+        @value_h[k]=v
+      end
+    end
+  end
+end

data/lib/ezframe/controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Ezframe
+  class Boot
+    class << self
+      def exec(request, response)
+        @request = request
+        Config.load_files("./config")
+        Model.init
+        model = Model.get_clone
+        Auth.init_warden
+        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}"
+        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
+        # request.env["rack.session"]["kamatest"]="usable"
+        mylog "method: #{klass}.#{method_full_name}"
+        mylog "rack.session.id=#{request.env['rack.session'].id}"
+        mylog "rack.session.keys=#{request.env['rack.session'].keys}"
+        body = if page.respond_to?(method_full_name)
+                    page.send(method_full_name)
+                  else
+                    mylog "no such method: #{method_full_name}"
+                    page.public_default_page
+                  end
+        if body.is_a?(Hash) || body.is_a?(Array)
+          response.body = [ JSON.generate(body) ]
+          response['Content-Type'] = 'application/json; charset=utf-8'
+        else
+          response.body = [ body ]
+          response['Content-Type'] = 'text/html; charset=utf-8'
+        end
+        response.status = 200
+      end
+
+
+      def file_not_found(response)
+        response.body = ['path not found']
+        response.status = 404
+      end
+
+      def warden
+        @request.env["warden"]
+      end
+
+      def login?
+        !!warden.user
+      end
+
+      def user
+        warden.user
+      end
+    end
+  end
+end

data/lib/ezframe/database.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require "logger"
+
+module Ezframe
+  class Database
+    attr_accessor :sequel
+
+    def initialize(dbfile = "db/devel.sqlite")
+      @dbfile = dbfile
+      connect
+    end  
+
+    def connect
+      @sequel = Sequel.connect("sqlite://#{@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
+      @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
+    
+    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
+end

data/lib/ezframe/hthash.rb

@@ -0,0 +1,116 @@
+module Ezframe
+  module Ht
+    class << self
+      def wrap_tag(opts = {})
+        h = opts.dup
+        raise "Ht.wrap_tag: value must be a hash: #{h}" unless h.is_a?(Hash)
+        h[:tag] = __callee__.to_s
+        h
+      end
+
+      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 :button, :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 :icon, :wrap_tag
+      alias_method :checkbox, :wrap_tag
+      alias_method :radio, :wrap_tag
+
+      def multi_wrap(class_a, child)
+        class_a.reverse.each do |klass|
+          child = Ht.div(class: klass, child: child)
+        end
+        return child
+      end
+    end
+
+    class List
+      attr_accessor :array
+
+      def initialize(tag: "ul", array: [])
+        @tag = tag
+        @array = array.dup
+      end
+
+      def to_hash
+        return nil if @list.nil? || @list.empty?
+        child = @array.map do |elem|
+          { tag: "li", child: elem }
+        end
+        { tag: @tag, child: child }
+      end
+    end
+
+    class Ul < List
+      def initialize(array: [])
+        super(tag: "ul", array: array)
+      end
+    end
+
+    class Ol < List
+      def initialize(array: [])
+        super(tag: "ol", array: array)
+      end
+    end
+
+    class Table
+      attr_accessor :class_a, :header
+
+      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_hash
+        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 { |v| Ht.td(class: td_class, child: v) }
+          td_a[0].update(add_attr) if add_attr
+          Ht.tr(class: tr_class, child: td_a)
+        end
+        tr_a.unshift( Ht.thead(child: Ht.tr(child: @header.map {|v| Ht.th(child: v) }) )) if @header
+        Ht.table(class: table_class, child: tr_a)
+      end
+    end
+  end
+end