Show HN: NSString + Ruby(github.com)
github.com
Show HN: NSString + Ruby
https://github.com/zdavison/NSString-Ruby
52 comments
-(NSString*)capitalizeInPlace; is the actual signature.
The reasoning for this is for consistency, while still maintaining autocomplete proximity.
The reasoning for this is for consistency, while still maintaining autocomplete proximity.
I'm not really sure I understand; why would calling the method "capitalize" instead of "capitalizeInPlace" be inconsistent?
(Also, the comments in the header file and the README file contain the name "capitalizedStringInPlace" instead of "capitalizeInPlace")
Another inconsistency is that most mutating methods in ObjectiveC don't return self, but either void or a boolean or an integer that reports if the method succeeded. But I assume that this inconsistency is on purpose because you want to make the methods chainable.
(Also, the comments in the header file and the README file contain the name "capitalizedStringInPlace" instead of "capitalizeInPlace")
Another inconsistency is that most mutating methods in ObjectiveC don't return self, but either void or a boolean or an integer that reports if the method succeeded. But I assume that this inconsistency is on purpose because you want to make the methods chainable.
The issue with the default syntax in NSString is that the mutating methods are the more concise, but are also the ones you use the least. It makes far more sense for the more used methods to be more concise than their mutating siblings.
I don't disagree with you though. I'd prefer if the interface for this was more idiomatic.
Returning void is sort of pointless. A boolean, maybe. I feel like returning self is just making better use of things, really, and probably doesn't really cause any confusion.
I don't disagree with you though. I'd prefer if the interface for this was more idiomatic.
Returning void is sort of pointless. A boolean, maybe. I feel like returning self is just making better use of things, really, and probably doesn't really cause any confusion.
Okay, now I get it, the naming makes autocomplete more convenient.
Returning void makes it easier to spot errors. If you accidentally use "capitalizeInPlace" instead of "capitalizedString" your code will compile without issues. If the mutating method returned void, it would result in a compile error.
Returning void makes it easier to spot errors. If you accidentally use "capitalizeInPlace" instead of "capitalizedString" your code will compile without issues. If the mutating method returned void, it would result in a compile error.
That's an extreme edge case though, since if you're using a mutating method, you're using a mutating string, and you're probably aware of that.
What's stopping you from submitting a pull request with these suggestions?
Two reasons:
a) The author might disagree with my asessment. A pull request would imply that I consider it an error, but I think it's more a question of style.
b) I already waste too much time on HN. Forking a project, trying to understand all of it, making changes, writing a pull request, etc. would probably take me all day but I need to clean the kitchen and take care of the kids and work on some overdue client work that I have been postponing for far too long.
a) The author might disagree with my asessment. A pull request would imply that I consider it an error, but I think it's more a question of style.
b) I already waste too much time on HN. Forking a project, trying to understand all of it, making changes, writing a pull request, etc. would probably take me all day but I need to clean the kitchen and take care of the kids and work on some overdue client work that I have been postponing for far too long.
If you open a new issue on GitHub, somebody else could fix it.
I have to add the obligatory pitch for just using RubyMotion. I use it/love it, and def recommend it for those that have become a bit annoyed with the verbose-ness of obj-c.
I love the idea of RM and would like to give it a try, but I keep hearing murmurs about memory management issues and other little glitches that crop up from time to time. I also hear that these kinds of problems get fixed very quickly, but the idea of being stuck even for a short time while waiting for a proprietary abstraction to be patched up makes me a bit hesitant to reach for it for a serious app. Are these concerns overblown?
I'm writing a RM app right now and believe these concerns to be overblown. They're overblown in the same way "Rails doesn't scale" is nonsense. The addition of WeakRef to RM helps significantly. And you just have to look out for gotchas.
If you want to be really convinced, check out RMQ: https://github.com/infinitered/rmq. Has made my life so easy.
If you want to be really convinced, check out RMQ: https://github.com/infinitered/rmq. Has made my life so easy.
There were some showstoppers with regards to memory leaks using procs/blocks. There's still a few major ones occasionally where you might be unable to use certain newer frameworks. You'll have to wait for them to fix it. But if you aren't on the bleeding edge, it's not so bad.
I believe there was an actual problem with Procs that they fixed a couple of months or so ago. The core developers seem to be active on Twitter, so you could ask the source directly if nobody here knows.
A friend of mine made NSArray extensions with a Ruby syntax a while back. Certainly useful if you find these helpful.
https://github.com/nsantorello/nsarray-extensions
https://github.com/nsantorello/nsarray-extensions
Good, I was worried people could actually be able to correctly manipulate text through NSString, that fixes it as it's impossible to not break text when using Ruby strings.
>> hn.txt
Wow, this looks really useful. Thanks for building this!
hell yes - im a python guy but this still looks great!
Add a String format one, then is set!
Still don't have a clever implementation.
Unfortunately, although there's no particular reason for it, you're not allowed to write a method that takes only variadic arguments. This doesn't work:
- (NSString *)format: ...;
newstr = [@"%d %@ %s" format: 42, @"blah", "yep"];
newstr = fmt(@"%d %@ %s", 42, @"blah", "yep");Comedy option:
Or, for the completely insane approach that probably doesn't actually work (on top of being entirely unportable):
- (NSString *)format:(id)first, ... {
NSUInteger argCount = 0;
BOOL prevPercent = NO;
for (NSUInteger i = 0; i < [self length]; ++i) {
unichar c = [self characterAtIndex:i];
if (prevPercent && c != '%')
++argCount;
prevPercent = c == '%';
}
NSMutableArray *argArr = [NSMutableArray new];
va_list args;
va_start(args, first);
for (NSUInteger i = 0; i < argCount; ++i)
[argArr addObject:va_arg(args, id)];
va_end(args);
switch (argCount) {
case 0: return [NSString stringWithFormat:self, first];
case 1: return [NSString stringWithFormat:self, first, argArr[0]];
case 2: return [NSString stringWithFormat:self, first, argArr[0], argArr[1]];
// ...
}
}
Or, for the completely insane approach that probably doesn't actually work (on top of being entirely unportable):
- (NSString *)format:(id)first, ... {
NSUInteger argCount = ...;
va_list args;
va_start(args, first);
void *argList = malloc(sizeof(id) * (argCount + 1));
memcpy(argList, (void*)&first, sizeof(id));
memcpy(argList + sizeof(id), &va_arg(args, void *), sizeof(id) * argCount);
va_end(args);
NSString *ret = [[NSString alloc] initWithFormat:self arguments:argList];
free(argList);
return ret;
}Why not just have it be a static method like stringWithFormat?
+ (id)stringWithFormat:(NSString *)format, ...;
The problem people have with the format implementation is that no matter what you do, it's either obtuse shorthand, or incredibly verbose.
The reality is, that NSString needs native formatting sugar. Anything else would really just be a hack. I'm not particularly even happy with the [@"Hello ":@"World] syntax, either.
The reality is, that NSString needs native formatting sugar. Anything else would really just be a hack. I'm not particularly even happy with the [@"Hello ":@"World] syntax, either.
Exactly I just want this:
NSString *newS = @"blah " + @(42) + @"!";Here's a crazy idea:
newstr = [@"%d %@" format 42, @"blah"];
- (NSString *)format:(int)dummy, ...
#define format format:0,
I'm not super comfortable with breaking message syntax like that. Also, very wary of using a #define with a short oft used keyword in a library that will be imported in majority of headers.
Unfortunately, something like "fmt()" isn't really elegant enough, or "objective-c" enough.
They look like convenient additions... but I'd be reluctant to add so many category methods onto a Foundation class. Especially for un-prefixed methods.
If a future version of iOS adds an -sum method, for example, you'd better hope it has the exact same semantics as yours, otherwise if the system calls -sum expecting its implementation to be used, bad things (or worse, bad things with no apparent cause) will happen when your implementation is used instead.
If a future version of iOS adds an -sum method, for example, you'd better hope it has the exact same semantics as yours, otherwise if the system calls -sum expecting its implementation to be used, bad things (or worse, bad things with no apparent cause) will happen when your implementation is used instead.
I'd correct the category. Also, NSString is not going to change. If it does, it will be rewritten extensively, most probably obsoleting this category.
Methods are often added to core classes like NSString. For example, in iOS 6:
https://developer.apple.com/library/ios/releasenotes/General...
And you changing the category won't help the versions already out in the wild. Hopefully, automatic updates will mitigate this to some degree but not everyone will turn them on.
There are workarounds (like prefixing methods with a pseudo-namespace), but they're all a bit ugly. Might be worth considering though.
And you changing the category won't help the versions already out in the wild. Hopefully, automatic updates will mitigate this to some degree but not everyone will turn them on.
There are workarounds (like prefixing methods with a pseudo-namespace), but they're all a bit ugly. Might be worth considering though.
Actually, I might add some protection around this specific case.
Is 'category' like a extension method in c#?
Yeah, except you can add properties, though you have to do it with objc_(s|g)etAssociatedObject
https://developer.apple.com/library/ios/documentation/Cocoa/...
https://developer.apple.com/library/ios/documentation/Cocoa/...
Super! Are you motivated to do more like this?
I'll donate $100 to you if you want to continue with NS+Ruby classes.
I'll donate $100 to you if you want to continue with NS+Ruby classes.
There are already a lot of Ruby categories out there. ObjectiveSugar covers a lot of bases. I personally wouldn't import more Ruby categories. The NSString API is a weak point of Cocoa, IMO, but in general I wouldn't like to see a large amount of unique, dependent, astonishing code.
This is awesome and, as an Obj-C dev, is yet another thing that makes me want to learn Ruby.
Like! Much as I love ObjC, reducing verbosity via better syntax can go a long way to making code more readable.
For example, I ended up putting together some defines like this after building a bunch of UI programmatically.
Definitely interested to see more projects along these lines.
For example, I ended up putting together some defines like this after building a bunch of UI programmatically.
#define RGB(r, g, b) [NSColor colorWithDeviceRed:(r)/255.0 green:(g)/255.0 blue:(b)/255.0 alpha:1]
#define RGBA(r, g, b, a) [NSColor colorWithDeviceRed:(r)/255.0 green:(g)/255.0 blue:(b)/255.0 alpha:(a)]
Definitely interested to see more projects along these lines.
I prefer:
#define RGB(color) \
(((color & 0xFF0000) >> 16) / 255.f), \
(((color & 0x00FF00) >> 8) / 255.f), \
(((color & 0x0000FF)) / 255.f)
#define RGB(r,g,b) RGBA(r,g,b,1)I wrote a utility class with idiomatic Obj-C color methods like the one you mentioned and more. I hate to plug it, but I'm fairly proud of it. It also generates color schemes when you throw a UIColor object at it, and includes 100 different UIColor generics like [UIColor seafoamColor].
https://github.com/bennyguitar/Colours-for-iOS
https://github.com/bennyguitar/Colours-for-iOS
Why on Earth would you hate to plug this? I could definitely see someone using this and being thankful they don't have to do it themselves. Hell, I'd use it if I hadn't already done my own category.
Suggestions: you might want to allow for three-digit hex strings and eight/four digit hex strings with alpha, I found that convenient in mine. And in the documentation it would be way cool if you made the names of the colors self-referential.
Nits: I would have made all the system color methods like "systemThingColor", capitalized RGB and HSB, and made "RGBDictionary" return @{@"red": ...} (and made static NSStrings for the keys so nobody needs to go to the .m file to see what will happen). Obviously I am a pedant and I live right on the edge of the 80 character limit; of these I'd only suggest making static dictionary keys as an actually desirable change.
Nice work, you shouldn't be ashamed to share it at all.
Suggestions: you might want to allow for three-digit hex strings and eight/four digit hex strings with alpha, I found that convenient in mine. And in the documentation it would be way cool if you made the names of the colors self-referential.
Nits: I would have made all the system color methods like "systemThingColor", capitalized RGB and HSB, and made "RGBDictionary" return @{@"red": ...} (and made static NSStrings for the keys so nobody needs to go to the .m file to see what will happen). Obviously I am a pedant and I live right on the edge of the 80 character limit; of these I'd only suggest making static dictionary keys as an actually desirable change.
Nice work, you shouldn't be ashamed to share it at all.
looks really nice, looking forward to using it!
I use a few like this in some of my helper macros[0] that I usually pull into my iOS projects.
[0]: https://gist.github.com/numo16/3407652
[0]: https://gist.github.com/numo16/3407652
I use the same thing to construct NSDecimalNumber instances. N(100.5) instead of [NSDecimalNumber decimalNumberFromString:@"100.5"]
SO handy.
SO handy.
You can do this now @(100.5) for NSNumber literals.
And even shorter, just @100.5 if what you have is a literal. The parentheses are needed if you're boxing a value, e.g.: @(price + 100.5)
In detail: http://clang.llvm.org/docs/ObjectiveCLiterals.html
In detail: http://clang.llvm.org/docs/ObjectiveCLiterals.html
Take for example the capitalize methods. In ruby, you have "capitalize" and "capitalize!" to distinguish the immutable and mutable versions. To make this distinction in ObjC, you generally use nouns vs. verbs. So for the equivalent of ruby's "capitalize", you'd use "capitalizedString" (which is in fact provided by NSString). But the mutable version, the equivalent of ruby's "capitalize" should simply be "capitalize", not "capitalizedStringInPlace".