under-os 1.3.0 → 1.4.0

data/lib/under_os/delegate.rb

@@ -1,10 +0,0 @@
-#
-# Just an app delegate to kick the things in
-#
-class AppDelegate
-  def application(application, didFinishLaunchingWithOptions:launchOptions)
-    UnderOs::App.setup(application, launchOptions)
-
-    true
-  end
-end

data/lib/under_os/events.rb

@@ -1,85 +0,0 @@
-#
-# A little events handling concern
-#
-module UnderOs::Events
-
-  def on(event, *args, &block)
-    Listeners.add(self, event, *args, block)
-  end
-
-  def off(event)
-    Listeners.remove(self, event)
-  end
-
-  def emit(event, params={})
-    Listeners.kick(self, event, params)
-  end
-
-  module Listeners
-    extend self
-
-    def list(model, event=nil)
-      @listeners ||= Hash.new{|h,k| h[k] = Hash.new{|h,k| h[k] = []} }
-      event ? @listeners[model][event.to_sym] : @listeners[model]
-    end
-
-    def add(model, event, *args, block)
-      list(model, event) << [block, *args]
-      model
-    end
-
-    def all(model, event)
-      list(model, event)
-    end
-
-    def remove(model, event)
-      list(model).delete event.to_sym
-      model
-    end
-
-    def kick(model, event, params)
-      event = Event.new(event, params) unless event.is_a?(Event)
-
-      all(model, event.name).each do |block, method_name, *args|
-        if !block && method_name
-          block   = Proc.new{ |e|
-            a = method(method_name).arity == 0 ? [] : [e];
-            __send__(method_name, *a) }
-          context = model
-        elsif block && method_name # <- considering it's a context reference
-          context = method_name
-        else
-          context = nil
-        end
-
-        args = block.arity == 0 ? [] : [event]
-
-        if context
-          context.instance_exec *args, &block
-        else
-          block.call *args
-        end
-      end
-
-      model
-    end
-  end
-
-  class Event
-    attr_reader :name, :params
-
-    def initialize(name, params)
-      @name   = name.to_sym
-      @params = params
-    end
-
-    def method_missing(name, *args, &block)
-      if @params.has_key?(name.to_sym)
-        @params[name.to_sym]
-      else
-        super name, *args, &block
-      end
-    end
-  end
-
-end

data/lib/under_os/file.rb

@@ -1,110 +0,0 @@
-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.to_data('utf-8') 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

@@ -1,53 +0,0 @@
-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
-    controller = @_.topViewController
-
-    controller.is_a?(UnderOs::Page::UIViewControllerWrap) ?
-      controller.wrapper : root_page
-  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.rb

@@ -1,31 +0,0 @@
-class UnderOs::HTTP
-  def self.get(url, options={}, &block)
-    request url, options.merge(method: :get), &block
-  end
-
-  def self.post(url, options={}, &block)
-    request url, options.merge(method: :post), &block
-  end
-
-  def self.put(url, options={}, &block)
-    request url, options.merge(method: :put), &block
-  end
-
-  def self.patch(url, options={}, &block)
-    request url, options.merge(method: :patch), &block
-  end
-
-  def self.head(url, options={}, &block)
-    request url, options.merge(method: :head), &block
-  end
-
-  def self.delete(url, options={}, &block)
-    request url, options.merge(method: :delete), &block
-  end
-
-protected
-
-  def self.request(*args, &block)
-    Request.new(*args, &block).send
-  end
-end

data/lib/under_os/http/cookies.rb

@@ -1,30 +0,0 @@
-#
-# A simple cookie jar thing
-#
-class UnderOs::HTTP::Cookies
-  def initialize(cookies, url)
-    @url  = url.is_a?(String) ? NSURL.URLWithString(url) : url
-    @hash = cookies
-  end
-
-  def headers
-    NSHTTPCookie.requestHeaderFieldsWithCookies(ios_cookies)
-  end
-
-  def to_s
-    headers["Cookie"]
-  end
-
-protected
-
-  def ios_cookies
-    @hash.map do |key, value|
-      NSHTTPCookie.cookieWithProperties({
-        NSHTTPCookieDomain => @url.host,
-        NSHTTPCookiePath   => "/",
-        NSHTTPCookieName   => key.to_s,
-        NSHTTPCookieValue  => value.to_s
-      })
-    end
-  end
-end

data/lib/under_os/http/receiver.rb

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

@@ -1,106 +0,0 @@
-#
-# Options:
-#
-#   * :method   - GET, POST, ...
-#   * :cookies  - Hash of cookie values
-#   * :stream   - boolean, in case you want to stream stuff
-#   * :params   - the POST/PUT/PATCH params hash
-#   * :encoding - the POST data encoding
-#
-# 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
-
-    return self
-  end
-
-  def cancel
-    @connection.cancel
-
-    return self
-  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
-
-  def params
-    @options[:params] || {}
-  end
-
-  def encoding
-    @options[:encoding] || 'utf-8'
-  end
-
-protected
-
-  def build_request
-    query = params.to_query
-    url   = build_url(query)
-
-    NSMutableURLRequest.requestWithURL(url).tap do |request|
-      request.setHTTPMethod method
-
-      headers.merge(UnderOs::HTTP::Cookies.new(cookies, url).headers).each do |key, value|
-        request.addValue value, forHTTPHeaderField:key
-      end
-
-      if %w[POST PUT PATCH DELETE].include?(method) && !query.empty?
-        request.addValue "application/x-www-form-urlencoded;charset=#{encoding}", forHTTPHeaderField:"Content-Type"
-        request.setHTTPBody query.to_data(encoding)
-      end
-    end
-  end
-
-  def build_url(query)
-    url  = @url
-
-    if method == "GET" && !query.empty?
-      url += url.include?('?') ? '&' : '?'
-      url += query
-    end
-
-    NSURL.URLWithString(url)
-  end
-end
-