ezframe 0.0.1

data/lib/ezframe/html.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ezframe
+  class Html
+    class << self
+      def convert(ht_h = {})
+        return "" if ht_h.nil? || ht_h.to_s.empty?
+        return ht_h.to_html if ht_h.respond_to?(:to_html)
+        return ht_h.to_s if ht_h.is_a?(String) || ht_h.is_a?(Symbol) || ht_h.is_a?(Integer) || ht_h.is_a?(Time)
+        return ht_h.map { |args| convert(args) }.join if ht_h.is_a?(Array)
+
+        tag = ht_h[:tag]
+        case tag
+        when "select"
+          return select(ht_h) if ht_h[:items]
+        when "icon"
+          tag = "i"
+        end
+        opt_s, child_s = join_attributes(ht_h)
+        if child_s.length.positive?
+          return "<#{tag} #{opt_s}>\n#{child_s}\n</#{tag}>\n"
+        end
+        "<#{tag} #{opt_s}/>"
+      end
+
+      def join_attributes(attrs)
+        child_s = ""
+        opt_a = attrs.map do |k, v|
+          case k
+          when :child
+            child_s = convert(v)
+            next
+          when :tag, :final
+            next
+          when :key
+            "name=\"#{v}\"" if attrs[:tag].to_sym == :input
+            next
+          else
+            if v.is_a?(Array)
+              "#{k}=\"#{v.join(" ")}\""
+            elsif v.nil?
+              nil
+            else
+              "#{k}=\"#{v}\""
+            end
+          end
+        end
+        [opt_a.compact.join(" "), child_s]
+      end
+
+      def select(ht_h = {})
+        attr = ht_h.clone
+        items = attr[:items]
+        if items.is_a?(Hash)
+          option_a = ht_h[:items].map do |k, v|
+            h = { tag: "option", value: k }
+            if v.is_a?(Array)
+              v, selected = v
+              h[:selected] = "selected" if selected
+            end
+            h[:child] = v
+            h
+          end
+        elsif items.is_a?(Array)
+          option_a = items.map do |v|
+            h = { tag: "option", value: v[0], child: v[1] }
+            if %w[selected default].include?(v[2])
+              h[:selected] = "selected"
+            end
+            h
+          end
+        else
+          warn "unknown items: #{ht_h.inspect}"
+        end
+        attr[:tag] = "select"
+        attr[:child] = option_a
+        attr[:name] = attr[:key]
+        attr[:final] = true
+        attr.delete(:items)
+        Html.convert(attr)
+      end
+    end
+  end
+end

data/lib/ezframe/materialize.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Ezframe
+  class Materialize
+    class << self
+      def into_html_header
+        str =<<~EOHEAD2
+          <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+          <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/css/materialize.min.css">
+          <script src="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/js/materialize.min.js"></script>
+        EOHEAD2
+
+        css_files = Dir["./asset/css/*.css"]||[]
+        css_a = css_files.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|
+          file.gsub!("./asset", "")
+          "<script src=\"#{file}\"></script>\n"
+        end
+        str+(css_a+js_a).join
+      end
+
+      def into_bottom_of_body
+        ""
+#        Dir["./asset/js"].each do ||
+#        <<~EOBOT
+#          <script src="/js/htmlgen.js"></script>
+#          <script src="/js/common.js"></script>
+#        EOBOT
+      end
+
+      def convert(ht_h)
+        return nil unless ht_h
+        return ht_h if (ht_h.kind_of?(Hash) && ht_h[:final])
+        new_h = ht_h.clone
+        if ht_h.kind_of?(Array)
+          new_h = ht_h.map { |v| convert(v) }
+        elsif ht_h.kind_of?(Hash)
+          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
+            return radio(ht_h)
+          when :icon
+            return icon(ht_h)
+          when :form
+            return new_h = form(ht_h)
+          when :table
+            new_h.add_class(%w[striped highlight])
+          end
+          new_h[:child] = convert(ht_h[:child]) if ht_h[:child]
+        end
+        return new_h
+      end
+
+      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")
+        new_h.update({ tag: "i", child: ht_h[:name] })
+        new_h.delete(:name)
+        return new_h
+      end
+
+      def form(ht_h)
+        new_h = ht_h.clone
+        new_h[:child] = convert(new_h[:child])
+        return new_h
+      end
+
+      def input(ht_h)
+        ht_h[:name] ||= ht_h[:key]
+        width_s = "s#{ht_h[:width_s] || 12}"
+        ht_h.delete(:witdth_s)
+        label = Ht.label(for: ht_h[:key], child: ht_h[:label], final: true )
+        cls = ["input-field", "col", width_s]
+        new_h = Ht.div(class: cls, child: [ht_h, label])
+        new_h = Ht.div(child: new_h, class: "row")
+        return new_h
+      end
+
+      def checkbox(ht_h)
+        ht_h[:tag] = "input"
+        ht_h[:type] = "checkbox"
+        Ht.label(child: [ht_h, { tag: "span", child: ht_h[:value] }])
+      end
+
+      def radio(ht_h)
+        ht_h[:tag] = "input"
+        ht_h[:type] = "radio"
+        Ht.label(child: [ht_h, { tag: "span", child: ht_h[:label] }])
+      end
+
+      def add_sibling(dest, elem)
+        if dest.is_a?(Array)
+          dest.push(elem)
+        else
+          [dest, elem]
+        end
+      end
+    end
+  end
+end

