under-os 0.0.0 → 1.0.0

data/lib/under_os/page.rb

@@ -0,0 +1,153 @@
+#
+# UOS::Page is kind of a wrap over an iOS controller
+# but instead of the controller, it presents more the
+# main (root) view of the controller in a sence you've
+# got for DOM documents in web
+#
+class UnderOs::Page
+  include UnderOs::Events
+  include UnderOs::UI
+
+  attr_reader :_, :stylesheet
+
+  def self.new(*args)
+    alloc.setup_wrap(*args)
+  end
+
+  def self.layout(name=nil)
+    name ? (@layout = name) : @layout
+  end
+
+  def initialize
+    # page building goes in here
+  end
+
+  def view
+    @_view
+  end
+
+  def view=(view)
+    @_view = view
+  end
+
+  %w[insert append prepend find first].each do |method|
+    define_method method do |*args|
+      @_view.__send__ method, *args
+    end
+  end
+
+  def alert(*args)
+    Alert.new(*args)
+  end
+
+  def history
+    UnderOs::App.history
+  end
+
+  def navbar
+    history.navbar
+  end
+
+  def title
+    @_.navigationItem.title
+  end
+
+  def title=(text)
+    @_.navigationItem.title = text
+  end
+
+  def name
+    self.class.name.underscore.sub(/_page$/, '')
+  end
+
+  def setup_wrap(*args)
+    @_ = UIViewControllerWrap.alloc.init(self, {
+      on_load_view:      Proc.new{ emit('init')      },
+      on_view_loaded:    Proc.new{ emit('load')      },
+      on_view_appear:    Proc.new{ emit('appear')    },
+      on_view_disappear: Proc.new{ emit('disappear') },
+      on_view_rerender:  Proc.new{ emit('rerender')  },
+      on_view_rotate:    Proc.new{ emit('rotate')    }
+    })
+
+    on 'init' do
+      build_layout
+      compile_styles
+    end
+
+    on 'load' do
+      repaint
+      initialize(*args)
+      repaint
+    end
+
+    on 'rotate' do
+      repaint
+    end
+
+    self
+  end
+
+  def build_layout
+    @_layout = Layout.new(self)
+  end
+
+  def compile_styles
+    @stylesheet = Stylesheet.new
+    @stylesheet << UnderOs::App.stylesheet
+    @stylesheet.load("#{name}.css")
+  end
+
+  def repaint
+    view.repaint(stylesheet)   if view
+    navbar.repaint(stylesheet) if navbar
+  end
+
+  #
+  # A simple wrap over UIViewController to intercept
+  # the iOS events
+  #
+  class UIViewControllerWrap < UIViewController
+    attr_reader :wrapper
+
+    def init(wrapper, options)
+      @wrapper = wrapper
+      @options = options
+      initWithNibName(nil, bundle: nil)
+    end
+
+    def loadView
+      super
+      @options[:on_load_view].call
+    end
+
+    def viewDidLoad
+      super
+      @options[:on_view_loaded].call
+    end
+
+    def viewDidAppear(animated)
+      super
+      @options[:on_view_appear].call
+    end
+
+    def viewDidDisappear(animated)
+      super
+      @options[:on_view_disappear].call
+    end
+
+    def viewWillLayoutSubviews
+      super
+      @options[:on_view_rerender].call
+    end
+
+    def didRotateFromInterfaceOrientation(orientation)
+      super
+      @options[:on_view_rotate].call
+    end
+
+    def prefersStatusBarHidden
+      !UnderOs::App.config.status_bar
+    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

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/point.rb

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

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

@@ -0,0 +1,65 @@
+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/alert.rb

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

@@ -0,0 +1,22 @@
+class UnderOS::UI::Button < UnderOS::UI::View
+  wraps UIButton, tag: 'button'
+
+  def initialize(options={})
+    super
+
+    self.text  = options.delete(:text) || ''
+    @_.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
+
+end

data/lib/under_os/ui/collection/cell.rb

@@ -0,0 +1,21 @@
+#
+# This is a bridge to the iOS native functionality
+# please do not use it in your code
+#
+class UnderOs::UI::Collection::Cell < UICollectionViewCell
+
+  def self.classes
+    @classes ||= {}
+  end
+
+  def uos_view_for(collection)
+    @uos_view ||= self.class.classes[collection].for(collection).tap do |view|
+      contentView.addSubview(view._)
+    end
+  end
+
+  def prepareForReuse
+    super
+    @uos_view.cleanup if @uos_view
+  end
+end

data/lib/under_os/ui/collection/delegate.rb

