under-os 0.0.0 → 1.0.0

data/lib/under_os/file.rb

@@ -0,0 +1,110 @@
+class UnderOs::File
+  attr_reader :path, :mode
+
+  def self.open(path, *args, &block)
+    new path, *args, &block
+  end
+
+  def self.read(path, *args)
+    new(path, *args).read
+  end
+
+  def self.write(path, content)
+    new(path, "w"){|f| f.write(content) }
+  end
+
+  def self.size(path)
+    new(path).size
+  end
+
+  def self.delete(path)
+    NSFileManager.defaultManager.removeItemAtPath(UnderOs::File.path(path), error:nil)
+  end
+
+  def self.path(path)
+    path.to_s[0] == '/' ? path : NSHomeDirectory().stringByAppendingPathComponent(path)
+  end
+
+  def self.tmp(filename, mode="w", &block)
+    new NSTemporaryDirectory().stringByAppendingPathComponent(filename), mode, &block
+  end
+
+  def self.exists?(path, is_dir=nil)
+    NSFileManager.defaultManager.fileExistsAtPath(UnderOs::File.path(path), isDirectory:is_dir)
+  end
+
+  def self.file?(path)
+    exists?(path, false)
+  end
+
+  def self.dir?(path)
+    exists?(path, true)
+  end
+
+  def initialize(path, mode="r", &block)
+    @path = UnderOs::File.path(path)
+    @mode = mode
+
+    yield(self) if block_given?
+  end
+
+  def url
+    @url ||= NSURL.fileURLWithPath(@path)
+  end
+
+  def read(size=nil)
+    open
+    data = if size == nil
+      @handle.readDataToEndOfFile
+    else
+      @handle.readDataOfLength(size)
+    end
+    close
+
+    @mode == "b" ? data : NSString.alloc.initWithData(data, encoding:NSUTF8StringEncoding)
+  end
+
+  def write(content)
+    if ! UnderOs::File.exists?(@path)
+      NSFileManager.defaultManager.createFileAtPath @path, contents:nil, attributes:nil
+    end
+
+    content = content.dataUsingEncoding(NSUTF8StringEncoding) if content.is_a?(String)
+
+    open
+    @handle.writeData content
+    close
+  end
+
+  def open
+    @handle = if @mode == "r"
+      NSFileHandle.fileHandleForReadingAtPath(@path)
+    else
+      NSFileHandle.fileHandleForWritingAtPath(@path)
+    end
+
+    @handle.seekToEndOfFile if ["w+", "a"].include?(@mode)
+  end
+
+  def close
+    @handle.closeFile
+    @handle = nil
+  end
+
+  def seek(offset)
+    @handle.seekToFileOffset(offset)
+  end
+
+  def rewind
+    seek 0
+  end
+
+  def size
+    NSFileManager.defaultManager.attributesOfItemAtPath(@path, error: nil).fileSize
+  end
+
+  def truncate(size)
+    @handle.truncateFileAtOffset(size)
+  end
+
+end

data/lib/under_os/history.rb

@@ -0,0 +1,50 @@
+class UnderOs::History
+  attr_reader :_, :navbar
+
+  def initialize
+    @_      = UINavigationController.alloc
+    @navbar = UnderOs::UI::Navbar.new(@_)
+  end
+
+  def root_page
+    @_.topViewController.wrapper
+  end
+
+  def root_page=(page)
+    @_.initWithRootViewController(page._)
+  end
+
+  def current_page
+    @_.visibleViewController.wrapper
+  end
+
+  def push(page, animated=true)
+    if pages.include?(page)
+      pop_to(page)
+    else
+      @_.pushViewController(page._, animated: animated)
+    end
+  end
+
+  alias :<< :push
+
+  def pop(page=nil, animated=true)
+    if page
+      @_.popToViewController(page._, animated: animated)
+    else
+      @_.popViewControllerAnimated(animated)
+    end
+  end
+
+  def pages
+    @_.viewControllers.map{|c| c.wrapper rescue nil }.compact
+  end
+
+  def pop_to(page, animated=true)
+    pop(page, animated)
+  end
+
+  def pop_to_root(animated=true)
+    @_.popToRootViewControllerAnimated(animated)
+  end
+end

data/lib/under_os/http/receiver.rb

@@ -0,0 +1,44 @@
+#
+# A little wrap to handle iOS HTTP requests receiving
+#
+class UnderOs::HTTP::Request
+  class Receiver
+    def initialize(request, stream=false)
+      @request = request
+      @stream  = stream
+      @data    = NSMutableData.dataWithCapacity(0)
+    end
+
+    def connection(connection, didReceiveResponse:response)
+      @data.setLength(0)
+      @response = UnderOs::HTTP::Response.new(response, @data)
+
+      emit(:response)
+    end
+
+    def connection(connection, didReceiveData:data)
+      @data.setLength(0) if @stream
+      @data.appendData(data)
+      emit(:data)
+    end
+
+    # def connection(connection, willCacheResponse:cachedResponse)
+    #   return nil # don't cache
+    # end
+
+    def connection(connection, didFailWithError:error)
+      @response = UnderOs::HTTP::Response.new(error, @data)
+
+      emit(:failure)
+    end
+
+    def connectionDidFinishLoading(connection)
+      emit(:success)
+    end
+
+    def emit(event)
+      @request.emit(event, response: @response)
+      @request.emit(:complete, response: @response) if event == :failure || event == :success
+    end
+  end
+end

