droiuby 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d80b4b3f1f57823a9abc631a671014c10bd0c348
-  data.tar.gz: 90e65885732363c9438f60afd4ab7df3e52bef63
+  metadata.gz: c99a0427b7d58933183c619cfa0f72c8865cc96e
+  data.tar.gz: 207329828f330d981798948cabb1f116fd235fde
 SHA512:
-  metadata.gz: 16365865f6071727185220870931377b1bfbfb3dfd845525527e0c72ae285c5c3bdf57be21975a2cfbcf1632e374a2cd00b460267b6973a2d4508023ea2c002c
-  data.tar.gz: 26e4a4f39e90ffd7bf3fab19fa22df52cb176c92b136f69a8186aab4313defe71bdffe311dae0438bcd6eb0d1850f7204dcaecfc3862de1b7bd5d3f0e20e0aa3
+  metadata.gz: 5085ed07cf25a2ad536790c0c373d313126908f626400c33c5e142e81755667805b6e726c7a281f3f3e73585e385fd9cc86343885b6aecef46d1706e28429e26
+  data.tar.gz: 4bb8b45851683725c3c279e8ed3464d2e3295ac42030588fe9016424142aa7733c8ff2aabea1d15317f941c73e25f42df085cba02243bae0789b6aeab1453856

data/bin/drby

@@ -8,6 +8,7 @@ require "readline"
 
 $droiuby_host = ENV['DROIUBY_HOST'] || '10.0.2.2'
 $device_ip = ENV['DROIUBY_DEVICE'] || nil
+$app_name = nil
 
 options = OptionParser.new do |o|
   o.banner =
@@ -19,13 +20,15 @@ options = OptionParser.new do |o|
        drby live [PROJECT_NAME] [options]                      # runs a web instance of the app and tells Droiuby to load it.
        drby new PROJECT_NAME [options]                         # Create a new project
        drby pack [PROJECT_NAME] [options]                      # zips and packages an app
-       drby standalone [PROJECT_NAME] --package [JAVA_PACKAGE] # creates a standalone android project for the current app
+       drby standalone [PROJECT_NAME] --package JAVA_PACKAGE   # creates a standalone android project for the current app
+            [--name APP_NAME]
        drby reload                                             # uploads and then reload the current app
        drby switch INSTANCE_NAME [options]                     # Switch to the specified instance
        drby bundle                                             # unzips all gems in vendor/cache for deployment to droiuby\n"
 
   o.separator ""
   o.separator "options:"
+  o.on('-n','--name app_name','The name of the app that appears in the launcher') {|b| $app_name =b }
   o.on('-p','--package java_package','The java package name to use') {|b| $java_package = b}
   o.on('-h','--host HOST_IP','The IP Address of the host computer (for droiuby live mode)') { |b| $droiuby_host = b }
   o.on('-d','--device DEVICE_IP','The IP Address of the Android Device') { |b| $device_ip = b }
@@ -113,7 +116,8 @@ case command
       puts '--package [JAVA_PACKAGE] is required.'
       exit(1)
     end
-    project.standalone(project_name, $java_package, '')
+    project.standalone(project_name, $java_package, $app_name.nil? ? 'HelloWorld'
+        : $app_name,'')
   when 'switch'
     instance_name = nil
     unless ARGV[1].blank?

data/lib/droiuby/scripts/project.rb

@@ -5,8 +5,8 @@ require 'zip'
 require 'thor'
 require "uri"
 require 'cgi'
-require 'active_support/core_ext/object'
-require 'active_support/core_ext/string'
+require 'droiuby/support/object'
+require 'droiuby/support/string'
 
 class Project < Thor
 
@@ -119,7 +119,7 @@ class Project < Thor
   end
 
   desc "standalone NAME [PACKAGE_NAME]", "create an android project for this app with the specified java package name"
-  def standalone(name, package_name, output_dir = 'projects')
+  def standalone(name, package_name, title = 'HelloWorld', output_dir = 'projects')
 
     if output_dir.blank?
       output_dir = Dir.pwd
@@ -150,7 +150,7 @@ class Project < Thor
     archive_name = File.basename(dest_folder.sub!(%r[/$],'')) if archive_name.nil?
 
     init = Init.new
-    init.init(package_name, "#{archive_name}.zip")
+    init.init(package_name, "#{archive_name}.zip", title)
     Dir.chdir dest_folder
     bundle
     package(name, '', "true")
