bowline 0.4.6 → 0.5.0

data/lib/bowline/commands/build.rb

@@ -0,0 +1,3 @@
+require 'rake'
+require 'bowline/tasks/bowline'
+Rake::Task['app:build'].invoke

data/lib/bowline/commands/generate.rb

@@ -1 +1,3 @@
-# todo
+require 'bowline/generators'
+
+Bowline::Generators.run_cli(APP_ROOT, 'bowline', Bowline::Version::STRING, ARGV)

data/lib/bowline/commands/run.rb

@@ -1,4 +1,7 @@
-require 'rake'
-require 'bowline/tasks/bowline'
-ENV['TIRUN'] = 'true'
-Rake::Task['app'].invoke
+unless Bowline::Library.downloaded?
+  require 'rake'
+  require 'bowline/tasks/bowline'
+  Rake::Task['libs:download'].invoke
+end
+
+exec("#{Bowline::Library.desktop_path} #{APP_ROOT}")

data/lib/bowline/desktop.rb

@@ -0,0 +1,26 @@
+module Bowline
+  module Desktop
+    include Bowline::Logging
+    extend Bowline::Watcher::Base
+    watch :on_tick, :on_idle
+    
+    def enabled?
+      $0 == "bowline"
+    end
+    module_function :enabled?
+    
+    def idle
+      watcher.call(:on_idle)
+    rescue => e
+      log_error e
+    end
+    module_function :idle
+
+    def tick
+      watcher.call(:on_tick)
+    rescue => e
+      log_error e
+    end
+    module_function :tick
+  end
+end

data/lib/bowline/desktop/app.rb

@@ -0,0 +1,9 @@
+module Bowline
+  module Desktop
+    module App
+      # Methods:
+      #   busy()
+      #   exit()
+    end
+  end
+end

data/lib/bowline/desktop/bridge.rb

@@ -0,0 +1,97 @@
+module Bowline
+  module Desktop
+    module Bridge
+      module ClassMethods
+        # Extend you own classes with this
+        # module, and then call js_expose 
+        # to expose your classes' class
+        # variables to JavaScript.
+        #
+        # Ruby Class:
+        #   class FooClass
+        #     extend Bowline::Desktop::Bridge::ClassMethods
+        #     js_expose
+        #     
+        #     def self.foo
+        #       return :bar
+        #     end
+        #   end
+        #
+        # JavaScript:
+        #   Bowline.invoke("FooClass", "foo", function(res){
+        #     console.log(res);
+        #   })
+        def js_expose(opts = {})
+          # TODO - implement options, 
+          # like :except and :only
+          instance_eval <<-RUBY
+            def js_exposed?
+              true
+            end
+            
+            def js_invoke(window, method, *args)
+              send(method, *args)
+            end
+          RUBY
+        end
+      end
+      
+      class Message
+        include Bowline::Logging
+        
+        def self.from_array(window, arr)
+          arr.map {|i| self.new(window, i) }
+        end
+        
+        attr_reader :window, :id, :klass, :method, :args
+        
+        def initialize(window, atts)
+          @window = window
+          atts = atts.with_indifferent_access
+          @id     = atts[:id]
+          @klass  = atts[:klass]
+          @method = atts[:method].to_sym
+          @args   = atts[:args] || []
+        end
+
+        def invoke
+          if klass == "_window"
+            object = window
+          else
+            # TODO - security concerns with constantize
+            object = klass.constantize
+          end
+          trace "JS invoking: #{klass}.#{method}(#{args.join(',')})"
+          if object.respond_to?(:js_exposed?) && object.js_exposed?
+            result = object.js_invoke(window, method, *args)
+            proxy  = Proxy.new(window)
+            proxy.Bowline.invokeCallback(id, result)
+            window.run_script(proxy.to_s)
+          else
+            raise "Method not allowed"
+          end
+        rescue => e
+          log_error e
+        end
+      end
+      
+      def setup
+        Desktop.on_tick(method(:poll))
+      end
+      module_function :setup
+
+      def poll
+        WindowManager.allocated_windows.each do |window|
+          result   = window.run_script("try {Bowline.pollJS()} catch(e) {false}")
+          next if result.blank? || result == "false"
+          result   = JSON.parse(result)
+          messages = Message.from_array(window, result)
+          messages.each(&:invoke)
+        end
+      rescue => e
+        Bowline::Logging.log_error(e)
+      end
+      module_function :poll
+    end
+  end
+end

