swift-playground 0.0.1

data/lib/swift/playground/asset.rb

@@ -0,0 +1,52 @@
+module Swift
+  class Playground
+    assets_path = Pathname.new('swift/playground/assets')
+    autoload :Stylesheet, assets_path.join('stylesheet')
+    autoload :Javascript, assets_path.join('javascript')
+
+    class Asset
+      include Util::PathOrContent
+
+      class << self
+        protected
+
+        def default_filename(filename = nil)
+          @default_filename = filename unless filename.nil?
+          @default_filename
+        end
+      end
+
+      attr_accessor :content
+
+      def initialize(content, options = {})
+        pathname_or_content = path_or_content_as_io(content)
+        self.content = pathname_or_content.read
+
+        filename = options[:filename] || derived_filename(pathname_or_content)
+        @filename = filename || default_filename
+      end
+
+      def filename(number)
+        @filename % number
+      end
+
+      def save(destination_path, number)
+        destination_path = Pathname.new(destination_path)
+
+        expanded_filename = filename(number)
+        path = destination_path.join(expanded_filename)
+
+        FileUtils.mkdir_p path.dirname
+        path.open('w') do |file|
+          file.write content
+        end
+      end
+
+      protected
+
+      def default_filename
+        self.class.send(:default_filename)
+      end
+    end
+  end
+end

data/lib/swift/playground/assets/javascript.rb

@@ -0,0 +1,9 @@
+require 'sass'
+
+module Swift
+  class Playground
+    class Javascript < Asset
+      default_filename 'javascript-%d.js'
+    end
+  end
+end

data/lib/swift/playground/assets/stylesheet.rb

@@ -0,0 +1,36 @@
+require 'sass'
+
+module Swift
+  class Playground
+    class Stylesheet < Asset
+      default_filename 'stylesheet-%d.css'
+
+      def save(destination_path, number)
+        save_content
+
+        self.content = Sass.compile(content)
+        super(destination_path, number)
+
+        restore_content
+      end
+
+      protected
+
+      def derived_filename(pathname_or_content)
+        filename = super(pathname_or_content)
+        filename.gsub(/\.scss$/, '')
+      end
+
+      private
+
+      def save_content
+        @saved_content = content
+      end
+
+      def restore_content
+        self.content = @saved_content
+        @saved_content = nil
+      end
+    end
+  end
+end

data/lib/swift/playground/cli.rb

@@ -0,0 +1,29 @@
+require 'gli'
+require_relative 'cli/definition'
+require_relative 'cli/shared_attributes'
+require_relative 'cli/ui'
+require_relative 'cli/commands/new'
+require_relative 'cli/commands/generate'
+require_relative 'cli/global/error_handling'
+
+require_relative 'generator'
+
+module Swift
+  class Playground
+    module CLI
+      extend GLI::App
+
+      program_desc SUMMARY
+      version      VERSION
+
+      subcommand_option_handling :normal
+      arguments :strict
+      sort_help :manually
+
+      include Commands::Generate
+      include Commands::New
+
+      include Global::ErrorHandling
+    end
+  end
+end

data/lib/swift/playground/cli/commands/generate.rb

