bluepotion 0.0.1

data/lib/project/ruby_motion_query/rmq/tags.rb

@@ -0,0 +1,58 @@
+class RMQ
+
+  # Add tags
+  # @example
+  #    rmq(my_view).tag(:your_tag)
+  #    rmq(my_view).clear_tags.tag(:your_new_tag)
+  #    rmq(my_view).find(UILabel).tag(:selected, :customer)
+  #
+  # You can optionally store a value in the tag, which can be super useful in some rare situations
+  # @example
+  #    rmq(my_view).tag(your_tag: 22)
+  #    rmq(my_view).tag(your_tag: 22, your_other_tag: 'Hello world')
+  #
+  # @return [RMQ]
+  def tag(*tag_or_tags)
+    selected.each do |view|
+      view.rmq_data.tag(tag_or_tags)
+    end
+    self
+  end
+
+  def untag(*tag_or_tags)
+    selected.each do |view|
+      view.rmq_data.untag(tag_or_tags)
+    end
+    self
+  end
+
+  # @return [RMQ]
+  def clear_tags
+    selected.each do |view|
+      view.rmq_data.tags.clear
+    end
+    self
+  end
+
+  # Check if any of the selected has a given tag
+  # @example
+  #   rmq(my_view).has_tag?(:your_tag) #false
+  #   rmq(my_view).tag(:your_tag)
+  #   rmq(my_view).has_tag?(:your_tag) #true
+  #
+  # @return [Boolean] true if any selection views have tag provided
+  def has_tag? tag
+    out = false
+    selected.each do |view|
+      if view.rmq_data.has_tag?(tag)
+        out = true # This is weird because of RM android bug
+        break
+      end
+    end
+
+    out
+  end
+  # See data.rb for the rest of the tag stuff
+
+end
+

data/lib/project/ruby_motion_query/rmq/traverse.rb

