dom-rb 0.1.1

data/csr/dom/content.rb

@@ -0,0 +1,269 @@
+require 'dom/builder'
+require 'dom/util'
+require 'dom/debug'
+
+module CSR
+  module DOM
+    class Content
+      include CSR::DOM::Builder
+      include CSR::DOM::Util
+      include CSR::DOM::Debug
+
+      # options
+      #
+      # :value       # object appropriate to type or proc(context) or proc(value) or proc(context, value)
+      # :sort_value  # object appropriate to type or proc(context) or proc(value) or proc(context, value)
+      # :type        # :container, :media, :string, :integer, :decimal, :bool, :count, :percent, :sign, :date
+      # :css         # string with valid css classes or proc(value) or proc(context, value)
+      # :style       # { } hash of styles per Clearwater or proc(value) or proc(context, value)
+      # :format      # string or proc(value) or proc(context, value) for :decimal, :percent, :date
+      # :comma       # boolean for numeric values (default true)
+      # :events      # { click: ->{ clicked }, ... } - hash or proc(value) or proc(context, value)
+      #              # event names per 'developer.mozilla.org/en-US/docs/Web/Events'
+
+      attr_reader :options, :type
+
+      def initialize(**options)
+        # self.debug_level = 1
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "options=#{options}" ]}
+        @options = options
+        @type = @options[:type] ||= :container
+        @options[:css] ||= ''
+        @options[:style] ||= {}
+        @options[:events] ||= {}
+        @is_numeric = [:integer, :decimal, :percent, :count].include?(@type)
+        @is_text = !(container? || media?)
+        @options[:comma] = true if @options[:comma].nil?
+        debug 1, ->{[ __FILE__, __LINE__, __method__ ]}
+        set_format_defaults
+        debug 1, ->{[ __FILE__, __LINE__, __method__ ]}
+        set_css_defaults
+        debug 1, ->{[ __FILE__, __LINE__, __method__ ]}
+        set_style_defaults
+        debug 1, ->{[ __FILE__, __LINE__, __method__ ]}
+      end
+
+      def container?
+        @type == :container
+      end
+
+      def media?
+        @type == :media
+      end
+
+      def text?
+        @is_text
+      end
+
+      def date?
+        @type == :date
+      end
+
+      def numeric?
+        @is_numeric
+      end
+
+      # Returns a DOM element.
+      # Context may be anything meaningful to procs.
+      def element(tag_name, attributes: {}, context: nil)
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "tag_name=#{tag_name} attributes=#{attributes} context=#{context}" ]}
+        result = tag(
+          tag_name,
+          attributes: ->{
+            attributes.merge.({
+              id:     id(context: context, value: value),
+              class:  css(context: context, value: value),
+              style:  style(context: context, value: value),
+            })
+          },
+          content: ->{
+            formatted_value(context: context)
+          },
+          model: self
+        )
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "result=#{result}" ]}
+        result
+      end
+
+      # Context may be anything meaningful to procs.
+      # Returned value will be formatted (if applicable).
+      def value_and_attributes(context: nil)
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "context=#{context}" ]}
+        value = formatted_value(context: context)
+        result = [
+          value,
+          {
+            class:  css(context: context, value: value),
+            style:  style(context: context, value: value),
+          }.merge(
+            events(context: context, value: value)
+          )
+        ]
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "context=#{context} result=#{result}" ]}
+        result
+      end
+
+      def sort_value(context: nil)
+        # debug 1, ->{[ __FILE__, __LINE__,  __method__, "context=#{context.class.name}" ]}
+        option(:sort_value, context: context)
+      end
+
+      def value(context: nil)
+        option(:value, context: context)
+      end
+
+      def css(context: nil, value: nil)
+        option(:css, context: context, value: value)
+      end
+
+      def id(context: nil, value: nil)
+        option(:id, context: context, value: value) || hex_id
+      end
+
+      def style(context: nil, value: nil)
+        option(:style, context: context, value: value)
+      end
+
+      def events(context: nil, value: nil)
+        result = {}
+        events = option(:events, context: context, value: value)
+        if events && events.size > 0
+          # debug 1, ->{[ __FILE__, __LINE__, __method__, "events=#{events}" ]}
+          events.each do |event, proc|
+            event = event[0,2] == 'on' ? event : :"on#{event}"
+            result[event] = ->(_) {
+              # debug 1, ->{[ __FILE__, __LINE__, __method__, "event=#{event} context=#{context} value=#{value}" ]}
+              resolve(proc, context: context, value: nil)
+            }
+          end
+        end
+        # debug 1, ->{[ __FILE__, __LINE__, __method__, "result=#{result}" unless result.empty? ]}
+        result
+      end
+
+      def formatted_value(context: nil)
+        v = value(context: context)
+        if v
+          if text?
+            format = format(context: context, value: v)
+            if numeric?
+              comma_numeric(format % v.to_f)
+            elsif date?
+              parse_date(v).strftime(value)
+            else
+              v.to_s
+            end
+          else
+            v
+          end
+        end
+      end
+
+      def format(context: nil, value: nil)
+        option(:format, context: context, value: value)
+      end
+
+      def option(name, context: nil, value: nil)
+        option = @options[name]
+        resolve(option, context: context, value: value)
+      end
+
+      def resolve(thing, context: nil, value: nil)
+        if Proc === thing
+          if thing.arity == 2
+            thing.call(context, value)
+          elsif thing.arity == 1
+            thing.call(value || context)
+          else
+            thing.call
+          end
+        else
+          thing
+        end
+      end
+
+      def comma_numeric(s)
+        @options[comma] ? s.comma_numeric : s
+      end
+
+      def parse_date(d)
+        self.class.parse_date(d)
+      end
+
+      def self.parse_date(d)
+        return d if d.is_a?(Date)
+        # csr Date.parse can't handle strings with named months
+        # nor can it parse YYYYMMDD without separators!
+        if RUBY_PLATFORM == 'csr'
+          t = Time.parse(d)
+          Date.new(t.year, t.month, t.day)
+        else
+          Date.parse(d)
+        end
+      end
+
+      private
+
+      def set_tag_defaults
+        @options[:tag] ||= 'div'
+      end
+
+      def set_style_defaults
+        if text? && options[:style].nil?
+          @options[:style] = case @options[:type]
+            when :integer, :decimal, :count, :percent
+              { text_align: 'right' }
+            else
+              { text_align: 'center' }
+          end
+        end
+      end
+
+      def set_css_defaults
+        # ?
+      end
+
+      def set_format_defaults
+        if text? && @options[:format].nil?
+          @options[:format] = case @options[:type]
+            when :decimal
+              ->(v) {
+                comma_numeric('%0.2f' % v)
+              }
+            when :integer, :count
+              ->(v) {
+                comma_numeric(v.to_i.to_s)
+              }
+            when :percent
+              ->(v) {
+                comma_numeric((v * 100).round(0).to_s)
+              }
+            when :sign
+              ->(v) {
+                if v == 0
+                  '0'
+                else
+                  v < 0 ? '-' : '+'
+                end
+              }
+            when :date
+              ->(v) {
+                v.strftime('%Y/%m/%d')
+              }
+            when :bool
+              ->(v) {
+                v ? 'T' : 'F'
+              }
+            else # :text, ...
+              ->(v) {
+                v.to_s
+              }
+          end
+        end
+      end
+
+    end
+
+  end
+end
+