@@ -366,7 +366,8 @@ class Project < Thor
       FileUtils.rm archive, :force=>true
 
       Zip::File.open(archive, Zip::File::CREATE) do |zipfile|
-        Dir.glob("**{,/*/**}/*.*").reject{ |f| f==archive || f.match(/^build/) }.uniq.each do |file|
+        Dir.glob("**{,/*/**}/*.*").reject{ |f| f==archive ||
+            f.match(/^build/) || f.match(/^project/) }.uniq.each do |file|
           say_status 'adding', file
           begin
             zipfile.add(file, file)

data/lib/droiuby/support/object/acts_like.rb

@@ -0,0 +1,10 @@
+class Object
+  # A duck-type assistant method. For example, Active Support extends Date
+  # to define an <tt>acts_like_date?</tt> method, and extends Time to define
+  # <tt>acts_like_time?</tt>. As a result, we can do <tt>x.acts_like?(:time)</tt> and
+  # <tt>x.acts_like?(:date)</tt> to do duck-type-safe comparisons, since classes that
+  # we want to act like Time simply need to define an <tt>acts_like_time?</tt> method.
+  def acts_like?(duck)
+    respond_to? :"acts_like_#{duck}?"
+  end
+end

data/lib/droiuby/support/object/blank.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, '', '   ', +nil+, [], and {} are all blank.
+  #
+  # This simplifies:
+  #
+  #   if address.nil? || address.empty?
+  #
+  # ...to:
+  #
+  #   if address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not <tt>blank?</tt>.
+  def present?
+    !blank?
+  end
+
+  # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all. For example, this simplifies a common check for
+  # HTTP POST/query parameters:
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # ...becomes:
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  def blank?
+    false
+  end
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   { key: 'value' }.blank?  # => false
+  alias_method :blank?, :empty?
+end
+
+class String
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.blank?                 # => true
+  #   '   '.blank?              # => true
+  #   '　'.blank?               # => true
+  #   ' something here '.blank? # => false
+  def blank?
+    self !~ /[^[:space:]]/
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  def blank?
+    false
+  end
+end

data/lib/droiuby/support/object/deep_dup.rb

@@ -0,0 +1,46 @@
+require 'droiuby/support/object/duplicable'
+
+class Object
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) #=> false
+  #   dup.instance_variable_defined?(:@a)    #=> true
+  def deep_dup
+    duplicable? ? dup : self
+  end
+end
+
+class Array
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] #=> nil
+  #   dup[1][2]   #=> 4
+  def deep_dup
+    map { |it| it.deep_dup }
+  end
+end
+
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] #=> nil
+  #   dup[:a][:c]  #=> "c"
+  def deep_dup
+    each_with_object(dup) do |(key, value), hash|
+      hash[key.deep_dup] = value.deep_dup
+    end
+  end
+end

data/lib/droiuby/support/object/duplicable.rb

@@ -0,0 +1,90 @@
+#--
+# Most objects are cloneable, but not all. For example you can't dup +nil+:
+#
+#   nil.dup # => TypeError: can't dup NilClass
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+#++
+class Object
+  # Can you safely dup this object?
+  #
+  # False for +nil+, +false+, +true+, symbol, and number objects;
+  # true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass
+  # +nil+ is not duplicable:
+  #
+  #   nil.duplicable? # => false
+  #   nil.dup         # => TypeError: can't dup NilClass
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass
+  # +false+ is not duplicable:
+  #
+  #   false.duplicable? # => false
+  #   false.dup         # => TypeError: can't dup FalseClass
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass
+  # +true+ is not duplicable:
+  #
+  #   true.duplicable? # => false
+  #   true.dup         # => TypeError: can't dup TrueClass
+  def duplicable?
+    false
+  end
+end
+
+class Symbol
+  # Symbols are not duplicable:
+  #
+  #   :my_symbol.duplicable? # => false
+  #   :my_symbol.dup         # => TypeError: can't dup Symbol
+  def duplicable?
+    false
+  end
+end
+
+class Numeric
+  # Numbers are not duplicable:
+  #
+  #  3.duplicable? # => false
+  #  3.dup         # => TypeError: can't dup Fixnum
+  def duplicable?
+    false
+  end
+end
+
+require 'bigdecimal'
+class BigDecimal
+  begin
+    BigDecimal.new('4.56').dup
+
+    def duplicable?
+      true
+    end
+  rescue TypeError
+    # can't dup, so use superclass implementation
+  end
+end

