dom-rb 0.1.1

data/csr/dom/table/caption.rb

@@ -0,0 +1,59 @@
+require 'dom/content'
+require 'dom/builder'
+require 'dom/util'
+require 'dom/debug'
+
+module CSR
+  module DOM
+    class Table
+      class Caption
+        include CSR::DOM::Builder
+        include CSR::DOM::Debug
+
+        attr_reader :table, :content
+
+        def initialize(table, content)
+          # self.debug_level = 1
+          @table = table
+          @content = content
+        end
+
+        def update
+          if @root
+            debug 1, ->{[ __FILE__, __LINE__,  __method__ ]}
+            animate do
+              @root.clear
+              @root << resolve_content
+            end
+          end
+        end
+
+        def root
+          debug 1, ->{[ __FILE__, __LINE__,  __method__ ]}
+          @root ||= tag(
+            :caption,
+            attributes: @table.caption_attributes,
+            content: resolve_content
+          )
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@root=#{@root}" ]}
+          @root
+        end
+
+        def resolve_content
+          result = case content
+            when Content
+              content.element(:caption, attributes: attributes, context: @table)
+            when Proc
+              content.call
+            else
+              content
+          end
+          # debug 1, ->{[ __FILE__, __LINE__,  __method__, "result=#{result}" ]}
+          result
+        end
+      end
+
+
+    end
+  end
+end

data/csr/dom/table/column.rb

@@ -0,0 +1,84 @@
+require 'dom/content'
+
+module CSR
+  module DOM
+    class Table
+      class Column
+
+        attr_reader :id             # unique in table, default to field
+
+        # Content procs with arity 2 should expect context to be [table, section, row]
+        # where table is a Table; section is :head, :body or :foot; row is an element in
+        # head_rows, body_rows or foot_rows.
+
+        attr_reader :head_content   # Content or String or nil.
+        attr_reader :body_content   # Content or String or nil.
+        attr_reader :foot_content   # Content or String or nil.
+
+        # OPTIONS:
+        # :id             # unique in table
+        # :sort           # column may be sorted : boolean or nil
+        # :hide           # column may be hidden : boolean or nil
+        # :master         # column used for grouping in accordion table
+        # :head_content   # Content or String or nil for column head
+        # :body_content   # Content or String or nil for column body
+        # :foot_content   # Content or String or nil for column foot
+
+        # TODO:
+        # width:
+
+        def initialize(**options)
+          @id = options[:id]
+          @sort_callback = options[:sort]
+          @hide = !!options[:hide]
+          @master = !!options[:master]
+          @head_content = options[:head_content]
+          @body_content = options[:body_content]
+          @foot_content = options[:foot_content]
+        end
+
+        def hash
+          @id.hash
+        end
+
+        def eql?(other)
+          @id == other.id
+        end
+
+        def ==(other)
+          @id == other.id
+        end
+
+        def master?
+          @master
+        end
+
+        def sort_callback
+          @sort_callback
+        end
+
+        def sort?
+          !!@sort_callback
+        end
+
+        def hide?
+          @hide
+        end
+
+        # section is :head, :body or :foot
+        def section_content(section)
+          send(:"#{section}_content")
+        end
+
+        # Returns a (probably) unique column id.
+        def self.unique_id
+          @@id_chars ||= ('0'..'9').to_a + ('A'..'F').to_a
+          result = 'COL_'
+          8.times { result = result + @@id_chars.sample }
+          result
+        end
+
+      end
+    end
+end
+end

data/csr/dom/table/row.rb

