shift 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+
+.rvmrc
+.yardoc
+doc
+*.swp
+*.gem

data/.yardopts

@@ -0,0 +1,7 @@
+--hide-void-return 
+-m markdown
+-M rdiscount
+--title "Shift - State and logic-less compiler and compressor interface"
+lib/**/*.rb
+--no-private
+--main README.md

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jostein Berre Eliassen
+
+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,100 @@
+
+Shift (draft)
+=====
+
+**State and logic-less compiler and compressor interface**
+
+---
+
+Shift is a generic Ruby interface to different compilers, compressors, transformers and so on. What the [Tilt](https://github.com/rtomayko/tilt) gem does for template languages, Shift does for stuff that compiles in one step, without stateful template logic.
+
+* [Documentation](http://rubydoc.info/github/jbe/shift/master/frames)
+* [File type mappings](http://rubydoc.info/github/jbe/shift/master/Shift)
+
+### Installation
+
+  gem install tilt
+
+
+### Usage
+
+To read and process a file, using the preferred available default component for that filetype:
+
+```ruby
+
+  Shift.read('thefile.js') # => minified js string
+
+```
+
+Or to read, process, and then write:
+
+```ruby
+
+  Shift.read('canopy.sass').write('canopy.css')
+
+```
+
+The components can also be used directly:
+
+```ruby
+
+  cc = Shift::ClosureCompiler.new(:compilation_level => 'ADVANCED_OPTIMIZATIONS')
+  minified_js_string  = cc.read(path)
+
+```
+
+To simply process a string, or to process and save a string:
+
+```ruby
+
+  md = Shift::RDiscount.new
+  md.process("hello *there*") # => "<p>hello <em>there</em></p>"
+  md.process("hello *there*").write('message.html')
+
+```
+To see if a component is available (check if the gem is installed and so on):
+
+```ruby
+
+  Shift::YUICompressor.available?.
+
+```
+
+To get the first available preferred default component class for a file:
+
+```ruby
+
+  Shift['somefile.js'] # => Shift::UglifyJS
+
+```
+
+You can also do:
+
+```ruby
+
+  Shift[:md] # => Shift::RDiscount
+
+```
+
+### Available engines
+
+* UglifyJS
+* ClosureCompiler
+* YUICompressor
+* CoffeeScript
+* Sass
+* RDiscount
+* Redcarpet
+
+
+### Why not use or extend Tilt instead?
+
+I am making a separate library for this rather than extending Tilt, because i would usually only need one of the two in a given context. One and two step compilation are somewhat different things. Shift is more on the build side. Tilt is more on the dynamic side.
+
+### Bye
+
+Bye Bye, see you. There are proper [docs](http://rubydoc.info/github/jbe/shift/master/frames) if you want more. And once again, [the mappings are there too](http://rubydoc.info/github/jbe/shift/master/Shift). Contributions and feedback is welcome, of course.
+
+---
+
+© 2011 Jostein Berre Eliassen. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,17 @@
+
+task :test do
+  $LOAD_PATH.unshift './lib'
+  require 'shift'
+  require 'minitest/autorun'
+  begin; require 'turn'; rescue LoadError; end
+  Dir.glob("test/**/*_test.rb").each { |test| require "./#{test}" }
+end
+
+task :shell do
+  system 'pry -I lib -r shift'
+end
+
+task :default => :test
+
+
+

data/lib/shift/c/closure_compiler.rb

@@ -0,0 +1,19 @@
+
+
+module Shift
+  class ClosureCompiler < Identity
+
+  def self.gem_dependencies
+    %w{closure-compiler}
+  end
+
+  def self.compiler_class
+    Closure::Compiler
+  end
+
+  def process_plain(str)
+    @engine.compile(str)
+  end
+
+  end
+end

data/lib/shift/c/coffee_script.rb

@@ -0,0 +1,23 @@
+
+module Shift
+  class CoffeeScript < Identity
+
+    def self.gem_dependencies
+      %w{coffee-script}
+    end
+
+    def self.require_libs
+      %w{coffee-script}
+    end
+
+    def initialize(opts={})
+      @opts = opts
+    end
+    
+
+    def process_plain(str)
+      ::CoffeeScript.compile(str, @opts)
+    end
+
+  end
+end

data/lib/shift/c/identity.rb

@@ -0,0 +1,116 @@
+
+
+module Shift
+
+  # Returns the input unaltered. The purpose is mainly to inherit
+  # from this when defining other, more useful compilers.
+  #
+  class Identity
+
+    # Mixed into the resulting strings to make them easy to save.
+    #
+    module StringExtension
+
+      # Write the string to a sepcified path.
+      #
+      def write(path)
+        File.open(path, 'w') do |file|
+          file.write(self)
+        end
+        self
+      end
+    end
+
+
+    # One-liner on what the user must have/do to make it available.
+    # Used in DependencyError.
+    #
+    def self.instructions
+      if gem_dependencies.any?
+        'gem install ' + gem_dependencies.join(' ')
+      else
+        'Google it :)'
+      end
+    end
+
+    # Wether the requirements are met in the current environment.
+    # Typically checks if the required gems and/or command line
+    # stuff is available.
+    #
+    def self.available?
+      gem_dependencies.all? {|d| Gem.available?(d) }
+    end
+
+    # A list of Rubygems needed for the component to work.
+    #
+    def self.gem_dependencies
+      []
+    end
+
+    # A list of things to be required on initialization.
+    #
+    def self.require_libs
+      gem_dependencies
+    end
+
+    # The class of the wrapped compiler, or false if none
+    # is used.
+    #
+    def self.compiler_class
+      false
+    end
+
+    # A default instance without options.
+    #
+    def self.default
+      @default ||= new
+    end
+
+    def self.new(*prms)
+      unless available?
+        raise Shift::DependencyError, "#{self} not available. " +
+              "Possible fix: #{instructions}"
+      end
+      @req ||= require_libs.each {|str| require str }
+      super
+    end
+
+    # Create a new instance. Ignores the given options.
+    #
+    def initialize(*prms)
+      if self.class.compiler_class
+        @engine = self.class.compiler_class.new(*prms)
+      end
+    end
+
+    # Process the supplied string, returning the resulting `String` (with a #write method attached to it).
+    #
+    def process(str)
+      process_plain(str).extend(StringExtension)
+    end
+    alias :compress   :process
+    alias :compile    :process
+    alias :transform  :process
+
+    # Process the supplied string, returning the resulting `String`.
+    #
+    def process_plain(str)
+      str.dup
+    end
+
+    # Read and process a file.
+    #
+    # @raise [DependencyError] when none of the mapped
+    #   implementations are available.
+    #
+    # @return [String] The processed `String`
+    #
+    def read(path)
+      process(File.read(path)).extend(StringExtension)
+    end
+
+  end
+  Echo = Identity
+end
+
+

data/lib/shift/c/rdiscount.rb

@@ -0,0 +1,18 @@
+
+module Shift
+  class RDiscount < Identity
+
+    def self.gem_dependencies
+      %w{rdiscount}
+    end
+
+    def initialize(*switches)
+      @switches = switches
+    end
+    
+    def process_plain(str)
+      ::RDiscount.new(str, *@switches).to_html
+    end
+
+  end
+end

data/lib/shift/c/redcarpet.rb

@@ -0,0 +1,18 @@
+module Shift
+  class Redcarpet < Identity
+
+    def self.gem_dependencies
+      %w{redcarpet}
+    end
+
+    def initialize(*switches)
+      @switches = switches
+    end
+    
+    def process_plain(str)
+      ::Redcarpet.new(str, *@switches).to_html
+    end
+
+  end
+  RedCarpet = Redcarpet
+end

data/lib/shift/c/sass.rb

@@ -0,0 +1,17 @@
+module Shift
+  class Sass < Identity
+
+    def self.gem_dependencies
+      %w{sass}
+    end
+
+    def initialize(opts={})
+      @opts = opts
+    end
+    
+    def process_plain(str)
+      ::Sass::Engine.new(str, @opts).render
+    end
+
+  end
+end

data/lib/shift/c/uglify_js.rb

@@ -0,0 +1,19 @@
+
+
+module Shift
+  class UglifyJS < Identity
+
+    def self.gem_dependencies
+      %w{uglifier}
+    end
+
+    def self.compiler_class
+      Uglifier
+    end
+
+    def process_plain(str)
+      @engine.compile(str)
+    end
+
+  end
+end

data/lib/shift/c/yui_compressor.rb

@@ -0,0 +1,22 @@
+
+module Shift
+  class YUICompressor < Identity
+
+    def self.gem_dependencies
+      %w{yui-compressor}
+    end
+
+    def self.require_libs
+      %w{yui/compressor}
+    end
+
+    def self.compiler_class
+      YUI::JavaScriptCompressor
+    end
+
+    def process_plain(str)
+      @engine.compress(str)
+    end
+
+  end
+end

data/lib/shift/errors.rb

@@ -0,0 +1,20 @@
+
+
+module Shift
+
+  # Shift base error, from which other errors inherit.
+  #
+  class Error < StandardError; end
+
+  # Raised when the environment needed to perform a given
+  # action is not available. Typically, you will need to
+  # install another gem or some library/software.
+  #
+  class DependencyError < Error; end
+
+  # Raised when you try to read a file for which there are
+  # no mappings without specifying its type.
+  #
+  class UnknownFormatError < Error; end
+
+end

data/lib/shift/mappings.rb

@@ -0,0 +1,32 @@
+
+module Shift
+  
+  # Mappings from file names to implementation classes. The
+  # classes are listed in order of preference per type.
+  #
+  MAPPINGS = {
+    'echo'    => %w{ Identity },
+    'js'      => %w{ UglifyJS ClosureCompiler YUICompressor },
+    'coffee'  => %w{ CoffeeScript },
+    'sass'    => %w{ Sass },
+    'md'      => %w{ RDiscount Redcarpet }
+  }
+
+  # @raise [DependencyError] when none of the mapped
+  #   implementations are available.
+  #
+  # @return [Class] The preferred available class associated
+  #   with the file or extension.
+  #
+  def self.best_available_mapping_for(key)
+    MAPPINGS[key].each do |kls_name|
+      kls = const_get(kls_name)
+      return kls if kls.available?
+    end
+    help = const_get(MAPPINGS[key].first)::INSTRUCTIONS
+    raise DependencyError, "no implementation available for " +
+      "#{key.inspect}. Possible solution: #{help}"
+  end
+end
+
+

data/lib/shift.rb

@@ -0,0 +1,60 @@
+
+
+#  SHIFT
+#
+#  State and logic-less compiler and compressor interface
+#
+#  (c) 2011 Jostein Berre Eliassen - MIT licence
+
+
+module Shift
+
+  VERSION = '0.1.0'
+
+  require 'shift/errors'
+  require 'shift/mappings'
+
+
+  # components
+
+  autoload :Identity,         'shift/c/identity'
+  autoload :UglifyJS,         'shift/c/uglify_js'
+  autoload :ClosureCompiler,  'shift/c/closure_compiler'
+  autoload :YUICompressor,    'shift/c/yui_compressor'
+  autoload :CoffeeScript,     'shift/c/coffee_script'
+  autoload :Sass,             'shift/c/sass'
+  autoload :RDiscount,        'shift/c/rdiscount'
+  autoload :Redcarpet,        'shift/c/redcarpet'
+  autoload :RedCarpet,        'shift/c/redcarpet'
+
+
+  # Read and process a file with the mapped component.
+  #
+  # @see Shift.[]
+  #
+  # (see Identity#read)
+  #
+  def self.read(path, opts={})
+    self[path].new(opts).read(path)
+  end
+
+  # Get the preferred available class mapped to match the
+  # given filename or extension.
+  #
+  # @raise [UnknownFormatError] when none of the mappings match.
+  #
+  # (see Shift.best_available_mapping_for)
+  #
+  def self.[](file)
+    pattern = File.basename(file.to_s.downcase)
+    until pattern.empty?
+      if MAPPINGS[pattern]
+        return best_available_mapping_for(pattern)
+      end
+      pattern.sub!(/^[^.]*\.?/, '')
+    end
+    raise UnknownFormatError, "no mapping matches #{file}"
+  end
+
+end
+

data/shift.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'shift'
+
+Gem::Specification.new do |s|
+
+  s.name      = 'shift'
+
+  s.author    = 'Jostein Berre Eliassen'
+  s.email     = 'josteinpost@gmail.com'
+  s.homepage  = "http://github.com/jbe/shift"
+  s.license   = "MIT"
+
+  s.version   = Shift::VERSION
+  s.platform  = Gem::Platform::RUBY
+
+  s.summary       = 'Shift is a generic interface to different compilers, compressors, etc.'
+  s.description   = 'Shift is a generic interface to different compilers, compressors, etc. What the Tilt gem does for template languages, Shift does for compilers and compressors.'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_path  = 'lib'
+  s.bindir        = 'bin'
+end

data/test/c/closure_compiler_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'identity_test')
+
+
+class ClosureCompilerTest < IdentityTest
+
+  FUNCTION = <<-eos
+    function hello(name) {
+      alert('Hello, ' + name);
+    }
+  eos
+
+  INVOCATION = <<-eos
+    hello('New user');
+  eos
+
+  def subject
+    Shift::ClosureCompiler
+  end
+
+  def options
+    {:compilation_level => 'ADVANCED_OPTIMIZATIONS'}
+  end
+
+  def transformations
+    {
+      [FUNCTION, INVOCATION].join("\n") =>
+        "alert(\"Hello, New user\");\n",
+      FUNCTION    => "\n",
+      INVOCATION  => "hello(\"New user\");\n"
+    }
+  end
+
+end

data/test/c/coffee_script_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'identity_test')
+
+
+class CoffeeScriptTest < IdentityTest
+
+  def subject
+    Shift::CoffeeScript
+  end
+
+  def options
+    {:bare => true}
+  end
+
+  def transformations
+    {
+      'hello'           => 'hello;',
+      'x = 23'          => "var x;\nx = 23;",
+      'frog -> "croak"' =>
+        "frog(function() {\n  return \"croak\";\n});"
+    }
+  end
+
+end

data/test/c/identity_test.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+# Test Shift::Identity.
+class IdentityTest < TestCase
+
+  def subject
+    Shift::Identity
+  end
+
+  def instance
+    @instance ||= subject.new(options)
+  end
+
+  def options
+    {}
+  end
+
+  def transformations
+    {
+      'echo'        => 'echo',
+      ''            => ''
+    }
+  end
+
+  test 'instructions' do
+    unless subject == Shift::Identity
+      refute_same subject.instructions,
+                  subject.superclass.instructions,
+                  'gives instructions'
+    end
+  end
+
+  test 'has_default_instance' do
+    assert_instance_of subject, subject.default
+  end
+
+  test 'process' do
+    transformations.each do |a, b|
+      assert_equal b, instance.process(a)
+    end
+  end
+
+  # the usual ruby system file errors will just pass through,
+  # no use in testing for them.
+
+  test 'read' do
+    transformations.each do |a, b|
+      with_tempfile(a) do |path|
+        assert_equal b, instance.read(path)
+      end
+    end
+  end
+
+  test 'read and write' do
+    transformations.each do |a, b|
+      with_tempfile(a) do |src_path|
+        with_tempfile do |trg_path|
+          instance.read(src_path).write(trg_path)
+          assert_equal b, IO.read(trg_path)
+        end
+      end
+    end
+  end
+
+  test 'process and write' do
+    transformations.each do |a, b|
+      with_tempfile do |path|
+        instance.process(a).write(path)
+        assert_equal b, IO.read(path)
+      end
+    end
+  end
+
+  test 'initialize when unavailable' do
+    wrap = Class.new(subject).extend(Unavabelizer)
+    assert_raises(Shift::DependencyError) { wrap.new }
+  end
+
+end

data/test/c/rdiscount_test.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), 'identity_test')
+
+
+class RDiscountTest < IdentityTest
+
+  def subject
+    Shift::RDiscount
+  end
+
+  def instance
+    subject.new
+  end
+
+  def transformations
+    { 'hello' => "<p>hello</p>\n" }
+  end
+
+end

data/test/c/redcarpet_test.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), 'identity_test')
+
+
+class RedCarpetTest < IdentityTest
+
+  def subject
+    Shift::Redcarpet
+  end
+
+  def instance
+    subject.new
+  end
+
+  def transformations
+    { 'hello' => "<p>hello</p>\n" }
+  end
+
+end

data/test/c/sass_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'identity_test')
+
+
+class SassTest < IdentityTest
+
+  def subject
+    Shift::Sass
+  end
+
+  def transformations
+    {"#footer\n  :height 200px" => "#footer {\n  height: 200px; }\n"}
+  end
+
+end

data/test/c/uglify_js_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'identity_test')
+
+
+class UglifyJSTest < IdentityTest
+
+  FUNCTION = <<-eos
+    function hello(name) {
+      alert('Hello, ' + name);
+    }
+  eos
+
+  INVOCATION = <<-eos
+    hello('New user');
+  eos
+
+  def subject
+    Shift::UglifyJS
+  end
+
+  def options
+    {}
+  end
+
+  def transformations
+    {
+      [FUNCTION, INVOCATION].join("\n") =>
+        "function hello(a){alert(\"Hello, \"+a)}hello(\"New user\")",
+      FUNCTION    => "function hello(a){alert(\"Hello, \"+a)}",
+      INVOCATION  => "hello(\"New user\")"
+    }
+  end
+
+end

data/test/c/yui_compressor_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'identity_test')
+
+
+class YUICompressorTest < IdentityTest
+
+  FUNCTION = <<-eos
+    function hello(name) {
+      alert('Hello, ' + name);
+    }
+  eos
+
+  INVOCATION = <<-eos
+    hello('New user');
+  eos
+
+  def subject
+    Shift::YUICompressor
+  end
+
+  def options
+    {}
+  end
+
+  def transformations
+    {
+      [FUNCTION, INVOCATION].join("\n") =>
+        "function hello(name){alert(\"Hello, \"+name)}hello(\"New user\");",
+      FUNCTION    => "function hello(name){alert(\"Hello, \"+name)};",
+      INVOCATION  => "hello(\"New user\");"
+    }
+  end
+
+end

data/test/data/letter.echo

@@ -0,0 +1,6 @@
+
+Hello dear.
+
+Could you please bring with you my electric power drill, a cup of baking soda, three rolls of duct tape and The Brothers Karamazov when you come back from the apartment? I'm going on a mission again.
+
+Thanks.

data/test/data/piglet.coffee

@@ -0,0 +1,5 @@
+
+
+piglet = -> 'grunt grunt'
+
+piglet()

data/test/helper.rb

@@ -0,0 +1,37 @@
+require 'tempfile'
+
+class TestCase < MiniTest::Unit::TestCase
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} already defined in #{self}" if defined
+
+    block ||= proc { skip }
+    define_method(test_name, &block)
+  end
+
+  def with_tempfile(data=nil)
+    file = Tempfile.new('shift_test')
+    file.write(data) if data
+    file.close
+    yield(file.path)
+    file.unlink
+  end
+
+  def file(name)
+    File.join(File.dirname(__FILE__), 'data', name)
+  end
+
+end
+
+
+
+
+
+module Unavabelizer
+  def available?
+    false
+  end
+end
+
+

data/test/shift_test.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), 'support')
+
+
+
+
+# Test Shift base module methods
+class ShiftTest < TestCase
+
+  test 'read nonexistant file' do
+    assert_raises(Errno::ENOENT) do
+      Shift.read('/ubongobaluba-hepp-piglets/seriously.echo')
+    end
+  end
+
+  test 'read file' do
+    assert_match Shift.read(file 'letter.echo'),
+                 /electric power drill/
+  end
+
+  test 'reads existing file and writes result' do
+    with_tempfile do |path|
+      Shift.read(file('letter.echo')).write(path)
+      assert_equal(IO.read(file 'letter.echo'), IO.read(path))
+    end
+  end
+
+
+  # mappings
+
+  test 'has mappings' do
+    assert_kind_of Hash, Shift::MAPPINGS
+  end
+
+  test 'reads unmapped file' do
+    assert_raises(Shift::UnknownFormatError) do
+      Shift.read('oy-oy-oy.noformatforthis')
+    end
+  end
+
+  test 'gets available mapping' do
+    assert_equal Shift[:echo], Shift::Identity, 'given type'
+    assert_equal Shift['treaty.null'], NullComponent, 'given path'
+    assert_equal Shift['some/path/hey.bingo.bongo'],
+                 NullComponent, 'with detailed mapping'
+  end
+
+  test 'prioritizes' do
+    assert_equal Shift['file.null'], NullComponent,
+                 'first when available'
+    assert_equal Shift['file.prioritized'], NullComponent,
+                 'second when available but not first'
+  end
+
+  test 'raises DependencyError' do
+    begin
+      Shift[:unavailable] # defined in test/support.rb
+      assert false, 'when no components available'
+    rescue Shift::DependencyError => err
+      assert_match /meditate/, err.message, 'with helpful message'
+    end
+  end
+
+end
+

data/test/support.rb

@@ -0,0 +1,37 @@
+
+class UnavailableComponent < Shift::Identity
+  
+  INSTRUCTIONS = 'meditate.'
+
+  def self.available?
+    false
+  end
+
+end
+
+class NullComponent < Shift::Identity
+
+  def self.available?
+    true
+  end
+
+  def process(str)
+    ''
+  end
+
+end
+
+Shift::MAPPINGS['unavailable'] = ['UnavailableComponent'] * 10
+
+Shift::MAPPINGS['null']             = %w{NullComponent}
+Shift::MAPPINGS['bingo.bongo']  = %w{NullComponent}
+
+Shift::MAPPINGS['prioritized'] = %w{UnavailableComponent
+                          NullComponent Identity}
+
+
+
+
+
+
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: shift
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jostein Berre Eliassen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-09 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Shift is a generic interface to different compilers, compressors, etc. What the Tilt gem does for template languages, Shift does for compilers and compressors.
+email: josteinpost@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .yardopts
+- LICENSE
+- README.md
+- Rakefile
+- lib/shift.rb
+- lib/shift/c/closure_compiler.rb
+- lib/shift/c/coffee_script.rb
+- lib/shift/c/identity.rb
+- lib/shift/c/rdiscount.rb
+- lib/shift/c/redcarpet.rb
+- lib/shift/c/sass.rb
+- lib/shift/c/uglify_js.rb
+- lib/shift/c/yui_compressor.rb
+- lib/shift/errors.rb
+- lib/shift/mappings.rb
+- shift.gemspec
+- test/c/closure_compiler_test.rb
+- test/c/coffee_script_test.rb
+- test/c/identity_test.rb
+- test/c/rdiscount_test.rb
+- test/c/redcarpet_test.rb
+- test/c/sass_test.rb
+- test/c/uglify_js_test.rb
+- test/c/yui_compressor_test.rb
+- test/data/letter.echo
+- test/data/piglet.coffee
+- test/helper.rb
+- test/shift_test.rb
+- test/support.rb
+has_rdoc: true
+homepage: http://github.com/jbe/shift
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Shift is a generic interface to different compilers, compressors, etc.
+test_files: []
+