data/lib/droiuby/support/object/inclusion.rb

@@ -0,0 +1,24 @@
+class Object
+  # Returns true if this object is included in the argument. Argument must be
+  # any object which responds to +#include?+. Usage:
+  #
+  #   characters = ["Konata", "Kagami", "Tsukasa"]
+  #   "Konata".in?(characters) # => true
+  #
+  # This will throw an ArgumentError if the argument doesn't respond
+  # to +#include?+.
+  def in?(*args)
+    if args.length > 1
+      puts "Calling #in? with multiple arguments is" \
+        " deprecated, please pass in an object that responds to #include? instead."
+      args.include? self
+    else
+      another_object = args.first
+      if another_object.respond_to? :include?
+        another_object.include? self
+      else
+        raise ArgumentError.new 'The single parameter passed to #in? must respond to #include?'
+      end
+    end
+  end
+end

data/lib/droiuby/support/object/instance_variables.rb

@@ -0,0 +1,28 @@
+class Object
+  # Returns a hash with string keys that maps instance variable names without "@" to their
+  # corresponding values.
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #
+  #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
+  def instance_values
+    Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
+  end
+
+  # Returns an array of instance variable names as strings including "@".
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #
+  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
+  def instance_variable_names
+    instance_variables.map { |var| var.to_s }
+  end
+end

data/lib/droiuby/support/object/to_param.rb

@@ -0,0 +1,58 @@
+class Object
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+end
+
+class NilClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class TrueClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class FalseClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class Array
+  # Calls <tt>to_param</tt> on all its elements and joins the result with
+  # slashes. This is used by <tt>url_for</tt> in Action Pack.
+  def to_param
+    collect { |e| e.to_param }.join '/'
+  end
+end
+
+class Hash
+  # Returns a string representation of the receiver suitable for use as a URL
+  # query string:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_param
+  #   # => "name=David&nationality=Danish"
+  #
+  # An optional namespace can be passed to enclose the param names:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_param('user')
+  #   # => "user[name]=David&user[nationality]=Danish"
+  #
+  # The string pairs "key=value" that conform the query string
+  # are sorted lexicographically in ascending order.
+  #
+  # This method is also aliased as +to_query+.
+  def to_param(namespace = nil)
+    collect do |key, value|
+      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+    end.sort * '&'
+  end
+end

data/lib/droiuby/support/object/to_query.rb

@@ -0,0 +1,27 @@
+require 'droiuby/support/object/to_param'
+
+class Object
+  # Converts an object into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
+  # param name.
+  #
+  # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
+  def to_query(key)
+    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+  end
+end
+
+class Array
+  # Converts an array into a string suitable for use as a URL query string,
+  # using the given +key+ as the param name.
+  #
+  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
+  def to_query(key)
+    prefix = "#{key}[]"
+    collect { |value| value.to_query(prefix) }.join '&'
+  end
+end
+
+class Hash
+  alias_method :to_query, :to_param
+end

data/lib/droiuby/support/object/try.rb

@@ -0,0 +1,78 @@
+class Object
+  # Invokes the public method whose name goes as first argument just like
+  # +public_send+ does, except that if the receiver does not respond to it the
+  # call returns +nil+ rather than raising an exception.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.try(:name)
+  #
+  # instead of
+  #
+  #   @person ? @person.name : nil
+  #
+  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
+  # to the method:
+  #
+  #   nil.try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # The number of arguments in the signature must match. If the object responds
+  # to the method the call is attempted and +ArgumentError+ is still raised
+  # otherwise.
+  #
+  # If +try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.try do |p|
+  #     ...
+  #   end
+  #
+  # Please also note that +try+ is defined on +Object+, therefore it won't work
+  # with instances of classes that do not have +Object+ among their ancestors,
+  # like direct subclasses of +BasicObject+. For example, using +try+ with
+  # +SimpleDelegator+ will delegate +try+ to the target instead of calling it on
+  # delegator itself.
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      public_send(*a, &b) if respond_to?(a.first)
+    end
+  end
+
+  # Same as #try, but will raise a NoMethodError exception if the receiving is not nil and
+  # does not implemented the tried method.
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      public_send(*a, &b)
+    end
+  end
+end
+
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes specially helpful when navigating through associations that may return +nil+.
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && !@person.children.blank? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(*args)
+    nil
+  end
+
+  def try!(*args)
+    nil
+  end
+end

