bowline 0.4.6 → 0.5.0

data/lib/bowline/async.rb

@@ -1,29 +0,0 @@
-module Bowline
-  module Async
-    def self.included(base)
-      base.extend Methods
-      base.send :include, Methods
-      class << base
-        extend Methods
-      end
-    end
-
-    module Methods
-      def async(*methods)
-        methods.each {|meth|
-          define_method("#{meth}_with_async") {|*args|
-            callback = nil
-            if(args.last.is_a?(::RubyKMethod))
-              callback = args.pop
-            end
-            Thread.new do
-              res = send("#{meth}_without_async", *args)
-              callback.call(res) if callback
-            end
-          }
-          alias_method_chain meth, :async
-        }
-      end
-    end
-  end
-end

data/lib/bowline/binders/collection.rb

@@ -1,59 +0,0 @@
-module Bowline
-  module Binders
-    class Collection < Base
-      class ItemsProxy
-        def initialize(&block)
-          @callback = block
-          @items = []
-        end
-        
-        def real
-          @items
-        end
-        
-        def method_missing(*args, &block)
-          diff = @items.hash
-          res = @items.send(*args, &block)
-          if diff != @items.hash
-            @callback.call
-          end
-          res
-        end
-      end
-      
-      class << self
-        def items=(args)
-          if args
-            items.replace(args)
-          else
-            items.clear
-          end
-        end
-        
-        def items
-          @items ||= ItemsProxy.new {
-            self.item_sync!
-          }
-        end
-    
-        def item_sync!
-          return unless @items && @elements
-          value = @items.real.map {|item|
-            hash = item.to_js
-            hash.merge!({:_id => item.__id__})
-            hash.stringify_keys 
-          }
-          @elements.each {|i|
-            i.updateCollection(value) 
-          }
-        end
-    
-        def find(id)
-          @items.real.find {|item| 
-            item.__id__ == id
-          }
-        end
-      end
-    end
-  end
-end

data/lib/bowline/binders/singleton.rb

@@ -1,31 +0,0 @@
-module Bowline
-  module Binders
-    class Singleton < Base
-      class << self
-        def item
-          @item
-        end
-        
-        def item=(arg)
-          @item = arg
-          self.item_sync!
-        end
-    
-        def item_sync!
-          return unless @item && @elements
-          value = @item.to_js
-          value.merge!({:_id => @item.__id__})
-          value.stringify_keys!
-          # Call the chain.js function 'item' on elements
-          @elements.each {|i| 
-            i.updateSingleton(value) 
-          }
-        end
-      
-        def find(*a)
-          @item
-        end
-      end
-    end
-  end
-end

data/lib/bowline/jquery.rb

@@ -1,31 +0,0 @@
-module Bowline
-  class JQuery
-    # Equivalent to: $.foo()
-    def method_missing(sym, args)
-      self.class.dollar.send(sym, *args)
-    end
-    
-    class << self
-      # Equivalent to: $('#item_id')
-      def for_element(el)
-        Bowline::js.send("jQuery", el)
-      end
-      
-      # For binding global events
-      # Equivalent to: $('body').bind()
-      def bind(event, fun, data)
-        for_element("body").bind(event, data, fun)
-      end
-      
-      # Equivalent to: $
-      def dollar
-        Bowline::js.send("jQuery")
-      end
-      
-      # Equivalent to: $.bowline
-      def bowline
-        dollar.bowline
-      end
-    end
-  end
-end

data/lib/bowline/observer.rb

@@ -1,66 +0,0 @@
-# o = Observable.new
-# o.append('greet') {
-#  puts 'hi'
-# }
-# o.call('greet')
-#
-# def greet(who)
-#  puts "Hi #{who}"
-# end
-# event = o.append('greet', method(:greet), 'Alex')
-# o.call('greet')
-# event.remove
-
-module Bowline
-  class Observable
-    class Event
-      attr_reader :type, :callback
-      def initialize(observable, type, callback = nil)
-        @observable = observable
-        @type       = type
-        @callback   = callback
-      end
-      
-      def call(*args)
-        @callback.call(*args)
-      end
-      
-      def remove
-        @observable.remove(self)
-      end
-    end
-    
-    def initialize
-      @listeners = {}
-    end
-
-    def append(event, method = nil, &block)
-      event = Event.new(self, event, method||block)
-      (@listeners[event] ||= []) << event
-      event
-    end
-
-    def call(event, *args)
-      return unless @listeners[event]
-      @listeners[event].each do |callback|
-        callback.call(*args)
-      end
-    end
-    
-    def remove(event, value=nil)
-      return unless @listeners[event]
-      if value
-        @listeners[event].delete(value)
-        if @listeners[event].empty?
-          @listeners.delete(event)
-        end
-      else
-        @listeners.delete(event)
-      end
-    end
-
-    def clear
-      @listeners = {}
-    end
-  end
-end

data/lib/bowline/window.rb

@@ -1,19 +0,0 @@
-module Bowline
-  class Window
-    def self.window
-      defined?(Titanium) && Titanium.UI.mainWindow.window
-    end
-    
-    def initialize(obj = self.class.window)
-      @object = obj
-    end
-    
-    def method_missing(*args)
-      Bowline.logger.info "Sending to Window: #{args.inspect}"
-      if defined?(Titanium)        
-        @object = @object.send(*args)
-      end
-      self
-    end
-  end
-end