guard-typescript 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Payton Yao
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,273 @@
+# Guard::TypeScript
+
+Guard::TypeScript compiles or validates your TypeScripts automatically when files are modified.
+
+This is a clone of [Guard CoffeeScript](https://github.com/guard/guard-coffeescript) that was shamelessly stolen 
+and modified to work with TypeScript.
+
+If you have any questions please join us on our [Google group](http://groups.google.com/group/guard-dev) or on `#guard`
+(irc.freenode.net).
+
+## Install
+
+The simplest way to install Guard is to use [Bundler](http://gembundler.com/).
+Please make sure to have [Guard](https://github.com/guard/guard) installed.
+
+Add Guard::TypeScript to your `Gemfile`:
+
+```ruby
+group :development do
+  gem 'guard-typescript'
+end
+```
+Add the default Guard::TypeScript template to your `Guardfile` by running:
+
+```bash
+$ guard init typescript
+```
+
+## JSON
+
+The JSON library is also required but is not explicitly stated as a gem dependency. If you're on Ruby 1.8 you'll need
+to install the `json` or `json_pure` gem. On Ruby 1.9, JSON is included in the standard library.
+
+## TypeScript
+
+Guard::TypeScript uses [Typescript Node](https://github.com/typescript-ruby/typescript-node-ruby) to compile the TypeScripts.
+
+## Usage
+
+Please read the [Guard usage documentation](https://github.com/guard/guard#readme).
+
+## Guardfile
+
+Guard::TypeScript can be adapted to all kind of projects. Please read the
+[Guard documentation](https://github.com/guard/guard#readme) for more information about the Guardfile DSL.
+
+### Ruby project
+
+In a Ruby project you want to configure your input and output directories.
+
+```ruby
+guard 'typescript', :input => 'typescripts', :output => 'javascripts'
+```
+
+If your output directory is the same as the input directory, you can simply skip it:
+
+```ruby
+guard 'typescript', :input => 'javascripts'
+```
+
+### Rails app with the asset pipeline
+
+With the introduction of the [asset pipeline](http://guides.rubyonrails.org/asset_pipeline.html) in Rails 3.1 there is
+no need to compile your TypeScripts with this Guard.
+
+However, if you would still like to have feedback on the validation of your TypeScripts
+(preferably with a Growl notification) directly after you save a change, then you can still
+use this Guard and simply skip generation of the output file:
+
+```ruby
+guard 'typescript', :input => 'app/assets/javascripts', :noop => true
+```
+
+This give you a faster compilation feedback compared to making a subsequent request to your Rails application. If you
+just want to be notified when an error occurs you can hide the success compilation message:
+
+```ruby
+guard 'typescript', :input => 'app/assets/javascripts', :noop => true, :hide_success => true
+```
+
+### Rails app without the asset pipeline
+
+Without the asset pipeline you just define an input and output directory like within a normal Ruby project:
+
+```ruby
+guard 'typescript', :input => 'app/typescripts', :output => 'public/javascripts'
+```
+
+## Options
+
+There following options can be passed to Guard::TypeScript:
+
+```ruby
+:input => 'typescripts'             # Relative path to the input directory.
+                                    # Files will be added that match end in .ts
+                                    # default: nil
+
+:output => 'javascripts'            # Relative path to the output directory.
+                                    # default: the path given with the :input option
+
+:noop => true                       # No operation: do not write an output file.
+                                    # default: false
+
+:shallow => true                    # Do not create nested output directories.
+                                    # default: false
+
+:source_map => true                 # Do create the source map file.
+                                    # default: false
+
+:source_root => 'typescripts'       # Root path for typescript sources.
+                                    # Used in source map to determine root URL for
+                                    # all sources
+                                    # default: nil (using the `:input` directory)
+
+:hide_success => true               # Disable successful compilation messages.
+                                    # default: false
+
+:all_on_start => true               # Regenerate all files on startup
+                                    # default: false
+
+:error_to_js => true                # Print the Typescript error message directly in
+                                    # the JavaScript file
+                                    # default: false
+```
+
+### Output short notation
+
+In addition to the standard configuration, this Guard has a short notation for configure projects with a single input
+and output directory. This notation creates a watcher from the `:input` parameter that matches all TypeScript files
+under the given directory and you don't have to specify a watch regular expression.
+
+```ruby
+guard 'typescript', :input => 'javascripts'
+```
+
+### Nested directories
+
+The Guard detects by default nested directories and creates these within the output directory. The detection is based on
+the match of the watch regular expression:
+
+A file
+
+```ruby
+/app/typescripts/ui/buttons/toggle_button.ts
+```
+
+that has been detected by the watch
+
+```ruby
+watch(%r{^app/typescripts/(.+\.ts)$})
+```
+
+with an output directory of
+
+```ruby
+:output => 'public/javascripts/compiled'
+```
+
+will be compiled to
+
+```ruby
+public/javascripts/compiled/ui/buttons/toggle_button.js
+```
+
+Note the parenthesis around the `.+\.ts`. This enables Guard::TypeScript to place the full path that was matched
+inside the parenthesis into the proper output directory.
+
+This behavior can be switched off by passing the option `:shallow => true` to the Guard, so that all JavaScripts will be
+compiled directly to the output directory.
+
+### Multiple source directories
+
+The Guard short notation
+
+```ruby
+guard 'typescript', :input => 'app/typescripts', :output => 'public/javascripts/compiled'
+```
+
+will be internally converted into the standard notation by adding `/(.+\.ts)` to the `input` option string and
+create a Watcher that is equivalent to:
+
+```ruby
+guard 'typescript', :output => 'public/javascripts/compiled' do
+  watch(%r{^app/typescripts/(.+\.ts)$})
+end
+```
+
+To add a second source directory that will be compiled to the same output directory, just add another watcher:
+
+```ruby
+guard 'typescript', :input => 'app/typescripts', :output => 'public/javascripts/compiled' do
+  watch(%r{lib/typescripts/(.+\.ts)})
+end
+```
+
+which is equivalent to:
+
+```ruby
+guard 'typescript', :output => 'public/javascripts/compiled' do
+  watch(%r{app/typescripts/(.+\.ts)})
+  watch(%r{lib/typescripts/(.+\.ts)})
+end
+```
+
+## Issues
+
+You can report issues and feature requests to [GitHub Issues](https://github.com/jabbawookiees/guard-typescript/issues). Try to figure out
+where the issue belongs to: Is it an issue with Guard itself or with a Guard::TypeScript?
+
+When you file an issue, please try to follow to these simple rules if applicable:
+
+* Make sure you run Guard with `bundle exec` first.
+* Add debug information to the issue by running Guard with the `--debug` option.
+* Add your `Guardfile` and `Gemfile` to the issue.
+* Make sure that the issue is reproducible with your description.
+
+## Development
+
+- Source hosted at [GitHub](https://github.com/jabbawookiees/guard-typescript).
+
+Pull requests are very welcome! Please try to follow these simple rules if applicable:
+
+* Please create a topic branch for every separate change you make.
+* Make sure your patches are well tested.
+* Update the [Yard](http://yardoc.org/) documentation.
+* Update the README.
+* Update the CHANGELOG for noteworthy changes.
+* Please **do not change** the version number.
+
+For questions please join us in our [Google group](http://groups.google.com/group/guard-dev) or on
+`#guard` (irc.freenode.net).
+
+## Author
+
+Developed by Payton Yao.
+
+## Contributors
+
+See the GitHub list of [contributors](https://github.com/jabbawookiees/guard-typescript/contributors).
+
+## Acknowledgment
+
+* [Michael Kessler](https://twitter.com/#!/netzpirat) for [Guard CoffeeScript](https://github.com/netzpirat/guard-coffeescript/),
+from which this was shamelessly stolen from and modified to work with TypeScript.
+* The [Guard Team](https://github.com/guard/guard/contributors) for giving us such a nice piece of software
+that is so easy to extend, one *has* to make a plugin for it!
+* All the authors of the numerous [Guards](https://github.com/guard) available for making the Guard ecosystem
+so much growing and comprehensive.
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2014 Payton Yao
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/guard/typescript/formatter.rb

@@ -0,0 +1,77 @@
+module Guard
+  class TypeScript
+
+    # The Guard::TypeScript formatter collects console and
+    # system notification methods and enhances them with
+    # some color information.
+    #
+    module Formatter
+      class << self
+
+        # Print an info message to the console.
+        #
+        # @param [String] message the message to print
+        # @param [Hash] options the output options
+        # @option options [Boolean] :reset reset the UI
+        #
+        def info(message, options = { })
+          ::Guard::UI.info(message, options)
+        end
+
+        # Print a debug message to the console.
+        #
+        # @param [String] message the message to print
+        # @param [Hash] options the output options
+        # @option options [Boolean] :reset reset the UI
+        #
+        def debug(message, options = { })
+          ::Guard::UI.debug(message, options)
+        end
+
+        # Print a red error message to the console.
+        #
+        # @param [String] message the message to print
+        # @param [Hash] options the output options
+        # @option options [Boolean] :reset reset the UI
+        #
+        def error(message, options = { })
+          ::Guard::UI.error(color(message, ';31'), options)
+        end
+
+        # Print a green success message to the console.
+        #
+        # @param [String] message the message to print
+        # @param [Hash] options the output options
+        # @option options [Boolean] :reset reset the UI
+        #
+        def success(message, options = { })
+          stamped_message = "#{Time.now.strftime('%r')} #{message}"
+          ::Guard::UI.info(color(stamped_message, ';32'), options)
+        end
+
+        # Outputs a system notification.
+        #
+        # @param [String] message the message to print
+        # @param [Hash] options the output options
+        # @option options [Symbol, String] :image the image to use, either :failed, :pending or :success, or an image path
+        # @option options [String] :title the title of the system notification
+        #
+        def notify(message, options = { })
+          ::Guard::Notifier.notify(message, options)
+        end
+
+        private
+
+        # Print a info message to the console.
+        #
+        # @param [String] text the text to colorize
+        # @param [String] color_code the color code
+        #
+        def color(text, color_code)
+          ::Guard::UI.send(:color_enabled?) ? "\e[0#{ color_code }m#{ text }\e[0m" : text
+        end
+
+      end
+    end
+  end
+end

data/lib/guard/typescript/inspector.rb

@@ -0,0 +1,40 @@
+module Guard
+  class TypeScript
+
+    # The inspector verifies of the changed paths are valid
+    # for Guard::TypeScript.
+    #
+    module Inspector
+      class << self
+
+        # Clean the changed paths and return only valid
+        # TypeScript files.
+        #
+        # @param [Array<String>] paths the changed paths
+        # @param [Hash] options the clean options
+        # @option options [String] :missing_ok don't remove missing files from list
+        # @return [Array<String>] the valid spec files
+        #
+        def clean(paths, options = {})
+          paths.uniq!
+          paths.compact!
+          paths.select { |p| typescript_file?(p, options) }
+        end
+
+        private
+
+        # Tests if the file is valid.
+        #
+        # @param [String] path the file
+        # @param [Hash] options the clean options
+        # @option options [String] :missing_ok don't remove missing files from list
+        # @return [Boolean] when the file valid
+        #
+        def typescript_file?(path, options)
+          path =~ /\.(?:ts)$/ && (options[:missing_ok] || File.exists?(path))
+        end
+
+      end
+    end
+  end
+end

data/lib/guard/typescript/runner.rb

@@ -0,0 +1,236 @@
+require 'ruby-typescript'
+
+module Guard
+  class TypeScript
+    module Runner
+      class << self
+
+        attr_accessor :last_run_failed
+
+        # The TypeScript runner handles the TypeScript compilation,
+        # creates nested directories and the output file, writes the result
+        # to the console and triggers optional system notifications.
+        #
+        # @param [Array<String>] files the spec files or directories
+        # @param [Array<Guard::Watcher>] watchers the Guard watchers in the block
+        # @param [Hash] options the options for the execution
+        # @option options [String] :input the input directory
+        # @option options [String] :output the output directory
+        # @option options [Boolean] :shallow do not create nested directories
+        # @option options [Boolean] :hide_success hide success message notification
+        # @option options [Boolean] :noop do not generate an output file
+        # @option options [Boolean] :source_map generate the source map files
+        # @return [Array<Array<String>, Boolean>] the result for the compilation run
+        #
+        def run(files, watchers, options = { })
+          notify_start(files, options)
+          changed_files, errors = compile_files(files, watchers, options)
+          notify_result(changed_files, errors, options)
+
+          [changed_files, errors.empty?]
+        end
+
+        # The remove function deals with TypeScript file removal by
+        # locating the output javascript file and removing it.
+        #
+        # @param [Array<String>] files the spec files or directories
+        # @param [Array<Guard::Watcher>] watchers the Guard watchers in the block
+        # @param [Hash] options the options for the removal
+        # @option options [String] :output the output directory
+        # @option options [Boolean] :shallow do not create nested directories
+        #
+        def remove(files, watchers, options = { })
+          removed_files = []
+          directories   = detect_nested_directories(watchers, files, options)
+
+          directories.each do |directory, scripts|
+            scripts.each do |file|
+              javascript = javascript_file_name(file, directory)
+              if File.exists?(javascript)
+                FileUtils.remove_file(javascript)
+                removed_files << javascript
+              end
+            end
+          end
+
+          if removed_files.length > 0
+            message = "Removed #{ removed_files.join(', ') }"
+            Formatter.success(message)
+            Formatter.notify(message, :title => 'TypeScript results')
+          end
+        end
+
+        private
+
+        # Generates a start compilation notification.
+        #
+        # @param [Array<String>] files the generated files
+        # @param [Hash] options the options for the execution
+        # @option options [Boolean] :noop do not generate an output file
+        #
+        def notify_start(files, options)
+          message = options[:message] || (options[:noop] ? 'Verify ' : 'Compile ') + files.join(', ')
+          Formatter.info(message, :reset => true)
+        end
+
+        # Compiles all TypeScript files and writes the JavaScript files.
+        #
+        # @param [Array<String>] files the files to compile
+        # @param [Array<Guard::Watcher>] watchers the Guard watchers in the block
+        # @param [Hash] options the options for the execution
+        # @return [Array<Array<String>, Array<String>] the result for the compilation run
+        #
+        def compile_files(files, watchers, options)
+          errors        = []
+          changed_files = []
+          directories   = detect_nested_directories(watchers, files, options)
+
+          directories.each do |directory, scripts|
+            scripts.each do |file|
+              begin
+                js, map = compile(file, directory, options)
+                if options[:noop]
+                  if File.exists?(js)
+                    FileUtils.remove_file(js)
+                  end
+                  if map and File.exists?(map)
+                    FileUtils.remove_file(map)
+                  end
+                end
+                changed_files << js << map
+              rescue => e
+                error_message = file + ': ' + e.message.to_s
+
+                if options[:error_to_js]
+                  js_error_message = "throw \"#{ error_message }\";"
+                  changed_files << write_javascript_file(js_error_message, nil, file, directory, options)
+                end
+
+                errors << error_message
+                Formatter.error(error_message)
+              end
+            end
+          end
+          [changed_files.flatten.compact, errors]
+        end
+
+        # Compile the TypeScript and generate the source map.
+        #
+        # @param [String] filename the TypeScript file name
+        # @param [Hash] options the options for the execution
+        # @option options [Boolean] :source_map generate the source map files
+        # @return [Array<String, String>] the JavaScript filename and the source map filename
+        #
+        def compile(filename, directory, options)
+          options = options.clone
+          options[:output] = javascript_file_name(filename, directory)
+          result = ::TypeScript.compile_file(filename, options)
+          if options[:source_map]
+            js, map = result[:js], result[:source_map]
+          else
+            js  = result[:js]
+          end
+
+          [js, map]
+        end
+
+        # Analyzes the CoffeeScript compilation output and creates the
+        # nested directories and writes the output file.
+        #
+        # @param [String] js the JavaScript content
+        # @param [String] map the source map content
+        # @param [String] file the CoffeeScript file name
+        # @param [String] directory the output directory
+        # @param [Hash] options the options for the execution
+        # @option options [Boolean] :noop do not generate an output file
+        # @return [String] the JavaScript file name
+        #
+        def write_javascript_file(js, map, file, directory, options)
+          directory = Dir.pwd if !directory || directory.empty?
+          filename = javascript_file_name(file, directory)
+
+          return filename if options[:noop]
+
+          if options[:source_map]
+            map_name = filename + '.map'
+            js += "\n/*\n//@ sourceMappingURL=#{File.basename(map_name)}\n*/\n"
+          end
+
+          FileUtils.mkdir_p(File.expand_path(directory)) if !File.directory?(directory)
+          File.open(File.expand_path(filename), 'w') { |f| f.write(js) }
+
+          if options[:source_map]
+            File.open(File.expand_path(map_name), 'w') { |f| f.write(map) }
+            [filename, map_name]
+          else
+            filename
+          end
+        end
+
+        # Calculates the output filename from the typescript filename and
+        # the output directory
+        #
+        # @param [string] filename the TypeScript file name
+        # @param [String] directory the output directory
+        #
+        def javascript_file_name(filename, directory)
+          File.join(directory, File.basename(filename.gsub(/((?:js\.)?(?:ts))$/, 'js')))
+        end
+
+        # Detects the output directory for each TypeScript file. Builds
+        # the product of all watchers and assigns to each directory
+        # the files to which it belongs to.
+        #
+        # @param [Array<Guard::Watcher>] watchers the Guard watchers in the block
+        # @param [Array<String>] files the TypeScript files
+        # @param [Hash] options the options for the execution
+        # @option options [String] :output the output directory
+        # @option options [Boolean] :shallow do not create nested directories
+        #
+        def detect_nested_directories(watchers, files, options)
+          return { options[:output] => files } if options[:shallow]
+
+          directories = { }
+
+          watchers.product(files).each do |watcher, file|
+            if matches = file.match(watcher.pattern)
+              if options[:output]
+                target = matches[1] ? File.join(options[:output], File.dirname(matches[1])).gsub(/\/\.$/, '') : options[:output] || File.dirname(file)
+              else
+                target = File.dirname(file)
+              end
+              if directories[target]
+                directories[target] << file
+              else
+                directories[target] = [file]
+              end
+            end
+          end
+
+          directories
+        end
+
+        # Writes console and system notifications about the result of the compilation.
+        #
+        # @param [Array<String>] changed_files the changed JavaScript files
+        # @param [Array<String>] errors the error messages
+        # @param [Hash] options the options for the execution
+        # @option options [Boolean] :hide_success hide success message notification
+        # @option options [Boolean] :noop do not generate an output file
+        #
+        def notify_result(changed_files, errors, options = { })
+          if !errors.empty?
+            self.last_run_failed = true
+            Formatter.notify(errors.join("\n"), :title => 'TypeScript results', :image => :failed, :priority => 2)
+          elsif !options[:hide_success] || last_run_failed
+            self.last_run_failed = false
+            message = "Successfully #{ options[:noop] ? 'verified' : 'generated' } #{ changed_files.join(', ') }"
+            Formatter.success(message)
+            Formatter.notify(message, :title => 'TypeScript results')
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/guard/typescript/templates/Guardfile

@@ -0,0 +1 @@
+guard 'typescript', :input => 'app/assets/javascripts'

data/lib/guard/typescript/version.rb

@@ -0,0 +1,6 @@
+module Guard
+  module TypeScriptVersion
+    # Guard::TypeScript version that is used for the Gem specification
+    VERSION = '0.1.0'
+  end
+end

data/lib/guard/typescript.rb

@@ -0,0 +1,81 @@
+require 'guard'
+require 'guard/guard'
+require 'guard/watcher'
+
+module Guard
+  # The TypeScript guard that gets notifications about the following
+  # Guard events: `start`, `stop`, `reload`, `run_all` and `run_on_change`.
+  #
+  class TypeScript < Guard
+    autoload :Formatter, 'guard/typescript/formatter'
+    autoload :Inspector, 'guard/typescript/inspector'
+    autoload :Runner, 'guard/typescript/runner'
+
+    DEFAULT_OPTIONS = {
+        :shallow      => false,
+        :hide_success => false,
+        :error_to_js  => false,
+        :all_on_start => false,
+        :source_map   => false
+    }
+
+    # Initialize Guard::TypeScript.
+    #
+    # @param [Array<Guard::Watcher>] watchers the watchers in the Guard block
+    # @param [Hash] options the options for the Guard
+    # @option options [String] :input the input directory
+    # @option options [String] :output the output directory
+    # @option options [Boolean] :shallow do not create nested directories
+    # @option options [Boolean] :hide_success hide success message notification
+    # @option options [Boolean] :all_on_start generate all JavaScripts files on start
+    # @option options [Boolean] :source_map generate the source map files
+    #
+    def initialize(watchers = [], options = {})
+      watchers = [] if !watchers
+      defaults = DEFAULT_OPTIONS.clone
+
+      if options[:input]
+        defaults.merge!({ :output => options[:input] })
+        watchers << ::Guard::Watcher.new(%r{^#{ options[:input] }/(.+\.(?:ts))$})
+      end
+
+      super(watchers, defaults.merge(options))
+    end
+
+    # Gets called once when Guard starts.
+    #
+    # @raise [:task_has_failed] when stop has failed
+    #
+    def start
+      run_all if options[:all_on_start]
+    end
+
+    # Gets called when all files should be regenerated.
+    #
+    # @raise [:task_has_failed] when stop has failed
+    #
+    def run_all
+      run_on_modifications(Watcher.match_files(self, Dir.glob('**{,/*/**}/*.ts')))
+    end
+
+    # Gets called when watched paths and files have changes.
+    #
+    # @param [Array<String>] paths the changed paths and files
+    # @raise [:task_has_failed] when stop has failed
+    #
+    def run_on_modifications(paths)
+      changed_files, success = Runner.run(Inspector.clean(paths), watchers, options)
+
+      throw :task_has_failed unless success
+    end
+
+    # Called on file(s) deletions that the Guard watches.
+    #
+    # @param [Array<String>] paths the deleted files or paths
+    # @raise [:task_has_failed] when run_on_change has failed
+    #
+    def run_on_removals(paths)
+      Runner.remove(Inspector.clean(paths, :missing_ok => true), watchers, options)
+    end
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: guard-typescript
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Payton Yao
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-10-12 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-typescript
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Guard::TypeScript automatically generates JavaScripts from your TypeScripts
+email: 
+- payton.yao@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/guard/typescript/formatter.rb
+- lib/guard/typescript/inspector.rb
+- lib/guard/typescript/runner.rb
+- lib/guard/typescript/templates/Guardfile
+- lib/guard/typescript/version.rb
+- lib/guard/typescript.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/jabbawookiees/guard-typescript
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: guard-typescript
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Guard gem for TypeScript
+test_files: []
+