data/csr/dom/debug.rb

@@ -0,0 +1,61 @@
+module CSR
+  module DOM
+    module Debug
+      module_function
+
+      def stack_trace
+        callback = ->(stackframes) {
+          %x(
+            var stringifiedStack = stackframes.map(function(sf) {
+              return sf.toString();
+            }).join('\n');
+            console.log(stringifiedStack);
+          )
+        }
+        errback = ->(err) {
+          `console.log(err.message)`
+        }
+        `StackTrace.get().then(callback).catch(errback)`
+      end
+
+      def debug_level=(l)
+        @debug_level = l
+      end
+
+      def debug_level
+        @debug_level ||= 0
+      end
+
+      def debug_method_missing=(v)
+        @debug_method_missing = v
+      end
+
+      def debug_method_missing?
+        !!@debug_method_missing
+      end
+
+      def method_missing(name, *args, &block)
+        if true # debug_method_missing?
+          debug 0, ->{[__FILE__, __LINE__, __method__, "METHOD_MISSING: self=#{self} method=#{name}"]}
+          # debug 0, ->{[__FILE__, __LINE__, __method__, "called by: #{caller.first.to_s}"]}
+          stack_trace
+        end
+        super
+      end
+
+      def debug(level, proc)
+        if level == 0 || level <= debug_level
+          file, line, method, msg = proc.call
+          s = "#{file}[#{line}] #{self.is_a?(Class) ? (self.name + '#') : self.class.name}##{method}"
+          s = s + " >> #{msg}" if msg
+          if RUBY_PLATFORM == 'opal'
+            `console.log(s)`
+          else
+            puts s
+          end
+        end
+      end
+
+    end
+  end
+end

