under-os 0.0.0 → 1.0.0

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

@@ -0,0 +1,89 @@
+#
+# The styles handling API for UIView
+#
+module UnderOs::UI::Styles
+  def style(hash=nil)
+    if hash
+      self.style = hash
+      self
+    else
+      @_style ||= UnderOs::UI::Style.new(_, tagName.downcase.to_sym)
+    end
+  end
+
+  def style=(hash)
+    hash.each{ |key, value| style.__send__("#{key}=", value)}
+  end
+
+  def className
+    classNames.join(' ')
+  end
+
+  def className=(names)
+    self.classNames = names.scan(/([a-z0-9\-_]+)/).map{|e| e[0]}
+  end
+
+  def classNames
+    @_class_names ||= []
+  end
+
+  def classNames=(list)
+    repaint_if_classes_change do
+      @_class_names = list.uniq.map(&:to_s)
+    end
+  end
+
+  def hasClass(name)
+    classNames.include?(name)
+  end
+
+  def addClass(name)
+    repaint_if_classes_change do
+      self.classNames += [name]
+    end
+  end
+
+  def removeClass(name)
+    repaint_if_classes_change do
+      self.classNames -= [name]
+    end
+  end
+
+  def toggleClass(name)
+    if hasClass(name)
+      removeClass name
+    else
+      addClass name
+    end
+  end
+
+  def radioClass(name)
+    parent.children.each do |view|
+      view.removeClass(name) if view != self
+    end
+
+    addClass name
+  end
+
+  def repaint(stylesheet=nil, &block)
+    stylesheet ||= page && page.stylesheet
+
+    if stylesheet
+      styles = stylesheet.styles_for(self)
+      styles = block.call(styles) if block_given?
+      self.style = styles
+      children.each{ |view| view.repaint(stylesheet) }
+    end
+
+    self
+  end
+
+private
+
+  def repaint_if_classes_change
+    prev_list = @_class_names.to_s
+    yield if block_given?
+    repaint if prev_list != @_class_names.to_s
+    self
+  end
+end

data/lib/under_os/ui/utils/traversing.rb

@@ -0,0 +1,44 @@
+module UnderOs::UI::Traversing
+  def first(css_rule)
+    find(css_rule)[0]
+  end
+
+  def find(css_rule)
+    [].tap do |result|
+      children.each do |view|
+        result << view if view.matches(css_rule)
+        view.find(css_rule).each do |sub|
+          result << sub
+        end
+      end
+    end
+  end
+
+  def matches(css_rule)
+    UnderOs::Page::StylesMatcher.new(css_rule).match(self)
+  end
+
+  def parent(css_rule=nil)
+    if ! css_rule
+      UnderOs::UI::View.new(@_.superview) if @_.superview
+    else
+      parent = self
+      while parent.is_a?(UnderOs::UI::View) && (parent = parent.parent)
+        return parent if parent.matches(css_rule)
+      end
+    end
+  end
+
+  def children(css_rule=nil)
+    result = @_.subviews.map{|v| UnderOs::UI::View.new(v) if v}.compact
+    css_rule ? result.select{|v| v.matches(css_rule)} : result
+  end
+
+  def siblings(css_rule=nil)
+    parent ? (parent.children(css_rule) - [self]) : []
+  end
+
+  def empty?
+    @_.subviews.empty?
+  end
+end

data/lib/under_os/ui/utils/wrap.rb

@@ -0,0 +1,77 @@
+#
+# The raw -> abstraction wrapping code
+# for UI::Views
+#
+module UnderOs::UI::Wrap
+  INSTANCES_CACHE = {}
+  RAW_WRAPS_MAP   = {}
+  WRAPS_TAGS_MAP  = {}
+
+  def self.included(base)
+    base.instance_eval do
+      attr_accessor :_
+
+      def self.wraps(raw_class, options={})
+        RAW_WRAPS_MAP[self] = raw_class
+        tag(options[:tag]) if options[:tag]
+      end
+
+      def self.tag(name)
+        WRAPS_TAGS_MAP[name.to_s] = self
+      end
+
+      def self.new(options={}, *args, &block)
+        return INSTANCES_CACHE[options] if INSTANCES_CACHE[options]
+
+        if options.is_a?(UIView)
+          klass = find_wrap_for(options.class)
+          view  = options; options = args.shift || {}
+        else
+          klass = self
+          view  = find_raw_class_for(self).alloc
+          if view.class == UICollectionView
+            view.initWithFrame([[0, 0], [0, 0]], collectionViewLayout: UICollectionViewFlowLayout.alloc.init)
+          else
+            view.initWithFrame([[0, 0], [0, 0]])
+          end
+        end
+
+        return nil if ! klass
+
+        klass.alloc.tap do |inst|
+          INSTANCES_CACHE[inst._ = view] = inst
+          inst.__send__ :initialize, options, *args, &block
+        end
+      end
+
+      def self.rewrap(view, *args, &block)
+        view = view._ if view.is_a?(UnderOs::UI::View)
+
+        alloc.tap do |inst|
+          INSTANCES_CACHE[inst._ = view] = inst
+          inst.__send__ :initialize, *args, &block
+        end
+      end
+
+      def self.find_wrap_for(raw_class)
+        RAW_WRAPS_MAP.each do |wrap, raw|
+          return wrap if raw == raw_class
+        end
+
+        return nil
+      end
+
+      def self.find_raw_class_for(wrap)
+        while wrap
+          return RAW_WRAPS_MAP[wrap] if RAW_WRAPS_MAP[wrap]
+          wrap = wrap.superclass
+        end
+      end
+
+      def self.wrap_for(raw_view)
+        INSTANCES_CACHE[raw_view]
+      end
+    end
+  end
+
+end

