sugarcube 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f332d4a3b61ffc635ce448e7a662e58e29404fa0
-  data.tar.gz: dccc86101c347f94556f6caed6a45e12e4a495fd
+  metadata.gz: bf12c1ec6c187149c1cf88532de668af937ad888
+  data.tar.gz: 8f360b97c2eaa04c42c059136a0d692bebc01865
 SHA512:
-  metadata.gz: 3fdc960198799be70183442d44bbe1cd18516ad81ad24a780c48b8e72e0efb15b301c91d1124e150dff671fa664681149f4cca2a437a23b83675ee1c34074f69
-  data.tar.gz: 1b877867bf647b79edd367090bef377a0b1efc9434ab5a21784a1094ab833e5011169f02f065531e398118e190ac79a75284f7c5d37989490e1f6819b5f140e3
+  metadata.gz: 29031d55a41d4fa2ebb6be17be7617a217a40d0f063b7c09d2a536065fd84c64f9c271b2bf4281401d99fbe11b3e96c4b50a13c947b30a7c53363cbc1e3b456f
+  data.tar.gz: 02cd003ce97a249f4b0359ed01f918af71902aa22dd4e323430411fbd92e75314ade30185be0acb49f21c1ccbf6ed3576df97674a3739cf33e28f413fb78ac36

data/README.md

@@ -456,6 +456,8 @@ image.in_rect([[10, 10], [100, 100]])  # get part of an image
 
 image.darken  # => good for "pressed" buttons
 image.darken(brightness: -0.5, saturation: -0.2)  # these are the defaults
+image.gaussian_blur(radius: 5)
+image.inverted
 
 image.rotate(:left)
 image.rotate(:right)

data/lib/cocoa/sugarcube-localized/nsstring.rb

@@ -3,7 +3,7 @@ class NSString
   # This can be called as `"Hello".localized` or `"Hello"._`.  The `str._`
   # syntax is meant to be reminiscent of gettext-style `_(str)`.
   def localized(value=nil, table=nil)
-    @localized = NSBundle.mainBundle.localizedStringForKey(self, value: value, table: table)
+    NSBundle.mainBundle.localizedStringForKey(self, value: value, table: table)
   end
   alias _ localized
 

data/lib/cocoa/sugarcube-pointer/nsarray.rb

@@ -10,4 +10,15 @@ class NSArray
     ret
   end
 
+  # @param type [Symbol] type A pointer type from the list at {http://www.rubymotion.com/developer-center/guides/runtime/ RubyMotion Pointers Reference#_pointers}
+  # @return [Pointer] An array of pointers of the specified type
+  def to_pointers(type)
+    self.map do |val|
+      ptr = Pointer.new(type)
+      ptr[0] = val
+      ptr
+    end
+  end
+
+
 end

data/lib/ios/sugarcube-constants/symbol.rb

@@ -60,9 +60,15 @@ class Symbol
   alias nsalignment nstextalignment
 
   def uilinebreakmode
-    SugarCube.look_in(self, Symbol.uilinebreakmode, Symbol.uilinebreakmode__deprecated)
+    SugarCube.log('uilinebreakmode is deprecated.  Use nslinebreakmode instead.')
+    SugarCube.look_in(self, Symbol.nslinebreakmode)
   end
 
+  def nslinebreakmode
+    SugarCube.look_in(self, Symbol.nslinebreakmode)
+  end
+  alias nslinebreak nslinebreakmode
+
   def uibaselineadjustment
     SugarCube.look_in(self, Symbol.uibaselineadjustment, Symbol.uibaselineadjustment__deprecated)
   end
@@ -242,8 +248,7 @@ class Symbol
     attr :uikeyboardtype__deprecated
     attr :uitextalignment
     attr :nstextalignment
-    attr :uilinebreakmode
-    attr :uilinebreakmode__deprecated
+    attr :nslinebreakmode
     attr :uibaselineadjustment__deprecated
     attr :uibaselineadjustment
     attr :uibordertype
@@ -415,20 +420,25 @@ class Symbol
     center: NSTextAlignmentCenter,
   }
 