data/lib/droiuby/support/object.rb

@@ -1,11 +1,11 @@
-class Object
+require 'droiuby/support/object/acts_like'
+require 'droiuby/support/object/blank'
+require 'droiuby/support/object/duplicable'
+require 'droiuby/support/object/deep_dup'
+require 'droiuby/support/object/try'
+require 'droiuby/support/object/inclusion'
 
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-  
-  def boolean?
-    self.is_a?(TrueClass) || self.is_a?(FalseClass) 
-  end
-  
-end
+require 'droiuby/support/object/instance_variables'
+
+require 'droiuby/support/object/to_param'
+require 'droiuby/support/object/to_query'

data/lib/droiuby/support/string/access.rb

@@ -0,0 +1,104 @@
+class String
+  # If you pass a single Fixnum, returns a substring of one character at that
+  # position. The first character of the string is at position 0, the next at
+  # position 1, and so on. If a range is supplied, a substring containing
+  # characters at offsets given by the range is returned. In both cases, if an
+  # offset is negative, it is counted from the end of the string. Returns nil
+  # if the initial offset falls outside the string. Returns an empty string if
+  # the beginning of the range is greater than the end of the string.
+  #
+  #   str = "hello"
+  #   str.at(0)      #=> "h"
+  #   str.at(1..3)   #=> "ell"
+  #   str.at(-2)     #=> "l"
+  #   str.at(-2..-1) #=> "lo"
+  #   str.at(5)      #=> nil
+  #   str.at(5..-1)  #=> ""
+  #
+  # If a Regexp is given, the matching portion of the string is returned.
+  # If a String is given, that given string is returned if it occurs in
+  # the string. In both cases, nil is returned if there is no match.
+  #
+  #   str = "hello"
+  #   str.at(/lo/) #=> "lo"
+  #   str.at(/ol/) #=> nil
+  #   str.at("lo") #=> "lo"
+  #   str.at("ol") #=> nil
+  def at(position)
+    self[position]
+  end
+
+  # Returns a substring from the given position to the end of the string.
+  # If the position is negative, it is counted from the end of the string.
+  #
+  #   str = "hello"
+  #   str.from(0)  #=> "hello"
+  #   str.from(3)  #=> "lo"
+  #   str.from(-2) #=> "lo"
+  #
+  # You can mix it with +to+ method and do fun things like:
+  #
+  #   str = "hello"
+  #   str.from(0).to(-1) #=> "hello"
+  #   str.from(1).to(-2) #=> "ell"
+  def from(position)
+    self[position..-1]
+  end
+
+  # Returns a substring from the beginning of the string to the given position.
+  # If the position is negative, it is counted from the end of the string.
+  #
+  #   str = "hello"
+  #   str.to(0)  #=> "h"
+  #   str.to(3)  #=> "hell"
+  #   str.to(-2) #=> "hell"
+  #
+  # You can mix it with +from+ method and do fun things like:
+  #
+  #   str = "hello"
+  #   str.from(0).to(-1) #=> "hello"
+  #   str.from(1).to(-2) #=> "ell"
+  def to(position)
+    self[0..position]
+  end
+
+  # Returns the first character. If a limit is supplied, returns a substring
+  # from the beginning of the string until it reaches the limit value. If the
+  # given limit is greater than or equal to the string length, returns self.
+  #
+  #   str = "hello"
+  #   str.first    #=> "h"
+  #   str.first(1) #=> "h"
+  #   str.first(2) #=> "he"
+  #   str.first(0) #=> ""
+  #   str.first(6) #=> "hello"
+  def first(limit = 1)
+    if limit == 0
+      ''
+    elsif limit >= size
+      self
+    else
+      to(limit - 1)
+    end
+  end
+
+  # Returns the last character of the string. If a limit is supplied, returns a substring
+  # from the end of the string until it reaches the limit value (counting backwards). If
+  # the given limit is greater than or equal to the string length, returns self.
+  #
+  #   str = "hello"
+  #   str.last    #=> "o"
+  #   str.last(1) #=> "o"
+  #   str.last(2) #=> "lo"
+  #   str.last(0) #=> ""
+  #   str.last(6) #=> "hello"
+  def last(limit = 1)
+    if limit == 0
+      ''
+    elsif limit >= size
+      self
+    else
+      from(-limit)
+    end
+  end
+end

data/lib/droiuby/support/string/behavior.rb