@@ -0,0 +1,118 @@
+require 'dom/table/column'
+require 'dom/builder'
+require 'dom/util'
+require 'dom/debug'
+
+module CSR
+  module DOM
+    class Table
+      class Row
+        include CSR::DOM::Builder
+        include CSR::DOM::Util
+        include CSR::DOM::Debug
+
+        attr_reader :table, :section, :index
+
+        def initialize(table, section, index)
+          # self.debug_level = 1
+          @table, @section, @index = table, section, index
+        end
+
+        def root
+          debug 1, ->{[ __FILE__, __LINE__, __method__, "@root=#{@root}" ]}
+          @root ||= tag(
+            :tr,
+            attributes: attributes,
+            content: cells
+          )
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@root=#{@root}" ]}
+          @root
+        end
+
+        def attributes
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@section_id=#{@section_id} @index=@{index}" ]}
+          result = section.row_attributes(@index)
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "result=#{result}" ]}
+          result
+        end
+
+        # columns may be indexes in table columns or Column's
+        def update(_columns = nil)
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "_columns=#{_columns}" ]}
+          if @root
+            animate do
+              if _columns
+                columns = _columns.map { |c| Integer === c ? @table.columns[c] : c }
+                debug 1, ->{[ __FILE__, __LINE__,  __method__, "columns=#{columns.map{|e|e.id}}" ]}
+                @table.visible_columns.each_with_index do |c, i|
+                  if columns.include?(c)
+                    debug 1, ->{[ __FILE__, __LINE__,  __method__, "updating column[#{i}] #{c.id}" ]}
+                    new_cell = cell(c)
+                    @cells[i].replace(new_cell)
+                    @cells[i] = new_cell
+                  end
+                end
+              else
+                debug 1, ->{[ __FILE__, __LINE__,  __method__, "updating all columns" ]}
+                @cells = nil
+                @root.clear
+                @root << cells
+              end
+            end
+          end
+        end
+
+        # Returns array of cell elements in table's visible column order
+        def cells
+          unless @cells
+            @cells = @table.visible_columns.map do |column|
+              cell(column)
+            end
+          end
+          @cells
+        end
+
+        def head?
+          @section.head?
+        end
+        
+        def row_source
+          @section.row_source(@index)
+        end
+
+        def cell(column)
+          attributes, content = cell_attributes_content(column)
+          tag(
+            head? ? :th : :td,
+            attributes: attributes,
+            content: content
+          )
+        end
+
+        def cell_attributes_content(column)
+          content = column.section_content(@section.id)
+          attributes = nil
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "section.id=#{@section.id} row_index=#{@index} column.id=#{column.id} content=#{content}" ]}
+          if Content === content
+            content, attributes = content.value_and_attributes(context: row_source)
+            debug 1, ->{[ __FILE__, __LINE__,  __method__, "section.id=#{@section.id} row_index=#{@index} column.id=#{column.id} content=#{content} attributes=#{attributes}" ]}
+          end
+          if head? && column.sort?
+            debug 1, ->{[ __FILE__, __LINE__,  __method__, "section.id=#{@section.id} row_index=#{@index} column.id=#{column.id} content=#{content}" ]}
+            content = div_with_sort_icon(
+              column.sort_callback,
+              direction: @table.sort_column_id == column.id ? @table.sort_order : 0,
+              content: content
+            )
+            debug 1, ->{[ __FILE__, __LINE__,  __method__, "section.id=#{@section.id} column.id=#{column.id} content=#{content}" ]}
+          end
+          attributes ||= {}
+          attributes[:id] ||= hex_id
+          [attributes, content]
+        end
+
+      end
+
+    end
+  end
+end

data/csr/dom/table/section.rb