@@ -0,0 +1,287 @@
+class RMQ
+  def activity
+    # TODO we can get the activity in better ways, and in more
+    # situations
+    if @originated_from.is_a?(PMScreen)
+      @originated_from.activity
+    elsif @originated_from.is_a?(Potion::Activity)
+      @originated_from
+    elsif @originated_from.is_a?(Potion::View)
+      if @originated_from.rmq_data
+        @originated_from.rmq_data.activity
+      else
+        RMQ.app.current_activity
+      end
+    else
+      RMQ.app.current_activity
+    end
+  end
+
+  def screen
+    # TODO we can get the screen in better ways, and in more
+    # situations
+    if @originated_from.is_a?(PMScreen)
+      @originated_from
+    elsif @originated_from.is_a?(Potion::View)
+      if @originated_from.rmq_data
+        @originated_from.rmq_data.screen
+      else
+        RMQ.app.current_screen
+      end
+    else
+      RMQ.app.current_screen
+    end
+  end
+
+  def controller
+    self.screen || self.activity
+  end
+
+  def root_view
+    if @originated_from.is_a?(Android::App::Activity)
+      @originated_from.root_view
+    else
+      self.controller.root_view
+    end
+  end
+
+  def filter(opts = {}, &block)
+    out = []
+    limit = opts[:limit]
+
+    selected.each do |view|
+      results = yield(view)
+      unless RMQ.is_blank?(results)
+        out << results
+        break if limit && (out.length >= limit)
+      end
+    end
+    out.flatten!
+    out = out.uniq if opts[:uniq]
+
+    if opts[:return_array]
+      out
+    else
+      RMQ.create_with_array_and_selectors(out, selectors, @originated_from, self)
+    end
+  end
+
+  def all
+    wrap(root_view).find
+  end
+
+  def children(*working_selectors)
+    normalize_selectors(working_selectors)
+
+    filter do |view|
+      sbvws = view.subviews
+
+      if RMQ.is_blank?(working_selectors)
+        sbvws
+      else
+        sbvws.inject([]) do |out, subview|
+          out << subview if match(subview, working_selectors)
+          out
+        end
+      end
+    end
+  end
+  alias :subviews :children
+
+  def find(*working_selectors)
+    normalize_selectors(working_selectors)
+
+    #if working_selectors.length == 1 && self.selected.length == 1 && working_selectors.first.is_a?(Java::Lang::Integer)
+        #return selected_first.findViewById(r(:id, working_selectors.first))
+    #end
+
+    filter(uniq: true) do |view|
+      sbvws = all_subviews_for(view)
+
+      if RMQ.is_blank?(working_selectors)
+        sbvws
+      else
+        sbvws.inject([]) do |out, subview|
+          out << subview if match(subview, working_selectors)
+          out
+        end
+      end
+    end # filter
+
+  end
+
+  # @return [RMQ] A new rmq instance reducing selected views to those that match selectors provided
+  #
+  # @param selectors your selector
+  #
+  # @example
+  #   rmq(UIImage).and(:some_tag).attr(image: nil)
+  def and(*working_selectors)
+    return self unless working_selectors
+    normalize_selectors(working_selectors)
+
+    self.select do |view|
+      match(view, working_selectors)
+    end
+  end
+
+  # @return [RMQ] A new rmq instance removing selected views that match selectors provided
+  #
+  # @param selectors
+  #
+  # @example
+  #   # Entire family of labels from siblings on down
+  #   rmq(my_label).parent.find(UILabel).not(my_label).move(left: 10)
+  def not(*working_selectors)
+    return self unless working_selectors
+    normalize_selectors(working_selectors)
+
+    self.reject do |view|
+      match(view, working_selectors)
+    end
+  end
+
+  # @return [RMQ] A new rmq instance adding the context to the selected views
+  #
+  # @example
+  #   rmq(my_view).children.and_self
+  def and_self
+    if self.parent_rmq
+      out = self.parent_rmq.selected.dup
+      out << selected
+      out.flatten!
+      RMQ.create_with_array_and_selectors(out, selectors, @context, self)
+    else
+      self
+    end
+  end
+  alias :add_self :and_self
+
+  # @return [RMQ] The parent rmq instance. This is useful when you want to go down
+  # into the tree, then move back up to do more work. Like jQuery's "end"
+  #
+  # @example
+  #   rmq(test_view).find(Potion::Button).tag(:foo).back.find(UILabel).tag(:bar)
+  def back
+    self.parent_rmq || self
+  end
+
+  # @return [RMQ] rmq instance selecting the parent of the selected view(s)
+  #
+  # @example
+  #   rmq(my_view).parent.find(:delete_button).toggle_enabled
+  def parent
+    closest(Potion::View)
+  end
+  alias :superview :parent
+
+  # @return [RMQ] Instance selecting the parents, grandparents, etc, all the way up the tree
+  # of the selected view(s)
+  #
+  # @param selectors
+  #
+  # @example
+  #   rmq(my_view).parents.log
+  def parents(*working_selectors)
+    normalize_selectors(working_selectors)
+
+    filter(uniq: true) do |view|
+      superviews = all_superviews_for(view)
+
+      if RMQ.is_blank?(working_selectors)
+        superviews
+      else
+        superviews.inject([]) do |subview, out|
+          out << subview if match(subview, working_selectors)
+          out
+        end
+      end
+    end
+  end
+  alias :superviews :parents
+
+  # @return [RMQ] Siblings of the selected view(s)
+  #
+  # @param selectors
+  #
+  # @example
+  #   rmq(my_view).siblings.send(:poke)
+  def siblings(*working_selectors)
+    normalize_selectors(working_selectors)
+
+    self.parent.children.not(selected)
+  end
+
+  # @return [RMQ] Sibling below the selected view(s) (in the subview array)
+  #
+  # @param selectors
+  #
+  # @example
+  #   rmq(my_view).next.hide
+  #   rmq(my_view).next(UITextField).focus
+  def next(*working_selectors)
+    normalize_selectors(working_selectors)
+
+    filter do |view|
+      subs = view.superview.subviews
+      location = subs.index(view)
+      if location < subs.length - 1
+        subs[location + 1]
+      end
+    end
+  end
+
+  # @return [RMQ] Sibling above the selected view(s) (in the subview array)
+  #
+  # @param selectors
+  #
+  # @example
+  #   rmq(my_view).prev.hid
+  #   rmq(my_view).prev(UITextField).focus
+  def prev(*working_selectors)
+    normalize_selectors(working_selectors)
+
+    filter do |view|
+      if sv = view.superview
+        subs = sv.subviews
+        location = subs.index(view)
+        if location > 0
+          subs[location - 1]
+        end
+      end
+    end
+  end
+
+  # For each selected view, get the first view that matches the selector(s) by testing the view's parent and
+  # traversing up through its ancestors in the tree
+  #
+  # @return [RMQ] Instance selecting the first parent or grandparent or ancestor up the tree of the selected view(s)
+  #
+  # @param selectors
+  #
+  # @example
+  #   rmq.closest(Potion::View).get.setContentOffset([0,0])
+  def closest(*working_selectors)
+    normalize_selectors(working_selectors)
+
+    filter do |view|
+      closest_view(view, working_selectors)
+    end
+  end
+
+
+  protected
+
+  def closest_view(view, working_selectors)
+    if nr = view.superview
+      if match(nr, working_selectors)
+        nr
+      else
+        closest_view(nr,working_selectors)
+      end
+    else
+      nil
+    end
+  end
+
+end

data/lib/project/ruby_motion_query/rmq/utils.rb

