shift 0.1.0 → 0.4.0

data/lib/shift/interfaces.rb

@@ -0,0 +1,20 @@
+
+
+module Shift
+
+  autoload :Interface,        'shift/interface'
+
+  autoload :Echo,             'shift/i/echo'
+  autoload :UglifyJS,         'shift/i/uglify_js'
+  autoload :ClosureCompiler,  'shift/i/closure_compiler'
+  autoload :YUICompressor,    'shift/i/yui_compressor'
+  autoload :CoffeeScript,     'shift/i/coffee_script'
+  autoload :Sass,             'shift/i/sass'
+  autoload :RDiscount,        'shift/i/rdiscount'
+  autoload :Redcarpet,        'shift/i/redcarpet'
+  autoload :RedCarpet,        'shift/i/redcarpet'
+
+  autoload :ZlibReader,       'shift/i/zlib_reader'
+  autoload :ZlibWriter,       'shift/i/zlib_writer'
+
+end

data/lib/shift/mapper.rb

@@ -0,0 +1,95 @@
+
+module Shift
+
+  require 'shift/interface_list'
+  require 'shift/action_map'
+
+  MAP = {}
+
+  # Herein lies the logic concerned with mapping (format, action)
+  # to compiler interfaces.
+  #
+  class << self
+
+    # Global actions that apply to all types
+    #
+    def global
+      @global ||= ActionMap.new(nil)
+    end
+    attr_writer :global
+
+    # Register mappings for file types.
+    #
+    def map(*synonyms)
+      actions = synonyms.pop
+
+      synonyms.each do |syn|
+        am = MAP[syn.to_s] ||= ActionMap.new(global, actions)
+      end
+    end
+
+    # Get the preferred available class mapped to the given format 
+    # or path and action.
+    #
+    def [](name, action=:default)
+      try_to_match(name) do |fmt|
+
+        if action_map = MAP[fmt]
+          if iface_list = action_map[action]
+            return iface_list.pick
+          else
+            raise UnknownActionError,
+              "#{action.inspect} with format #{name.inspect}."
+          end
+        end
+        return global[action].pick if global[action]
+      end
+      raise UnknownFormatError, "no mappings for #{name}"
+    end
+
+
+    def synonyms
+      MAP.group_by do |name, actions|
+        actions
+      end.map do |action_map, hsh_ary|
+        hsh_ary.map {|k,v| k }.flatten.uniq
+      end
+    end
+
+    def action_overview(globals=false)
+      result = {}
+      synonyms.each do |group|
+        result[group] = group.map do |fmt|
+          MAP[fmt].atoms(globals).keys
+        end.uniq
+      end
+      result
+    end
+
+    def inspect_actions
+      buf = []
+      buf << "GLOBAL: #{global.atoms(true).keys.join(', ')}"
+
+      action_overview.each do |types, actions|
+        buf << "#{types.join(', ')}: #{actions.join(', ')}"
+      end
+
+      buf.join("\n")
+    end
+
+  private
+
+    # Given a file name, yield all the formats it could match.
+    #
+    def try_to_match(name)
+      return yield name if name.nil?
+
+      pattern = File.basename(name.to_s.downcase)
+      until pattern.empty?
+        yield pattern
+        pattern.sub!(/^[^.]*\.?/, '')
+      end
+    end
+
+  end
+end

data/lib/shift/mappings.rb

@@ -1,32 +1,55 @@
 
 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
 
+  global.map(
+    :gzip => 'ZlibWriter'
+    )
+
+  map(:echo, 'Echo')
+
+  map(:coffee,
+    :default  => :compile,
+    :compile  => 'CoffeeScript'
+    )
+
+  #map(:haml,
+  #  :default  => :compile,
+  #  :compile  => 'Haml'
+  #  )
+
+  #map('haml.compiled',
+  #  :default  => :render,
+  #  :render   => 'HamlTemplate'
+  #  )
+
+  #map(:rbt,
+  #  :default  => :render,
+  #  :render   => 'RubyTemplate'
+  #  )
+
+  map(:gz,
+    :default  => :inflate,
+    :decompress => :inflate,
+    :unzip    => :inflate,
+    :inflate  => 'ZlibReader'
+    )
+
+  map(:js,
+    :default  => :compress,
+    :minify   => :compress,
+    :compress => %w{UglifyJS YUICompressor ClosureCompiler}
+    )
+
+  map(:md, :markdown,
+    :default  => :render,
+    :compile  => :render,
+    :render   => %w{RDiscount Redcarpet}
+    )
+
+  map(:sass,
+    :default  => :compile,
+    :compile  => 'Sass'
+    )
+
+end
 

data/lib/shift/mappings.yml

@@ -0,0 +1,6 @@
+
+shift.global:
+  gzip: ZlibCompressor
+
+echo:
+  default: :echo

data/lib/shift/string.rb

