parcels 0.0.1

data/lib/parcels/fortitude_alongside_parcel.rb

@@ -0,0 +1,38 @@
+require 'parcels/fortitude_parcel'
+
+require 'parcels/utils/path_utils'
+
+module Parcels
+  class FortitudeAlongsideParcel < FortitudeParcel
+    def self.logical_path_prefix
+      "#{logical_path_prefix_base}alongside"
+    end
+
+    def to_css(sprockets_context)
+      if widget_class.respond_to?(:_parcels_widget_class_alongside_css) &&
+        (!(css = widget_class._parcels_widget_class_alongside_css(widget_tree.parcels_environment, sprockets_context)).blank?)
+        css
+      end
+    end
+
+    def tag_types_that_must_come_before
+      [ ]
+    end
+
+    def tag_type
+      :alongside
+    end
+
+    def usable?
+      widget_class_full_path
+    end
+
+    private
+    attr_reader :widget_tree, :full_path
+
+    def widget_class_full_path
+      @widget_class_full_path ||= (::Parcels::Utils::PathUtils.widget_class_file_for_alongside_file(full_path) || :none)
+      @widget_class_full_path unless @widget_class_full_path == :none
+    end
+  end
+end

data/lib/parcels/fortitude_inline_parcel.rb

@@ -0,0 +1,31 @@
+require 'parcels/fortitude_parcel'
+
+module Parcels
+  class FortitudeInlineParcel < FortitudeParcel
+    def self.logical_path_prefix
+      "#{logical_path_prefix_base}inline"
+    end
+
+    def to_css(sprockets_context)
+      if widget_class.respond_to?(:_parcels_widget_class_inline_css) &&
+        (!(css = widget_class._parcels_widget_class_inline_css(widget_tree.parcels_environment, sprockets_context)).blank?)
+        css
+      end
+    end
+
+    def tag_type
+      :inline
+    end
+
+    def tag_types_that_must_come_before
+      [ :alongside ]
+    end
+
+    private
+    attr_reader :widget_tree, :full_path
+
+    def widget_class_full_path
+      full_path
+    end
+  end
+end

data/lib/parcels/fortitude_parcel.rb

@@ -0,0 +1,102 @@
+require 'active_support/core_ext/module/delegation'
+
+require 'parcels/utils/path_utils'
+
+module Parcels
+  class FortitudeParcel
+    def self.logical_path_prefix_base
+      "_parcels_"
+    end
+
+    def self.is_fortitude_logical_path?(logical_path)
+      logical_path =~ /^#{Regexp.escape(logical_path_prefix_base)}/
+    end
+
+    def initialize(widget_tree, full_path)
+      @widget_tree = widget_tree
+      @full_path = full_path
+    end
+
+    def to_s
+      "<#{self.class.name.demodulize} for #{widget_class}>"
+    end
+
+    def inspect
+      "<#{self.class.name.demodulize} for #{widget_class}, tree #{widget_tree}>"
+    end
+
+    def usable?
+      true
+    end
+
+    def included_in_any_set?(set_names)
+      if set_names.length == 0
+        true
+      else
+        result = (widget_class._parcels_get_sets(full_path) & set_names)
+        result.length > 0
+      end
+    end
+
+    def add_to_sprockets_context!(sprockets_context)
+      if has_content?(sprockets_context)
+        sprockets_context.require_asset(logical_path)
+      else
+        sprockets_context.depend_on_asset(logical_path)
+      end
+    end
+
+    def tag
+      [ tag_type, widget_class ]
+    end
+
+    def tags_that_must_come_before
+      out = tag_types_that_must_come_before.map { |tt| [ tt, widget_class ] }
+      widget_class.all_fortitude_superclasses.each do |superclass|
+        all_tag_types.each do |tt|
+          out << [ tt, superclass ]
+        end
+      end
+      out
+    end
+
+    def all_tag_types
+      [ :alongside, :inline ]
+    end
+
+    def tag_type
+      raise "must implement in #{self.class.name}"
+    end
+
+    def tag_types_that_must_come_before
+      raise "must implement in #{self.class.name}"
+    end
+
+    def to_css(sprockets_context)
+      raise "must implement in #{self.class.name}"
+    end
+
+    private
+    attr_reader :widget_tree, :full_path
+
+    def has_content?(sprockets_context)
+      !! to_css(sprockets_context)
+    end
+
+    def subpath
+      @subpath ||= widget_tree.subpath_to(full_path)
+    end
+
+    def logical_path
+      @logical_path ||= File.join(self.class.logical_path_prefix, subpath)
+    end
+
+    def widget_class_full_path
+      raise "must implement in #{self.class.name}"
+    end
+
+    def widget_class
+      @widget_class ||= ::Fortitude::Widget.widget_class_from_file(widget_class_full_path, :root_dirs => [ widget_tree.root ])
+    end
+  end
+end

