Options:

• help (shows options / commands)
• init
  • --platform: [all | macOS | iOS] = all
  • --type: [[f | framework] | [a | app]] = framework
  • --demo (makes demo app targets for frameworks)
• update
  • [-f | -frameworks]: Update frameworks
  • [-c | -config]: Update configuration

See the Carthage command line tool implementation of Commandant.

It looks like just the iOS paths are being generated for both platforms.

For the xcodeproj dependency, we will run bundle install from rubygems.

For this, we will have to include the Gemfile with the product.

Currently, running update both calls to carthage to download dependencies, and injects them into the project.

However, there should be a way to just inject the frameworks that are currently present (in the case that some custom carthage action was taken).

Xcode doesn't seem to like the code signing build configuration settings I am giving it.

Currently trying:

            'EXPANDED_CODE_SIGN_IDENTITY' => "",
            'CODE_SIGNING_REQUIRED' => "NO",
            'CODE_SIGNING_ALLOWED' => "NO"

The Bundle Identifier is not set yet in any target.

• $(Framework)
• $(Framework)Tests

If Carthage build has ever been run locally, a version of the primary framework target lingers in the Carthage/build directory.

This is the directory which is searched to inject paths into the PBXShellScriptPhase.

Add a condition that the primary framework target is not copied into the carthage script phase.

Update frameworks in current project:

• Manage nonexistent project
• Make inventory of targets
• Run carthage update
• Replace frameworks in embed phase
• Replace run script phases of test targets

• dn-m init
• -platform (iOS macOS)
• -framework (create framework target)
  • --demo (create demo application targets in .xcodeproj)
• -app (create application target)

Teach update that there need to be frameworks to update.

Old version:

  jazzy \
    --swift-version 2.2 \ # Update to 3
    --clean \
    --author James\ Bean \
    --author_url http://jamesbean.info \
    --github_url https://github.com/dn-m/$FRAMEWORK \
    --module-version $VERSION \
    --module $FRAMEWORK \
    --root-url https://dn-m.github.io \
    --output $SITE_DIR/$FRAMEWORK \
    --skip-undocumented \
    --hide-documentation-coverage \
    --theme $SITE_DIR/dependencies/templates/bean

The bundle is not compiled correctly if testing a Mac target with nested frameworks if the Runpath Search Paths does not also include $(SRCROOT)/Carthage/Build/Mac

Because this is only macOS, SPM is available for use.

This enables use of Commandant and Result as Package dependencies. The sources of these are currently injected directly into this codebase, as dylibs (frameworks) are not possible with command line tools.

Called as dn-m config.

• Create README.md (see: #9)
• Create .travis.yml (see: #1)
• Create .hound.yml (see: #3)
• Create .swiftlint.yml (see: #4)
• First, test presence of Cartfile
• Create Cartfile (see: #2)
• Create .gitignore (see: #8)

This is not a real point of configuration on the macOS platform.

Therefore, this build config setting just shows up as an awkward 'USER DEFINED'.

• Add .jazzy.yaml file
• Add config --jazzy option

After git init.

system("git remote add origin https://github.com/dn-m/#{name}")

• Update product version (Xcode build configuration)
• git tag ...
• git push origin tag ...
• carthage build --no-skip-current
• carthage archive

• Run script for primary target
• Embedded files phase

If exists demo applications for frameworks, add these to .travis.yml for smoke testing.

Implement a script to be run upon downloading / cloning .zip product.

This script will:

• Check for ruby gems dependency
• Download xcodeproj dependency
• Install dn-m & dn-m-xcodeproj.rb to /usr/local/bin

• Create workspace
• App target for each platform
• Add targets and frameworks to workspace
• Embed frameworks phase
• Run script phase

Connecting Swift -> Bash -> Ruby is becoming so convoluted that there's really no reason not to just write a single ruby script to do this.

Add to .travis.yml (in dn-m config)

  global:
    secure: HzHlU2k0TOepFV+LU12XuPjFcca8LuWrIxW/xB0S432EPdW+GHC6hpvNQq7mcJC9VAikNMcQy3ExE9jjjNAlyXZ26rxOmhIe/mkB2lVaKxGpYlahArkBjJdBp7wgfen0EQHEAx4ClxfNmoPD+DuZ2WSeYT4qnwnynpGY2tcjfM01pEOYLFXGDmmKFunkn1i9Z5bb0hWxWMffBDFd5M2bikwDqC1c/yZxEmGp8fUWtood0OnoMFh7dKq4B+0R/OMWVGg+lJjbJVU4/syY8EhnSTDQmJ6ufI6iQYyBrNtxi75VRdoh6vq8sdyhQjmP4jTY149xuURbI+GSiJLgKhy5rLKkGqNxYwhgZSc0P8q/7GcUpPavTfh9CWiFd5SSvY7Uw5bLyFzUk5c2llDJb+z/uUruFJKRsdrntY9VZpYfKvy0cfaZNwBLCWH4qSxyMXXYgdRmID7fPP35S1aIZO2UnItCpmhp4JB17tr9WSViwp2tk5hv0dEhYiZWnQz84jQDhLnjT4oGUc+byQMCMQhNP6gxbx4Srw/B/Pv+776Iu1PClLmOyLpKdCoAdSpo+PVkaoKcO4LB8lwSQzmQ66y0JD3++Y8mfancalNZ2W6N/Tlj/0XW4aa6YkPMJWLXGQxORAlZySH8+YecYSGeGSAPI628hC51frRFb1JxzqdqbWk=

Then:

- gem install jazzy


- git config credential.helper "store --file=.git/credentials"
- echo "https://${GH_TOKEN}:@github.com" > .git/credentials

- git clone https://github.com/dn-m/dn-m.github.io

- jazzy
- cp -r docs dn-m.github.io/$project_name

- cd dn-m.github.io
- git add .
- git commit -m "Update docs"
- git push origin master

For each component of the config command, add a separate option:

• --travis
• --git
• --readme
• --carthage

• Clone dn-m.github.io repo
• Build local docs
  • Use proper jazzy settings
  • Consider using `jazzy.yml
• Transform Cartfile into better format (JSON / YAML)
• Inject dependencies into local docs
• Build frontpage

In the case of nesting frameworks into other frameworks, only the Carthage Run Script Phase looks like it's necessary.

For application targets, though, we need to add a path to the Embed Frameworks Build Phase for each embedded framework.

Currently, these files are generated line-by-line within the dn-m config script.

Really, each of these have 0...1 variables.

Ultimately, we can use something like mustache to do this.

We currently have FMWK and BNDL Info.plist files, but still need to establish what the application-type target Info.plist is.

Perhaps this is actually stored somewhere in Xcodeproj...