@@ -0,0 +1,208 @@
+require 'dom/table/row'
+require 'dom/builder'
+require 'dom/util'
+require 'dom/debug'
+
+module CSR
+  module DOM
+    class Table
+      class Section
+        include CSR::DOM::Builder
+        include CSR::DOM::Util
+        include CSR::DOM::Debug
+
+        attr_reader :table, :id
+
+        def initialize(table, id)
+          # self.debug_level = 1
+          @table, @id = table, id
+        end
+
+        def head?
+          @id == :head
+        end
+
+        def foot?
+          @id == :foot
+        end
+
+        def body?
+          @id == :body
+        end
+
+        def update
+          if @root
+            animate do
+              # debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id} @root=#{@root}" ]}
+              @row_sources = @row_indexes = @rows = nil
+              @root.clear
+              @root << content
+            end
+          else
+              # debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id} @root=nil" ]}
+          end
+        end
+
+        def row_attributes(index)
+          # TODO: implement
+        end
+
+        # source should be source (unsorted) index or row source (model)
+        # columns may be column indexes or Column's
+        def update_row(source, _columns = nil)
+          debug 1, ->{[ __FILE__, __LINE__, __method__, "source=#{source} _columns=#{_columns} @rows.size=#{@rows ? @rows.size : 'nil'}" ]}
+          if @rows
+            columns = if _columns
+              _columns.map { |c| Integer === c ? @table.columns[c] : c }
+            end
+            debug 1, ->{[ __FILE__, __LINE__, __method__, "source=#{source} columns=#{columns}" ]}
+            if @id == :body && (columns.nil? || (@table.sort_column && columns.include?(@table.sort_column)))
+              debug 1, ->{[ __FILE__, __LINE__, __method__, "updating whole section" ]}
+              update
+            else
+              row_index = Integer === source ? source : source_index(source)
+              debug 1, ->{[ __FILE__, __LINE__, __method__, "calling @rows[#{row_index}].update(#{columns})" ]}
+              @rows[row_index].update(columns)
+            end
+          end
+        end
+
+        # source should be source (unsorted) index or row source (model)
+        # column may be visible column index or a Column
+        def update_cell(source, column)
+          update_row(source, [column])
+        end
+
+        def root
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id}" ]}
+          @root ||= tag(
+            "t#{@id}",
+            attributes: attributes,
+            content: content
+          )
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id} @root=#{@root}" ]}
+          @root
+        end
+
+        def empty?
+          row_sources.size == 0
+        end
+
+        def attributes
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id}" ]}
+          result = table.section_attributes(@id)
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id} result=#{result}" ]}
+          result
+        end
+
+        def content
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id}" ]}
+          result = rows.map { |row| row.root }
+          debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id} result=#{result}" ]}
+          result
+        end
+
+        # Returns array of Table::Row's (in table sort order)
+        def rows
+          unless @rows
+            # debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id}" ]}
+            @rows = []
+            row_indexes.each do |model_index|
+              @rows << Row.new(@table, self, model_index)
+            end
+              # debug 1, ->{[ __FILE__, __LINE__,  __method__, "@id=#{@id} @rows=#{@rows.map(&:index)}}" ]}
+          end
+          @rows
+        end
+
+        def row_source(index)
+          row_sources[index]
+        end
+
+        def source_index(source)
+          row_sources.index(source)
+        end
+
+        def row_sources
+          unless @row_sources
+            # debug 1, ->{[ __FILE__, __LINE__, __method__, "@id=#{@id}" ]}
+            source = @table.row_source(@id)
+            @row_sources = case source
+              when Fixnum
+                source.times.to_a
+              when Proc
+                source.call
+              when NilClass
+                []
+              else
+                source
+            end
+            # if body?
+            #   debug 1, ->{[ __FILE__, __LINE__, __method__, "@id=#{@id} @row_sources=#{@row_sources.map(&:code)}" ]}
+            # end
+          end
+          @row_sources
+        end
+
+        # Returns array of indexes to row models
+        # in sorted display order.
+        def row_indexes
+          unless @row_indexes
+            models = row_sources
+            @row_indexes = models.size.times.to_a
+            if @id == :body && @table.sorted?
+              order = @table.sort_order
+              sort_column = @table.sort_column
+              @row_indexes = @row_indexes.sort do |a, b|
+                val_a = sort_value(sort_column, models[a])
+                val_b = sort_value(sort_column, models[b])
+                # debug 2, ->{[__FILE__, __LINE__, __method__, "a=#{val_a} b=#{val_b} order=#{order}"]}
+                compare(val_a, val_b) * order
+              end
+            end
+          end
+          @row_indexes
+        end
+
+        # Returns the display index for an unsorted row index or row model
+        def row_display_index(row)
+          sources = row_sources
+          if Integer === row
+            return row_index.index(row)
+          else
+            row_indexes.each_with_index do |source_index, display_index|
+              if row == sources[source_index]
+                return display_index
+              end
+            end
+          end
+          nil
+        end
+
+        private
+
+        def sort_value(column, row_source)
+          content = column.section_content(@id)
+          result = if Content === content
+            content.sort_value(context: row_source)
+          else
+            content
+          end
+          result
+        end
+
+        def compare(a, b)
+          if a && b
+            a <=> b
+          elsif a
+            1
+          elsif b
+            -1
+          else
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/csr/dom/table.rb