@@ -0,0 +1,68 @@
+#
+# The iOS level events receiver, not for a public use
+#
+class UnderOs::UI::Collection::Delegate < UIViewController
+
+  def self.new(collection)
+    alloc.tap do |instance|
+      instance.instance_eval do
+        @collection = collection
+      end
+    end
+  end
+
+  ################################################################
+  # DataSource API
+  ################################################################
+
+  def numberOfSectionsInCollectionView(collection)
+    @collection.number_of_sections
+  end
+
+  def collectionView(collection, numberOfItemsInSection: section)
+    @collection.number_of_items(section)
+  end
+
+  def collectionView(collection, cellForItemAtIndexPath: indexPath)
+    collection.dequeueReusableCellWithReuseIdentifier('UOSCollectionCell', forIndexPath:indexPath).tap do |item|
+      @collection.emit(:item, item: item.uos_view_for(@collection), index: indexPath.row, section: indexPath.section)
+    end
+  end
+
+  # def collectionView(collection, viewForSupplementaryElementOfKind: kind, atIndexPath: indexPath)
+  #   # kind is a string
+  #   UICollectionReusableView.alloc.init
+    # UICollectionReusableView * reusableview = nil ;
+
+    # if ( kind == UICollectionElementKindSectionHeader ) {
+    #     RecipeCollectionHeaderView * headerView = [ collectionView dequeueReusableSupplementaryViewOfKind : UICollectionElementKindSectionHeader withReuseIdentifier : @ "HeaderView" forIndexPath : indexPath ] ;
+    #     NSString * title = [ [ NSString alloc ] initWithFormat : @ "Recipe Group #%i" , indexPath.section + 1 ] ;
+    #     headerView.title.text = title;
+    #     UIImage * headerImage = [ UIImage imageNamed : @ "header_banner.png" ] ;
+    #     headerView.backgroundImage.image = headerImage;
+
+    #     reusableview = headerView;
+    # }
+
+    # if ( kind == UICollectionElementKindSectionFooter ) {
+    #     UICollectionReusableView * footerview = [ collectionView dequeueReusableSupplementaryViewOfKind : UICollectionElementKindSectionFooter withReuseIdentifier : @ "FooterView" forIndexPath : indexPath ] ;
+
+    #     reusableview = footerview;
+    # }
+
+    # return reusableview;
+  # end
+
+
+  ################################################################
+  # DataSource API
+  ################################################################
+
+  def collectionView(collection, didSelectItemAtIndexPath: indexPath)
+    @collection.emit(:select, index: indexPath.row, section: indexPath.section)
+  end
+
+  def collectionView(collection, didDeselectItemAtIndexPath: indexPath)
+    @collection.emit(:unselect, index: indexPath.row, section: indexPath.section)
+  end
+end

data/lib/under_os/ui/collection/item.rb

@@ -0,0 +1,32 @@
+#
+# This is the collection item class that you supposed
+# to inherit (well, if you need to)
+#
+class UnderOs::UI::Collection::Item < UnderOs::UI::View
+
+  tag :item
+
+  def self.build(collection, &builder)
+    @builders           ||= {}
+    @builders[collection] = builder
+    collection.item_class = self
+  end
+
+  def self.for(collection, stylesheet=nil)
+    new.tap do |view|
+      def view.parent; @_parent; end
+      view.instance_variable_set('@_parent', collection)
+
+      @builders[collection] && @builders[collection].call.each do |child|
+        view.insert child
+      end
+
+      view.repaint(stylesheet || UnderOs::App.history.current_page.stylesheet)
+    end
+  end
+
+  def cleanup
+    # implement me if you need to clean cells between reuse
+  end
+
+end

data/lib/under_os/ui/collection/layout.rb

@@ -0,0 +1,43 @@
+#
+# The basic, grid (flow) layout. inheritable.
+#
+class Layout
+  attr_reader :_
+
+  def initialize(layout=nil)
+    @_ = layout || UICollectionViewFlowLayout.alloc.init
+
+    self.items_spacing = 0
+    self.rows_spacing  = 1
+  end
+
+  def item_size
+  end
+
+  def item_size=(*size)
+    size = UnderOs::Point.new(*size)
+    @_.itemSize = CGSizeMake(size.x, size.y)
+  end
+
+  def items_spacing
+    @_.minimumInteritemSpacing
+  end
+
+  def items_spacing=(value)
+    @_.minimumInteritemSpacing = value
+  end
+
+  def rows_spacing
+    @_.minimumLineSpacing
+  end
+
+  def rows_spacing=(value)
+    @_.minimumLineSpacing = value
+  end
+
+  def section_inset
+  end
+
+  def section_inset=(value)
+  end
+end

data/lib/under_os/ui/collection/styles.rb

@@ -0,0 +1,15 @@
+#
+# This thing catches styles from the collection element
+# and adjusts the layout settings for them
+#
+class UnderOs::UI::Collection::Styles
+  def self.build(collection, stylesheet)
+    item = UnderOs::UI::Collection::Item.for(collection, stylesheet)
+
+    collection.layout.item_size     = item.size
+    collection.layout.items_spacing = item.style.marginLeft + item.style.marginRight
+    collection.layout.rows_spacing  = item.style.marginTop  + item.style.marginBottom
+
+    # TODO header/footer
+  end
+end