data/lib/parcels/fragments/css_fragment.rb

@@ -0,0 +1,107 @@
+module Parcels
+  module Fragments
+    class CssFragment
+      class << self
+        def to_css(parcels_environment, context, fragments)
+          fragments = Array(fragments)
+          fragments.map { |f| f.to_css(parcels_environment, context) }.join("\n")
+        end
+      end
+
+      def initialize(css_string, source, file, line, options)
+        options.assert_valid_keys(:engines, :wrap, :prefix)
+
+        @css_string = css_string
+        @source = source
+        @file = file
+        @line = line
+        @options = options
+      end
+
+      def wrapping_css_class_required?
+        wrapped?
+      end
+
+      def to_s
+        "<#{self.class.name.demodulize}: from '#{file}', line #{line}, options #{options.inspect}>"
+      end
+
+      def to_css(parcels_environment, context)
+        scss = css_string
+
+        if wrapped? && (wrapper_css_class = source.try(:_parcels_widget_outer_element_class))
+          scss = %{.#{wrapper_css_class} {
+    #{scss}
+  }}
+        end
+
+        if options[:prefix]
+          if options[:prefix].kind_of?(String)
+            scss = "#{options[:prefix]}\n\n#{scss}"
+          else
+            raise "You supplied a css_prefix (or a :prefix option) that wasn't a String, but, rather: #{options[:prefix].inspect}"
+          end
+        end
+
+        asset_attributes = ::Sprockets::AssetAttributes.new(parcels_environment.sprockets_environment, synthetic_filename)
+        processors = asset_attributes.processors
+        out = process_with_processors(processors, context, scss)
+
+        header_comment + out
+      end
+
+      private
+      attr_reader :css_string, :source, :options, :file, :line
+
+      def header_comment
+        out = "/* From '#{file}'"
+        out << ":#{line}" if line
+        out << " */\n"
+        out
+      end
+
+      def wrapped?
+        options.fetch(:wrap, true)
+      end
+
+      def synthetic_filename
+        @synthetic_filename ||= begin
+          synthetic_name = File.basename(file)
+          synthetic_name = $1 if synthetic_name =~ /^([^\.]+)\./i
+          synthetic_name << ".css.scss"
+          synthetic_name << engines_as_extensions
+
+          File.join(File.dirname(file), synthetic_name)
+        end
+      end
+
+      def engines_as_extensions
+        @engines_as_extensions ||= begin
+          engines = options[:engines] || [ ]
+          out = Array(engines).flatten.map do |component|
+            component = component.to_s
+            component = ".#{component}" unless component =~ /^\./
+            component
+          end.join(".")
+          ".#{out}".gsub(/\.\.+/, '.')
+        end
+      end
+
+      def process_with_processors(processors, context, data)
+        result = data
+
+        processors.each do |processor|
+          args = [ file ]
+          if processor == ::Tilt::ScssTemplate && (::Parcels::Sprockets.requires_explicit_load_paths_for_css_template?)
+            args = [ file, 1, { :load_paths => context.environment.paths } ]
+          end
+
+          template = processor.new(*args) { result }
+          result = template.render(context, {})
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/parcels/index.rb

@@ -0,0 +1,16 @@
+require 'active_support/core_ext/module/delegation'
+
+module Parcels
+  class Index
+    def initialize(environment)
+      @environment = environment
+    end
+
+    delegate :root, :logical_path_for, :is_underneath_root?, :add_all_widgets_to!, :widget_class_from_file, :add_widget_tree!, :to => :environment
+
+    private
+    attr_reader :environment
+
+    delegate :sprockets_environment, :to => :environment
+  end
+end

data/lib/parcels/rails/rails_loader.rb