data/csr/dom/globals.rb

@@ -0,0 +1,19 @@
+require 'opal-browser'
+
+module CSR
+  module DOM
+    module Globals
+
+      module_function
+
+      def document
+        $document
+      end
+
+      def window
+        $window
+      end
+
+    end
+  end
+end

data/csr/dom/root.rb

@@ -0,0 +1,37 @@
+require 'dom/globals'
+require 'dom/util'
+require 'dom/debug'
+
+module CSR
+  module DOM
+    module Root
+      include CSR::DOM::Globals
+      include CSR::DOM::Util
+      include CSR::DOM::Debug
+
+      module_function
+
+      # TODO: should this be here?
+      def dom_root
+        unless @dom_root
+          if respond_to? :first_element # or container, Volt methods
+            # debug 1, ->{[ __FILE__, __LINE__, __method__, "setting @dom_root to first_element=#{first_element}" ]}
+            self.dom_root = first_element
+          else
+            # in a separate model?
+            fail "#{self.class.name}##{__method__}:#{__LINE_} : dom_root= must be called first"
+          end
+        end
+        @dom_root
+      end
+
+      # TODO: should this be here?
+      def dom_root=(element)
+        # debug 1, ->{[ __FILE__, __LINE__, __method__, "element = #{element}" ]}
+        @dom_root = DOM(element)
+        # debug 1, ->{[ __FILE__, __LINE__, __method__, "element = #{element}" ]}
+      end
+
+    end
+  end
+end

data/csr/dom/table/base.rb

