spreadsheet_builder 0.0.1

data/lib/spreadsheet_builder/css_parser.rb

@@ -0,0 +1,163 @@
+module SpreadsheetBuilder
+  class CssParser
+
+    def self.px_from_input(val, base = :width)
+      case val
+      when /%$/
+        val.to_f / 100 * { width: 1024, height: 16 }[base]
+      when /px$/
+        val.to_f
+      when /cm$/
+        val.to_f * 37.795275591
+      when /em$/
+        val.to_f * 16
+      when /pt$/
+        val.to_f * 16 / 12
+      else 
+        nil
+      end
+    end
+
+    def self.pt_from_input(val, base = :width)
+      px_from_input(val, base) * 12 / 16
+    end
+
+    attr_reader :cache, :rules
+
+    def initialize
+      reset
+    end
+
+    def reset(level = :parser)
+      method = "reset_#{level}"
+
+      __send__(method)
+    end
+
+    def format_from_node(node)
+      format_from_klass_tree(klass_tree_from_node(node), node)
+    end
+
+    private
+    def accepted_keys
+      # TODO Keep these in a config
+      keys = %w{ color background-color font-size font-weight vertical-align text-align border border-width border-style border-color height width }
+      dirs = %w{ top bottom left right }
+      types = %w{ width style color }
+      dirs.each do |dir|
+        keys << "border-#{dir}"
+        types.each { |type| keys << "border-#{dir}-#{type}" }
+      end
+      keys
+    end
+
+    def klass_tree_from_node(base)
+      tree = (base.ancestors.reverse.drop(1) << base)
+      tree.map { |n, t| klass_node_from_node(n) }
+    end
+
+    def format_from_klass_tree(klass, node)
+      # klass is uniq to each node (because of first-child, nth-child, etc)
+      # so caching with the class is useless
+      # TODO find a better way to cache that works
+      if @cache[klass]
+        format = @cache[klass]
+      else
+        declarations = declarations_from_klass_tree(klass)
+        format = format_from_declarations(declarations, node)
+        @cache[klass] = format
+      end
+
+      format || {}
+    end
+
+    def klass_node_from_node(node)
+      name     = node.name
+      root     = node.ancestors.last
+      siblings = node.parent.element_children
+
+      index         = siblings.index(node) + 1
+      first_of_kind = root.css(name).first == node
+      last_of_kind  = root.css(name).last  == node
+
+      klasses = node.attributes["class"] && node.attributes["class"].value
+      klasses = klasses.to_s.split(/ /).map { |k| "." + k }
+      klasses << name
+      klasses << "#{name}:nth-child(#{index})"
+      klasses << "#{name}:nth-child(odd)"  if index.odd?
+      klasses << "#{name}:nth-child(even)" if index.even?
+      klasses << "#{name}:first-child)"    if index == 1
+      klasses << "#{name}:last-child)"     if index == siblings.length
+      klasses << "#{name}:first-of-kind)"  if first_of_kind
+      klasses << "#{name}:last-of-kind)"   if last_of_kind
+      klasses 
+    end
+
+    def find_rules(tree)
+      @rules.each_with_object(Hash.new {|h,k| h[k] = []}) do |rule,rules_found|
+        found = rule.find_selector(tree)
+        rules_found[found.length] << rule if found
+      end
+    end
+
+    def reset_none
+    end
+
+    def reset_rules(parser = @parser)
+      @rules = []
+      parser.each_rule_set(:all) { |r| 
+        @rules << SpreadsheetBuilder::CssRule.new(r) 
+      }
+      @rules.delete_if { |rule| 
+        rule.each_declaration do |key,_|
+          rule.remove_declaration!(key) unless accepted_keys.include?(key)
+        end
+        rule.declarations.empty?
+      }
+    end
+
+    def translate_declaration(key, val)
+      f = TRANSLATIONS[key].call(val) if key && val
+      f || {}
+    end
+
+    def format_from_declarations(declarations, node)
+      denied = Hash.new { |h,k| h[k] = [] }.merge(
+        "table" => %w{ width height },
+        "tr"    => %w{ width }
+      )
+      declarations.delete_if { |k,v| 
+        v.nil? || v.empty? || denied[node.name].include?(k) 
+      }
+
+      declarations.each_with_object({}) { |(k,v), format|
+        format.merge!(translate_declaration(k,v[:value]))
+      }
+    end
+
+    def declarations_from_klass_tree(klass)
+      rules = find_rules(klass).sort_by { |specificity,_| specificity }
+      declarations = rules.map { |_,rules| 
+        rules.inject({}) { |dec, r| dec.merge(r.declarations) }
+      }.inject({},&:merge)
+    end
+
+    def reset_cache
+      @cache = {}
+    end
+
+    def reset_parser
+      parser = CssParser::Parser.new
+      # TODO load these files from a config
+      parser.load_uri!("file://#{Dir.pwd}/test2.css")
+      # TODO or even better parse the html doc for spreadsheet links 
+      # and load those
+      #parser.load_uri!("file://#{Dir.pwd}/test2.css")
+
+      # Explicity reset rules to avoid infinite loop or bad data
+      reset_rules(parser)
+      reset_cache
+      @parser = parser
+    end
+  end
+end