@@ -0,0 +1,23 @@
+# See if we can load Rails -- but don't fail if we can't; we'll just use this to decide whether we should
+# load the Rails extensions or not.
+begin
+  gem 'rails'
+rescue Gem::LoadError => le
+  # ok
+end
+
+begin
+  require 'rails'
+rescue LoadError => le
+  # ok
+end
+
+if defined?(::Rails)
+  require 'parcels/rails/railtie'
+
+  begin
+    require 'sass-rails'
+  rescue LoadError => le
+    # ok
+  end
+end

data/lib/parcels/rails/railtie.rb

@@ -0,0 +1,16 @@
+require "parcels"
+
+module Parcels
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer :parcels, :after => [ :append_assets_path, :finisher_hook ] do |app|
+        parcels = ::Rails.application.assets.parcels
+
+        ::ActionController::Base.view_paths.map(&:to_s).each do |view_path|
+          view_path = File.expand_path(view_path)
+          parcels.add_widget_tree!(view_path)
+        end
+      end
+    end
+  end
+end

data/lib/parcels/sprockets.rb

@@ -0,0 +1,153 @@
+require 'active_support'
+require 'active_support/core_ext/string'
+
+require "parcels/index"
+
+module Parcels
+  module Sprockets
+    def self.sprockets_version_components
+      @sprockets_version_components ||= ::Sprockets::VERSION.split(".").map { |x| x.to_i }
+    end
+
+    def self.requires_explicit_load_paths_for_css_template?
+      sprockets_version_components[0] <= 2 && sprockets_version_components[1] < 11
+    end
+
+    def self.requires_fix_for_protected_methods_on_directive_processor?
+      RUBY_VERSION =~ /^2/ && sprockets_version_components[0] <= 2 && sprockets_version_components[1] < 11
+    end
+  end
+end
+
+::Sprockets::Environment.class_eval do
+  def parcels
+    @parcels ||= ::Parcels::Environment.new(self)
+  end
+
+  def index_with_parcels
+    parcels.create_and_add_all_workaround_directories!
+    index_without_parcels
+  end
+
+  alias_method_chain :index, :parcels
+end
+
+::Sprockets::Index.class_eval do
+  # Older versions of Sprockets don't actually hang on to the environment here.
+  def initialize_with_parcels(environment)
+    initialize_without_parcels(environment)
+    @environment ||= environment
+  end
+
+  alias_method_chain :initialize, :parcels
+
+  def parcels
+    @parcels ||= ::Parcels::Index.new(@environment.parcels)
+  end
+end
+
+::Sprockets::DirectiveProcessor.class_eval do
+  def process_require_parcels_directive(*set_names)
+    set_names = set_names.map do |set_name|
+      set_name = set_name.to_s.strip
+      set_name = $1 if set_name =~ /,?(.*?),?$/i
+      set_name.strip.to_sym
+    end
+    context.environment.parcels.add_all_widgets_to!(context, set_names.map(&:to_sym))
+  end
+end
+
+::Sprockets::AssetAttributes.class_eval do
+  def format_extension_with_parcels
+    out = format_extension_without_parcels
+    out = nil if out && out =~ /^\.html$/i
+    out
+  end
+
+  alias_method_chain :format_extension, :parcels
+end
+
+if ::Parcels::Sprockets.requires_fix_for_protected_methods_on_directive_processor?
+  ::Sprockets::DirectiveProcessor.class_eval do
+    instance_methods(true).select { |m| m =~ /^process_.*directive$/i }.each do |method_name|
+      public method_name
+    end
+  end
+end
+
+static_compiler_class = '::Sprockets::StaticCompiler'.constantize rescue nil
+if static_compiler_class
+  instance_methods = static_compiler_class.instance_methods(true).map(&:to_s)
+  if instance_methods.include?('compile_path?')
+    static_compiler_class.class_eval do
+      def compile_path_with_parcels?(logical_path)
+        return false if ::Parcels.is_fortitude_logical_path?(logical_path)
+        compile_path_without_parcels?(logical_path)
+      end
+
+      alias_method_chain :compile_path?, :parcels
+    end
+  elsif instance_methods.include?('compile')
+    module ::Parcels::Sprockets
+      class StaticCompilerEnvProxy
+        def initialize(env)
+          @env = env
+        end
+
+        def each_logical_path(*args, &block)
+          @env.each_logical_path do |logical_path|
+            unless ::Parcels.is_fortitude_logical_path?(logical_path)
+              block.call(logical_path)
+            end
+          end
+        end
+
+        def method_missing(name, *args, &block)
+          @env.send(name, *args, &block)
+        end
+      end
+    end
+
+    static_compiler_class.class_eval do
+      def env
+        @_parcels_env_proxy ||= ::Parcels::Sprockets::StaticCompilerEnvProxy.new(@env)
+      end
+    end
+  end
+end
+
+begin
+  require 'sass/rails/importer'
+rescue LoadError => le
+  # oh, well
+end
+
+[ '::Sprockets::SassImporter', '::Sass::Rails::Importer' ].each do |class_name|
+  klass = class_name.constantize rescue nil
+
+  if klass
+    klass.class_eval do
+      if defined?(klass::GLOB)
+        def find_relative_with_parcels(name, base, options)
+          parcels = context.environment.parcels
+          expanded_locations_to_search = context.environment.paths + [ File.dirname(base) ]
+
+          if name =~ self.class.const_get(:GLOB) && parcels.is_underneath_root?(base)
+            paths_to_search = expanded_locations_to_search
+
+            imports = nil
+            paths_to_search.each do |path_to_search|
+              glob_against = Pathname.new(File.join(path_to_search.to_s, 'dummy'))
+              imports = glob_imports(name, glob_against, :load_paths => [ path_to_search ])
+              return imports if imports
+            end
+          end
+
+          return find_relative_without_parcels(name, base, options.merge(:load_paths => expanded_locations_to_search))
+        end
+
+        alias_method_chain :find_relative, :parcels
+      end
+    end
+  end
+end