@@ -0,0 +1,95 @@
+module Swift::Playground::CLI
+  module Commands
+    module Generate
+      extend Definition
+
+      definition do
+        desc 'Generate a playground file from the provided Markdown file'
+        arg '<markdown_file>'
+        arg '<playground_file>', :optional
+        command :generate do |c|
+          c.extend SharedCreationSwitches
+
+          c.flag   :stylesheet,
+                   arg_name: '<file>',
+                   type: String,
+                   desc: 'CSS stylesheet for the HTML documentation sections of the playground. SASS/SCSS syntax is supported. This will be included after the default stylesheet.'
+
+          c.flag   :javascript,
+                   arg_name: '<file>',
+                   type: String,
+                   desc: 'A javascript file for the HTML documentation sections of the playground. Each section is rendered independently of another and the script will not have access to the DOM from any other sections.'
+
+          c.switch :emoji,
+                   default_value: true,
+                   desc: "Convert emoji aliases (e.g. `:+1:`) into emoji characters."
+
+          c.switch :highlighting,
+                   default_value: true,
+                   desc: "Detect non-swift code blocks and add syntax highlighting. Only has an effect if 'github-linguist' and 'pygments.rb' gems are installed."
+
+          c.flag   :'highlighting-style',
+                   arg_name: '<style>',
+                   type: 'String',
+                   default_value: 'default',
+                   desc: "The name of a pygments (http://pygments.org/) style to apply to syntax highlighted code blocks. Set to 'custom' if providing your own pygments-compatible stylesheet. Ignored if --no-highlighting is set."
+
+          # c.flag   :resources,
+          #          arg_name: '<directory>',
+          #          type: String,
+          #          desc: 'A directory of resources to be bundled with the playground.'
+
+          c.action do |_, options, args|
+            markdown_file = Pathname.new(args[0]).expand_path
+            if args[1]
+              playground_file = Pathname.new(args[1]).expand_path
+            else
+              playground_file = markdown_file.sub_ext('.playground')
+            end
+
+            playground = Swift::Playground::Generator.generate(markdown_file)
+            playground.platform = options['platform']
+            playground.allow_reset = options['reset']
+            playground.convert_emoji = options['emoji']
+
+            if options['highlighting']
+              playground.syntax_highlighting = options['highlighting-style']
+            else
+              playground.syntax_highlighting = false
+            end
+
+            if options['stylesheet']
+              stylesheet_path = Pathname.new(options['stylesheet']).expand_path
+
+              unless stylesheet_path.exist?
+                raise "Stylesheet file does not exist: '#{stylesheet_path}'."
+              end
+
+              stylesheet = Swift::Playground::Stylesheet.new(stylesheet_path)
+              playground.stylesheets << stylesheet
+            end
+
+            if options['javascript']
+              javascript_path = Pathname.new(options['javascript']).expand_path
+
+              unless javascript_path.exist?
+                raise "Javascript file does not exist: '#{javascript_path}'."
+              end
+
+              javascript = Swift::Playground::Javascript.new(javascript_path)
+              playground.javascripts << javascript
+            end
+
+            playground.save(playground_file)
+
+            UI.say "Created playground at #{playground_file}"
+
+            if options['open']
+              system('open', playground_file.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/swift/playground/cli/commands/new.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/string/strip'
+
+module Swift::Playground::CLI
+  module Commands
+    module New
+      extend Definition
+
+      definition do
+        desc 'Create an empty playground (just as Xcode would via "File > New > Playground...")'
+        arg '<playground_file>'
+        command :new do |c|
+          c.extend SharedCreationSwitches
+
+          c.action do |_, options, args|
+            playground_file = Pathname.new(args[0]).expand_path
+
+            playground = Swift::Playground.new(platform: options[:platform])
+
+            case options[:platform]
+            when 'ios'
+              contents = <<-IOS.strip_heredoc
+                // Playground - noun: a place where people can play
+
+                import UIKit
+
+                var str = "Hello, playground"
+              IOS
+            when 'osx'
+              contents = <<-OSX.strip_heredoc
+                // Playground - noun: a place where people can play
+
+                import Cocoa
+
+                var str = "Hello, playground"
+              OSX
+            end
+
+            playground.sections << Swift::Playground::CodeSection.new(contents)
+            playground.save(playground_file)
+
+            if options['open']
+              system('open', playground_file.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/swift/playground/cli/definition.rb

@@ -0,0 +1,32 @@
+require 'active_support/concern'
+
+# This class makes it possible to provide helper methods in a module that will
+# be included inside the main Swift::Playground::CLI module.
+#
+# It's unfortunately a little magical, but its difficult to work around this
+# due to the way the GLI dsl is not designed to use anywhere except at the top
+# level (or at best, inside a module) and not in a class.
+module Swift::Playground::CLI
+  module Definition
+    # Include ActiveSupport::Concern methods, so this module behaves like
+    # ActiveSupport::Concern for any other module or class that extends it:
+    include ActiveSupport::Concern
+
+    def self.extended(mod)
+      # Use the behaviour of the ActiveSupport::Concern modules `self.extended`
+      # implementation:
+      ActiveSupport::Concern.extended(mod)
+    end
+
+    def definition(&block)
+      self.included do
+        # The use of `extend(self)` here makes sure that a module that extends
+        # the Definition module will have access to its methods from within
+        # the GLI command actions it defines. It will define these commands
+        # inside the block it passes to its call of the `definition` method.
+        extend(self)
+        self.class_eval(&block)
+      end
+    end
+  end
+end

data/lib/swift/playground/cli/global/error_handling.rb

@@ -0,0 +1,34 @@
+module Swift::Playground::CLI
+  module Global
+    module ErrorHandling
+      extend Definition
+
+      definition do
+        on_error do |exception|
+          case exception
+          when Interrupt
+            UI.error
+            UI.error("Execution interrupted.")
+          when SystemExit
+            # An intentional early exit has occurred and all relevant messages
+            # have already been displayed, so do nothing
+          else
+            # We only want to display details of the exception under debug if it
+            # is not a GLI exception (as a GLI exception relates to parsing
+            # errors - e.g. wrong command, that we do not need to expand upon):
+            debug_exception = (exception.class.to_s !~ /\AGLI/) ? exception : nil
+
+            if exception.message
+              UI.error("Execution failed: #{exception.message}", debug_exception)
+            else
+              UI.error("Execution failed.", debug_exception)
+            end
+          end
+
+          false # Prevent default GLI error handling
+        end
+
+      end
+    end
+  end
+end

data/lib/swift/playground/cli/shared_attributes.rb

@@ -0,0 +1,19 @@
+module Swift::Playground::CLI
+  module SharedCreationSwitches
+    def self.extended(command)
+      command.flag   :platform,
+                     default_value: 'ios',
+                     arg_name: '[ios|osx]',
+                     must_match: %w{ios osx},
+                     desc: 'The target platform for the generated playground.'
+
+      command.switch :reset,
+                     default_value: true,
+                     desc: 'Allow the playground to be reset to it\'s original state via "Editor > Reset Playground" in Xcode.'
+
+      command.switch :open,
+                     negatable: false,
+                     desc: 'Open the playground in Xcode once it has been created.'
+    end
+  end
+end

data/lib/swift/playground/cli/ui.rb

@@ -0,0 +1,120 @@
+require 'highline/import'
+require 'paint'
+require 'forwardable'
+require 'active_support/core_ext/module'
+
+unless STDOUT.tty?
+  # If we aren't using a TTY, then we need to avoid Highline attempting to set
+  # TTY specific features (such as 'no echo mode'), as these will fail. We can
+  # do so by monkey patching Highline to make the methods that peform these
+  # functions no-ops:
+  class HighLine
+    module SystemExtensions
+      def raw_no_echo_mode
+      end
+
+      def restore_mode
+      end
+    end
+  end
+end
+
+Paint::SHORTCUTS[:swift_playground] = {
+  :red => Paint.color(:red),
+  :blue => Paint.color(:blue),
+  :cyan => Paint.color(:cyan),
+  :bright => Paint.color(:bright)
+}
+$paint = Paint::SwiftPlayground
+
+# Convenience module for accessing Highline features
+module Swift::Playground::CLI
+  module UI
+    extend SingleForwardable
+
+    mattr_accessor :show_debug, :color_mode, :silence
+
+    def_delegators :$terminal, :agree, :ask, :choose
+    def_delegators :$paint, *Paint::SHORTCUTS[:swift_playground].keys
+
+    class << self
+      def say(message = "\n")
+        return if silence
+
+        terminal.say message
+      end
+
+      def error(message = nil, exception = nil)
+        return if silence
+
+        stderr.puts red(message)
+        if exception && show_debug
+          exception_details = ["Handled <#{exception.class}>:",
+                               exception.message,
+                               *exception.backtrace]
+          stderr.puts red("\n" + exception_details.join("\n") + "\n")
+        end
+      end
+
+      def debug(message = nil, &block)
+        return if silence
+
+        if show_debug
+          message = formatted_log_message(message, &block)
+          stderr.puts blue(message)
+        end
+      end
+
+      def info(message = nil, &block)
+        return if silence
+
+        if show_debug
+          message = formatted_log_message(message, &block)
+          stderr.puts cyan(message)
+        end
+      end
+
+      private
+
+      def formatted_log_message(message = nil, &block)
+        if block
+          lines = block.call.split("\n")
+          if message
+            message = "#{message}: "
+            message += "\n  " if lines.count > 1
+            message += lines.join("\n  ")
+          else
+            message += lines.join("\n")
+          end
+        end
+
+        message
+      end
+
+      def colorize(stream)
+        case (color_mode || 'auto')
+        when 'auto'
+          if stream.tty?
+            Paint.mode = Paint.detect_mode
+          else
+            Paint.mode = 0
+          end
+        when 'always'
+          Paint.mode = Paint.detect_mode
+        when 'never'
+          Paint.mode = 0
+        end
+      end
+
+      def terminal
+        colorize($stdout)
+        $terminal
+      end
+
+      def stderr
+        colorize($stderr)
+        $stderr
+      end
+    end
+  end
+end