data/lib/bowline/desktop/clipboard.rb

@@ -0,0 +1,9 @@
+module Bowline
+  module Desktop
+    module Clipboard
+      # Methods:
+      #   write(str)
+      #   read #=> str
+    end
+  end
+end

data/lib/bowline/desktop/dialog.rb

@@ -0,0 +1,28 @@
+module Bowline
+  module Desktop
+    module Dialog
+      def message(msg, options = {})
+        style = 0
+        style |= YES_NO if options[:yes_no]
+        style |= OK     if options[:ok]
+        style |= CANCEL if options[:cancel]
+        style |= ICON_EXCLAMATION if options[:icon_exclamation]
+        style |= ICON_HAND   if options[:icon_hand]
+        style |= ICON_ERROR  if options[:icon_error]
+        style |= QUESTION    if options[:question]
+        style |= INFORMATION if options[:information]
+        caption = options[:caption] || "Message"
+        
+        result = _message(msg, caption, style)
+        
+        case result
+        when YES then :yes
+        when NO  then :no
+        when OK  then :ok
+        when CANCEL then :cancel
+        end
+      end
+      module_function :message
+    end
+  end
+end

data/lib/bowline/desktop/dock.rb

@@ -0,0 +1,9 @@
+module Bowline
+  module Desktop
+    module Dock
+      # Methods:
+      #  badge=(str)
+      #  clear_badge
+    end
+  end
+end

data/lib/bowline/desktop/host.rb

@@ -0,0 +1,10 @@
+module Bowline
+  module Desktop
+    module Host
+      # Methods
+      #  ip()
+      #  public_ip()
+      #  host_name()
+    end
+  end
+end

data/lib/bowline/desktop/js.rb

@@ -0,0 +1,92 @@
+module Bowline
+  module Desktop
+    module JS    
+      class Script
+        include Bowline::Logging
+        
+        attr_reader :window, :script, :prok
+        def initialize(window, script, prok = nil)
+          @window = window
+          @script = script
+          @prok   = prok
+        end
+        alias :windows :window
+        
+        def ready?
+          multiple_windows? ? 
+            windows.all?(&:loaded?) : 
+              window.loaded?
+        end
+      
+        def call
+          if Desktop.enabled?
+            trace "JS eval on #{window}: #{script}"
+            if multiple_windows?
+              windows.each {|w| w.run_script(script) }
+              raise "Can't return from multiple windows" if prok
+            else
+              result = parse(window.run_script(script))
+              Thread.new { prok.call(result) } if prok
+            end
+            result
+          else
+            trace "Pseudo JS eval on #{window}: #{script}"
+            prok.call(nil)
+          end
+        end
+        
+        private
+          def multiple_windows?
+            windows.is_a?(Array)
+          end
+        
+          def parse(str)
+            # This is crazy! The JSON 
+            # lib can't parse booleans
+            case str
+            when "true"  then true
+            when "false" then false
+            when nil     then nil
+            else
+              JSON.parse(str)
+            end
+          end
+      end
+
+      def poll
+        run_scripts
+      end
+      module_function :poll
+      
+      def setup
+        Desktop.on_tick(method(:poll))
+      end
+      module_function :setup
+    
+      def eval(win, str, method = nil, &block)
+        script = Script.new(win, str, method||block)
+        if Thread.current == Thread.main && script.ready?
+          script.call
+        else
+          scripts << script
+        end
+      end
+      module_function :eval
+    
+      private
+        def run_scripts
+          ready_scripts = scripts.select(&:ready?)
+          while script  = ready_scripts.shift
+            script.call
+          end
+        end
+        module_function :run_scripts
+        
+        # TODO - thread safety, needs mutex
+        def scripts
+          Thread.main[:scripts] ||= []
+        end
+        module_function :scripts
+    end
+  end
+end

data/lib/bowline/desktop/misc.rb