data/lib/ezframe/model.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module Ezframe
+  class Model
+    class << self
+
+      def init_column_sets
+        @base_column_sets = ColumnSets.new
+        @base_column_sets.load_files('./columns')
+      end  
+
+      def init_db
+        @base_db = Database.new
+      end
+
+      def init
+        unless @base_column_sets
+          init_column_sets
+          init_db
+        end
+      end
+
+      def get_clone
+        new(@base_column_sets.deep_dup, @base_db)
+      end
+    end
+
+    attr_accessor :column_sets, :db
+
+    def initialize(column_sets, db)
+      @column_sets, @db = column_sets, db
+      @column_sets.model = self
+      # @column_sets.each {|name, colset| colset.model = self }
+    end
+
+    def create_tables
+      @column_sets.tables.each do |table_name, column_set|
+        begin
+          create_one_table(table_name, column_set)
+        rescue => e
+          mylog("*** #{e.inspect}\n#{$@.inspect}")
+        end
+      end
+    end
+
+    def create_one_table(table_name, column_set)
+      col_h = column_set.get_hash(:db_type)
+      mylog "create_one_table: col_h=#{col_h.inspect}"
+      @db.create_table(table_name, col_h)
+    end  
+  end
+end

data/lib/ezframe/page_base.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+require_relative "util"
+
+module Ezframe
+  class PageBase
+    class << self
+      def get_class(keys)
+        keys = [keys] if keys.is_a?(String)
+        klass = (%w[Ezframe] + keys.map { |k| k.to_camel }).join("::")
+        if Object.const_defined?(klass)
+          return Object.const_get(klass)
+        end
+        return nil
+      end
+
+      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
+          klass = get_class(path_parts)
+          if klass
+            return [klass, default_method]
+          else
+            return [get_class(default_class), parth_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
+    end
+
+    attr_accessor :auth
+
+    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.x-session"]
+        if request.post?
+          parse_json_body
+          mylog "json=#{@json.inspect}"
+        end
+      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
+    end
+
+    def common_page(opts = {})
+      args = {
+        title: opts[:title],
+        body: opts[:body],
+        into_html_header: Materialize.into_html_header,
+        into_bottom_of_body: Materialize.into_bottom_of_body,
+      }
+      EzView::Template.fill_template("template/base.html", args)
+    end
+
+    def parse_json_body
+      body = @request.body.read
+      return {} if !body || body.length==0
+      begin
+        @json = JSON.parse(body)
+      rescue => e
+        mylog "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
+    end
+
+    def warden
+      @request.env["warden"]
+    end
+
+    def login?
+      !!warden.user
+    end
+
+    def user
+      warden.user
+    end
+  end
+end

data/lib/ezframe/page_kit.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ezframe
+  module PageKit
+    class IndexTable
+      def initialize(attr = {})
+        @attribute = attr
+      end
+
+      def make_table(row_a)
+        column_set = @attribute[:column_set]
+        table_a = row_a.map do |row_h|
+          column_set.values = row_h
+          id = column_set[:id].value
+          value_a = @attribute[:column_header].map do |key|
+            col = column_set[key]
+            checkbox_key = @attribute[:add_checkbox]
+            if checkbox_key && key == checkbox_key
+              text = add_checkbox(col)
+            else
+              text = col.view
+            end
+            deco = @attribute[:decorate_column]
+            if deco
+              text = deco.call(key, id, text) 
+              # mylog "deco: #{text}"
+            end
+            td = { tag: "td", child: text }
+            # td.update(@attribute[:onclick_rows].call(id, text)) if @attribute[:onclick_rows]
+            td
+          end
+          tr = { tag: "tr", child: value_a }
+          if @attribute[:onclick_rows]
+            tr[:id] = elem_id = "tr_#{id}"
+            # tr.update(@attribute[:onclick_rows].call(id))
+          end
+          tr
+        end
+        { tag: "table", child: [make_header, table_a] }
+      end
+
+      def add_checkbox(col)
+        { tag: "checkbox", name: "checkbox_#{col.key}_#{col.value}", value: col.value, label: col.view }
+      end
+
+      def make_header
+        column_set = @attribute[:column_set]
+        th_a = @attribute[:column_header].map do |key|
+          col = column_set[key]
+          if col
+            { tag: "th", child: col.label }
+          else
+            nil
+          end
+        end
+        if @attribute[:add_checkbox]
+        end
+        { tag: "tr", child: th_a }
+      end
+    end
+
+    class Tab
+      def self.base_hthash(link_list)
+        size = 12 / link_list.length
+        tabs = link_list.map do |link|
+          { tag: "li", class: ["tab", "s#{size}"], child: link }
+        end
+        ul = { tag: "ul", class: %w[tabs], child: tabs }
+        div = { tag: "div", class: %w[row s12], child: ul }
+        { tag: "div", class: %w[row], child: div }
+      end
+    end
+
+    class Card
+      def self.base_hthash(title: "", content: "")
+        multi_div([%w[row], %w[col s12], %w[card blue-grey darken-1], %w[card-content white-text]],
+                  [
+                  { tag: "span", class: %w[card-tite], child: title },
+                  { tag: "p", child: content },
+                ])
+      end
+    end
+  end
+end

data/lib/ezframe/pages.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+if File.exist?("pages/common.rb")
+  require "#{Dir.pwd}/pages/common.rb"
+end
+Dir["pages/*.rb"].each do |file|
+  require "#{Dir.pwd}/#{file}"
+end