data/lib/under_os/http/request.rb

@@ -0,0 +1,89 @@
+#
+# Options:
+#
+#   * :method  - GET, POST, ...
+#   * :cookies - Hash of cookie values
+#   * :stream  - boolean, in case you want to stream stuff
+#
+# Events:
+#
+#   * :response - when response header is received
+#   * :data     - when a chunk of data is received
+#   * :success  - when the request is successfully finished
+#   * :failure  - when request has failed for whatever reason
+#   * :complete - when it's complete (either way)
+#
+class UnderOs::HTTP::Request
+  include UnderOs::Events
+
+  attr_reader :url, :method, :params
+
+  def initialize(url, options={}, &block)
+    @url     = url
+    @options = options
+
+    on :complete, &block if block_given?
+  end
+
+  def on(*args, &block)
+    super *args do |event|
+      args = block.arity == 0 ? [] : [event.params[:response]]
+      block.call *args
+    end
+  end
+
+  def send
+    @request    = build_request
+    @receiver   = Receiver.new(self, @options[:stream])
+    @connection = NSURLConnection.alloc.initWithRequest(@request, delegate:@receiver)
+    @connection.start
+  end
+
+  def cancel
+    @connection.cancel
+  end
+
+  def method
+    method = @options[:method] || :get
+    method = method.to_s.upcase
+    method = 'GET' unless %w[GET POST PUT DELETE PATCH HEAD].include?(method)
+    method
+  end
+
+  def headers
+    @options[:headers] || {}
+  end
+
+  def cookies
+    @options[:cookies] || {}
+  end
+
+protected
+
+  def build_request
+    url = NSURL.URLWithString(NSString.stringWithFormat(@url))
+    NSMutableURLRequest.requestWithURL(url).tap do |request|
+      request.setHTTPMethod self.method
+      #request.setHTTPBody self.params
+
+      cookies = self.cookies.map do |key, value|
+        NSHTTPCookie.cookieWithProperties({
+          NSHTTPCookieDomain => url.host,
+          NSHTTPCookiePath   => "/",
+          NSHTTPCookieName   => key.to_s,
+          NSHTTPCookieValue  => value.to_s
+        })
+      end
+
+      request.setAllHTTPHeaderFields NSHTTPCookie.requestHeaderFieldsWithCookies(cookies) if cookies.size > 0
+
+      headers.each do |key, value|
+        request.addValue value, forHTTPHeaderField:key
+      end
+
+      # [newRequest addValue:@"application/x-www-form-urlencoded;charset=UTF-8" forHTTPHeaderField:@"Content-Type"];
+      # [newRequest setHTTPBody:[query dataUsingEncoding:NSUTF8StringEncoding]];
+    end
+  end
+end
+

data/lib/under_os/http/response.rb

@@ -0,0 +1,24 @@
+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 content_length
+    headers["Content-Length"].to_i
+  end
+
+  def content_type
+    headers["Content-Type"]
+  end
+end

data/lib/under_os/http/session.rb

@@ -0,0 +1,49 @@
+#
+# 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/http.rb

@@ -0,0 +1,5 @@
+class UnderOs::HTTP
+  def self.get(url, options={}, &block)
+    Request.new(url, options.merge(method: :get), &block).send
+  end
+end

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,83 @@
+class UnderOs::Page::StylesMatcher
+
+  def self.new(css_rule)
+    @cache           ||= {}
+    @cache[css_rule] ||= super
+  end
+
+  def initialize(css_rule)
+    css_rule = css_rule.strip
+    rules    = css_rule.scan(/([\S]+)/).map(&:first)
+    @rule    = parse(rules.pop)
+    @parent  = rules.size == 0 ? false : self.class.new(rules.join(' '))
+  end
+
+  def match(view)
+    score_for(view) != 0
+  end
+
+  def score_for(view)
+    id_score    = id_score_for(view)
+    tag_score   = tag_score_for(view)
+    class_score = class_score_for(view)
+
+    return 0 if @rule[:id]  && id_score     == 0
+    return 0 if @rule[:tag] && tag_score    == 0
+    return 0 if @rule[:classes].size > 0 && class_score == 0
+    return 0 if (this_score = id_score + tag_score + class_score) == 0
+
+    parent_score = parent_score_for(view)
+
+    return 0 if @parent && parent_score == 0
+
+    parent_score + this_score
+  end
+
+private
+
+  def id_score_for(view)
+    @rule[:id] == view.id ? 1 : 0
+  end
+
+  def tag_score_for(view)
+    @rule[:tag] == view.tagName ? 1 : 0
+  end
+
+  def class_score_for(view)
+    match = @rule[:classes] & view.classNames
+    match.size == @rule[:classes].size ? match.size : 0
+  end
+
+  def parent_score_for(view)
+    return 0 if ! @parent
+
+    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]}
+      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