Using Markdown with Postach.io

Hello World!!!

This HTML is highlighted with Prism using code marks for the highlighting like language-html

<!DOCTYPE html>
<html>
<head>
   ...
   <link href="themes/prism.css" rel="stylesheet" />
</head>
<body>
   ...
   <script src="prism.js"></script>
</body>
</html>

Why Bother?

I do love my work on code highlighting in Evernote. But this markdown stuff may be cooler? Hard to decide. With Markdown, it's definitely more flexible to pop out to a text editor and then back in.

[Testing edit from iPad... just added this]

Are there extra lines or not?

let stringSet = Set(["car", "boat", "bike", "toy"])
let stringArray = stringSet.sorted()

print(stringArray)
// will print ["bike", "boat", "car", "toy"]

Okay, the extra lines are only there if you switch the format using Make Plain Text. Do NOT use Make Plain Text, and always use Simplify Formatting

Attachment

What About Embeds?

Will Postachio deal with the embeds, still?

[So this embed got removed because I edited this note on iPad... so that's an issue. Maybe a big issue?]

OMG that's absolutely awesome. Which means you could also do iframes and probably even random html.

Dan Rosenstark Posted on August 21st, 2017

Lazy Array in Swift

Obviously if you google "lazy array in Swift," you'll find out the right way to do this, which uses NSPointerArray and whatever else. As you should.

But sometimes you want to make your own to see how far you can get in half an hour with generics. Here's my naive implementation.

import Foundation

private class WeakWrapperAnyObject> {
    weak var thing: T?
    
    init(_ thing:T) {
        self.thing = thing
    }
}

struct WeakArrayAnyObject> : Sequence {
    
    private var array: [WeakWrapper<T>] = []
    var count: Int { return objects.count }
    
    init(_ objects: [T]) {
        append(objects)
    }
    
    var objects: [T] {
        get {
            let retVal: [T?] = array.map { $0.thing != nil ? $0.thing : nil }
            return retVal.flatMap { $0 }
        }
    }
    
    mutating func append(_ object: T) {
        array.append(WeakWrapper(object))
    }
    
    mutating func append(_ objects: [T]) {
        array.append(contentsOf: objects.map { WeakWrapper($0) })
    }
    
    mutating func compress() {
        array = array.filter{ $0.thing != nil }
    }
    
    // MARK: - Sequence Protocol methods 
    
    typealias Iterator = IndexingIterator<Array<T>>
    
    func makeIterator() -> Iterator {
        return objects.makeIterator()
    }
}

let firstObject = NSString(string: "one")
 
var things = WeakArray([firstObject, NSString(string: "two"), NSString(string: "three")])
 
things.count
 
for thing in things {
    print("Just one \(thing)")
}
 
things.compress()

Of course, I did have to look some stuff up, particularly to understand how easy Sequence was to implement (since I already have an array).

Dan Rosenstark Posted on August 19th, 2017

Method Selection in Swift

When I was growing up, methods were selected based solely on the stuff on the right side of the equals sign. Not so in Swift. Consider this example.

class ThingWithTwoSameNamedMethods {
    func doIt() {
        let h: Int = doIt()
        print("thank you for calling outer doit \(h)")
    }

    func doIt() -> Int {
        return 32
    }
}

let _: Void = ThingWithTwoSameNamedMethods().doIt()
let someInt: Int = ThingWithTwoSameNamedMethods().doIt()
let sum = ThingWithTwoSameNamedMethods().doIt() + 4

If this doesn't scare you, it should, because like most things in Swift: if it's compiling, it's wonderful. But if it's not compiling, for any reason, method selection and typing information is just not there... and you cannot infer it.

Dan Rosenstark Posted on August 19th, 2017

Code Blocks in Postachio

My final CSS (which is linked from this blog):

/** this is for the markdown stuff **/
:not(pre) > code[class*="language-"], pre[class*="language-"] {
    border: 1px solid gray;
    border-radius: 5px;
    background-color: #ffffe0;
}


/** non-markdown background and border **/
div[style*="box-sizing: border-box;"] {
   background-color: #ffffe0;
   border: 1px solid gray;
   border-radius: 5px;
}

/** non-markdown indention **/
div[style*="box-sizing: border-box;"] div {
    margin: 0px;
    padding: 5px !important;
    overflow: auto;
    white-space: pre-wrap;
}

/** non-markdown line-height consistency **/
div[style*="box-sizing: border-box;"] div,
div[style*="box-sizing: border-box;"] div span,
div[style*="box-sizing: border-box;"] div span  {
    line-height: 15px;
    font-size: 14px;
    font-family: Monaco, Menlo, Consolas, monospace;
}

div.posts div.item .post-content p,
div.posts div.item .post-content div,
.post-content div {
  line-height: 1em !important;
  margin-top: .25em;
  margin-bottom: .25em;
  padding-top: 0px;
  padding-bottom: 0px;
}

.post-content div div {
    margin: 1px !important;
padding: 1px !important;
}

/** markdown **/
.post-content p {
    background-color: white;
    line-height: 1em !important;
    margin-top: .5em !important;
    margin-bottom: 1em !important;
    padding: 0px;
}

div.posts h3, div.post-content h3 {
    position: relative;
    padding: 0 0 12.5px 0;
    margin: 0;
    font-size: 1.55rem;
    font-family: 'Roboto';
    font-weight: 300;
    color: #0e3029;
}

Which works with this solution in Evernote and this other solution using Markdown in Postachio (make sure to use languages like language-swift for your code blocks to activate Prism).

Also note Elliot's solution here, which attacks this whole problem from another side.

Dan Rosenstark Posted on August 17th, 2017

Swift 2 to 3, Method Calls, Magic First Parameters & Automatic Conversion Woes

Swift 2 Calling Swift 2

Consider these two methods in Swift 2:

func doThis(thing: AnyObject) {}

func doThisThing(thing thing: AnyObject) {}

are called like this in Swift 2.

doThis("")

doThisThing(thing: "")

So:

The first parameter in the doThis method cannot be named by the caller.
Whether the method name ends in the first parameter name or not, the behavior doesn't change.

Swift 2 Calling Objective-C

Here are two methods in Objective-C:

- (void) doIt:(NSObject *)thing;

- (void) doThisThing:(NSObject *)thing;

Both of these methods get called without their first parameter name from Swift 2:

someObjcObject.doIt("")

someObjcObject.doThisThing("")

So:

First parameter name is not used.
The method name is the same as the method name in Objective-C.
This is true even if the method end in an obvious parameter name, like "doThisWithThing"

Objective-C Calling Swift 2

The method name is the same as that seen in Swift unless you've doubled up on the parameter name as in the above example. So:

func doThis(thing: AnyObject) {}

func doThisThing(thing thing: AnyObject) {}

results in this calling code in Objective-C (note the altered method name in the second example):

[vc doThis:@""];

[vc doThisThingWithThing:@""];

The first method doesn't change even if we use an underscore in the Swift method declaration:

func doThis(_ thing: AnyObject) {}

So:

The method names translate normally
Doubled-up parameter names get added to the method name in Objective-C with the conjunction "with"

Changes in Swift 3

There is no automatic removal of the first parameter name, so:

func doThisThing(thing: AnyObject) {}

gets called like this:

doThisThing(thing: "" as AnyObject)

If you want to remove the first parameter label for callers, you can use an underscore, of course.

Weird Automatic Conversion to Swift 3

So this converted just fine:

func doThis(thing: AnyObject) {}

func doThisThing(thing thing: AnyObject) {}

// calling code
doThisThing(thing: "what")
doThis("what")

and became this in Swift 3

func doThisThing(thing: AnyObject) {}

func doThis(_ thing: AnyObject) {}

// calling code
doThisThing(thing: "what" as AnyObject)
doThis("what" as AnyObject)

So that makes sense.

Converting Again

Now you realize that your massive conversion needs to forward merge more Swift 2 code into the same target. Xcode warns you not to do automatic conversion again, but you do it anyway.

The two methods now look like this, which makes no sense (the second one has now lost its parameter label):

func doThisThing(_ thing: AnyObject) {
    print("doThisThing \(thing.hash)")
}

func doThis(_ thing: AnyObject) {
    print("doThis \(thing.hash)")
}

// calling code
doThisThing("what" as AnyObject)
doThis("what" as AnyObject)

In this simple case the callers get updated, but the Objective-C callers do not:

And in many cases, your calling code will be broken in Swift as well.

Calling Objective-C from Swift 2 vs. 3

The automatic madness deepens with Swift 3 interop.

Consider this signature in Objective-C:

+ (NSObject *)deserializeNewOrExistingObjectFromAPIV1JSON:(NSDictionary *)json

In Swift 2 you called it this way:

ThatObject.deserializeNewOrExistingObjectFromAPIV1JSON(json.dictionaryObject)

But this changes in Swift 3 to:

ThatObject.deserializeNewOrExistingObject(fromAPIV1JSON: json.dictionaryObject)

And now the result comes back as a forced optional, whereas in Swift 2 it came back as a non-optional.

Which may or may not get picked up by the automatic converter. The more complex your compilation target is, the less likely the automatic conversion is to succeed.

Some capitalization changes as Objective-C gets magically converted:

- (instancetype)initWithJSON:(NSDictionary *)messageBody

// Swift 2
ThatObject(JSON: dict)!

// Swift 3
ThatObject(json: dict)

And some stuff gets even weirder in Objective-C interop:

+ (id)findForUuid:(NSString *)uuid

// Swift 2
ThatObject.findForUuid(uuid)

// Swift 3
ThatObject.find(forUuid: tender.uuid)!

Dan Rosenstark Posted on August 16th, 2017

Code Highlighting in Evernote... Kinda

A while back, Evernote for Mac added Code Blocks. To enable this feature, you cannot use the App Store version of Evernote.

In addition, you have to check Enable Code Block in Preferences

Code blocks were okay, allowing you to do nice simple stuff maintaining your plain text formatting like this:

    func commonInit() {
        self.backgroundColor = UIColor.black;
        let imageView = UIImageView(image: UIImage(named: "splash.png")!)
        imageView.contentMode = .scaleAspectFit
        self.addSubview(imageView)
        constrain(self, imageView) { me, imageView  in
            imageView.size == me.size
            imageView.center == me.center
        }
    }

But there was no way to keep your colored syntax formatting (from Xcode, App Code and others) until Evernote 6.11 for Mac (or sometime like that).

Here's how to do it:

Type one line of text
Turn that into a code block
Replace the contents of that code block with code you paste from Xcode
That's it!

Stubbed Code Block

Stub a code block

Stubbed Code Block, Content Replaced

func commonInit() {
    self.backgroundColor = UIColor.black;
    let imageView = UIImageView(image: UIImage(named: "splash.png")!)
    imageView.contentMode = .scaleAspectFit
    self.addSubview(imageView)
    constrain(self, imageView) { me, imageView  in
        imageView.size == me.size
        imageView.center == me.center
    }
}

In Atom: Use Copy as RTF

The Copy as RTF package in Atom will make this work there too. Fun!

Dan Rosenstark Posted on August 5th, 2017

Associated Object Support for Swift 2.3

This is your AssociatedObjectSupport.swift. It's for Swift 2.3 and it's based on this. It can handles nulls, and non-objects, too (by wrapping them in Lifted).

import UIKit

final class Lifted {
    let value: Any
    init(_ x: Any) {
        value = x
    }
}

extension NSObject {
    func setAssociatedObject(value: T, associativeKey: UnsafePointer<Void>, policy: objc_AssociationPolicy = .OBJC_ASSOCIATION_RETAIN_NONATOMIC) {
        if let v: AnyObject = value as? AnyObject {
            objc_setAssociatedObject(self, associativeKey, v,  policy)
        }
        else {
            let liftedObject = Lifted(value)
            objc_setAssociatedObject(self, associativeKey, liftedObject,  policy)
        }
    }
    
    func getAssociatedObject(associativeKey: UnsafePointer<Void>) -> T? {
        let value = objc_getAssociatedObject(self, associativeKey)
        if let value = value as? Lifted {
            return value.value as? T
        }
        return value as? T
    }
}

Example UIView Extension

And here's an example extension to UIView that uses it. Note the clever use of a private struct to get static variables on the Extension nicely.

extension UIView {    
    private struct AssociatedKeys {
        static var viewExtension = "viewExtension"
        static var anotherView = "someOtherView"
        static var someFloat = "someFloat"
    }
        
    var someFloat: Float {
        get {
            return getAssociatedObject(&AssociatedKeys.someFloat) ?? 0.0
        }
        set {
            setAssociatedObject(newValue, associativeKey: &AssociatedKeys.someFloat)
        }
    }
    
    var baseTransform: CGAffineTransform? {
        get {
            return getAssociatedObject(&AssociatedKeys.viewExtension)
        }
        set {
            setAssociatedObject(newValue, associativeKey: &AssociatedKeys.viewExtension)
        }
    }
    
    var anotherView: UIView? {
        get {
            return getAssociatedObject(&AssociatedKeys.anotherView)
        }
        
        set {
            setAssociatedObject(newValue, associativeKey: &AssociatedKeys.anotherView)
        }
    }
}


Using the Example

var view = UIView()
view.baseTransform = CGAffineTransformIdentity
print("what's up \(view.baseTransform)")
view.baseTransform = nil
print("what's up \(view.baseTransform == nil)")
view.anotherView = UIView()
print("you got another view? \(view.anotherView)   \(view.anotherView?.anotherView)")
view.anotherView = nil
view.someFloat = 32.5
print("what's it? \(view.someFloat)")

Dan Rosenstark Posted on December 6th, 2016

Associated Object Support for Swift 3.x

Of course in Swift 3, this is all trivial... but plus, if you're not using self, why bother? (Credit to this Swift 2.x example)

extension NSObject {
    func setAssociated(value: T, associativeKey: UnsafeRawPointer, policy: objc_AssociationPolicy = .OBJC_ASSOCIATION_RETAIN_NONATOMIC) {
        objc_setAssociatedObject(self, associativeKey, value,  policy)
    }

    func getAssociated(associativeKey: UnsafeRawPointer) -> T? {
        let value = objc_getAssociatedObject(self, associativeKey)
        return value as? T
    }
}

extension UIView {
    
    private struct AssociatedKeys {
        static var viewExtension = "viewExtension"
        static var anotherView = "someOtherView"
        static var someFloat = "someFloat"
    }
    
    var someFloat: Float {
        get {
            return getAssociated(associativeKey: &AssociatedKeys.someFloat) ?? 0.0
        }
        set {
            setAssociated(value: newValue, associativeKey: &AssociatedKeys.someFloat)
        }
    }
    
    var baseTransform: CGAffineTransform? {
        get {
            return getAssociated(associativeKey: &AssociatedKeys.viewExtension)
        }
        set {
            setAssociated(value: newValue, associativeKey: &AssociatedKeys.viewExtension)
        }
    }
    
    var anotherView: UIView? {
        get {
            return getAssociated(associativeKey: &AssociatedKeys.anotherView)
        }
        
        set {
            setAssociated(value: newValue, associativeKey: &AssociatedKeys.anotherView)
        }
    }
}

var view = UIView()
view.baseTransform = CGAffineTransform.identity
print("what's up \(view.baseTransform)")
view.baseTransform = nil
print("what's up \(view.baseTransform == nil)")
view.anotherView = UIView()
print("you got another view? \(view.anotherView)   \(view.anotherView?.anotherView)")
view.anotherView = nil
view.someFloat = 32.5
print("what's it? \(view.someFloat)")

My own notes: you cannot get proper weak object support with Associated Objects, so only use them if you do not extend the actual class yourself.

Later Note

That's really not true: by wrapping your object in a Weak wrapping object, you can always get weak object support. So that's quite cool.

Dan Rosenstark Posted on November 10th, 2016

Subprojects in Xcode with Static Libs

Static libraries produce .a files. The catch is: static libraries cannot contain Swift files. But anyway...

Workspaces and Projects

You can add projects to projects (subprojects) or to workspaces
Projects can be saved as workspaces
Add a project to another project -- or a workspaces -- by adding the .xcodeproj file.

Early Setup

Add GBDevice as a submodule

git submodule add https://github.com/lmirosevic/GBDeviceInfo.git GBDeviceInfo

Set It Up

Create a new, Single View Application for iOS
Add the .xcodeproj for an Xcode project that produces a .a file

In this example we're using GBDevice.
Set up the primary project like this

Import Objective-C to Swift

Create a new header file called BridgingHeader.h
Add it to the Build Settings for the Single Window App
Utilize it in a Swift file

let version = GBDeviceInfo.init().modelString
print(version)
That's it.

The kicker is: you cannot use Swift in a static library, so there's that. Hence this other article I wrote (longer, and uses Cocoapods)

Dan Rosenstark Posted on January 30th, 2016

Hangouts, Spaces on OSX

So this frustration has existed since Mavericks:

Chrome apps (incl. Hangouts) don't play well with OSX Spaces

The answer is in the Hangouts App itself... shut this option off.

Dan Rosenstark Posted on November 1st, 2015