under-os 1.3.0 → 1.4.0

data/lib/under_os/page/stylesheet.rb

@@ -1,67 +0,0 @@
-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

@@ -1,24 +0,0 @@
-#
-# 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

@@ -1,37 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

data/lib/under_os/point.rb

@@ -1,47 +0,0 @@
-#
-# Generic Point/Size unit
-#
-class UnderOs::Point
-
-  def initialize(x, y=nil)
-    if x.is_a?(UnderOs::Point)
-      y = x.y if x.y
-      x = x.x
-    elsif x.is_a?(Hash)
-      y = x[:y] || x['y'] || nil
-      x = x[:x] || x['x'] || nil
-    end
-
-    @x = x
-    @y = y
-  end
-
-  def x
-    @x
-  end
-
-  def y
-    @y
-  end
-
-  def ==(*args)
-    point = UnderOs::Point.new(*args) # normalizing
-    x == point.x && y == point.y
-  end
-
-  def *(multiplier)
-    self.class.new(x: @x * multiplier, y: @y * multiplier)
-  end
-
-  def /(divider)
-    self.class.new(x: @x / divider.to_f, y: @y / divider.to_f)
-  end
-
-  def to_s
-    "x=#{x} y=#{y}"
-  end
-
-  def inspect
-    "#<#{self.class.name}:0x#{__id__.to_s(16)} #{to_s}>"
-  end
-end

data/lib/under_os/screen.rb

@@ -1,9 +0,0 @@
-class UnderOs::Screen
-  def self.size
-    # TODO make it handle the screen orientation
-    UnderOs::Point.new({
-      x: UIScreen.mainScreen.bounds.size.width,
-      y: UIScreen.mainScreen.bounds.size.height
-    })
-  end
-end

data/lib/under_os/timer.rb

@@ -1,65 +0,0 @@
-class UnderOs::Timer
-  def self.in(duration, options={}, &block)
-    duration = Duration.new(duration) if duration.is_a?(Numeric)
-    new duration.to_f, options.merge(repeat: false), &block
-  end
-
-  def self.every(duration, options={}, &block)
-    duration = Duration.new(duration) if duration.is_a?(Numeric)
-    new duration.to_f, options.merge(repeat: true), &block
-  end
-
-  attr_reader :block, :counter, :interval, :repeats, :_
-
-  def initialize(seconds, options={}, &block)
-    @block    = block
-    @counter  = options[:repeat].to_i if options[:repeat].is_a?(Numeric)
-    @interval = seconds
-    @repeats  = options[:repeat] != false
-
-    @_ = NSTimer.scheduledTimerWithTimeInterval @interval,
-      target: self, selector: :kick, userInfo: nil, repeats: @repeats
-  end
-
-  def stop
-    @_.invalidate
-    self
-  end
-
-  def kick
-    @block.call
-    stop if @counter && (@counter -= 1) <= 0
-  end
-
-  class Duration
-    attr_reader :seconds
-
-    def initialize(seconds)
-      @seconds = seconds.to_f
-    end
-
-    def to_f
-      @seconds
-    end
-
-    def to_i
-      to_f.to_i
-    end
-
-    def to_s
-      "#{to_f} seconds"
-    end
-
-    def ==(duration)
-      duration.is_a?(UnderOs::Timer::Duration) && duration.seconds == @seconds
-    end
-
-    def later(options={}, &block)
-      UnderOs::Timer.in self, options={}, &block
-    end
-
-    def repeat(options={}, &block)
-      UnderOs::Timer.every self, options={}, &block
-    end
-  end
-end

data/lib/under_os/ui.rb

@@ -1,3 +0,0 @@
-module UnderOs::UI
-  # Just a namespace for UI things
-end

data/lib/under_os/ui/alert.rb

@@ -1,52 +0,0 @@
-class UnderOs::UI::Alert
-  include UnderOs::Events
-
-  def initialize(options={})
-    options = {message: options}  if options.is_a?(String)
-    self.on = options.delete[:on] if options[:on]
-
-    @_ = CustomAlertView.alloc.initiWithOptions(self, options)
-    @_.show unless options[:show] == false
-  end
-
-  def show
-    @_.show
-    self
-  end
-
-  def hide(animated=true)
-    @_.dismissWithClickedButtonIndex(0, animated: animated)
-    self
-  end
-
-  def visible
-    @_.visible
-  end
-
-  def hidden
-    !visible
-  end
-
-  class CustomAlertView < UIAlertView
-    def initiWithOptions(wrapper, options)
-      @wrapper = wrapper
-
-      initWithTitle(     options[:title]   || "",
-                message: options[:message] || "No message given",
-               delegate: self,
-      cancelButtonTitle: options[:button]  || "Ok",
-      otherButtonTitles: nil )
-
-      (options[:buttons] || []).each do |title|
-        addButtonWithTitle title
-      end
-
-      self
-    end
-
-    def alertView(alertView, willDismissWithButtonIndex:buttonIndex)
-      @wrapper.emit(:tap, buttonIndex: buttonIndex, buttonTitle: buttonTitleAtIndex(buttonIndex))
-      @wrapper.emit(:close)
-    end
-  end
-end

data/lib/under_os/ui/button.rb

@@ -1,42 +0,0 @@
-class UnderOS::UI::Button < UnderOS::UI::View
-  wraps UIButton, tag: 'button'
-
-  def initialize(options={})
-    super
-
-    self.text = options.delete(:text) || ''
-    self.disable if options[:disabled]
-
-    @_.showsTouchWhenHighlighted = true
-    @_.setBackgroundImage(options.delete(:image), forState:UIControlStateNormal) if options[:image]
-    @_.sizeToFit
-  end
-
-  def text
-    @_.currentTitle
-  end
-
-  def text=(new_text, state=UIControlStateNormal)
-    @_.setTitle new_text, forState:state
-    repaint
-  end
-
-  def disabled
-    ! @_.isEnabled
-  end
-
-  alias :disabled? :disabled
-
-  def disabled=(value)
-    @_.enabled = ! value
-  end
-
-  def disable
-    self.disabled = true
-  end
-
-  def enable
-    self.disabled = false
-  end
-
-end