under-os 1.3.0 → 1.4.0

data/lib/under_os/http/response.rb

@@ -1,28 +0,0 @@
-class UnderOs::HTTP::Response
-  attr_reader :data
-
-  def initialize(response, data)
-    @response = response
-    @data     = data # raw NSData
-  end
-
-  def headers
-    @response.allHeaderFields
-  end
-
-  def body
-    @body ||= @data.to_s
-  end
-
-  def json
-    JSON.parse(body)
-  end
-
-  def content_length
-    headers["Content-Length"].to_i
-  end
-
-  def content_type
-    headers["Content-Type"]
-  end
-end

data/lib/under_os/http/session.rb

@@ -1,49 +0,0 @@
-#
-# Basically keeps track of cookies between the requests
-#
-class Session
-  def initialize(default_options={})
-    @options = default_options
-    @options[:cookies] ||= {}
-  end
-
-  def cookies
-    @options[:cookies]
-  end
-
-  def get(url, options={}, &block)
-    request(url, {method: 'GET'}.merge(options), &block).send
-  end
-
-  def post(url, options={}, &block)
-    request(url, {method: 'POST'}.merge(options), &block).send
-  end
-
-  def put(url, options={}, &block)
-    request(url, {method: 'PUT'}.merge(options), &block).send
-  end
-
-  def delete(url, options={}, &block)
-    request(url, {method: 'DELETE'}.merge(options), &block).send
-  end
-
-  def request(url, options={}, &block)
-    options = options.merge(@options){|k,a,b| a.merge(b) }
-
-    UnderOs::HTTP::Request.new(url, options, &block).tap do |request|
-      request.on :response do |response|
-        save_cookies response.headers["Set-Cookie"] || ''
-      end
-    end
-  end
-
-protected
-
-  def save_cookies(cookies)
-    cookies.scan(/([a-z_]+?)=([^; ]+)/).each do |key, value|
-      unless ['path', 'domain', 'expires'].include?(key)
-        @options[:cookies][key] = value
-      end
-    end
-  end
-end

data/lib/under_os/page.rb

@@ -1,169 +0,0 @@
-#
-# 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
-
-    def touchesBegan(touches, withEvent:event)
-      UnderOs::UI::Events::TouchListeners.notify :touchstart, event
-    end
-
-    def touchesMoved(touches, withEvent:event)
-      UnderOs::UI::Events::TouchListeners.notify :touchmove, event
-    end
-
-    def touchesEnded(touches, withEvent: event)
-      UnderOs::UI::Events::TouchListeners.notify :touchend, event
-    end
-
-    def touchesCancelled(touches, withEvent: event)
-      UnderOs::UI::Events::TouchListeners.notify :touchcancel, event
-    end
-  end
-end

data/lib/under_os/page/builder.rb

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

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

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