data/lib/under_os/ui/view.rb

@@ -0,0 +1,31 @@
+class UnderOs::UI::View
+  include UnderOs::UI::Wrap
+  include UnderOs::UI::Events
+  include UnderOs::UI::Styles
+  include UnderOs::UI::Commons
+  include UnderOs::UI::Animation
+  include UnderOs::UI::Dimensions
+  include UnderOs::UI::Traversing
+  include UnderOs::UI::Manipulation
+
+  wraps UIView, tag: 'view'
+
+  def initialize(options={})
+    self.id        = options.delete(:id)    if options.has_key?(:id)
+    self.className = options.delete(:class) if options.has_key?(:class)
+    self.style     = options.delete(:style) if options.has_key?(:style)
+    self.on        = options.delete(:on)    if options.has_key?(:on)
+    self.data      = options.delete(:data)  if options.has_key?(:data)
+  end
+
+  def inspect
+    params = {tag: tagName}
+    params[:id]    = id if id
+    params[:class] = className unless classNames.empty?
+    params = params.map do |key, value|
+      "#{key}=\"#{value}\""
+    end
+
+    "#<#{self.class.name} #{params.join(" ")}>"
+  end
+end

data/lib/under_os/ui.rb

@@ -0,0 +1,3 @@
+module UnderOs::UI
+  # Just a namespace for UI things
+end

data/lib/under_os.rb

@@ -1,5 +1,5 @@
 module UnderOs
-  VERSION='0.0.0'
+  VERSION='1.0.0'
 end
 
-UnderOS = UnderOs
+UOS = UnderOS = UnderOs

data/spec/assets/app.css

@@ -0,0 +1,13 @@
+page {
+  background: white;
+}
+
+.test {
+  background:    blue;
+  border-radius: 5;
+  color:         yellow;
+}
+
+view.test {
+  border-radius: 10;
+}

data/spec/assets/test.css

@@ -0,0 +1,7 @@
+page {
+  background: yellow;
+}
+
+.test {
+  background: green;
+}

data/spec/assets/test.html

@@ -0,0 +1,3 @@
+<page title="Hello World">
+  <button id="hello">Say Hello</button>
+</page>

data/spec/assets/test_page.rb

@@ -0,0 +1,2 @@
+class TestPage < UnderOs::Page
+end

data/spec/lib/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/lib/core/string_spec.rb

@@ -0,0 +1,87 @@
+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::UI::View".constantize.should == UnderOs::UI::View
+    end
+
+    it "raises an error if the constant is missing" do
+      -> {
+        "Something::Totally::Bogus".constantize
+      }.should.raise(NameError)
+    end
+  end
+end

data/spec/lib/under_os/color_spec.rb