@@ -0,0 +1,125 @@
+
+
+
+module Shift
+
+  # Mixin for things that should be transformable by Shift.
+  # Classes using the mixin should implement two methods:
+  # 
+  # - `#data` the data to be processed
+  # - `#name` the file or extension name of the data
+  # 
+  # This is needed for the mappings to work, even if the type
+  # is not a string, and/or is not persisted to disk. In this
+  # respect, the name is actually the name of the type.
+  #
+  module Transformable
+
+    attr_accessor   :name
+    alias :path     :name
+    alias :path=    :name=
+    alias :format   :name
+    alias :format=  :name=
+
+    # Get the default interface class for this transformable.
+    #
+    # @param [Symbol] action The action to perform.
+    #   Sample: `:compress`
+    # @param [String] name_override Use the specified file name or
+    #   extension rather than `#name`
+    # @return [Shift::Interface] The preferred available default
+    #   interface
+    # @raise [UnknownFormatError] when a type is needed but cannot
+    #   be determined.
+    # @raise [UnknownActionError] when no such action exists.
+    # @raise [DependencyError] when required interfaces are 
+    #   not available.
+    #
+    def interface(action=:default, name_override=nil)
+      return action if action.is_a?(Shift::Interface)
+      iface = Shift[name_override || name, action] || name_error
+      iface.new
+    end
+    def can?(*args)
+      begin
+        interface(*args)
+      rescue LookupError
+        return false
+      end
+      true
+    end
+
+    # Process the string with one of the Shift interfaces.
+    # @return [Shift::String] transformed Shift string.
+    # (see Shift::String#interface)
+    #
+    def process(action=:default, name_override=nil)
+      iface = interface(action, name_override)
+      self.class.new(
+        iface.process(data),
+        iface.rename(name_override || name)
+        )
+    end
+
+    def method_missing(*args)
+      can?(*args) ? process(*args) : super
+    end
+
+    def respond_to?(method)
+      super || can?(method)
+    end
+
+  private
+
+    def name_error
+      raise(UnknownFormatError, 'cannot determine format without clues.')
+    end
+
+  end
+
+
+
+  # String result from one of the operations.
+  # Extends string with some useful helper methods to write to
+  # disk, do further transformations etc, allowing chaining of
+  # operations.
+  #
+  class String < ::String
+
+    include Transformable
+    
+    # Create a new shift string from a standard string.
+    # @param [String] str The source string
+    # @param [String] name A file path, partial path, or
+    #   extension associated with the string.
+    # @return [Shift::String] A Shift string that can be
+    #   manipulated further.
+    def initialize(str='', name=nil)
+      super(str)
+      @name = name
+    end
+
+    def data
+      self
+    end
+    
+    # Read a file and append its contents.
+    #
+    def read_append(path)
+      data << File.read(path)
+      self
+    end
+    alias :append_read :read_append
+
+    # Write the string to a sepcified path.
+    # @ return self
+    def write(name_override=nil)
+      path = name_override || name || name_error
+      File.open(path, 'w') {|f| f.write(data) }
+      self
+    end
+
+  end
+
+
+end

data/shift.gemspec

@@ -13,11 +13,12 @@ Gem::Specification.new do |s|
   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.summary       = 'Compiler and transformer interface framework'
+  s.description   = 'Shift is a generic interface to different compilers, compressors, and so on. You can use it to build chains, like Shift.read("cup.coffee").compile.minify.write'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.require_path  = 'lib'
   s.bindir        = 'bin'
+  s.executables   = ['shifter']
 end

data/test/data/letter.echo

@@ -1,6 +1 @@
 
-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/helper.rb

@@ -10,28 +10,18 @@ class TestCase < MiniTest::Unit::TestCase
     define_method(test_name, &block)
   end
 
-  def with_tempfile(data=nil)
-    file = Tempfile.new('shift_test')
+  def with_tempfile(data=nil,fmt='')
+    file = Tempfile.new("shift_test#{fmt}")
     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/{c → i}/closure_compiler_test.rb

@@ -1,7 +1,7 @@
-require File.join(File.dirname(__FILE__), 'identity_test')
+require File.join(File.dirname(__FILE__), '..', 'interface_test')
 
 
-class ClosureCompilerTest < IdentityTest
+class ClosureCompilerTest < InterfaceTest
 
   FUNCTION = <<-eos
     function hello(name) {
@@ -30,4 +30,8 @@ class ClosureCompilerTest < IdentityTest
     }
   end
 
+  def name_transformations
+    { 'script.js' => 'script.min.js' }
+  end
+
 end

data/test/{c → i}/coffee_script_test.rb

@@ -1,7 +1,7 @@
-require File.join(File.dirname(__FILE__), 'identity_test')
+require File.join(File.dirname(__FILE__), '..', 'interface_test')
 
 
-class CoffeeScriptTest < IdentityTest
+class CoffeeScriptTest < InterfaceTest
 
   def subject
     Shift::CoffeeScript
@@ -20,4 +20,8 @@ class CoffeeScriptTest < IdentityTest
     }
   end
 
+  def name_transformations
+    { 'cup.coffee' => 'cup.js' }
+  end
+
 end

data/test/i/rdiscount_test.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), '..', 'interface_test')
+
+
+class RDiscountTest < InterfaceTest
+
+  def subject
+    Shift::RDiscount
+  end
+
+  def instance
+    subject.new
+  end
+
+  def transformations
+    { 'hello' => "<p>hello</p>\n" }
+  end
+
+  def name_transformations
+    { 'doc.md' => 'doc.html' }
+  end
+
+end