@@ -0,0 +1,9 @@
+module Bowline
+  module Desktop
+    module Misc
+      # Methods:
+      #   launch_browser(url)
+      #   bell()
+    end
+  end
+end

data/lib/bowline/desktop/network.rb

@@ -0,0 +1,7 @@
+module Bowline
+  module Desktop
+    class Network
+      # Implement address polling to see if we're online
+    end
+  end
+end

data/lib/bowline/desktop/proxy.rb

@@ -0,0 +1,94 @@
+module Bowline
+  module Desktop
+    class Proxy      
+      # Use to call out to JavaScript.
+      #
+      # Use the method 'call' if you want 
+      # to call a function, or the method 'res' if you want 
+      # the result of a variable evaluation.
+      #
+      # You can pass a block as the last argument which will
+      # be called with the result of the evaluation.
+      # 
+      # All arguments are serialized by JSON, so you can only pass
+      # the following objects:
+      # * Hash
+      # * Array
+      # * String
+      # * Integer
+      #
+      # Usage:
+      #   proxy.FooObject.messages = [1,2,3] #=> "FooObject.messages = [1,2,3]"
+      #   proxy.FooObject.hi.call #=> "FooObject.hi()"
+      #   proxy.FooObject.hi(1,2,3).bye.call #=> "FooObject.hi(1,2,3).bye()"
+      #   proxy.FooObject.messages.res #=> "FooObject.messages"
+      #   proxy.FooObject.messages.res {|result|
+      #     puts "Messages are: #{result}"
+      #   }
+      #
+      # Reasoning behind this class:
+      #  * JavaScript needs to be called all at once
+      #  * We don't know if it's a method call, or a variable
+      
+      def initialize(win)
+        @window = win
+        @crumbs = []
+      end
+      
+      # Call a JavaScript function:
+      #  proxy.myFunction('arg1').call
+      def call(method = nil, &block)
+        if @crumbs.empty?
+          raise "No method provided"
+        end
+        string = to_s
+        string << "()" unless string.last == ")"
+        Bowline::Desktop::JS.eval(
+          @window,
+          "Bowline.invokeJS(#{string.inspect});", 
+          method,
+          &block
+        )
+      end
+      
+      # Evaluate a JavaScript variable:
+      #  proxy.my_variable.res {|result| p result }
+      def res(method = nil, &block)
+        if @crumbs.empty?
+          raise "No attribute provided"
+        end
+        Bowline::Desktop::JS.eval(
+          @window,
+          "Bowline.invokeJS(#{to_s.inspect});", 
+          method,
+          &block
+        )
+      end
+      
+      def method_missing(sym, *args) #:nodoc:
+        method_name = sym.to_s
+        @crumbs << [method_name, args]
+        if method_name.last == "="
+          call
+        end
+        self
+      end
+      
+      # Return the JavaScript that is to be evaluated
+      def to_s
+        (@crumbs || []).inject([]) do |arr, (method, args)|
+          str = method
+          if args.any?
+            str << "(" + args.to_json[1..-2] + ")"
+          end
+          arr << str
+        end.join(".")
+      end
+      alias :to_js :to_s
+      
+      def inspect
+        "<#{self.class.name}:#{@window} #{to_s}>"
+      end   
+    end
+  end
+end

data/lib/bowline/desktop/sound.rb

@@ -0,0 +1,8 @@
+module Bowline
+  module Desktop
+    module Sound
+      # Methods:
+      #   play(wav_file_path)
+    end
+  end
+end

data/lib/bowline/desktop/window.rb

@@ -0,0 +1,31 @@
+module Bowline
+  module Desktop
+    class Window
+      include WindowMethods
+      # Methods:
+      #  new()
+      #  center(direction = :both)
+      #  close
+      #  chrome=
+      #  disable
+      #  enable
+      #  file=      
+      #  id 
+      #  modal(flag = true)
+      #  name=
+      #  run_script(str) #=> str
+      #  raise
+      #  show
+      #  hide
+      #  set_size(width, height)
+      #  set_position(x, y)
+      #  select_dir(
+      #  )
+      #  shown?
+    end
+    
+    class MainWindow
+      include WindowMethods
+    end
+  end
+end