xcake 0.1.5

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require
+
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/xcake

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "xcake"
+
+Xcake::Command.run(ARGV)

data/docs/Cakefile.md

@@ -0,0 +1,166 @@
+<!-- TODO: Maybe split into files ? -->
+#Cakefile Syntax Reference
+
+The `Cakefile` contains a lightweight DSL which provides the instructions on how to generate
+a project file. We adopt the convention over configuration and thus it can be very simple:
+
+```ruby
+Project.new do |c|
+    c.application_for :ios, 8.0 do |t|
+        t.name = "MyApp"
+    end
+end
+```
+
+and here is much more complicated one:
+
+```ruby
+Project.new do |c|
+
+    c.debug_configuration :staging
+    c.debug_configuration :debug
+    c.release_configuration :release
+
+    c.application_for :ios, 8.0 do |t|
+      t.name = "test"
+      t.all_configurations.supported_devices = :iphone_only
+
+      c.unit_tests_for(t)
+    end
+end
+```
+
+As you can see, it is super easy to read; The goal of Xcake is to keep everything
+readable, efficient and concise.
+
+## Project
+
+To create a project we must write the following:
+
+```ruby
+Project.new do |c|
+end
+```
+By default Xcake will create a project named "Project" but we can change the name
+by passing a String argument with the name we would like it to be called:
+
+```ruby
+Project.new "Workspace" do |c|
+end
+```
+We can also customize the structure of the project between the first and second lines, like so:
+
+```ruby
+Project.new "Workspace" do |c|
+  c.debug_configuration :debug
+end
+```
+There are two main ways you can customize a Project, Targets and Configurations.
+
+## Targets
+
+Targets are the way we make products such as Applications, Extensions, Libraries and Tests.
+Xcake provides some easy ways to produce these types of targets but also
+allows you to drop down a level if you need more power.
+
+###Applications
+
+A project can specify any application targets such as iOS or Mac Apps.
+
+iOS App:
+
+```ruby
+Project.new "Workspace" do |c|
+  c.application_for :ios, 8.0
+end
+```
+
+Mac App:
+
+```ruby
+Project.new "Workspace" do |c|
+  c.application_for :mac, 8.0
+end
+```
+
+###Tests
+
+We can also specify a testing targets for other targets as well
+
+```ruby
+Project.new "Workspace" do |c|
+  c.application_for :mac, 8.0 do |t|
+    c.unit_tests_for(t)
+  end
+end
+```
+
+###Custom Targets
+
+If these aren't enough for you then you can specify a target
+and manually set up it's properties.
+
+```ruby
+Project.new "Workspace" do |c|
+  c.target do |t|
+    t.name = "Target"
+  end
+end
+```
+
+###Properties
+
+#### Name
+
+Sets the name of the project
+
+```ruby
+t.name = "Target"
+```
+
+#### Type
+
+Sets the type of the target, Can be `:application`, `:dynamic_library`,
+`:framework` or `:static_library`.
+
+```ruby
+t.type = :application
+```
+
+#### Platform
+
+Sets the platform of the target. Can be `:ios` or `:osx`
+
+```ruby
+t.platform = :ios
+```
+
+#### Deployment Target
+
+Sets the deployment target for the platform.
+
+```ruby
+t.deployment_target = 8.0
+```
+
+#### Language
+
+Sets the primary language of the target, can be `:objc` or `:swift`.
+
+```ruby
+t.language = :swift
+```
+
+## Configurations
+
+### Debug Configurations
+
+### Release Configurations
+
+### All Configurations
+
+### Configuration Hiearchy
+
+###Properties
+
+#### Build Settings

data/docs/Getting Started.md