data/lib/parcels/utils/path_utils.rb

@@ -0,0 +1,32 @@
+module Parcels
+  module Utils
+    module PathUtils
+      class << self
+        def path_under(path, under_what)
+          path = path.to_s.strip
+          under_what = under_what.to_s.strip
+
+          if (path.length - under_what.length) > 1 && path[0..(under_what.length - 1)] == under_what &&
+            path[under_what.length..under_what.length] == File::SEPARATOR
+
+            path[(under_what.length + 1)..-1]
+          else
+            raise Errno::ENOENT, %{Path #{path.inspect} is not underneath directory #{under_what.inspect}.}
+          end
+        end
+
+        def widget_class_file_for_alongside_file(alongside_file)
+          directory = File.dirname(alongside_file)
+          basename = File.basename(alongside_file)
+          basename = $1 if basename =~ /^(.+?)\./
+
+          entries = Dir.entries(directory).select { |e| e =~ /^#{Regexp.escape(basename)}\./ && e =~ /\.rb$/i }
+          entries = entries.sort_by(&:length)
+          entry = entries[-1]
+
+          File.join(directory, entry) if entry
+        end
+      end
+    end
+  end
+end

data/lib/parcels/version.rb

@@ -0,0 +1,3 @@
+module Parcels
+  VERSION = "0.0.1"
+end

data/lib/parcels/widget_tree.rb

@@ -0,0 +1,158 @@
+require 'active_support/core_ext/module/delegation'
+
+require 'parcels/fortitude_inline_parcel'
+require 'parcels/fortitude_alongside_parcel'
+require 'parcels/dependency_parcel_list'
+
+require 'find'
+
+module Parcels
+  class WidgetTree
+    attr_reader :root, :parcels_environment
+
+    def initialize(parcels_environment, root)
+      @parcels_environment = parcels_environment
+      @root = File.expand_path(root, parcels_environment.root)
+
+      @sprockets_environments_added_to = { }
+    end
+
+    def add_workaround_directory_to_sprockets!(sprockets_environment)
+      return if (! root_exists?)
+
+      @sprockets_environments_added_to[sprockets_environment] ||= begin
+        ensure_workaround_directory_is_set_up!
+        sprockets_environment.prepend_path(workaround_directory)
+        true
+      end
+    end
+
+    def subpath_to(full_path)
+      ::Parcels::Utils::PathUtils.path_under(full_path, root)
+    end
+
+    def add_all_widgets_to_sprockets_context!(sprockets_context, set_names)
+      return unless root_exists?
+      sprockets_context.depend_on(root)
+
+      all_parcels = [ ]
+
+      Find.find(root) do |path|
+        full_path = File.expand_path(path, root)
+        stat = File.stat(full_path)
+
+        sprockets_context.depend_on(path) if stat.directory?
+        next unless stat.file?
+
+        extension = File.extname(full_path).strip.downcase
+        if (klass = EXTENSION_TO_PARCEL_CLASS_MAP[extension])
+          parcel = klass.new(self, full_path)
+          all_parcels << parcel if parcel.usable? && parcel.included_in_any_set?(set_names)
+        end
+      end
+
+      parcel_list = ::Parcels::DependencyParcelList.new
+      parcel_list.add_parcels!(all_parcels)
+      parcel_list.parcels_in_order.each do |parcel|
+        parcel.add_to_sprockets_context!(sprockets_context)
+      end
+    end
+
+    private
+    EXTENSION_TO_PARCEL_CLASS_MAP   = {
+      '.rb'.freeze => ::Parcels::FortitudeInlineParcel,
+      '.pcss'.freeze => ::Parcels::FortitudeAlongsideParcel
+    }.freeze
+
+    ALL_EXTENSIONS                    = EXTENSION_TO_PARCEL_CLASS_MAP.keys.dup.freeze
+
+    PARCELS_WORKAROUND_DIRECTORY_NAME = ".parcels_sprockets_workaround".freeze
+
+    PARCELS_LOGICAL_PATH_PREFIXES     = EXTENSION_TO_PARCEL_CLASS_MAP.values.map { |k| k.logical_path_prefix }
+
+    def root_exists?
+      File.exist?(root)
+    end
+
+    def workaround_directory
+      @workaround_directory ||= File.join(root, PARCELS_WORKAROUND_DIRECTORY_NAME)
+    end
+
+    def ensure_workaround_directory_is_set_up!
+      @workaround_directory_exists ||= begin
+        ensure_workaround_directory_exists!
+        ensure_nothing_else_is_in_workaround_directory!
+        ensure_symlinks_point_to_the_right_place!
+
+        true
+      end
+    end
+
+    def ensure_workaround_directory_exists!
+      unless File.directory?(workaround_directory)
+        if File.exist?(workaround_directory)
+          raise Errno::EEXIST, %{Parcels uses the directory '#{workaround_directory}' internally
+  (to allow us to safely add assets to Sprockets without treading on the global asset namespace);
+  however, there is already something at that path that is not a directory.}
+        end
+
+        FileUtils.mkdir_p(workaround_directory)
+      end
+    end
+
+    def ensure_nothing_else_is_in_workaround_directory!
+      entries = Dir.entries(workaround_directory).reject { |e| e =~ /^\./ }
+      extra = entries - PARCELS_LOGICAL_PATH_PREFIXES
+
+      if extra.length > 0
+        raise Errno::EEXIST, %{Parcels uses the directory '#{workaround_directory}' internally
+(to allow us to safely add assets to Sprockets without treading on the global asset namespace);
+it should either be empty, or contain at most symlinks named any of
+#{PARCELS_LOGICAL_PATH_PREFIXES.map { |p| "'#{p}'" }.join(", ")}.
+(Parcels will create those symlinks automatically; you should not manage them yourself.)
+
+However, this directory currently contains other file(s) that we weren't expecting:
+
+#{extra.join("\n")}}
+      end
+    end
+
+    SYMLINK_TARGET = "..".freeze
+
+    def ensure_symlinks_point_to_the_right_place!
+      PARCELS_LOGICAL_PATH_PREFIXES.each do |prefix|
+        symlink = File.join(workaround_directory, prefix)
+
+        if File.exist?(symlink)
+          if File.symlink?(symlink)
+            contents = File.readlink(symlink)
+
+            if contents == SYMLINK_TARGET
+              # ok, great
+            else
+              File.delete(symlink)
+              create_symlink!(prefix)
+            end
+          else
+            raise Errno::EEXIST, %{Parcels uses the directory '#{workaround_directory}' internally
+(to allow us to safely add assets to Sprockets without treading on the global asset namespace);
+it should either be empty, or contain at most symlinks named any of
+#{PARCELS_LOGICAL_PATH_PREFIXES.map { |p| "'#{p}'" }.join(", ")}.
+
+This directory has a file called '#{prefix}' that isn't a symlink.
+Out of respect for your data, we're going to raise this fatal error. Please check what's going on,
+and try again.}
+          end
+        else
+          create_symlink!(prefix)
+        end
+      end
+    end
+
+    def create_symlink!(prefix)
+      Dir.chdir(workaround_directory) do
+        FileUtils.ln_s(SYMLINK_TARGET, prefix)
+      end
+    end
+  end
+end