@@ -0,0 +1,6 @@
+class String
+  # Enable more predictable duck-typing on String-like classes. See <tt>Object#acts_like?</tt>.
+  def acts_like_string?
+    true
+  end
+end

data/lib/droiuby/support/string/droiuby.rb

@@ -0,0 +1,60 @@
+class String
+  
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      self.first + camelize(self)[1..-1]
+    end
+  end
+  
+  def to_pixels
+    Java::com.droiuby.client.core.builder.ActivityBuilder.toPixels(_current_activity, self)
+  end
+  
+  def to_color
+    Java::android.graphics.Color.parseColor(self)
+  end
+  
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+  
+  def constantize
+    names = self.split('::')
+    names.shift if names.empty? || names.first.empty?
+    index = 1
+    names.inject(Object) do |constant, name|
+      if constant == Object
+        constant.const_get(name)
+      else
+        begin
+          candidate = constant.const_get(name)
+        rescue NameError => e
+          Object.const_missing(names[0..index].join('::'))
+          candidate = constant.const_get(name)
+        end
+        index += 1
+        next candidate if constant.const_defined?(name, false)
+        next candidate unless Object.const_defined?(name)
+
+        # Go down the ancestors to check it it's owned
+        # directly before we reach Object or the end of ancestors.
+        constant = constant.ancestors.inject do |const, ancestor|
+          break const    if ancestor == Object
+          break ancestor if ancestor.const_defined?(name, false)
+          const
+        end
+
+        # owner is in Object, so raise
+        constant.const_get(name, false)
+
+      end
+    end
+  end
+  
+end

data/lib/droiuby/support/string/exclude.rb

@@ -0,0 +1,11 @@
+class String
+  # The inverse of <tt>String#include?</tt>. Returns true if the string
+  # does not include the other string.
+  #
+  #   "hello".exclude? "lo" #=> false
+  #   "hello".exclude? "ol" #=> true
+  #   "hello".exclude? ?h   #=> false
+  def exclude?(string)
+    !include?(string)
+  end
+end

data/lib/droiuby/support/string/filters.rb

@@ -0,0 +1,55 @@
+class String
+  # Returns the string, first removing all whitespace on both ends of
+  # the string, and then changing remaining consecutive whitespace
+  # groups into one space each.
+  #
+  # Note that it handles both ASCII and Unicode whitespace like mongolian vowel separator (U+180E).
+  #
+  #   %{ Multi-line
+  #      string }.squish                   # => "Multi-line string"
+  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
+  def squish
+    dup.squish!
+  end
+
+  # Performs a destructive squish. See String#squish.
+  def squish!
+    gsub!(/\A[[:space:]]+/, '')
+    gsub!(/[[:space:]]+\z/, '')
+    gsub!(/[[:space:]]+/, ' ')
+    self
+  end
+
+  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27)
+  #   # => "Once upon a time in a wo..."
+  #
+  # Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: ' ')
+  #   # => "Once upon a time in a..."
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
+  #   # => "Once upon a time in a..."
+  #
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+  # for a total length not exceeding <tt>length</tt>:
+  #
+  #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
+  #   # => "And they f... (continued)"
+  def truncate(truncate_at, options = {})
+    return dup unless length > truncate_at
+
+    options[:omission] ||= '...'
+    length_with_room_for_omission = truncate_at - options[:omission].length
+    stop = \
+      if options[:separator]
+        rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
+      else
+        length_with_room_for_omission
+      end
+
+    "#{self[0...stop]}#{options[:omission]}"
+  end
+end

data/lib/droiuby/support/string/indent.rb