data/lib/spreadsheet_builder/css_rule.rb

@@ -0,0 +1,42 @@
+module SpreadsheetBuilder
+  class CssRule
+    def initialize(rule)
+      @rule = rule
+    end
+
+    def declarations
+      @rule.instance_variable_get(:@declarations)
+    end
+
+    def selectors 
+      @rule.selectors.map { |s| 
+        s = s.split(/[\s>]/).map { |node| node.split('.') }
+        s.each do |node| 
+          n = node.length
+          node[1...n] = node[1...n].map { |k| '.' + k }
+          node.delete_if { |k| k.empty? || k == "." }
+        end 
+      }.sort_by(&:length)
+    end
+
+    def find_selector(tree) 
+      selectors.find { |s| 
+        next unless tree.last & s.last == s.last
+
+        s[0..-2].reverse.inject(tree.length - 2) do |i, s_node|
+          break false unless i
+          tree[0..i].index { |kt_node| kt_node & s_node == s_node }
+        end
+      }
+    end
+
+    private
+    def method_missing(method, *attrs, &block)
+      if @rule.respond_to?(method)
+        @rule.__send__(method, *attrs, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/spreadsheet_builder/data.rb

@@ -0,0 +1,31 @@
+module SpreadsheetBuilder
+  def self.from_data(data)
+    builder = Builder.new
+    [:merges, :row_heights, :col_widths].each do |d|
+      if data[d]
+        builder.instance_variable_get("@#{d}".to_sym).merge!(data[d])
+      end
+    end
+    if data[:sheets]
+      builder.instance_variable_set(:@sheets, data[:sheets])
+    end
+    if data[:cells]
+      data[:cells].group_by { |c| c[:sheet] }.each do |sheet, cells|
+        sheet ||= 0
+        if sheet.respond_to?(:to_str)
+          builder.set_sheet_by_name(sheet)
+        else
+          builder.set_sheet(sheet)
+        end
+        cells.each do |cell|
+          # row and col required
+          builder.set_cell_value(cell[:row], cell[:col], cell[:value])
+          if format = cell[:format]
+            builder.add_format_to_cell(cell[:row], cell[:col], format)
+          end
+        end
+      end
+    end
+    builder
+  end
+end

data/lib/spreadsheet_builder/html_parser.rb

@@ -0,0 +1,96 @@
+module SpreadsheetBuilder
+  class HtmlParser
+    def self.from_slim(file, options = {}, context = self, &block)
+      html = Slim::Template.new(file, options).render(context, &block)
+      new(html)
+    end
+
+    def self.from_erb(file)
+      html     = File.read(file)
+      template = ERB.new(html)
+      html     = template.result
+
+      new(html)
+    end
+
+    def initialize(html)
+      @html = html
+      @css  = SpreadsheetBuilder::CssParser.new
+    end
+
+    def build(force_level = :none)
+      SpreadsheetBuilder.from_data(to_data(force_level))
+    end
+
+    # TODO clean this up
+    def to_data(force_level = :none)
+      @css.reset(force_level)
+
+      # need to check for attributes colspan and row span
+      cells       = [] 
+      merges      = []
+      col_widths  = {}
+      row_heights = {}
+
+      doc = Nokogiri::HTML(@html)
+      tb  = doc.css('table').first 
+
+      # ignoring specified formats for anything other than table tr td/th
+      tb_format = @css.format_from_node(tb) 
+
+      doc.css('tr').each_with_index do |tr, row|
+        tr_format = tb_format.merge(@css.format_from_node(tr))
+
+        tr.css('td, th').each_with_index do |td, col|
+           
+          rowheight = td.attributes["rowheight"]
+          colwidth  = td.attributes["colwidth"]
+          rowspan   = td.attributes["rowspan"]
+          colspan   = td.attributes["colspan"]
+
+          rowheight &&= rowheight.value.to_i
+          colwidth  &&= colwidth.value.to_i
+          rowspan   &&= rowspan.value.to_i
+          colspan   &&= colspan.value.to_i
+
+          add_td_to_cells(row, col, td, tr_format, cells)
+          if colspan
+            (1..colspan-1).each {|t| 
+              add_td_to_cells(row, col+t, td, tr_format, cells)
+            }
+          end
+          if rowspan
+            (1..rowspan-1).each {|t| 
+              add_td_to_cells(row+t, col, td, tr_format, cells)
+            }
+          end
+          if colspan || rowspan
+            merges << [
+              row, col, row + (rowspan || 1)-1, col + (colspan || 1)-1
+            ]
+          end
+        end
+      end
+
+      { cells: cells, merges: { 0 => merges } }
+    end
+
+    private
+    # TODO Document
+    def add_td_to_cells(row, col, td, tr_format, cells)
+      found = cells.find { |cell| cell[:row] == row && cell[:col] == col}
+      unless found 
+        td_format = tr_format.merge(@css.format_from_node(td))
+        cells << { 
+          row: row, 
+          col: col, 
+          value: td.text.strip, 
+          format: td_format, 
+          path: td.css_path 
+        } 
+      else
+        add_td_to_cells(row, col + 1, td, tr_format, cells)
+      end
+    end
+  end
+end

data/lib/spreadsheet_builder/palette.rb

@@ -0,0 +1,32 @@
+module SpreadsheetBuilder
+  Rgb = Spreadsheet::Excel::Rgb
+
+  CUSTOM_PALETTE = {
+    :xls_color_0 => Rgb.new(0,0,0),
+    :xls_color_1 => Rgb.new(255,255,255),
+    :xls_color_2 => Rgb.new(204,204,204),
+    :xls_color_3 => Rgb.new(249,249,249)
+  }
+
+  PALETTE = Shade::Palette.new do |p| 
+    Rgb.class_variable_get(:@@RGB_MAP).merge(CUSTOM_PALETTE).each do 
+      |name, value|
+      p.add("##{value.to_i.to_s(16).ljust(6, "0")}", name.to_s)
+    end
+  end
+
+  module Palette
+    def self._color_from_input(input)
+      input = input.to_s
+      if input =~ /^rgb/i
+        _, r, g, b = input.match(/^rgba*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)[^\)]*/)
+        r, g, b = [r, g, b].map(&:to_i)
+        input = "##{Spreadsheet::Excel::Rgb.new(r, g, b).as_hex.ljust(6, "0")}"
+      end
+
+      # Assume a color is always found
+      color = PALETTE.nearest_value(input).name.to_sym
+      color
+    end
+  end
+end

