under-os-ui 1.4.0

data/lib/under_os/page/builder.rb

@@ -0,0 +1,96 @@
+class UnderOs::Page::Builder
+
+  def self.views_from(source)
+    @inst ||= new
+    if source.is_a?(String)
+      @inst.from_html(source)
+    else
+      @inst.from_nodes(source)
+    end
+  end
+
+  def from_html(source)
+    @html ||= UnderOs::Parser::HTML.new
+    from_nodes @html.parse(source)
+  end
+
+  def from_nodes(list)
+    list.map do |node|
+      build_view_from(node)
+    end
+  end
+
+  def build_view_from(node)
+    klass   = class_for(node)
+    options = options_from_attrs(node[:attrs] || {})
+
+    if klass.instance_methods.include?(:text) && node[:text]
+      options[:text] = node[:text]
+    end
+
+    klass.new(options).tap do |view|
+      if node[:children] && node[:children].any?
+        build_children_for(view, node[:children])
+      end
+    end
+  end
+
+  def class_for(node)
+    if node[:attrs] && node[:attrs][:wrapper].is_a?(String)
+      node[:attrs].delete(:wrapper).constantize
+    else
+      UnderOs::UI::Wrap::WRAPS_TAGS_MAP[node[:tag]] || UnderOs::UI::View
+    end
+  end
+
+  def options_from_attrs(hash)
+    {}.tap do |options|
+      hash.each do |key, value|
+        options[key] = value
+      end
+    end
+  end
+
+  def build_children_for(view, nodes)
+    if view.is_a?(UnderOs::UI::Select)
+      view.optgroups = select_optgroups_from(nodes)
+    elsif view.is_a?(UnderOs::UI::Collection)
+      find_collection_items_for(view, nodes)
+    else
+      from_nodes(nodes).each do |child|
+        view.insert child
+      end
+    end
+  end
+
+  def select_optgroups_from(nodes)
+    nodes = [{tag: 'optgroup', children: nodes}] if nodes[0][:tag] == 'option'
+
+    nodes.map do |group|
+      {}.tap do |options|
+        group[:children].each do |option|
+          if option[:tag] == 'option'
+            label = option[:text]
+            value = option[:attrs][:value] || label
+
+            options[value] = label if value && label
+          end
+        end
+      end
+    end
+  end
+
+  def find_collection_items_for(collection, nodes)
+    nodes.each do |node|
+      klass = class_for(node)
+
+      if klass <= UnderOs::UI::Collection::Item
+        klass.build(collection) { from_nodes(node[:children]) }
+      end
+
+      # header
+      # footer
+    end
+  end
+
+end

data/lib/under_os/page/layout.rb

@@ -0,0 +1,43 @@
+class UnderOs::Page::Layout
+
+  def initialize(page)
+    @page = page
+
+    build_layout_from_xib || build_layout_from_html || build_layout_from_nothing
+
+    @page.view = UnderOs::UI::View.new(@page._.view)
+    @page.view.instance_variable_set('@_tag_name', 'PAGE')
+  end
+
+  def build_layout_from_xib
+    if filename = find_layout_with_type('xib')
+      @page._.view = NSBundle.mainBundle.loadNibNamed(filename.sub(/\.xib$/, ''), owner:self, options:nil)[0]
+    end
+  end
+
+  def build_layout_from_html
+    if filename = find_layout_with_type('html')
+      if layout = UnderOs::Parser.parse(filename)
+        if view = UnderOs::Page::Builder.views_from(layout)[0]
+          @page._.view = view._
+          @page.title  = layout[0][:attrs][:title] || ''
+        end
+      end
+    end
+  end
+
+  def build_layout_from_nothing
+    @page._.view = UIView.alloc.init
+    @page._.view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight
+  end
+
+  def find_layout_with_type(ext)
+    filename = @page.class.layout || "#{@page.name}.#{ext}"
+    filename, type = filename.match(/^(.+?)\.([a-z]+)$/).to_a.slice(1,2)
+
+    if type == ext && NSBundle.mainBundle.pathForResource(filename, ofType:type)
+      "#{filename}.#{type}"
+    end
+  end
+
+end

data/lib/under_os/page/matcher.rb