@@ -0,0 +1 @@
+require 'dom/table/base'

data/csr/dom/util.rb

@@ -0,0 +1,86 @@
+require 'opal-browser'
+require 'browser/animation_frame'
+
+module CSR
+  module DOM
+    module Util
+      module_function
+
+      def set_interval(milliseconds, callback)
+        `setInterval(callback, milliseconds)`
+      end
+
+      def clear_interval(interval)
+        `clearInterval(interval)` if interval
+      end
+
+      def cursor(which, &block)
+        current = $document.body.style.cursor
+        $document.body.style.cursor = which
+        if block
+          yield
+          $document.body.style.cursor = current
+        end
+      end
+
+      def cursor_wait(&block)
+        cursor('wait', &block)
+      end
+
+      def cursor_auto(&block)
+        cursor('auto', &block)
+      end
+
+      def cursor_normal(&block)
+        cursor_auto(&block)
+      end
+
+      def animate(&block)
+        # Browser::AnimationFrame.new(window, &block)
+        animation_frame(&block)
+      end
+
+      # Returns a (probably) unique element id
+      # composed of hexadecimal digits.
+      def hex_id
+        @@hex_digits ||= ('0'..'9').to_a + ('A'..'F').to_a
+        result = ''
+        8.times { result = result + @@hex_digits.sample }
+        result
+      end
+
+      # make a single array from args
+      # args may be mix of non-enumerables and enumerables
+      # nils will not be included
+      def arrify(*args)
+        result = []
+        args.each do |arg|
+          if arg
+            if Enumerable === arg
+              arg.each do |e|
+                result << e if e
+              end
+            else
+              result << arg if arg
+            end
+          end
+        end
+        result
+      end
+
+      def normalize_style(style)
+        unless style.respond_to?(:to_h)
+          raise TypeError, "#{__FILE__}[#{__LINE__}] : style #{style.class} must respond to :to_h"
+        end
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "style=#{style}" ]}
+        result = {}
+        style.to_h.each do |k,v|
+          k = k.to_s.gsub('_', '-')
+          result[k] = v.to_s
+        end
+        debug 1, ->{[ __FILE__, __LINE__, __method__, "result=#{result}" ]}
+        result
+      end
+    end
+  end
+end

data/csr/dom.rb

@@ -0,0 +1,5 @@
+require 'dom/builder'
+require 'dom/factory'
+require 'dom/content'
+require 'dom/table'
+require 'dom/util'

data/lib/dom/version.rb

@@ -0,0 +1,5 @@
+module CSR
+  module DOM
+    VERSION = "0.1.1"
+  end
+end

data/lib/dom-rb.rb

@@ -0,0 +1,11 @@
+require 'opal'
+require 'paggio'
+require 'opal-browser'
+
+module CSR
+  module DOM
+    require_relative "dom/version"
+  end
+end
+
+Opal.append_path(File.expand_path(File.join("..", "..", "csr"), __FILE__).untaint)

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: dom-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Colin Gunn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal-browser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: DOM management in client-side Ruby.
+email:
+- colgunn@icloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- csr/dom.rb
+- csr/dom/browser_ext/node.rb
+- csr/dom/builder.rb
+- csr/dom/builder/base.rb
+- csr/dom/builder/binding.rb
+- csr/dom/builder/helpers.rb
+- csr/dom/content.rb
+- csr/dom/debug.rb
+- csr/dom/globals.rb
+- csr/dom/root.rb
+- csr/dom/table.rb
+- csr/dom/table/base.rb
+- csr/dom/table/caption.rb
+- csr/dom/table/column.rb
+- csr/dom/table/row.rb
+- csr/dom/table/section.rb
+- csr/dom/util.rb
+- lib/dom-rb.rb
+- lib/dom/version.rb
+homepage: https://github.com/balmoral/dom-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: DOM management in Ruby
+test_files: []
+has_rdoc: