guard-entangle 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 27e56ed3b4c431a44f1767c95c4d75dcc6a5502b
+  data.tar.gz: 6be2f2e9ab8b6847f5bba4a4a61d9c962e4b1788
+SHA512:
+  metadata.gz: 1ef5d8ce547953d5c61618c345ca449ffaed937a38ba412182aebd4a40aad280694f8b1ab2be80c38244fd01d92e7ecc180d89b6916b98a005f4271ea401ed64
+  data.tar.gz: 8bddb67b1f907edfafd3a0f4d3864564fbfaac33e717aa3e32cc5f3fb5bef158de5f817afda17e98595923ef2835403fc05d1a594aad5c83bbd89065d87460ec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Deshi Rahim
+
+MIT License
+
+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,104 @@
+# Guard::Entangle
+
+This is a plugin for the Ruby gem [Guard](https://github.com/guard/guard). Guard-Entangle allows you to include one file inline into another. It uses a syntax of `//= path/to/file` to substitute that file in place of that line.
+
+## Common usage
+
+Often you might have separate JavaScript files that need to be included into one file. Or partials of a file that need to be included into a master file.
+
+## Installation
+
+NOTE: This is an innitial release - just to make sure the name isn't stolen now that it's on Github (I'm told this happens). There are a couple of Rpecs missing. It will be a full release once those files are added to this gem.
+
+Add this line to your application's Gemfile:
+
+    gem 'guard-entangle'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install guard-entangle
+
+## Usage
+
+As mentioned above, this is only a plugin for [Guard](https://github.com/guard/guard) and does not run on it's own. This plugin will look for `//= path/to/file` in a file and then replace it with the contents of the file stated after `//= `. For example:
+
+```
+This is some content in the file
+//= src/File1.js
+
+This is someother content in the file.
+```
+When this is triggered, `//= src/File1.js` will be replaced with the contents of _src/File1.js_.
+
+This functionality is not limited to JavaScript files. However, only JavaScript files can be run through Uglifier.
+
+The rules that trigger this behavior are defined in a _Guardfile_ in your project. For further instructions visit the [Guard website](https://github.com/guard/guard). In the _Guardfile_ you can include the following rules:
+
+### Run all / Run
+Guard will trigger the files either on their own or by the _run all_ command (when you press enter in Guard).
+
+When a single file is triggered, it will check if the file is a partial or not.
+
+A partial is a file that is not meant to be complied on its own, but is included within another file. Guard-Entangle determines this by check if the file or folder has **_**
+ at the start of its name. For example a file named *_File1.js* will be considered to be a partial. Folders that start with _ will be skipped when runnign the run all command. All files within a partials folder should also start with an _.
+ 
+If it is a partial, it will trigger the _run all_ command. If its not a partial, it will compile that file only. This is because partials don't get compiled on their own, but its their parent that needs to be compiled.
+
+The _run all_ command will take all the file(s) in the input directory (that are not partials) and compile them into the output directory.
+
+### Compile all files in a directory to the output directory
+
+```
+guard :entangle, output: 'output', all_on_start: false, input: 'src', uglifier_options: {} do
+    watch(%r{^src/.+\..+$})
+end
+```
+This will watch all files that match the regex _%r{^src/.+\..+$}_ or its subdirectory and then compile them into the output directory (:output). If the _run all_ command is triggered, all the files in the source directory (:input) will get compiled into the output directory (:output). In this instance, the input directory is _src_ and the output directory is _output_.
+
+### Compile only one file
+
+```
+guard :entangle, output: 'output', all_on_start: false, input: 'src/File1.js', uglifier_options: {} do
+    watch(%r{^src/.+\..+$})
+end
+```
+This will watch all files that match the regex _%r{^src/.+\..+$}_ or its subdirectory and then when a file has been changed, it will compile _src/File1.js_ and write the compiled file into _output/File1.js_. This is because the __:output__ folder is defined as output.
+
+### Specifying the output filename
+When compiling one file you may choose to specify the name of the output file. This has 2 different behaviors depending on the input. If the input is a directory, then it will entangle all the files into the output file. If the input is a file, then it will take that file and entangle it into the output file.
+
+```
+guard :entangle, output: 'output/output.js', all_on_start: false, input: 'src', uglifier_options: {} do
+    watch(%r{^src/.+\..+$})
+end
+```
+This will watch all files that match the regex _%r{^src/.+\..+$}_ or its subdirectory and then when a file has been changed, it will compile all the files in _src_ and write the compiled file into _output/output.js_. This is because the __:output__ is defined as that file.
+
+```
+guard :entangle, output: 'output/output.js', all_on_start: false, input: 'src/File.js', uglifier_options: {} do
+    watch(%r{^src/.+\..+$})
+end
+```
+This will watch all files that match the regex _%r{^src/.+\..+$}_ or its subdirectory and then when a file has been changed, it will compile all the file _src/File.js_ and write the compiled file into _output/output.js_. This is because the __:output__ is defined as that file.
+
+## Options
+The options that can be passed are
+
+* :output           = The output file/folder
+* :input            = The input file/folder
+* :uglify           = If js files should be uglified
+* :all_on_start     = If all files should be engtangled when guard has started
+* :uglifier_options = {} Pass a Hash of any [uglifier options](https://github.com/lautis/uglifier)
+* :copy             = Saves a copy of the non uglified file along with the min file
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/guard/entangle.rb

@@ -0,0 +1,94 @@
+require 'guard'
+require 'guard/plugin'
+
+module Guard
+  class Entangle < Plugin
+
+    attr_accessor :options, :runner
+
+    DEFAULTS = {
+      :output           => 'js',
+      :input            => 'input',
+      :uglify           => true,
+      :run_all          => { message: 'Entangling all files' },
+      :all_on_start     => false,
+      :hide_success     => false,
+      :uglifier_options => {},
+      :copy             => true #save a copy of the original file
+    }
+
+    # Initializes a Guard plugin.
+    # Don't do any work here, especially as Guard plugins get initialized even if they are not in an active group!
+    #
+    # @param [Hash] options the custom Guard plugin options
+    # @option options [Array<Guard::Watcher>] watchers the Guard plugin file watchers
+    # @option options [Symbol] group the group this Guard plugin belongs to
+    # @option options [Boolean] any_return allow any object to be returned from a watcher
+    #
+    def initialize(options = {})
+      options = DEFAULTS.merge(options)
+
+      @runner = Runner.new(options)
+      super(options)
+    end
+
+    # Called once when Guard starts. Please override initialize method to init stuff.
+    #
+    # @raise [:task_has_failed] when start has failed
+    # @return [Object] the task result
+    #
+    def start
+      ::Guard::UI.info 'Guard::Entangle is running'
+      run_all if options[:all_on_start]
+    end
+
+    # Called when `reload|r|z + enter` is pressed.
+    # This method should be mainly used for "reload" (really!) actions like reloading passenger/spork/bundler/...
+    #
+    # @raise [:task_has_failed] when reload has failed
+    # @return [Object] the task result
+    #
+    def reload
+      runner.reload
+    end
+
+    # Called when just `enter` is pressed
+    # This method should be principally used for long action like running all specs/tests/...
+    #
+    # @raise [:task_has_failed] when run_all has failed
+    # @return [Object] the task result
+    #
+    def run_all
+      _throw_if_failed { runner.run_all }
+    end
+
+    # Default behaviour on file(s) changes that the Guard plugin watches.
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_change has failed
+    # @return [Object] the task result
+    #
+    def run_on_changes(paths)
+      run_on_modifications(paths)
+    end
+
+    # Called on file(s) modifications that the Guard plugin watches.
+    #
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_modifications has failed
+    # @return [Object] the task result
+    #
+    def run_on_modifications(paths)
+      return false if paths.empty?
+      _throw_if_failed { runner.run(paths) }
+    end
+
+    private
+
+    def _throw_if_failed
+      throw :task_has_failed unless yield
+    end
+  end
+end
+
+require 'guard/entangle/runner'
+require 'guard/entangle/formatter'

data/lib/guard/entangle/entangler.rb

@@ -0,0 +1,82 @@
+module Guard
+  class Entangle
+    class Entangler
+      attr_reader :options
+
+      # Initialize entangler
+      #
+      # @param [Hash] options The options passed in
+      #
+      def initialize(options={})
+        @options = options
+      end
+
+      # Convert the file
+      #
+      # @param  [String] path    The path of file
+      # @return [String] The entangled content
+      #
+      def convert(path)
+        if not File.exists?(path) or not File.readable?(path)
+          return false
+        end
+        pn = Pathname.new(path)
+        file = File.open(path, 'rb')
+        contents = file.read
+        contents = convert_file(contents, pn.dirname)
+      end
+
+      private
+
+      # Convert the file
+      #
+      # @param  [String]  contents    The content to replace in
+      # @param  [String]  base        The base path
+      # @return [String]  The replaced content
+      #
+      def convert_file(contents, base)
+        matches = Set.new search(contents)
+        if not matches.empty?
+          matches.each do |entry|
+            contents = replace(contents, entry, base)
+          end
+        else
+          return contents
+        end
+        contents
+      end
+
+      # Search the contnet for any file hooks
+      #
+      # @param  [String]  contents    The content to search
+      # @return [Array]   The array of found hooks
+      #
+      def search(contents)
+        contents.scan(/\/\/=.+$/)
+      end
+
+      # Replace the file hook with the contents of the file
+      #
+      # @param  [String]  content   The content of the file
+      # @param  [String]  file      The file hook
+      # @param  [String]  path      The base path of the file
+      # @return [String]  The replaced content
+      #
+      def replace(content, file, path)
+        name = file.sub '//=', ''
+        stripped = name.strip
+        file = "#{path}/#{stripped}"
+        if File.exists?(file) && File.readable?(file)
+          insert = File.open(file, 'rb')
+          insert_content = insert.read
+          pn = Pathname.new(insert)
+          insert = convert_file(insert_content, pn.dirname)
+          content.gsub! "//=#{name}", insert_content
+        else
+          content.gsub! "// #{name}: Does not exist or isn't readable!"
+        end
+        content
+      end
+    end
+  end
+end

data/lib/guard/entangle/formatter.rb

@@ -0,0 +1,71 @@
+module Guard
+  class Entangle
+
+    # The formatter handles providing output to the user.
+    class Formatter
+
+      # 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 = {})
+          ::Guard::UI.info(color(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

data/lib/guard/entangle/runner.rb

@@ -0,0 +1,191 @@
+require 'guard/entangle/entangler'
+require 'guard/entangle/formatter'
+require 'guard/entangle/writer'
+
+module Guard
+  class Entangle
+    class Runner
+
+      attr_accessor :options
+
+      # Initialize the object
+      #
+      # @param [hash] options The options passed in
+      #
+      def initialize(options={})
+        @options = options
+        @entangler = Entangler.new(options)
+        @formatter = Formatter.new
+        @writer = Writer.new(options)
+      end
+
+      # Run a changed file
+      #
+      # @param  [array] files Contains the changed file
+      # @return [void]
+      #
+      def run(files)
+        # Check if it's a partial
+        if partial?(files.first)
+          run_all
+        else
+          # We need to check to see if the input is a
+          # directory, else only check that file
+          if File.directory?(options[:input])
+            # Check if the output is one file
+            if output_dir?
+              compile_files(files)
+            else
+              compile_all(files)
+            end
+          else
+            compile(options[:input])
+          end
+        end
+      end
+
+
+      # Run all the file(s) that are set in input
+      #
+      # @return [void]
+      #
+      def run_all
+        paths = options[:input]
+        if File.directory?(paths)
+          options = @options.merge(@options[:run_all]).freeze
+          return if paths.empty?
+          ::Guard::UI.info(options[:message], reset: true)
+          if output_dir?
+            run_paths(paths)
+          else
+            compile_all(paths)
+          end
+        else
+          compile(paths)
+        end
+      end
+
+      private
+
+
+      # Run through all the paths
+      #
+      # @param  [array] paths   The paths array
+      # @return [void]
+      #
+      def run_paths(paths)
+        if paths.kind_of?(Array)
+          paths.each do |path|
+            process_dir(path)
+          end
+        elsif paths.kind_of?(String)
+          process_dir(paths)
+        else
+          ::Guard::UI.info "Paths in configuration are incorrect"
+        end
+      end
+
+
+      # Process the entire directory
+      #
+      # @param  [array]  paths        The paths array
+      # @param  [boolen] only_compile If the file shouldn't be saved
+      # @return [void]
+      #
+      def process_dir(paths, only_compile = false)
+        return false unless File.directory?(paths)
+        skip = %w[. ..];
+
+        cwd = Dir.pwd
+        path = "#{cwd}/#{paths}"
+        compiled = ''
+
+        entries = Dir.entries(path)
+        entries.each do |file|
+          # Skip the dot files and the partials
+          if not skip.include?(file) and not partial?(file)
+            if File.directory?("#{path}/#{file}")
+              contents = process_dir("#{paths}/#{file}", only_compile)
+            else
+              contents = compile("#{path}/#{file}", only_compile)
+            end
+            compiled << contents if only_compile
+          end
+        end
+        if (only_compile)
+          return compiled
+        end
+      end
+
+      # Compile all files and save then in the same file
+      #
+      # @param  [string] path The input path
+      # @return [void]
+      #
+      def compile_all(path)
+        compiled = process_dir(path, true)
+        saved = @writer.output(compiled, options[:output])
+        if saved
+          message = "Successfully compiled and saved #{ options[:output] }"
+          @formatter.success(message)
+        end
+      end
+
+
+      # Compile each of the files
+      #
+      # @param  [array] files The array of files
+      # @return [void]
+      #
+      def compile_files(files)
+        files.each do |file|
+          compile(file)
+        end
+      end
+
+
+      # Compile a file
+      #
+      # @param  [string]  file         The file to compile
+      # @param  [boolean] only_compile If the file shouldn't be saved
+      # @return [string]               The saved file or contents
+      #
+      def compile(file, only_compile = false)
+        contents = @entangler.convert(file)
+
+        # If we are only compiling
+        return contents if only_compile
+
+        # save the contents to a file
+        if contents
+          saved = @writer.output(contents, file)
+          if saved
+            message = "Successfully compiled and saved #{ saved }"
+            @formatter.success(message)
+          end
+        else
+          message = "#{ file } does not exist or is not accessable"
+          @formatter.error(message)
+        end
+        saved
+      end
+
+      # Check if the file is a partial or not
+      #
+      # @param  [string] path The path to check
+      # @return [boolean] If it is a partial
+      #
+      def partial?(path)
+        File.basename(path).start_with? '_'
+      end
+
+      # If the output is a directory
+      #
+      # @return [boolean]
+      #
+      def output_dir?
+        File.extname(options[:output]).empty?
+      end
+    end
+  end
+end

data/lib/guard/entangle/templates/Guardfile

@@ -0,0 +1,5 @@
+# Watch any file in the src directory - change as required
+# Output directory set as output:
+guard :entangle, output: 'output' do
+    watch(%r{^src/.+\..+$})
+end

data/lib/guard/entangle/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  class EntangleVersion
+    VERSION = "0.0.4"
+  end
+end

data/lib/guard/entangle/writer.rb

@@ -0,0 +1,140 @@
+require 'uglifier'
+require 'guard/entangle/formatter'
+
+module Guard
+  class Entangle
+
+    # The writter class to create an write files
+    class Writer
+
+      attr_accessor :options, :cwd
+
+
+      # Initialize entangler
+      #
+      # @param [Hash]   options   The options passed in
+      #
+      def initialize(options={})
+        @cwd = Dir.pwd
+        @options = options
+        @formatter = Formatter.new
+      end
+
+
+      # Outputs the file in it's needed location
+      #
+      # @param  [string] content The content to be written
+      # @param  [string] file    The file path
+      # @return [mixed] path on success else false
+      #
+      def output(content, file)
+        # Output the file
+        path = get_path(file)
+        if create_path?(path)
+          if File.writable?(File.dirname(path))
+            # Uglify the files if the flag is set
+            if options[:uglify]
+              uglify(content, file, path)
+            else
+              save(content, path)
+            end
+          else
+            path.gsub! "#{cwd}/", ''
+            message = "The path #{ rel } is not writable."
+            @formatter.error(message)
+            return
+          end
+        end
+      end
+
+      private
+
+      # Uglify the js file
+      #
+      # @param  [string] content The content
+      # @param  [string] file    The source file path
+      # @param  [string] path    The destination path
+      # @return [mixed] path on success, else false
+      #
+      def uglify(content, file, path)
+        if File.extname(path) == '.js'
+          min = path.gsub(/\.[^.]+$/, '.min.js')
+          begin
+            uglify = Uglifier.new(options[:uglifier_options]).compile(content)
+            save(uglify, min)
+          rescue Exception => e
+            # Get a readable message
+            message = e.message.split(/[\n\r]/).first
+            @formatter.error("Uglifier - #{message}")
+            return nil
+          end
+
+          # If it's specified to keep a copy of the original
+          if options[:copy]
+            save(content, path)
+          end
+        else
+          save(content, path)
+        end
+      end
+
+
+      # Save the file
+      #
+      # @param  [string] content The content to write
+      # @param  [string] path    The destination file
+      # @return [mixed] path on success, else false
+      #
+      def save(content, path)
+        file = path.gsub "#{cwd}/", ''
+        if content
+          if File.writable?(File.dirname(path))
+            output = File.new(path, 'w+')
+            output.write(content)
+            output.close
+            return file
+          else
+            message = "The path #{ file } is not writable."
+            @formatter.error(message)
+          end
+        else
+          message = "Content for #{ file } was empty"
+          @formatter.error(message)
+        end
+      end
+
+
+      # Get the appropriate path depending on the settings
+      #
+      # @param  [string] file The file path
+      # @return [string] The correct file path
+      #
+      def get_path(file)
+        path = "#{cwd}/#{options[:output]}"
+        if File.extname(options[:output]).empty?
+          filename = file.gsub "#{cwd}/", ''
+          source = filename.split('/').first
+          filename.gsub! "#{source}/", ''
+          path = "#{path}/#{filename}"
+        end
+        path
+      end
+
+      # Create the required directories
+      #
+      # @param  [string] path The file path
+      # @return [boolean] If the folder was created
+      #
+      def create_path?(path)
+        begin
+          FileUtils.mkdir_p(File.dirname(path))
+        rescue Exception => e
+          message = e.message.split(/[\n\r]/).first
+          @formatter.error("Uglifier - #{message}")
+          return false
+        end
+        true
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: guard-entangle
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Deshi Rahim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: uglifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+
+  This gem leverages Guard's watch ability to insert files inline within another file. When the parser incounters a //= path/to/file, it then gets the content of that file and then inserts the content replacing the comment. Optionally that file can then be passed through Uglifier. Files with no insertions will just be copied over.
+email:
+- deshi@deshiknaves.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/guard/entangle.rb
+- lib/guard/entangle/entangler.rb
+- lib/guard/entangle/formatter.rb
+- lib/guard/entangle/runner.rb
+- lib/guard/entangle/templates/Guardfile
+- lib/guard/entangle/version.rb
+- lib/guard/entangle/writer.rb
+homepage: http://rubygems.org/gems/guard-entangle
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Inserts file content inline into another document. Optionally uglifies the
+  output.
+test_files: []