@@ -0,0 +1,128 @@
+class UnderOs::Page::StylesMatcher
+
+  def self.new(css_rule)
+    @cache           ||= {}
+    @cache[css_rule] ||= super
+  end
+
+  def initialize(css_rule)
+    css_rules = css_rule.strip.split(/\s*,\s*/)
+
+    if css_rules.size == 1
+      rules    = css_rules[0].scan(/([\S]+)/).map(&:first)
+      @rule    = parse(rules.pop)
+      @parent  = rules.size == 0 ? false : self.class.new(rules.join(' '))
+    else
+      @multiple_matchers = css_rules.map{ |rule| self.class.new(rule) }
+    end
+  end
+
+  def match(view)
+    score_for(view) != 0
+  end
+
+  def score_for(view)
+    return summary_score_for(view) if @multiple_matchers
+
+    id_score    = id_score_for(view)
+    tag_score   = tag_score_for(view)
+    class_score = class_score_for(view)
+    attrs_score = attrs_score_for(view)
+    total_score = id_score + tag_score + class_score + attrs_score
+
+    total_score = 0 if id_score    == 0 && @rule[:id]
+    total_score = 0 if tag_score   == 0 && @rule[:tag]
+    total_score = 0 if class_score == 0 && @rule[:classes].size != 0
+    total_score = 0 if attrs_score == 0 && @rule[:attrs].size != 0
+
+    if @parent && total_score != 0
+      parent_score = parent_score_for(view)
+      total_score  = parent_score == 0 ? 0 : total_score + parent_score
+    end
+
+    total_score
+  end
+
+private
+
+  def summary_score_for(view)
+    @multiple_matchers.map{ |matcher| matcher.score_for(view) }.max
+  end
+
+  def id_score_for(view)
+    @rule[:id] == view.id ? 1 : 0
+  end
+
+  def tag_score_for(view)
+    @rule[:tag] == '*' || @rule[:tag] == view.tagName ? 1 : 0
+  end
+
+  def class_score_for(view)
+    return 0 if @rule[:classes].size == 0
+    match = @rule[:classes] & view.classNames
+    match.size == @rule[:classes].size ? match.size : 0
+  end
+
+  def attrs_score_for(view)
+    score = 0; return 0 if @rule[:attrs].size == 0
+
+    @rule[:attrs].each do |key, value, operand|
+      attr = view.respond_to?(key) && view.__send__(key)
+      attr = attr.to_s if attr.is_a?(Symbol) || attr.is_a?(Numeric)
+
+      if attr && attr.is_a?(String)
+        matches = case operand
+        when '='  then attr == value
+        when '*=' then attr.include?(value)
+        when '^=' then attr.starts_with?(value)
+        when '$=' then attr.ends_with?(value)
+        when '~=' then attr.split(' ').include?(value)
+        when '|=' then attr.split('-').include?(value)
+        end
+
+        score += 1 if matches
+      end
+    end
+
+    score
+  end
+
+  def parent_score_for(view)
+    parent = view; score = 0
+
+    while parent = parent.parent
+      score = @parent.score_for(parent)
+      break if score > 0
+    end
+
+    score
+  end
+
+  def parse(string)
+    {}.tap do |rule|
+      if m = string.match(/^([a-z\*]+)/)
+        rule[:tag] = m[1].upcase
+      else
+        rule[:tag] = false # so it wouldn't match nil
+      end
+
+      if m = string.match(/#([a-z_\-0-9]+)/)
+        rule[:id] = m[1]
+      else
+        rule[:id] = false # so it wouldn't match nil
+      end
+
+      if m = string.scan(/(\.)([a-z_\-0-9]+)/)
+        rule[:classes] = m.map{|c| c[1]}
+      else
+        rule[:classes] = []
+      end
+
+      if m = string.scan(/\[\s*([a-z]+)\s*([*^$~|]{0,1}=)\s*('|")?(.+?)(\3)?\s*\]/)
+        rule[:attrs] = m.map{|c| [c[0], c[3], c[1]] }
+      else
+        rule[:attrs] = []
+      end
+    end
+  end
+end

data/lib/under_os/page/stylesheet.rb

@@ -0,0 +1,67 @@
+class UnderOs::Page::Stylesheet
+  attr_reader :rules
+
+  def initialize(styles={})
+    @rules = {}
+
+    styles.each do |rule, style|
+      self[rule] = style
+    end
+  end
+
+  def styles_for(view)
+    {}.tap do |styles|
+      weighted_styles_for(view).each do |hash|
+        hash.each do |key, value|
+          styles[key] = value
+        end
+      end
+    end
+  end
+
+  def [](rule)
+    @rules[rule.to_s]
+  end
+
+  def []=(rule, values)
+    @rules[rule.to_s] ||= {}
+    @rules[rule.to_s].merge! values
+  end
+
+  def <<(another_stylesheet)
+    another_stylesheet.rules.each do |rule, styles|
+      self[rule] = styles
+    end
+  end
+
+  def +(another_stylesheet)
+    self.class.new.tap do |combined_sheet|
+      combined_sheet << self
+      combined_sheet << another_stylesheet
+    end
+  end
+
+  def load(filename)
+    UnderOs::Parser.parse(filename).each do |rule, styles|
+      self[rule] = styles
+    end
+  end
+
+private
+
+  def weighted_styles_for(view)
+    find_styles_for(view).
+      sort{|a,b| a[:score] <=> b[:score]}.
+      map{|e| e[:style]}
+  end
+
+  def find_styles_for(view)
+    [].tap do |styles|
+      @rules.each do |css, rule|
+        score = UnderOs::Page::StylesMatcher.new(css).score_for(view)
+        styles << {score: score, style: rule} if score != 0
+      end
+    end
+  end
+
+end

data/lib/under_os/parser.rb

@@ -0,0 +1,24 @@
+#
+# Generic templates/stylesheets parsing engine
+#
+class UnderOs::Parser
+  def self.parse(*args)
+    @inst ||= new
+    @inst.parse *args
+  end
+
+  def initialize
+    @css  = CSS.new
+    @html = HTML.new
+  end
+
+  def parse(filename)
+    filepath = NSBundle.mainBundle.pathForResource(filename, ofType:nil)
+    content  = filepath ? UnderOs::File.read(filepath) : ''
+
+    case filename.split('.').pop
+    when 'css'  then @css.parse(content)
+    when 'html' then @html.parse(content)
+    end
+  end
+end

data/lib/under_os/parser/css.rb

@@ -0,0 +1,37 @@
+class UnderOs::Parser::CSS
+  def parse(style)
+    style = style.gsub(/\/\*[\s\S]+?\*\//, '').strip
+
+    {}.tap do |result|
+      style.scan(/(\A|\})([a-z0-9_\*\-\.\s#:,]+)\{([^}]+)/).map do |rule|
+        values = parse_styles(rule[2])
+
+        rule[1].split(',').each do |css_rule|
+          result[css_rule.gsub(/\s+/, ' ').strip] = values
+        end
+      end
+    end
+  end
+
+  def parse_styles(styles)
+    {}.tap do |hash|
+      styles.scan(/([a-z\-]+)\s*:\s*([^;]+)\s*/).each do |param|
+        hash.merge! normalized_values(param[0], param[1])
+      end
+    end
+  end
+
+  def normalized_values(key, value)
+    key   = key.camelize.to_sym
+    value = value.strip.gsub(/px$/, '')
+    value = value.gsub(/^('|")(.*?)\1$/, '\2')
+    value = value.to_f if value =~ /^[\-\d\.]+$/
+
+    if key == :background && value =~ /^[\S]+$/
+      key = :backgroundColor
+    end
+
+
+    {key => value}
+  end
+end

data/lib/under_os/parser/html.rb

@@ -0,0 +1,97 @@
+class UnderOs::Parser::HTML
+  def parse(html)
+    html = html.strip.gsub(/<\!--[\s\S]*?-->/, '').gsub(/>\s+/, '>').gsub(/\s+</, '<')
+
+    [].tap do |top|
+      @top   = top
+      @stack = []
+      @node  = nil
+      i      = 0
+
+      while i < html.size
+        @chunk = html.slice(i, html.size)
+
+        i += open_tag || close_tag || plain_text
+      end
+
+      # closing all the missing tags
+      while node = @stack.shift
+        node.delete(:children)
+        node.delete(:text)
+        @top << node if ! @top.include?(node)
+      end
+    end
+  end
+
+  def open_tag
+    if m = @chunk.match(/\A<([a-z]+)([^>]*)>/)
+      @node = {tag: m[1], attrs: parse_attrs_in(m[2])}
+
+      if parent = @stack.last
+        parent[:children] ||= []
+        parent[:children] << @node
+        parent.delete(:text) # it can have either text or children
+      else
+        @top << @node
+      end
+
+      @stack << @node
+
+      m[0].size
+    end
+  end
+
+  def close_tag
+    if m = @chunk.match(/\A<\/([a-z]+)>/)
+      while node = @stack.pop
+        if node[:tag] != m[1]
+          if @stack.size > 0
+            @stack.last[:children] += node[:children] || []
+            node.delete(:children)
+            node.delete(:text)
+          end
+        else
+          break
+        end
+      end
+
+      @node = @stack.last
+
+      m[0].size
+    end
+  end
+
+  def plain_text
+    if m = @chunk.match(/\A([^<]+)/)
+      @stack.last[:text] = m[1] if @stack.last
+
+      m[0].size
+    end
+  end
+
+  def parse_attrs_in(string)
+    merge_data_attrs({}.tap do |hash|
+      string.scan(/([a-z][a-z_\-\d]+)=('|")(.+?)(\2)/).each do |match|
+        value = match[0] == match[2] ? true : match[2]
+        value = true  if value == 'true'
+        value = false if value == 'false'
+        hash[match[0].to_sym] = value
+      end
+    end)
+  end
+
+  def merge_data_attrs(hash)
+    hash.keys.each do |key|
+      if key.to_s.starts_with?('data-')
+        hash[:data] ||= {}
+
+        value = hash.delete(key)
+        key   = key.to_s.gsub(/^data\-/, '').camelize
+
+        hash[:data][key.to_sym] = value
+      end
+    end
+
+    hash
+  end
+end