@@ -0,0 +1,300 @@
+require 'dom/table/caption'
+require 'dom/table/section'
+require 'dom/table/column'
+require 'dom/builder'
+require 'dom/util'
+require 'dom/debug'
+
+module CSR
+  module DOM
+    class Table
+      include CSR::DOM::Builder
+      include CSR::DOM::Util
+      include CSR::DOM::Debug
+
+      # TODO: other than bootstrap, ...
+      DEFAULT_CSS = 'table table-condensed table-bordered table-hover'
+      DEFAULT_STYLE = {}
+
+      # :id,                # dom id - optional
+      # :css,               # table css class string or nil
+      # :style,             # table style hash or nil
+      # :caption_content,   # string or ComponentSpec with tag => 'caption'
+      # :head_rows,         # Proc or array of objects or nil
+      # :body_rows,         # Proc or array of objects or nil
+      # :foot_rows,         # Proc or array of objects or nil
+      # :sort_column_id,    # default sort column or nil
+      # :sort_order,        # nil, 1 or -1
+      # :accordion,         # whether table has master column which can be collapsed
+      # :context,           # something meaningful to column content procs or nil
+      # :reactive           # is the table reactive, default false
+
+      attr_reader :id
+      attr_reader :sort_column_id, :sort_column, :sort_orders, :sort_order
+      attr_reader :accordion
+      attr_reader :css
+      attr_reader :style
+      attr_reader :caption_content
+      attr_reader :context
+      attr_reader :section_ids
+
+      def initialize(**options)
+        # self.debug_level = 1
+        debug 1, ->{[ __FILE__, __LINE__,  __method__, "options: #{options}" ]}
+        @id = options[:id] || hex_id
+        @rooted = false
+        init_sections(options)
+        @raw_columns = options[:columns]
+        @context = options[:context]
+        debug 1, ->{[ __FILE__, __LINE__,  __method__]}
+        init_caption(options)
+        debug 1, ->{[ __FILE__, __LINE__,  __method__]}
+        init_css_style(options)
+        debug 1, ->{[ __FILE__, __LINE__,  __method__]}
+        init_row_sources(options)
+        debug 1, ->{[ __FILE__, __LINE__,  __method__]}
+        init_visibility
+        debug 1, ->{[ __FILE__, __LINE__,  __method__]}
+        init_sorting(options)
+        debug 1, ->{[ __FILE__, __LINE__,  __method__]}
+        init_accordion(options)
+        debug 1, ->{[ __FILE__, __LINE__,  __method__]}
+      end
+
+      def columns
+        unless @columns
+          @columns = if Proc === @raw_columns
+            debug 1, ->{[ __FILE__, __LINE__,  __method__, "@raw_columns=#{@raw_columns}"]}
+            c = @raw_columns.call
+            debug 1, ->{[ __FILE__, __LINE__,  __method__, "@columns=#{@columns}"]}
+            c
+          else
+            @raw_columns
+          end
+        end
+        @columns
+      end
+
+      def rooted?
+        @rooted
+      end
+
+      def root
+        debug 1, ->{[ __FILE__, __LINE__, __method__ ]}
+        @root ||= tag(
+          :table,
+          attributes: attributes,
+          content: content
+        )
+        @rooted = true
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "@root=#{@root}" ]}
+        @root
+      end
+
+      def attributes
+        debug 1, ->{[ __FILE__, __LINE__, __method__ ]}
+        result = {
+          class: css,
+          style: style
+        }
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "result=#{result}" ]}
+        result
+      end
+
+      def content
+        debug 1, ->{[ __FILE__, __LINE__, __method__]}
+        content = arrify(caption, sections)
+        result = content.map {|e| e.root }
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "result=#{result}" ]}
+        result
+      end
+
+      def caption
+        debug 1, ->{[ __FILE__, __LINE__, __method__]}
+        @caption ||= caption_content ? CSR::DOM::Table::Caption.new(self, caption_content) : nil
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "@caption=#{@caption}" ]}
+        @caption
+      end
+
+      def sections
+        @sections ||= section_ids.map do |id|
+          debug 1, ->{[ __FILE__, __LINE__, __method__, "id=#{id}"]}
+          section = CSR::DOM::Table::Section.new(self, id)
+          debug 1, ->{[ __FILE__, __LINE__, __method__, "section=#{section}"]}
+          section
+        end.reject do |section|
+          section.empty?
+        end
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "@sections=#{@sections}"]}
+        @sections
+      end
+
+      def section(id)
+        @sections ? @sections.detect {|e| e.id == id} : nil
+      end
+
+      def visible_columns
+        @visible_columns ||= visible_column_indexes.map {|i| columns[i]}
+      end
+
+      def visible_column_indexes
+        @visible_column_indexes
+      end
+
+      def column_ids
+        columns.map(&:id)
+      end
+
+      def caption_attributes
+        # TODO:
+        nil
+      end
+
+      def cell_attributes(section_id)
+        # TODO:
+        nil
+      end
+
+      def section_attributes(section_id)
+        nil
+      end
+
+      def sorted?
+        !!@sort_column_id
+      end
+
+      # set or toggle the sort order to/of the given column
+      def sort!(sort_column_id)
+        update_sorting(sort_column_id)
+        update_sections
+      end
+
+      def row_source(section_id)
+        @row_sources[section_id]
+      end
+
+      def update
+        # debug 1, ->{[ __FILE__, __LINE__,  __method__ ]}
+        @root = nil
+        init_sorting
+        update_caption
+        update_sections
+      end
+
+      def update_caption
+        @caption.update if @caption
+      end
+
+      def update_sections(ids = nil)
+        ids = ids || section_ids
+        ids.each do |id|
+          # debug 1, ->{[ __FILE__, __LINE__,  __method__, "id=#{id} " ]}
+          update_section(id)
+        end
+      end
+
+      def update_section(id)
+        section = section(id)
+        if section
+          section.update
+        end
+      end
+
+      def update_head
+        update_section :head
+      end
+
+      def update_body
+        update_section :body
+      end
+
+      def update_foot
+        update_section :foot
+      end
+
+      # source should be source (unsorted) index or row source (model)
+      # columns may be visible column indexes or Column's
+      def update_row(section_id, source, columns = nil)
+        section = section(section_id)
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "section_id=#{section_id} source=#{source} columns=#{columns} section=#{section}" ]}
+        if section
+          section.update_row(source, columns)
+        end
+      end
+
+      # source should be source (unsorted) index or row source (model)
+      # column may be visible column index or a Column
+      def update_cell(section_id, source, column)
+        section = section(section_id)
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "section_id=#{section_id} source=#{source} column=#{column} section=#{section}" ]}
+        if section
+          section.update_cell(source, column)
+        end
+      end
+
+      private
+
+      def init_sections(options)
+        # TODO: from options
+        @section_ids = [:head, :body, :foot]
+      end
+
+
+      def init_row_sources(options)
+        @row_sources = {}
+        section_ids.each do |id|
+          @row_sources[id] = options[:"#{id}_rows"]
+        end
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "@row_sources=#{@row_sources}" ]}
+      end
+
+      def init_accordion(options)
+        @accordion = !!options[:accordion]
+      end
+
+      def init_css_style(options)
+        @css = options[:css] || DEFAULT_CSS
+        @style = options[:style] || DEFAULT_STYLE
+      end
+
+      def init_caption(options)
+        @caption_content = options[:caption]
+      end
+
+      def init_sorting(options = nil)
+        # debug 1, ->{[ __FILE__, __LINE__,  __method__ ]}
+        if options
+          @initial_sort_column_id = options[:sort_column_id]
+          @initial_sort_order = options[:sort_order]
+        end
+        @sort_column_id = sort_column_id unless
+        @sort_column = @sort_column_id ? columns.detect {|c| c.id == @sort_column_id} : columns.detect {|c| c.sort?}
+        @sort_column_id = @sort_column ? @sort_column.id : nil
+        @sort_order = @initial_sort_order || 1 unless @sort_order
+        @sort_orders = {}
+        if @sort_column_id
+          columns.each { |c| sort_orders[c.id] = c.id == sort_column_id ? @sort_order : 1 }
+        end
+        # debug 1, ->{[ __FILE__, __LINE__, __method__, "@sort_column_id=#{@sort_column_id}" ]}
+      end
+
+      def update_sorting(sort_column_id)
+        # debug 1, ->{[ __FILE__, __LINE__, __method__, "column_id=#{column_id}" ]}
+        if @sort_column_id == sort_column_id
+          sort_orders[@sort_column_id] *= -1
+        else
+          @sort_column_id = sort_column_id
+          @sort_column = columns.detect {|c| c.id == @sort_column_id}
+        end
+        @sort_order = sort_orders[@sort_column_id]
+      end
+
+      def init_visibility
+        @visible_column_indexes = columns.size.times.to_a
+      end
+
+    end
+
+  end # module DOM
+end # module CSR
+