@@ -0,0 +1,43 @@
+class String
+  # Same as +indent+, except it indents the receiver in-place.
+  #
+  # Returns the indented string, or +nil+ if there was nothing to indent.
+  def indent!(amount, indent_string=nil, indent_empty_lines=false)
+    indent_string = indent_string || self[/^[ \t]/] || ' '
+    re = indent_empty_lines ? /^/ : /^(?!$)/
+    gsub!(re, indent_string * amount)
+  end
+
+  # Indents the lines in the receiver:
+  #
+  #   <<EOS.indent(2)
+  #   def some_method
+  #     some_code
+  #   end
+  #   EOS
+  #   # =>
+  #     def some_method
+  #       some_code
+  #     end
+  #
+  # The second argument, +indent_string+, specifies which indent string to
+  # use. The default is +nil+, which tells the method to make a guess by
+  # peeking at the first indented line, and fallback to a space if there is
+  # none.
+  #
+  #   "  foo".indent(2)        # => "    foo"
+  #   "foo\n\t\tbar".indent(2) # => "\t\tfoo\n\t\t\t\tbar"
+  #   "foo".indent(2, "\t")    # => "\t\tfoo"
+  #
+  # While +indent_string+ is typically one space or tab, it may be any string.
+  #
+  # The third argument, +indent_empty_lines+, is a flag that says whether
+  # empty lines should be indented. Default is false.
+  #
+  #   "foo\n\nbar".indent(2)            # => "  foo\n\n  bar"
+  #   "foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"
+  #
+  def indent(amount, indent_string=nil, indent_empty_lines=false)
+    dup.tap {|_| _.indent!(amount, indent_string, indent_empty_lines)}
+  end
+end

data/lib/droiuby/support/string/starts_ends_with.rb

@@ -0,0 +1,4 @@
+class String
+  alias_method :starts_with?, :start_with?
+  alias_method :ends_with?, :end_with?
+end

data/lib/droiuby/support/string.rb

@@ -1,60 +1,7 @@
-class String
-  
-  def camelize(first_letter_in_uppercase = true)
-    if first_letter_in_uppercase
-      self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-    else
-      self.first + camelize(self)[1..-1]
-    end
-  end
-  
-  def to_pixels
-    Java::com.droiuby.client.core.builder.ActivityBuilder.toPixels(_current_activity, self)
-  end
-  
-  def to_color
-    Java::android.graphics.Color.parseColor(self)
-  end
-  
-  def underscore
-    self.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr("-", "_").
-    downcase
-  end
-  
-  def constantize
-    names = self.split('::')
-    names.shift if names.empty? || names.first.empty?
-    index = 1
-    names.inject(Object) do |constant, name|
-      if constant == Object
-        constant.const_get(name)
-      else
-        begin
-          candidate = constant.const_get(name)
-        rescue NameError => e
-          Object.const_missing(names[0..index].join('::'))
-          candidate = constant.const_get(name)
-        end
-        index += 1
-        next candidate if constant.const_defined?(name, false)
-        next candidate unless Object.const_defined?(name)
-
-        # Go down the ancestors to check it it's owned
-        # directly before we reach Object or the end of ancestors.
-        constant = constant.ancestors.inject do |const, ancestor|
-          break const    if ancestor == Object
-          break ancestor if ancestor.const_defined?(name, false)
-          const
-        end
-
-        # owner is in Object, so raise
-        constant.const_get(name, false)
-
-      end
-    end
-  end
-  
-end
+require 'droiuby/support/string/filters'
+require 'droiuby/support/string/starts_ends_with'
+require 'droiuby/support/string/access'
+require 'droiuby/support/string/behavior'
+require 'droiuby/support/string/exclude'
+require 'droiuby/support/string/indent'
+require 'droiuby/support/string/droiuby'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: droiuby
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-20 00:00:00.000000000 Z
+date: 2014-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -80,20 +80,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Android app development and rapid prototyping using Ruby
 email: joseph.dayo@gmail.com
 executables:
@@ -122,7 +108,23 @@ files:
 - lib/droiuby/support/fixnum.rb
 - lib/droiuby/support/java.rb
 - lib/droiuby/support/object.rb
+- lib/droiuby/support/object/acts_like.rb
+- lib/droiuby/support/object/blank.rb
+- lib/droiuby/support/object/deep_dup.rb
+- lib/droiuby/support/object/duplicable.rb
+- lib/droiuby/support/object/inclusion.rb
+- lib/droiuby/support/object/instance_variables.rb
+- lib/droiuby/support/object/to_param.rb
+- lib/droiuby/support/object/to_query.rb
+- lib/droiuby/support/object/try.rb
 - lib/droiuby/support/string.rb
+- lib/droiuby/support/string/access.rb
+- lib/droiuby/support/string/behavior.rb
+- lib/droiuby/support/string/droiuby.rb
+- lib/droiuby/support/string/exclude.rb
+- lib/droiuby/support/string/filters.rb
+- lib/droiuby/support/string/indent.rb
+- lib/droiuby/support/string/starts_ends_with.rb
 - lib/droiuby/support/system.rb
 - lib/droiuby/support/thread.rb
 - lib/droiuby/support/to_query.rb