-  @uilinebreakmode__deprecated = {
-    wordwrap: :word_wrap,
-    characterwrap: :character_wrap,
-    headtruncation: :head_truncation,
-    tailtruncation: :tail_truncation,
-    middletruncation: :middle_truncation,
-  }
-  @uilinebreakmode = {
-    word_wrap:         UILineBreakModeWordWrap,
-    character_wrap:    UILineBreakModeCharacterWrap,
-    clip:              UILineBreakModeClip,
-    head_truncation:   UILineBreakModeHeadTruncation,
-    tail_truncation:   UILineBreakModeTailTruncation,
-    middle_truncation: UILineBreakModeMiddleTruncation,
+  @nslinebreakmode = {
+    word_wrapping:     NSLineBreakByWordWrapping,
+    word_wrap:         NSLineBreakByWordWrapping,
+    word:              NSLineBreakByWordWrapping,
+    char_wrapping:     NSLineBreakByCharWrapping,
+    char_wrap:         NSLineBreakByCharWrapping,
+    character_wrap:    NSLineBreakByCharWrapping,
+    char:              NSLineBreakByCharWrapping,
+    clipping:          NSLineBreakByClipping,
+    clip:              NSLineBreakByClipping,
+    truncating_head:   NSLineBreakByTruncatingHead,
+    head_truncation:   NSLineBreakByTruncatingHead,
+    head:              NSLineBreakByTruncatingHead,
+    truncating_tail:   NSLineBreakByTruncatingTail,
+    tail_truncation:   NSLineBreakByTruncatingTail,
+    tail:              NSLineBreakByTruncatingTail,
+    truncating_middle: NSLineBreakByTruncatingMiddle,
+    middle_truncation: NSLineBreakByTruncatingMiddle,
+    middle:            NSLineBreakByTruncatingMiddle
   }
 
   @uibaselineadjustment__deprecated = {
@@ -547,8 +557,10 @@ class Symbol
     info_dark:         UIButtonTypeInfoDark,
     contact:           UIButtonTypeContactAdd,
     contact_add:       UIButtonTypeContactAdd,
-    system:            UIButtonTypeSystem,
   }
+  if defined?(UIButtonTypeSystem)
+    @uibuttontype[:system] = UIButtonTypeSystem
+  end
 
   @uicontrolstate = {
     normal:      UIControlStateNormal,

data/lib/ios/sugarcube-image/cifilter.rb

@@ -97,7 +97,9 @@ class CIFilter
       end
 
       options.each do |key, value|
-        # translate the keys, but if there is no translation key then do nothing
+        # translate the keys, but if there is no translation key then try to
+        # assign the key as the user specified. This means you can pass options
+        # like `'inputRadius'` directly, without using an alias
         key = names[key] || key.to_s
 
         # translate the value if a block was given for that. `key` is always going

data/lib/ios/sugarcube-image/uiimage.rb

@@ -414,6 +414,18 @@ class UIImage
     return UIImage.imageWithCIImage(output, scale:self.scale, orientation:self.imageOrientation)
   end
 
+  # Invert the image
+  # @options - none
+  #
+  # @example
+  #   image.inverted
+  #
+  # similar to (image | CIFilter.color_invert).uiimage
+  def inverted
+    output = self.apply_filter(CIFilter.color_invert)
+    return UIImage.imageWithCIImage(output, scale:self.scale, orientation:self.imageOrientation)
+  end
+
   # Apply a gaussian filter
   # @options radius, default: 10
   #

data/lib/ios/sugarcube-uikit/uilabel.rb

@@ -1,17 +1,17 @@
 class UILabel
-	
-  # forces the given text to fit inside the label's frame starting at a given font size 
+
+  # forces the given text to fit inside the label's frame starting at a given font size
   def fit_to_size(max_size)
     #enforce word wrap
-    self.lineBreakMode = UILineBreakModeWordWrap
-    
+    self.lineBreakMode = NSLineBreakByWordWrapping
+
     dynamic_font = self.font.fontWithSize(max_size + 2)
     constraintSize = CGSizeMake(self.frame.size.width, 10000)
 
     # does it fit yet?
     begin
       dynamic_font = dynamic_font.fontWithSize(dynamic_font.pointSize - 2)
-      current_size = self.text.sizeWithFont(dynamic_font, constrainedToSize:constraintSize, lineBreakMode:UILineBreakModeWordWrap)
+      current_size = self.text.sizeWithFont(dynamic_font, constrainedToSize:constraintSize, lineBreakMode: NSLineBreakByWordWrapping)
     end while self.frame.size.height <= current_size.height
 
     #now set to font size we have settled on

data/lib/osx/sugarcube-constants/symbol.rb

@@ -48,6 +48,11 @@ class Symbol
     SugarCube.look_in(self, Symbol.nsfocusringtype)
   end
 
+  def nslinebreakmode
+    SugarCube.look_in(self, Symbol.nslinebreakmode)
+  end
+  alias nslinebreak nslinebreakmode
+
   def catimingfunction
     SugarCube.look_in(self, Symbol.catimingfunction)
   end
@@ -71,6 +76,7 @@ class Symbol
     attr :nsbuttontype
     attr :nsbezelstyle
     attr :nsfocusringtype
+    attr :nslinebreakmode
     attr :catimingfunction
     attr :cglinecap
     attr :cglinejoin
@@ -162,6 +168,23 @@ class Symbol
     exterior:  NSFocusRingTypeExterior,
   }
 
+  @nslinebreakmode = {
+    word_wrapping:     NSLineBreakByWordWrapping,
+    word_wrap:         NSLineBreakByWordWrapping,
+    word:              NSLineBreakByWordWrapping,
+    char_wrapping:     NSLineBreakByCharWrapping,
+    char_wrap:         NSLineBreakByCharWrapping,
+    char:              NSLineBreakByCharWrapping,
+    clipping:          NSLineBreakByClipping,
+    clip:              NSLineBreakByClipping,
+    truncating_head:   NSLineBreakByTruncatingHead,
+    head:              NSLineBreakByTruncatingHead,
+    truncating_tail:   NSLineBreakByTruncatingTail,
+    tail:              NSLineBreakByTruncatingTail,
+    truncating_middle: NSLineBreakByTruncatingMiddle,
+    middle:            NSLineBreakByTruncatingMiddle
+  }
+
   @catimingfunction = {
     linear:            KCAMediaTimingFunctionLinear,
     ease_in:           KCAMediaTimingFunctionEaseIn,

data/lib/version.rb

@@ -1,3 +1,3 @@
 module SugarCube
-  Version = '2.0.1'
+  Version = '2.0.2'
 end

data/spec/ios/animation_chain_spec.rb

@@ -1,6 +1,29 @@
 describe "SugarCube::AnimationChain" do
   tests SugarCube::AnimationChainController
 
+  it 'should not crash with a memory error' do
+    @did_run_1 = false
+    @did_run_2 = false
+    @did_run_3 = false
+
+    UIView.animation_chain(duration: 0.01) do
+      @did_run_1 = true
+      controller.view.scale_to 0.9, 0
+    end.and_then(duration: 0.01) do
+      @did_run_2 = true
+      controller.view.scale_to 1.1, 0
+    end.and_then(duration: 0.01) do
+      @did_run_3 = true
+      controller.view.scale_to 1, 0
+    end.start
+
+    wait 0.1 do
+      @did_run_1.should == true
+      @did_run_2.should == true
+      @did_run_3.should == true
+    end
+  end
+
   it "should support chains" do
     SugarCube::AnimationChain.chains.length.should == 0
     @variable_a = nil

data/spec/ios/date_parser_spec.rb

@@ -3,7 +3,7 @@ describe "Base Methods" do
   it "parses a relative natural language string, returning a date" do
     today = Time.now
     t = SugarCube::DateParser.parse_date("tomorrow at 7:30 PM")
-    t.should.is_a Time
+    t.should.be.kind_of Time
     t.hour.should == 19
     t.min.should == 30
     t.sec.should == 0

data/spec/ios/image_cifilters_spec.rb

@@ -2,547 +2,553 @@ describe "CIFilter extensions" do
 
   it "should implement the CIAdditionCompositing filter" do
     -> {
-      CIFilter.addition_compositing.should.is_a(CIFilter)
+      CIFilter.addition_compositing.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIAffineClamp filter" do
     -> {
-      CIFilter.affine_clamp.should.is_a(CIFilter)
+      CIFilter.affine_clamp.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIAffineTile filter" do
     -> {
-      CIFilter.affine_tile.should.is_a(CIFilter)
+      CIFilter.affine_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIAffineTransform filter" do
     -> {
-      CIFilter.affine_transform.should.is_a(CIFilter)
+      CIFilter.affine_transform.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIBarsSwipeTransition filter" do
     -> {
-      CIFilter.bars_swipe_transition.should.is_a(CIFilter)
+      CIFilter.bars_swipe_transition.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIBlendWithMask filter" do
     -> {
-      CIFilter.blend_with_mask.should.is_a(CIFilter)
+      CIFilter.blend_with_mask.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIBloom filter" do
     -> {
-      CIFilter.bloom.should.is_a(CIFilter)
+      CIFilter.bloom.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIBumpDistortion filter" do
     -> {
-      CIFilter.bump_distortion.should.is_a(CIFilter)
+      CIFilter.bump_distortion.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIBumpDistortionLinear filter" do
     -> {
-      CIFilter.bump_distortion_linear.should.is_a(CIFilter)
+      CIFilter.bump_distortion_linear.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CICheckerboardGenerator filter" do
     -> {
-      CIFilter.checkerboard_generator.should.is_a(CIFilter)
+      CIFilter.checkerboard_generator.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CICircleSplashDistortion filter" do
     -> {
-      CIFilter.circle_splash_distortion.should.is_a(CIFilter)
+      CIFilter.circle_splash_distortion.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CICircularScreen filter" do
     -> {
-      CIFilter.circular_screen.should.is_a(CIFilter)
+      CIFilter.circular_screen.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorBlendMode filter" do
     -> {
-      CIFilter.color_blend_mode.should.is_a(CIFilter)
+      CIFilter.color_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorBurnBlendMode filter" do
     -> {
-      CIFilter.color_burn_blend_mode.should.is_a(CIFilter)
+      CIFilter.color_burn_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorControls filter" do
     -> {
-      CIFilter.color_controls.should.is_a(CIFilter)
+      CIFilter.color_controls.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorCube filter" do
     -> {
-      CIFilter.color_cube.should.is_a(CIFilter)
+      CIFilter.color_cube.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorDodgeBlendMode filter" do
     -> {
-      CIFilter.color_dodge_blend_mode.should.is_a(CIFilter)
+      CIFilter.color_dodge_blend_mode.should.be.kind_of(CIFilter)
+    }.should.not.raise
+  end
+
+  it "should implement the CIColorInvert filter" do
+    -> {
+      CIFilter.color_invert.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorMap filter" do
     -> {
-      CIFilter.color_map.should.is_a(CIFilter)
+      CIFilter.color_map.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorMatrix filter" do
     -> {
-      CIFilter.color_matrix.should.is_a(CIFilter)
+      CIFilter.color_matrix.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorMonochrome filter" do
     -> {
-      CIFilter.color_monochrome.should.is_a(CIFilter)
+      CIFilter.color_monochrome.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIColorPosterize filter" do
     -> {
-      CIFilter.color_posterize.should.is_a(CIFilter)
+      CIFilter.color_posterize.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIConstantColorGenerator filter" do
     -> {
-      CIFilter.constant_color_generator.should.is_a(CIFilter)
+      CIFilter.constant_color_generator.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CICopyMachineTransition filter" do
     -> {
-      CIFilter.copy_machine_transition.should.is_a(CIFilter)
+      CIFilter.copy_machine_transition.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CICrop filter" do
     -> {
-      CIFilter.crop.should.is_a(CIFilter)
+      CIFilter.crop.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIDarkenBlendMode filter" do
     -> {
-      CIFilter.darken_blend_mode.should.is_a(CIFilter)
+      CIFilter.darken_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIDifferenceBlendMode filter" do
     -> {
-      CIFilter.difference_blend_mode.should.is_a(CIFilter)
+      CIFilter.difference_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIDisintegrateWithMaskTransition filter" do
     -> {
-      CIFilter.disintegrate_with_mask_transition.should.is_a(CIFilter)
+      CIFilter.disintegrate_with_mask_transition.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIDissolveTransition filter" do
     -> {
-      CIFilter.dissolve_transition.should.is_a(CIFilter)
+      CIFilter.dissolve_transition.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIDotScreen filter" do
     -> {
-      CIFilter.dot_screen.should.is_a(CIFilter)
+      CIFilter.dot_screen.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIEightfoldReflectedTile filter" do
     -> {
-      CIFilter.eightfold_reflected_tile.should.is_a(CIFilter)
+      CIFilter.eightfold_reflected_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIExclusionBlendMode filter" do
     -> {
-      CIFilter.exclusion_blend_mode.should.is_a(CIFilter)
+      CIFilter.exclusion_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIExposureAdjust filter" do
     -> {
-      CIFilter.exposure_adjust.should.is_a(CIFilter)
+      CIFilter.exposure_adjust.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIFalseColor filter" do
     -> {
-      CIFilter.false_color.should.is_a(CIFilter)
+      CIFilter.false_color.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIFlashTransition filter" do
     -> {
-      CIFilter.flash_transition.should.is_a(CIFilter)
+      CIFilter.flash_transition.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIFourfoldReflectedTile filter" do
     -> {
-      CIFilter.fourfold_reflected_tile.should.is_a(CIFilter)
+      CIFilter.fourfold_reflected_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIFourfoldRotatedTile filter" do
     -> {
-      CIFilter.fourfold_rotated_tile.should.is_a(CIFilter)
+      CIFilter.fourfold_rotated_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIFourfoldTranslatedTile filter" do
     -> {
-      CIFilter.fourfold_translated_tile.should.is_a(CIFilter)
+      CIFilter.fourfold_translated_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIGammaAdjust filter" do
     -> {
-      CIFilter.gamma_adjust.should.is_a(CIFilter)
+      CIFilter.gamma_adjust.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIGaussianBlur filter" do
     -> {
-      CIFilter.gaussian_blur.should.is_a(CIFilter)
+      CIFilter.gaussian_blur.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIGaussianGradient filter" do
     -> {
-      CIFilter.gaussian_gradient.should.is_a(CIFilter)
+      CIFilter.gaussian_gradient.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIGlideReflectedTile filter" do
     -> {
-      CIFilter.glide_reflected_tile.should.is_a(CIFilter)
+      CIFilter.glide_reflected_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIGloom filter" do
     -> {
-      CIFilter.gloom.should.is_a(CIFilter)
+      CIFilter.gloom.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIHardLightBlendMode filter" do
     -> {
-      CIFilter.hard_light_blend_mode.should.is_a(CIFilter)
+      CIFilter.hard_light_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIHatchedScreen filter" do
     -> {
-      CIFilter.hatched_screen.should.is_a(CIFilter)
+      CIFilter.hatched_screen.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIHighlightShadowAdjust filter" do
     -> {
-      CIFilter.highlight_shadow_adjust.should.is_a(CIFilter)
+      CIFilter.highlight_shadow_adjust.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIHoleDistortion filter" do
     -> {
-      CIFilter.hole_distortion.should.is_a(CIFilter)
+      CIFilter.hole_distortion.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIHueAdjust filter" do
     -> {
-      CIFilter.hue_adjust.should.is_a(CIFilter)
+      CIFilter.hue_adjust.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIHueBlendMode filter" do
     -> {
-      CIFilter.hue_blend_mode.should.is_a(CIFilter)
+      CIFilter.hue_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CILanczosScaleTransform filter" do
     -> {
-      CIFilter.lanczos_scale_transform.should.is_a(CIFilter)
+      CIFilter.lanczos_scale_transform.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CILightenBlendMode filter" do
     -> {
-      CIFilter.lighten_blend_mode.should.is_a(CIFilter)
+      CIFilter.lighten_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CILightTunnel filter" do
     -> {
-      CIFilter.light_tunnel.should.is_a(CIFilter)
+      CIFilter.light_tunnel.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CILinearGradient filter" do
     -> {
-      CIFilter.linear_gradient.should.is_a(CIFilter)
+      CIFilter.linear_gradient.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CILineScreen filter" do
     -> {
-      CIFilter.line_screen.should.is_a(CIFilter)
+      CIFilter.line_screen.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CILuminosityBlendMode filter" do
     -> {
-      CIFilter.luminosity_blend_mode.should.is_a(CIFilter)
+      CIFilter.luminosity_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIMaximumCompositing filter" do
     -> {
-      CIFilter.maximum_compositing.should.is_a(CIFilter)
+      CIFilter.maximum_compositing.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIMinimumCompositing filter" do
     -> {
-      CIFilter.minimum_compositing.should.is_a(CIFilter)
+      CIFilter.minimum_compositing.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIModTransition filter" do
     -> {
-      CIFilter.mod_transition.should.is_a(CIFilter)
+      CIFilter.mod_transition.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIMultiplyBlendMode filter" do
     -> {
-      CIFilter.multiply_blend_mode.should.is_a(CIFilter)
+      CIFilter.multiply_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIMultiplyCompositing filter" do
     -> {
-      CIFilter.multiply_compositing.should.is_a(CIFilter)
+      CIFilter.multiply_compositing.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIOverlayBlendMode filter" do
     -> {
-      CIFilter.overlay_blend_mode.should.is_a(CIFilter)
+      CIFilter.overlay_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIPerspectiveTile filter" do
     -> {
-      CIFilter.perspective_tile.should.is_a(CIFilter)
+      CIFilter.perspective_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIPerspectiveTransform filter" do
     -> {
-      CIFilter.perspective_transform.should.is_a(CIFilter)
+      CIFilter.perspective_transform.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIPerspectiveTransformWithExtent filter" do
     -> {
-      CIFilter.perspective_transform_with_extent.should.is_a(CIFilter)
+      CIFilter.perspective_transform_with_extent.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIPinchDistortion filter" do
     -> {
-      CIFilter.pinch_distortion.should.is_a(CIFilter)
+      CIFilter.pinch_distortion.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIPixellate filter" do
     -> {
-      CIFilter.pixellate.should.is_a(CIFilter)
+      CIFilter.pixellate.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIRadialGradient filter" do
     -> {
-      CIFilter.radial_gradient.should.is_a(CIFilter)
+      CIFilter.radial_gradient.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISaturationBlendMode filter" do
     -> {
-      CIFilter.saturation_blend_mode.should.is_a(CIFilter)
+      CIFilter.saturation_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIScreenBlendMode filter" do
     -> {
-      CIFilter.screen_blend_mode.should.is_a(CIFilter)
+      CIFilter.screen_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISepiaTone filter" do
     -> {
-      CIFilter.sepia_tone.should.is_a(CIFilter)
+      CIFilter.sepia_tone.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISharpenLuminance filter" do
     -> {
-      CIFilter.sharpen_luminance.should.is_a(CIFilter)
+      CIFilter.sharpen_luminance.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISixfoldReflectedTile filter" do
     -> {
-      CIFilter.sixfold_reflected_tile.should.is_a(CIFilter)
+      CIFilter.sixfold_reflected_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISixfoldRotatedTile filter" do
     -> {
-      CIFilter.sixfold_rotated_tile.should.is_a(CIFilter)
+      CIFilter.sixfold_rotated_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISoftLightBlendMode filter" do
     -> {
-      CIFilter.soft_light_blend_mode.should.is_a(CIFilter)
+      CIFilter.soft_light_blend_mode.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISourceAtopCompositing filter" do
     -> {
-      CIFilter.source_atop_compositing.should.is_a(CIFilter)
+      CIFilter.source_atop_compositing.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISourceInCompositing filter" do
     -> {
-      CIFilter.source_in_compositing.should.is_a(CIFilter)
+      CIFilter.source_in_compositing.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISourceOutCompositing filter" do
     -> {
-      CIFilter.source_out_compositing.should.is_a(CIFilter)
+      CIFilter.source_out_compositing.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISourceOverCompositing filter" do
     -> {
-      CIFilter.source_over_compositing.should.is_a(CIFilter)
+      CIFilter.source_over_compositing.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIStarShineGenerator filter" do
     -> {
-      CIFilter.star_shine_generator.should.is_a(CIFilter)
+      CIFilter.star_shine_generator.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIStraightenFilter filter" do
     -> {
-      CIFilter.straighten_filter.should.is_a(CIFilter)
+      CIFilter.straighten_filter.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIStripesGenerator filter" do
     -> {
-      CIFilter.stripes_generator.should.is_a(CIFilter)
+      CIFilter.stripes_generator.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CISwipeTransition filter" do
     -> {
-      CIFilter.swipe_transition.should.is_a(CIFilter)
+      CIFilter.swipe_transition.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CITemperatureAndTint filter" do
     -> {
-      CIFilter.temperature_and_tint.should.is_a(CIFilter)
+      CIFilter.temperature_and_tint.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIToneCurve filter" do
     -> {
-      CIFilter.tone_curve.should.is_a(CIFilter)
+      CIFilter.tone_curve.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CITriangleKaleidoscope filter" do
     -> {
-      CIFilter.triangle_kaleidoscope.should.is_a(CIFilter)
+      CIFilter.triangle_kaleidoscope.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CITwelvefoldReflectedTile filter" do
     -> {
-      CIFilter.twelvefold_reflected_tile.should.is_a(CIFilter)
+      CIFilter.twelvefold_reflected_tile.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CITwirlDistortion filter" do
     -> {
-      CIFilter.twirl_distortion.should.is_a(CIFilter)
+      CIFilter.twirl_distortion.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIUnsharpMask filter" do
     -> {
-      CIFilter.unsharp_mask.should.is_a(CIFilter)
+      CIFilter.unsharp_mask.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIVibrance filter" do
     -> {
-      CIFilter.vibrance.should.is_a(CIFilter)
+      CIFilter.vibrance.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIVignette filter" do
     -> {
-      CIFilter.vignette.should.is_a(CIFilter)
+      CIFilter.vignette.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIVortexDistortion filter" do
     -> {
-      CIFilter.vortex_distortion.should.is_a(CIFilter)
+      CIFilter.vortex_distortion.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 
   it "should implement the CIWhitePointAdjust filter" do
     -> {
-      CIFilter.white_point_adjust.should.is_a(CIFilter)
+      CIFilter.white_point_adjust.should.be.kind_of(CIFilter)
     }.should.not.raise
   end
 

data/spec/ios/image_uiimage_filters_spec.rb

@@ -6,17 +6,25 @@ describe "UIImage effects w/ CIImage & CIFilter" do
   describe 'should apply a gaussian blur' do
     it 'should have a gaussian_blur method' do
       -> {
-        @image.gaussian_blur.should.is_a(UIImage)
+        @image.gaussian_blur.should.be.kind_of(UIImage)
       }.should.not.raise
     end
     it 'should accept a :radius option' do
       -> {
-        @image.gaussian_blur(radius: 5).should.is_a(UIImage)
+        @image.gaussian_blur(radius: 5).should.be.kind_of(UIImage)
       }.should.not.raise
     end
     it 'should accept a :radius argument in 0th position' do
       -> {
-        @image.gaussian_blur(5).should.is_a(UIImage)
+        @image.gaussian_blur(5).should.be.kind_of(UIImage)
+      }.should.not.raise
+    end
+  end
+
+  describe 'should apply inverted colors' do
+    it 'should have inverted method' do
+      -> {
+        @image.inverted.should.be.kind_of(UIImage)
       }.should.not.raise
     end
   end
@@ -24,22 +32,22 @@ describe "UIImage effects w/ CIImage & CIFilter" do
   describe 'should apply a darken filter' do
     it 'should have a darken method' do
       -> {
-        @image.darken.should.is_a(UIImage)
+        @image.darken.should.be.kind_of(UIImage)
       }.should.not.raise
     end
     it 'should accept a :saturation option' do
       -> {
-        @image.darken(saturation: 5).should.is_a(UIImage)
+        @image.darken(saturation: 5).should.be.kind_of(UIImage)
       }.should.not.raise
     end
     it 'should accept a :brightness option' do
       -> {
-        @image.darken(brightness: 5).should.is_a(UIImage)
+        @image.darken(brightness: 5).should.be.kind_of(UIImage)
       }.should.not.raise
     end
     it 'should accept a :saturation and a :brightness option' do
       -> {
-        @image.darken(saturation: 5, brightness: 5).should.is_a(UIImage)
+        @image.darken(saturation: 5, brightness: 5).should.be.kind_of(UIImage)
       }.should.not.raise
     end
   end

data/spec/ios/nsdata_spec.rb

@@ -34,21 +34,21 @@ describe "NSData" do
 
     it "shouldn't need a format" do
       new_image = @image.nsdata.uiimage
-      new_image.should.is_a? UIImage
+      new_image.should.be.kind_of UIImage
       new_image.size.width.should == @image.size.width * @image.scale
       new_image.size.height.should == @image.size.height * @image.scale
     end
 
     it "should support :png" do
       new_image = @image.nsdata(:png).uiimage
-      new_image.should.is_a? UIImage
+      new_image.should.be.kind_of UIImage
       new_image.size.width.should == @image.size.width * @image.scale
       new_image.size.height.should == @image.size.height * @image.scale
     end
 
     it "should support :jpg" do
       new_image = @image.nsdata(:jpg).uiimage
-      new_image.should.is_a? UIImage
+      new_image.should.be.kind_of UIImage
       new_image.size.width.should == @image.size.width * @image.scale
       new_image.size.height.should == @image.size.height * @image.scale
     end

data/spec/ios/nsstring_files_spec.rb

@@ -194,7 +194,7 @@ describe 'NSString' do
   describe 'file_url' do
 
     it 'should convert path String to NSURL' do
-      'test'.resource_path.file_url.should.is_a?(NSURL)
+      'test'.resource_path.file_url.should.be.kind_of(NSURL)
     end
 
     it 'should be a file path' do

data/spec/ios/symbol_constants_spec.rb

@@ -99,13 +99,25 @@ describe "Symbol - constants" do
       :center.nstextalignment.should == NSTextAlignmentCenter
     end
 
-    it 'should support `uilinebreakmode`' do
-      :word_wrap.uilinebreakmode.should == UILineBreakModeWordWrap
-      :character_wrap.uilinebreakmode.should == UILineBreakModeCharacterWrap
-      :clip.uilinebreakmode.should == UILineBreakModeClip
-      :head_truncation.uilinebreakmode.should == UILineBreakModeHeadTruncation
-      :tail_truncation.uilinebreakmode.should == UILineBreakModeTailTruncation
-      :middle_truncation.uilinebreakmode.should == UILineBreakModeMiddleTruncation
+    it 'should support `nslinebreakmode`' do
+      :word_wrapping.nslinebreakmode.should == NSLineBreakByWordWrapping
+      :word_wrap.nslinebreakmode.should == NSLineBreakByWordWrapping
+      :word.nslinebreakmode.should == NSLineBreakByWordWrapping
+      :char_wrapping.nslinebreakmode.should == NSLineBreakByCharWrapping
+      :char_wrap.nslinebreakmode.should == NSLineBreakByCharWrapping
+      :character_wrap.nslinebreakmode.should == NSLineBreakByCharWrapping
+      :char.nslinebreakmode.should == NSLineBreakByCharWrapping
+      :clipping.nslinebreakmode.should == NSLineBreakByClipping
+      :clip.nslinebreakmode.should == NSLineBreakByClipping
+      :truncating_head.nslinebreakmode.should == NSLineBreakByTruncatingHead
+      :head_truncation.nslinebreakmode.should == NSLineBreakByTruncatingHead
+      :head.nslinebreakmode.should == NSLineBreakByTruncatingHead
+      :truncating_tail.nslinebreakmode.should == NSLineBreakByTruncatingTail
+      :tail_truncation.nslinebreakmode.should == NSLineBreakByTruncatingTail
+      :tail.nslinebreakmode.should == NSLineBreakByTruncatingTail
+      :truncating_middle.nslinebreakmode.should == NSLineBreakByTruncatingMiddle
+      :middle_truncation.nslinebreakmode.should == NSLineBreakByTruncatingMiddle
+      :middle.nslinebreakmode.should == NSLineBreakByTruncatingMiddle
     end
 
     it 'should support `uibaselineadjustment`' do
@@ -482,6 +494,17 @@ describe "Symbol - constants" do
 
     it 'should support `uitextalignment`' do
       :left.uialignment.should == :left.uitextalignment
+      SugarCube.log.length.should > 0
+    end
+
+    it 'should support `uilinebreakmode`' do
+      :word_wrap.uilinebreakmode.should == NSLineBreakByWordWrapping
+      :character_wrap.uilinebreakmode.should == NSLineBreakByCharWrapping
+      :clip.uilinebreakmode.should == NSLineBreakByClipping
+      :head_truncation.uilinebreakmode.should == NSLineBreakByTruncatingHead
+      :tail_truncation.uilinebreakmode.should == NSLineBreakByTruncatingTail
+      :middle_truncation.uilinebreakmode.should == NSLineBreakByTruncatingMiddle
+      SugarCube.log.length.should > 0
     end
 
     it 'should support `uibaselineadjustment`' do
@@ -509,15 +532,6 @@ describe "Symbol - constants" do
       SugarCube.log.length.should > 0
     end
 
-    it 'should support `uilinebreakmode`' do
-      :wordwrap.uilinebreakmode.should == :word_wrap.uilinebreakmode
-      :characterwrap.uilinebreakmode.should == :character_wrap.uilinebreakmode
-      :headtruncation.uilinebreakmode.should == :head_truncation.uilinebreakmode
-      :tailtruncation.uilinebreakmode.should == :tail_truncation.uilinebreakmode
-      :middletruncation.uilinebreakmode.should == :middle_truncation.uilinebreakmode
-      SugarCube.log.length.should > 0
-    end
-
     it 'should support `nsnumberstyle`' do
       :spellout.nsnumberstyle.should == :spell_out.nsnumberstyle
       SugarCube.log.length.should > 0
@@ -598,6 +612,10 @@ describe "Symbol - constants" do
       :align_baselines.uibaseline.should == :align_baselines.uibaselineadjustment
     end
 
+    it 'should have alias for `nslinebreakmode`' do
+      :head.nslinebreakmode.should == :head.nslinebreak
+    end
+
     it 'should have alias for `uibordertype`' do
       :none.uiborderstyle.should == :none.uibordertype
     end
@@ -731,6 +749,10 @@ describe "Symbol - constants" do
       should.raise(SugarCubeNotFoundException) { :definitely_doesnt_exist_i_am_really_sure_of_it.uilinebreakmode }
     end
 
+    it 'should not find nonexistant `nslinebreakmode`' do
+      should.raise(SugarCubeNotFoundException) { :definitely_doesnt_exist_i_am_really_sure_of_it.nslinebreakmode }
+    end
+
     it 'should not find nonexistant `uibaselineadjustment`' do
       should.raise(SugarCubeNotFoundException) { :definitely_doesnt_exist_i_am_really_sure_of_it.uibaselineadjustment }
     end

data/spec/ios/uiimage_spec.rb

@@ -3,7 +3,7 @@ describe 'UIImage' do
   describe 'UIImage.canvas' do
 
     it 'should create an image' do
-      UIImage.canvas(size: [10, 10]).should.is_a UIImage
+      UIImage.canvas(size: [10, 10]).should.be.kind_of UIImage
     end
 
     it 'should have the right size' do
@@ -486,7 +486,7 @@ describe 'UIImage' do
         CGContextAddRect(context, [[0, 0], [10, 10]])
         CGContextFillPath(context)
       end
-      red.overlay(:white).should.is_a?(UIImage)
+      red.overlay(:white).should.be.kind_of UIImage
     end
 
     it 'should return an image that is the same size' do

data/spec/osx/symbol_constants_spec.rb

@@ -88,6 +88,23 @@ describe "Symbol - constants" do
       :exterior.nsfocusringtype.should == NSFocusRingTypeExterior
     end
 
+    it 'should support `nslinebreakmode`' do
+      :word_wrapping.nslinebreakmode.should == NSLineBreakByWordWrapping
+      :word_wrap.nslinebreakmode.should == NSLineBreakByWordWrapping
+      :word.nslinebreakmode.should == NSLineBreakByWordWrapping
+      :char_wrapping.nslinebreakmode.should == NSLineBreakByCharWrapping
+      :char_wrap.nslinebreakmode.should == NSLineBreakByCharWrapping
+      :char.nslinebreakmode.should == NSLineBreakByCharWrapping
+      :clipping.nslinebreakmode.should == NSLineBreakByClipping
+      :clip.nslinebreakmode.should == NSLineBreakByClipping
+      :truncating_head.nslinebreakmode.should == NSLineBreakByTruncatingHead
+      :head.nslinebreakmode.should == NSLineBreakByTruncatingHead
+      :truncating_tail.nslinebreakmode.should == NSLineBreakByTruncatingTail
+      :tail.nslinebreakmode.should == NSLineBreakByTruncatingTail
+      :truncating_middle.nslinebreakmode.should == NSLineBreakByTruncatingMiddle
+      :middle.nslinebreakmode.should == NSLineBreakByTruncatingMiddle
+    end
+
     it 'should support `catimingfunction`' do
       :linear.catimingfunction.should == KCAMediaTimingFunctionLinear
       :ease_in.catimingfunction.should == KCAMediaTimingFunctionEaseIn
@@ -140,6 +157,10 @@ describe "Symbol - constants" do
       :miter.cglinejoinstyle.should == :miter.cglinejoin
     end
 
+    it 'should have alias for `nslinebreakmode`' do
+      :head.nslinebreakmode.should == :head.nslinebreak
+    end
+
   end
 
   describe "not found" do
@@ -171,6 +192,10 @@ describe "Symbol - constants" do
       should.raise(SugarCubeNotFoundException) { :definitely_doesnt_exist_i_am_really_sure_of_it.nsfocusringtype }
     end
 
+    it 'should not find nonexistant `nslinebreakmode`' do
+      should.raise(SugarCubeNotFoundException) { :definitely_doesnt_exist_i_am_really_sure_of_it.nslinebreakmode }
+    end
+
     it 'should not find nonexistant `catimingfunction`' do
       should.raise(SugarCubeNotFoundException) { :definitely_doesnt_exist_i_am_really_sure_of_it.catimingfunction }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sugarcube
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Colin T.A. Gray
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-23 00:00:00.000000000 Z
+date: 2014-08-26 00:00:00.000000000 Z
 dependencies: []
 description: |
   == Description