@@ -0,0 +1,89 @@
+# Getting Started
+
+Xcake allows you to describe a Xcode project via an easy to use DSL, We do this
+by creating a simple text file, our `Cakefile`. This tutorial will show you how
+to create your first project. This guide assumes you have a basic knowllege of
+xcode.
+
+Our first step is to create the folder for our project and a blank file for our `Cakefile`,
+so we're going to need some command line magic:
+
+- Firstly run `mkdir MyProject` to create the folder for our project
+- Next we will need a blank textfile, so lets run `touch Cakefile` to create it
+
+So we should have a folder called "MyProject" with a textfile named "Cakefile" inside of it,
+Xcake will look for this textfile, so make sure to keep it's name the same.
+
+This is all great but there are still no signs of a Project; Don't worry we still need to
+write some code to describe what the project should look like. So our first step is declaring
+we want to create a new project.
+
+So now in your textfile, type the following:
+
+```ruby
+Project.new do |c|
+end
+```
+
+This code is quite clearly telling xcake to create a new project; So lets see what happens.
+If we go to our folder and run `xcake` we should now have our xcode project. *phew* that was easy!
+
+If we open it however it's not quite ready to use, it's still lacking any targets to actually build.
+So let's fix that :)
+
+We're going to create an app for iOS 9.0 called `MyApp`, hopefully the syntax should be easy to grasp:
+
+```ruby
+Project.new do |c|
+  c.application_for :ios, 9.0 do |t|
+    t.name = "MyApp"
+  end
+end
+```
+
+Now if we run `xcake` again, we get the same project file but now with a target. In addition to this
+xcake has created a `debug` and `release` build configuration as well as two schemes for our target
+and these build configurations.
+
+For some situations you may want to provide your own build configurations, for example adding a
+staging build configuration. So now we will specify our own `staging` configuration, this configuration will be used for internal testing so we will specify that it should
+be a `debug` configuration so that the default build settings are optimised for testing.
+
+So lets add it, configurations are defined project-wide so we do it like this:
+
+```ruby
+Project.new do |c|
+
+  c.debug_configuration :staging
+
+  c.application_for :ios, 9.0 do |t|
+    t.name = "MyApp"
+  end
+
+end
+```
+
+Again we run `xcake` and voilla! Pretty easy but now if we open up our project
+our `debug` and `release` configurations are gone. Xcake operates an opt-out system, Xcode projects won't open
+without any configurations so Xcake provides these configurations as a sensible default. But as soon as we
+provide our own configurations we are opting out of these defaults.
+
+Xcake does this to force us to make sure we have everything setup as we need it, to get these configurations back
+its just an extra couple of lines:
+
+```ruby
+Project.new do |c|
+
+  c.debug_configuration :staging
+  c.debug_configuration :debug
+  c.release_configuration :release
+
+  c.application_for :ios, 9.0 do |t|
+    t.name = "MyApp"
+  end
+
+end
+```
+
+And there you have it, that is your first project created by Xcake. To learn what else you can do, read the
+[Cakefile syntax reference](Cakefile.md).

data/lib/fastlane_plugin.rb

@@ -0,0 +1,5 @@
+require "xcake/fastlane/xcake.rb"
+
+module Xcake
+
+end

data/lib/xcake.rb

@@ -0,0 +1,33 @@
+require "xcake/visitable"
+require "xcake/visitor"
+
+require "xcake/command"
+require "xcake/configuration"
+require "xcake/configuration/sugar"
+require "xcake/configurable"
+
+require "xcake/generator/build_phase"
+require "xcake/generator/build_phase/compile_source_build_phase"
+require "xcake/generator/build_phase/copy_resources_build_phase"
+require "xcake/generator/build_phase/copy_xcassets_build_phase"
+require "xcake/generator/build_phase/header_file_build_phase"
+require "xcake/generator/build_phase_registry"
+
+require "xcake/generator/configuration"
+require "xcake/generator/path"
+require "xcake/generator/project"
+require "xcake/generator/target"
+
+require "xcake/project"
+require "xcake/project_structure_resolver"
+require "xcake/node"
+require "xcake/target"
+require "xcake/version"
+
+require "xcake/xcode/project"
+require "xcake/xcode/scheme"
+require "xcake/xcode/scheme_list"
+
+module Xcake
+
+end

