under-os-core 1.4.0

data/lib/under_os/events.rb

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

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

@@ -0,0 +1,50 @@
+#
+# Generic Point/Size unit
+#
+class UnderOs::Point
+  attr_accessor :x, :y
+
+  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 ==(*args)
+    point = UnderOs::Point.new(*args) # normalizing
+    x == point.x && y == point.y
+  end
+
+  def *(multiplier)
+    UnderOs::Point.new(x: x * multiplier, y: y * multiplier)
+  end
+
+  def /(divider)
+    UnderOs::Point.new(x: x / divider.to_f, y: y / divider.to_f)
+  end
+
+  def -(point)
+    point = point.is_a?(Numeric) ? UnderOs::Point.new(x: point, y: point) : UnderOs::Point.new(point)
+    UnderOs::Point.new(x: x - point.x, y: y - point.y)
+  end
+
+  def +(point)
+    point = point.is_a?(Numeric) ? UnderOs::Point.new(x: point, y: point) : UnderOs::Point.new(point)
+    UnderOs::Point.new(x: x + point.x, y: y + point.y)
+  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/spec/core/json_spec.rb

@@ -0,0 +1,32 @@
+describe JSON do
+  describe ".parse" do
+    it "parses correct json strings" do
+      JSON.parse('{"a":1,"b":true,"c":["data"]}').should == {
+        "a" => 1, "b" => true, "c" => ["data"]
+      }
+    end
+
+    it "raises an exception on malformed data" do
+      -> {
+        JSON.parse("malformed")
+      }.should.raise(JSON::Malformed)
+    end
+  end
+
+  describe ".generate" do
+    it "generates JSON string out of objects" do
+      JSON.generate({a:1, b:true, c:[:data]}).should ==
+        '{"a":1,"b":true,"c":["data"]}'
+    end
+
+    it "generates pretty print when asked" do
+      JSON.generate({a:1, b:true, c:[:data]}, :pretty).should ==
+        "{\n  \"a\" : 1,\n  \"b\" : true,\n  \"c\" : [\n    \"data\"\n  ]\n}"
+    end
+
+    it "allows to export things directly of objects" do
+      {a:1, b:true, c:[:data]}.to_json.should ==
+        '{"a":1,"b":true,"c":["data"]}'
+    end
+  end
+end

data/spec/core/numeric_spec.rb

@@ -0,0 +1,37 @@
+describe Numeric do
+
+  describe '#milliseconds' do
+    it "returns timer duration in milliseconds" do
+      10.milliseconds.should == UnderOs::Timer::Duration.new(0.01)
+    end
+
+    it "has the 'ms' alias" do
+      10.milliseconds.should == 10.ms
+    end
+  end
+
+  describe '#seconds' do
+    it "returns the time duration in seconds" do
+      10.seconds.should == UnderOs::Timer::Duration.new(10)
+    end
+  end
+
+  describe '#minutes' do
+    it "returns the time duration in minutes" do
+      10.minutes.should == UnderOs::Timer::Duration.new(10 * 60)
+    end
+  end
+
+  describe '#hours' do
+    it "returns the time duration in hours" do
+      10.hours.should == UnderOs::Timer::Duration.new(10 * 60 * 60)
+    end
+  end
+
+  describe '#days' do
+    it "returns the time duration in days" do
+      10.days.should == UnderOs::Timer::Duration.new(10 * 60 * 60 * 24)
+    end
+  end
+
+end

data/spec/core/string_spec.rb

@@ -0,0 +1,101 @@
+describe String do
+  describe '#underscore' do
+    it "converts camelized strings into underscored" do
+      "SomeStuff".underscore.should == 'some_stuff'
+    end
+
+    it "converts dashed strings into underscored as well" do
+      "some-stuff".underscore.should == "some_stuff"
+    end
+  end
+
+  describe "#camelize" do
+    it "converts underscored strings into camelized" do
+      "some_stuff".camelize.should == "someStuff"
+    end
+
+    it "converts dashed strings into camelized as well" do
+      "some-stuff".camelize.should == "someStuff"
+    end
+
+    it "handles prefixes correctly" do
+      "_some_stuff".camelize.should == "SomeStuff"
+    end
+  end
+
+  describe '#dasherize' do
+    it "converts camelized strings into dashed" do
+      "SomeStuff".dasherize.should == "some-stuff"
+    end
+
+    it "converts underscored strings into dashed as well" do
+      "some_stuff".dasherize.should == "some-stuff"
+    end
+  end
+
+  describe '#capitalize' do
+    it "capitalizes strings" do
+      "some stuff".capitalize.should == "Some stuff"
+    end
+  end
+
+  describe '#starts_with?' do
+    it "returns true if a string starts with the substring" do
+      "some stuff".starts_with?("some").should == true
+    end
+
+    it "returns false if the string doesn't start with the substring" do
+      "some stuff".starts_with?("non matching").should == false
+    end
+  end
+
+  describe '#ends_with?' do
+    it "returns true if the string ends with the given substring" do
+      "some stuff".ends_with?("stuff").should == true
+    end
+
+    it "returns false if the string doesn't end with the substring" do
+      "some stuff".ends_with?("non matching").should == false
+    end
+  end
+
+  describe '#blank?' do
+    it "returns true if the string is empty" do
+      ''.blank?.should == true
+    end
+
+    it "returns true if the string has only white spaces" do
+      " \n\t\r ".blank?.should == true
+    end
+
+    it "returns false if the string has non-space chars in it" do
+      " a ".blank?.should == false
+    end
+  end
+
+  describe '#constantize' do
+    it "returns an object from it's value" do
+      "UnderOs::App".constantize.should == UnderOs::App
+    end
+
+    it "raises an error if the constant is missing" do
+      -> {
+        "Something::Totally::Bogus".constantize
+      }.should.raise(NameError)
+    end
+  end
+
+  describe '#to_data' do
+    before do
+      @data = "ohai there".to_data
+    end
+
+    it "converts the string into a data object" do
+      @data.is_a?(NSData).should == true
+    end
+
+    it "converts it into data with correct content" do
+      @data.to_s.should == "ohai there"
+    end
+  end
+end