@@ -0,0 +1,36 @@
+class RMQ
+  class << self
+
+    def is_class?(o)
+      o.class == Java::Lang::Class
+    end
+
+    def is_blank?(o)
+      if o.is_a?(RMQ)
+        RMQ.is_blank?(o.to_a)
+      else
+        o.respond_to?(:empty?) ? o.empty? : !o
+      end
+    end
+
+    def weak_ref(o)
+      o
+    end
+
+    def weak_ref_to_strong_ref(weak_ref)
+      weak_ref
+    end
+
+    def is_object_weak_ref?(o)
+      false
+    end
+
+    def weak_ref_value(o)
+      o
+    end
+
+    def symbolize(s)
+      s.to_s.gsub(/\s+/,"_").gsub(/\W+/,"").downcase.to_sym
+    end
+  end
+end

data/lib/project/ruby_motion_query/rmq/version.rb

@@ -0,0 +1,6 @@
+class RMQ
+  VERSION = "0.1.0"
+  def version
+    VERSION
+  end
+end

data/lib/project/ruby_motion_query/rmq_activity_data.rb

@@ -0,0 +1,3 @@
+class RMQActivityData
+  attr_accessor :stylesheet, :cached_rmq
+end

data/lib/project/ruby_motion_query/rmq_app.rb

@@ -0,0 +1,9 @@
+class RMQ
+  def app
+    PMApplication.current_application
+  end
+
+  def self.app
+    PMApplication.current_application
+  end
+end

data/lib/project/ruby_motion_query/rmq_color.rb

@@ -0,0 +1,121 @@
+# many hacks in this: we can't duplicate the iOS implementation because
+# define_singleton_method isn't implemented in Android :'(
+class RMQ
+
+  def self.color(*params)
+    if params.empty?
+      RMQColor
+    else
+      RMQColorFactory.build(params)
+    end
+  end
+
+  def color(*params)
+    self.class.color(*params)
+  end
+
+end
+
+class RMQColor < Android::Graphics::Color
+  class << self
+    def clear ; self::TRANSPARENT ; end
+    def transparent ; self::TRANSPARENT ; end
+
+    def white ; self::WHITE ; end
+    def light_gray ; self::LTGRAY ; end
+    def gray ; self::GRAY ; end
+    def dark_gray ; self::DKGRAY ; end
+    def black ; self::BLACK ; end
+
+    #def cyan ; self::CYAN ; end
+    #def magenta ; self::MAGENTA ; end
+    #def yellow ; self::YELLOW ; end
+
+    # These are special as the methods already exist
+    #def blue ; self::BLUE ; end
+    #def green ; self::GREEN ; end
+    #def red ; self::RED ; end
+    #def blue_color ; self::BLUE ; end
+    #def green_color ; self::GREEN ; end
+    #def red_color ; self::RED ; end
+
+    # Maybe we should change this to: color(:white) rather than color.white, TOL
+
+
+    def add_named(key, hex_or_color)
+      c = if hex_or_color.is_a?(String)
+        RMQColor.parseColor(hex_or_color)
+      else
+        hex_or_color
+      end
+
+      rmq_color_cache[key] = c
+    end
+
+    def method_missing(color_key)
+      # define_singleton_method isn't implemented in Android :'(
+      rmq_color_cache[color_key]
+    end
+
+    # Creates a color from a hex triplet (rgb) or quartet (rgba)
+    #
+    # @param hex with or without the #
+    # @return [UIColor]
+    # @example
+    #   color.from_hex('#ffffff')
+    #   color.from_hex('ffffff')
+    #   color.from_hex('#336699cc')
+    #   color.from_hex('369c')
+    def from_hex(str)
+      RMQColorFactory.from_hex(str)
+    end
+
+    # @return [UIColor]
+    #
+    # @example
+    #   rmq.color.from_rgba(255,255,255,0.5)
+    def from_rgba(r,g,b,a)
+      RMQColorFactory.from_rgba(r,g,b,a)
+    end
+
+    def random
+      RMQColorFactory.from_rgba(rand(255), rand(255), rand(255), 1.0)
+    end
+
+    def rmq_color_cache
+      @_rmq_color_cache ||= {}
+    end
+  end
+
+end
+
+class RMQColorFactory
+
+  class << self
+    def build(params)
+      return RMQColor if params.empty?
+      return from_rgba(*params) if params.count > 1
+
+      param = params.first
+      return from_hex(params.join) if param.is_a?(String)
+
+      #return from_base_color(param) if base_values(param)
+      #return try_rgba(param) if rgba_values(param)
+      #return try_hsva(param) if hsva_values(param)
+      #return try_hex(param) if hex_values(param)
+    end
+
+    def from_hex(hex_string)
+      if hex_string.length == 7
+        # this is #RRGGBB format - we need to add the alpha
+        color_str = "#FF#{hex_string[1..hex_string.length]}"
+      end
+      RMQColor.parseColor(hex_string)
+    end
+
+    def from_rgba(r, g, b, a)
+      RMQColor.argb(a, r, b, g)
+    end
+  end
+
+end