data/lib/xcake/command.rb

@@ -0,0 +1,22 @@
+require 'claide'
+
+module Xcake
+  class Command < CLAide::Command
+
+    self.command = 'xcake'
+    self.description = 'Create and maintain Xcode project files easily.'
+
+    def run
+
+      puts "Reading Cakefile..."
+      file_contents = File.read("#{Dir.pwd}/Cakefile")
+      cakefile = eval(file_contents)
+
+      resolver = ProjectStructureResolver.new
+      cakefile.accept(resolver)
+
+      generator = Generator::Project.new
+      cakefile.accept(generator)
+    end
+  end
+end

data/lib/xcake/configurable.rb

@@ -0,0 +1,128 @@
+module Xcake
+  # This namespace provides all of methods for
+  # the DSL where configurations are specified.
+  #
+  # Classes for the DSL which want to either
+  # specifiy build settings or scheme launch arguments
+  # (i.e The Project or Targets) include this namespace.
+  #
+  # @example
+  #   class Application
+  #     include Xcake::Configurable
+  #   end
+  #
+  module Configurable
+
+    private
+
+    attr_accessor :all_configuration
+
+    public
+
+    attr_accessor :debug_configurations
+    attr_accessor :release_configurations
+
+    # This collects all of the configurations,
+    # flattens them and returns them as an array.
+    #
+    # The process of flattening combines each
+    # configuration settings with the defaults
+    # and shared "all" settings, in this priority:
+    #
+    # - default settings
+    # - shared settings
+    # - configuration settings
+    #
+    # @return [Array<Configuration>] list of all configurations flattened
+    #
+    def flatten_configurations
+      all_settings = all_configurations.settings
+      flattened_configurations = []
+
+      debug_configurations.each do |b|
+        b.settings = default_debug_settings.merge!(all_settings).merge!(b.settings)
+        flattened_configurations << b
+      end
+
+      release_configurations.each do |b|
+        b.settings = default_release_settings.merge!(all_settings).merge!(b.settings)
+        flattened_configurations << b
+      end
+
+      flattened_configurations
+    end
+
+    # @return [Array<Configuration>] list of debug configurations
+    #
+    def debug_configurations
+      @debug_configurations ||= []
+    end
+
+    # @return [Array<Configuration>] list of release configurations
+    #
+    def release_configurations
+      @release_configurations ||= []
+    end
+
+    # This returns the shared "all" configuration
+    # use this if you want to set a setting that
+    # applies across all configurations.
+    #
+    # Note: If this setting is set on a configuration
+    # already then this won't override it.
+    #
+    # @example Set a setting across all configurations
+    #
+    #     t.all_configurations.settings["INFO_PLIST"] = "./myapp/info.plist"
+    #
+    # @return [Configuration] configuration for the shared settings
+    #
+    def all_configurations
+      @all_configuration ||= Configuration.new(:all)
+    end
+
+    # This either finds a release configuration
+    # with the same name or creates one.
+    #
+    # @return [Configuration] the new or existing debug configuration
+    #
+    def debug_configuration(name, &block)
+
+      configuration = debug_configurations.find do |c|
+        c.name == name.to_s
+      end
+
+      if configuration == nil
+        configuration = Configuration.new(name) do |b|
+          block.call(b) if block_given?
+        end
+
+        debug_configurations << configuration
+      end
+
+      configuration
+    end
+
+    # This either finds a release configuration
+    # with the same name or creates one.
+    #
+    # @return [Configuration] the new or existing release configuration
+    #
+    def release_configuration(name, &block)
+
+      configuration = release_configurations.find do |c|
+        c.name == name.to_s
+      end
+
+      if configuration == nil
+        configuration = Configuration.new(name) do |b|
+          block.call(b) if block_given?
+        end
+
+        release_configurations << configuration
+      end
+
+      configuration
+    end
+  end
+end