@@ -0,0 +1,133 @@
+describe UnderOs::Color do
+  def from(*args)
+    UnderOs::Color.new(*args)
+  end
+
+  describe '#initialize' do
+    it "should initialize from a UIColor" do
+      color = from(UIColor.blueColor)
+      color.ui.should == UIColor.blueColor
+    end
+
+    it "should always return the same instance" do
+      color1 = from(UIColor.blackColor)
+      color2 = from(UIColor.blackColor)
+
+      color1.should === color2
+    end
+
+    it "should work with rgba arrays of integers" do
+      from(0, 0, 255, 1.0).should == UIColor.blueColor
+    end
+
+    it "should work with rgba arrays of floats" do
+      from(0.0, 0.0, 1.0, 1.0).should == UIColor.blueColor
+    end
+
+    it "should work with rgb arrays of integers" do
+      from(0, 0, 255).should == UIColor.blueColor
+    end
+
+    it "should work with rgb arrays of floats" do
+      from(0.0, 0.0, 1.0).should == UIColor.blueColor
+    end
+
+    it "should work with string color names" do
+      from('blue').should == UIColor.blueColor
+    end
+
+    it "should work with symbol color names" do
+      from(:blue).should == UIColor.blueColor
+    end
+
+    it "should work with string hex colors" do
+      from('#ff8000').should == UIColor.orangeColor
+    end
+
+    it "should work with short hand colors" do
+      from('#ff0').should == UIColor.yellowColor
+    end
+
+    it "should work with rgb() strings" do
+      from('rgb(10, 20, 30)').to_rgba.should == [10, 20, 30, 1.0]
+    end
+
+    it "should work with rgba() strings" do
+      from('rgba(100, 200, 250, 0.5)').to_rgba.should == [100, 200, 250, 0.5]
+    end
+
+    it 'should work with flaot color circle params' do
+      from(0.23).to_s.should == '#9eff00'
+    end
+
+    it 'should work with integer (in degrees) color circle params' do
+      from(23).to_s.should == '#9eff00'
+    end
+  end
+
+  describe '#to_rgba' do
+    it "should extract the data correctly" do
+      from(UIColor.blueColor).to_rgba.should == [0, 0, 255, 1.0]
+    end
+  end
+
+  describe '#to_rgb' do
+    it "should extract the data correctly" do
+      from(UIColor.yellowColor).to_rgb.should == [255, 255, 0]
+    end
+  end
+
+  describe '#to_hex' do
+    it "should extract the data correctly" do
+      from(UIColor.orangeColor).to_hex.should == '#ff8000'
+    end
+  end
+
+  describe '#to_s' do
+    it "should extract the data correctly" do
+      from(UIColor.brownColor).to_s.should == '#996633'
+    end
+  end
+
+  describe '#==' do
+    it "should work with other colors" do
+      from(UIColor.blueColor).should     == from(UIColor.blueColor)
+      from(UIColor.blueColor).should.not == from(UIColor.orangeColor)
+    end
+
+    it "should work with UIColors" do
+      from(UIColor.blueColor).should     == UIColor.blueColor
+      from(UIColor.blueColor).should.not == UIColor.orangeColor
+    end
+
+    it "should work with RGB arrays" do
+      from(UIColor.blueColor).should     == [0, 0, 255]
+      from(UIColor.blueColor).should.not == [0, 255, 0]
+    end
+
+    it "should work with RGBA arrays" do
+      from(UIColor.blueColor).should     == [0, 0, 255, 1.0]
+      from(UIColor.blueColor).should.not == [0, 255, 0, 1.0]
+    end
+
+    it "should work with string names" do
+      from(UIColor.blueColor).should     == 'blue'
+      from(UIColor.blueColor).should.not == 'orange'
+    end
+
+    it "should work with symbol names" do
+      from(UIColor.blueColor).should     == :blue
+      from(UIColor.blueColor).should.not == :orange
+    end
+
+    it "should work with hex values" do
+      from(UIColor.blueColor).should     == '#0000ff'
+      from(UIColor.blueColor).should.not == '#00ff00'
+    end
+
+    it "should work with short hex values" do
+      from(UIColor.blueColor).should     == '#00f'
+      from(UIColor.blueColor).should.not == '#0f0'
+    end
+  end
+end

data/spec/lib/under_os/events_spec.rb

@@ -0,0 +1,71 @@
+describe UnderOs::Events do
+  class Dummy
+    include UnderOs::Events
+  end
+
+  before do
+    @dummy = Dummy.new
+  end
+
+  describe "#on" do
+    it "should add event listeners" do
+      @dummy.on(:smth) { }
+      UnderOs::Events::Listeners.all(@dummy, :smth).size.should == 1
+    end
+
+    it "should return the object itself back" do
+      @dummy.on(:smth) { }.should.be.same_as @dummy
+    end
+  end
+
+  describe "#off" do
+    it "should remove event listeners" do
+      @dummy.on(:smth) { }
+      @dummy.off(:smth)
+      UnderOs::Events::Listeners.all(@dummy, :smth).size.should == 0
+    end
+
+    it "should return the object itself back" do
+      @dummy.off(:smth).should.be.same_as @dummy
+    end
+  end
+
+  describe "#emit" do
+    it "should emit events" do
+      kicked = false
+      @dummy.on(:smth) { kicked = true }
+      @dummy.emit(:smth)
+      kicked.should == true
+    end
+
+    it "should return the object itself back" do
+      @dummy.emit(:smth).should.be.same_as @dummy
+    end
+
+    it "should accept optional params" do
+      event = nil
+      @dummy.on(:smth) { |e| event = e }
+      @dummy.emit(:smth, param1: 1, param2: 2)
+      event.params.should == {param1: 1, param2: 2}
+    end
+  end
+
+  describe 'UnderOs::Events::Event' do
+    before do
+      @event = UnderOs::Events::Event.new('event-name', param1: 1, param2: 2)
+    end
+
+    it "should give access to it's name" do
+      @event.name.should == :"event-name"
+    end
+
+    it "should give access to it's params" do
+      @event.params.should == {param1: 1, param2: 2}
+    end
+
+    it "should magically pass all the missing requests to the params" do
+      @event.param1.should == 1
+      @event.param2.should == 2
+    end
+  end
+end