data/lib/spreadsheet_builder/translations.rb

@@ -0,0 +1,37 @@
+module SpreadsheetBuilder
+  TRANSLATIONS = {}
+  TRANSLATIONS["text-align"] = Proc.new { |val| 
+    allowed = %w{ left center right justify }
+    { horizontal_align: val.to_sym } if allowed.include?(val)
+  }
+  TRANSLATIONS["vertical-align"] = Proc.new { |val|
+    allowed = %{ top middle bottom }
+    { vertical_align: val.to_sym } if allowed.include?(val)
+  }
+  TRANSLATIONS["color"] = Proc.new { |val| 
+    { color: Palette._color_from_input(val) }
+  }
+  TRANSLATIONS["background-color"] = Proc.new { |val| 
+    { pattern_fg_color: Palette._color_from_input(val), pattern: 1 }
+  }
+  TRANSLATIONS["font-size"] = Proc.new { |val| 
+    { size: SpreadsheetBuilder::CssParser.pt_from_input(val, :height) }
+  }
+  TRANSLATIONS["font-weight"] = Proc.new { |val| 
+    accepted = %{ bold normal }
+    if accepted.inlcude?(val)
+      { weight: val }
+    end
+  }
+  %w{ border border-top border-bottom border-left border-right border-width border-top-width border-bottom-width border-left-width border-right-width }.each do 
+    |key|
+    TRANSLATIONS[key] = Proc.new { |val| Border.new(key, val).format }
+  end
+  # TODO Prove these ratios
+  TRANSLATIONS["height"] = Proc.new { |val| 
+    { height: SpreadsheetBuilder::CssParser.pt_from_input(val) }  
+  }
+  TRANSLATIONS["width"] = Proc.new { |val| 
+    { width: SpreadsheetBuilder::CssParser.px_from_input(val)  / 7.5 }  
+  }
+end

data/spreadsheet_builder.gemspec

@@ -0,0 +1,24 @@
+current_dir = File.expand_path('..', __FILE__)
+#extensions = %w{ rb yml haml erb slim html js json jbuilder }
+#files = Dir.glob(current_dir + "/**/*.{#{extensions.join(',')}}")
+files = Dir.glob(current_dir + '/**/*')
+files.collect! {|file| file.sub(current_dir + '/', '')}
+files.push('LICENSE')
+
+Gem::Specification.new do |s|
+  s.name        = 'spreadsheet_builder'
+  s.version     = '0.0.1'
+	s.date        = "#{Time.now.strftime("%Y-%m-%d")}"
+	s.homepage    = 'https://github.com/jphager2/spreadsheet_builder'
+  s.summary     = 'build xls spreadsheets'
+  s.description = 'A nice extension for building xls spreadsheets'
+  s.authors     = ['jphager2']
+  s.email       = 'jphager2@gmail.com'
+  s.files       = files 
+  s.license     = 'MIT'
+
+  s.add_runtime_dependency 'nokogiri', '~> 1.6'
+  s.add_runtime_dependency 'spreadsheet', '~> 1.0'
+  s.add_runtime_dependency 'css_parser', '~> 1.3 '
+  s.add_runtime_dependency 'shade', '~> 0.0'
+end