parcels 0.0.1

data/spec/lib/spec/fixtures/widget_file.rb

@@ -0,0 +1,108 @@
+module Spec
+  module Fixtures
+    class WidgetFile
+      def initialize(class_name, superclass, root_dir)
+        @class_name = class_name
+        @superclass = superclass
+        @root_dir = root_dir
+        @css = [ ]
+        @css_prefix_text = nil
+        @css_prefix_block = nil
+        @sets = nil
+        @sets_set = false
+        @requires = [ ]
+        @class_text = [ ]
+      end
+
+      def css(css_text, options = { })
+        @css << {
+          :text => css_text,
+          :options => options[:options]
+        }
+      end
+
+      def css_prefix(css_prefix_text)
+        @css_prefix_text = css_prefix_text
+      end
+
+      def css_prefix_block(css_prefix_block)
+        @css_prefix_block = css_prefix_block
+      end
+
+      def sets(*sets)
+        @sets = sets
+        @sets = nil if @sets == [ nil ]
+        @sets_set = true
+      end
+
+      def sets_block(sets_block)
+        @sets_block = sets_block
+      end
+
+      def content(content_text)
+        @content_text = content_text
+      end
+
+      def class_text(text)
+        @class_text << text
+      end
+
+      def requires(*the_requires)
+        the_requires = Array(the_requires).flatten.uniq
+        @requires |= the_requires
+      end
+
+      def source_text
+        text = [ ]
+
+        @requires.each do |the_require|
+          text << "require '#{File.join(@root_dir, the_require)}'"
+        end
+
+        text << "class #{class_name} < ::#{superclass}"
+
+        text += @class_text
+
+        if @sets_block
+          text += [ "  parcels_sets #{@sets_block}" ]
+        elsif @sets_set
+          if @sets.kind_of?(Array)
+            text << "  parcels_sets #{@sets.map { |s| s.inspect }.join(", ")}"
+          else
+            text << "  parcels_sets #{@sets.inspect}"
+          end
+        end
+
+        if @css_prefix_block
+          text += [ "  css_prefix #{@css_prefix_block}" ]
+        elsif @css_prefix_text
+          text += [ "  css_prefix <<-EOS", @css_prefix_text, "EOS" ]
+        end
+
+        @css.each do |data|
+          css_text = data[:text]
+          options = data[:options]
+
+          if options
+            text << "  css <<-EOS, #{options.inspect}"
+          else
+            text << "  css <<-EOS"
+          end
+
+          text << css_text
+          text << "EOS"
+        end
+
+        if @content_text
+          text += [ "  def content", @content_text, "  end" ]
+        end
+
+        text += [ "end" ]
+        text.join("\n") + "\n"
+      end
+
+      private
+      attr_reader :class_name, :superclass
+    end
+  end
+end

data/spec/lib/spec/parsing/compiled_asset.rb

@@ -0,0 +1,94 @@
+require 'spec/parsing/compiled_asset_fragment'
+
+module Spec
+  module Parsing
+    class CompiledAsset
+      def initialize(raw_asset)
+        @raw_asset = raw_asset
+      end
+
+      def where_from
+        "compiled asset for #{raw_asset.where_from}"
+      end
+
+      def fragments
+        @fragments ||= begin
+          if (raw_source = raw_asset.source)
+            parse_fragments_from_raw_source(raw_source)
+          else
+            :none
+          end
+        end
+
+        @fragments unless @fragments == :none
+      end
+
+      def source
+        raw_asset.source
+      end
+
+      def to_s
+        "<CompiledAsset for #{raw_asset}>"
+      end
+
+      def should_match(expected_asset_set, options = { })
+        remaining_fragments = (fragments || [ ]).dup
+        remaining_fragments = remaining_fragments.select { |f| (f.source || "").strip.length > 0 }
+
+        found_indices = [ ]
+        expected_asset_set.expected_assets.each do |expected_asset|
+          matched_fragments = expected_asset.should_match(remaining_fragments)
+          matched_fragments.each do |matched_fragment|
+            found_indices << fragments.index(matched_fragment)
+            remaining_fragments.delete(matched_fragment)
+          end
+        end
+
+        if options[:ordered] && (found_indices.sort != found_indices)
+          raise "All fragments were found, but not in order, and order was required. We found fragments at indices:\n  #{found_indices.inspect}"
+        end
+
+        if (! expected_asset_set.allows_additional?) && (remaining_fragments.length > 0)
+          raise "Unexpected fragments found in\n  #{self}:\nThese were found just fine:\n  #{expected_asset_set}\nbut we also found:\n  #{remaining_fragments.join("\n  ")}"
+        end
+      end
+
+      private
+      attr_reader :raw_asset
+
+      FROM_LINE_REGEXP = %r{^\s*\/\*\s*From[\s'"]*([^'"]+?)\s*[\s'"]*:\s*(\d+)[\s'"]*\*/\s*$}i
+      BREAK_LINE_REGEXP = %r{^\s*//\s*===\s*BREAK\s*===\s*$}i
+
+      def parse_fragments_from_raw_source(raw_source)
+        remaining = raw_source.strip
+        out = [ ]
+
+        current_fragment = ::Spec::Parsing::CompiledAssetFragment.new(self, :head, nil)
+        out << current_fragment
+
+        while remaining && remaining.length > 0
+          if (from_line_match = FROM_LINE_REGEXP.match(remaining))
+            current_fragment << remaining[0..(from_line_match.begin(0) - 1)] if from_line_match.begin(0) > 0
+            current_fragment = ::Spec::Parsing::CompiledAssetFragment.new(
+              self, from_line_match.captures[0], Integer(from_line_match.captures[1]))
+            out << current_fragment
+            remaining = remaining[(from_line_match.end(0) + 1)..-1]
+          else
+            if (break_line_match = BREAK_LINE_REGEXP.match(remaining))
+              current_fragment << remaining[0..(break_line_match.begin(0) - 1)]
+              tail_fragment = ::Spec::Parsing::CompiledAssetFragment.new(self, :tail, nil)
+              tail_fragment << remaining[(break_line_match.end(0) + 1)..-1]
+              out << tail_fragment
+            else
+              current_fragment << remaining
+            end
+
+            remaining = nil
+          end
+        end
+
+        out
+      end
+    end
+  end
+end

data/spec/lib/spec/parsing/compiled_asset_fragment.rb

@@ -0,0 +1,38 @@
+module Spec
+  module Parsing
+    class CompiledAssetFragment
+      attr_reader :filename, :line_number, :source
+
+      def initialize(compiled_asset, filename, line_number)
+        @compiled_asset = compiled_asset
+        @filename = filename
+        @line_number = line_number
+        @raw_source = nil
+      end
+
+      def where_from
+        "fragment at #{filename.inspect}, line #{line_number} from #{compiled_asset.where_from}"
+      end
+
+      def source
+        out = @raw_source
+        out = out.gsub(%r{/\*.*?\*/}mi, '') if out
+        out unless (! out) || (out.strip.length == 0)
+      end
+
+      def <<(source)
+        if (effective_source = source.strip) && effective_source.length > 0
+          @raw_source ||= ""
+          @raw_source << effective_source
+        end
+      end
+
+      def to_s
+        "<CompiledAssetFragment: #{filename.inspect}, line #{line_number.inspect}>"
+      end
+
+      private
+      attr_reader :compiled_asset
+    end
+  end
+end

data/spec/lib/spec/parsing/parsed_css_asset.rb

@@ -0,0 +1,34 @@
+require 'css_parser'
+
+module Spec
+  module Parsing
+    class ParsedCssAsset
+      def initialize(raw_asset)
+        @raw_asset = raw_asset
+      end
+
+      def style_rules
+        @style_rules ||= begin
+          out = { }
+
+          if raw_asset.source
+            parser = CssParser::Parser.new
+            parser.load_string!(raw_asset.source)
+            parser.each_selector do |selectors, declarations, specificity, media_types|
+              out[selectors] = Array(declarations).map do |declaration|
+                declaration = declaration.strip
+                declaration = $1 if declaration =~ /\A(.*?);\Z/mi
+                declaration
+              end
+            end
+          end
+
+          out
+        end
+      end
+
+      private
+      attr_reader :raw_asset
+    end
+  end
+end

data/spec/lib/spec/parsing/precompiled_rails_asset.rb

@@ -0,0 +1,52 @@
+module Spec
+  module Parsing
+    class PrecompiledRailsAsset
+      def initialize(rails_server, asset_path)
+        @rails_server = rails_server
+        @asset_path = asset_path
+      end
+
+      def where_from
+        "Rails precompiled asset '#{asset_path}'"
+      end
+
+      def exists?
+        !! source
+      end
+
+      def source
+        @source ||= begin
+          assets_dir = File.join(rails_server.rails_root, 'public', 'assets')
+          filename = extension = nil
+
+          if File.basename(asset_path) =~ /^(\S+)\.([^\.]+)$/i
+            filename = $1
+            extension = $2
+          else
+            raise "Can't get filename and extension from: #{asset_path.inspect}"
+          end
+
+          entries = Dir.entries(assets_dir).select { |e| e =~ /^#{Regexp.escape(filename)}\-[0-9a-f]+\.#{Regexp.escape(extension)}$/i }
+
+          if entries.length == 0
+            :none
+          elsif entries.length == 1
+            path = File.join(assets_dir, entries.first)
+            File.read(path)
+          elsif entries.length > 1
+            raise "Found multiple entries in #{assets_dir.inspect} matching #{filename.inspect}/#{extension.inspect}: #{entries.inspect}"
+          end
+        end
+
+        @source unless @source == :none
+      end
+
+      def to_s
+        "<PrecompiledRailsAsset '#{asset_path}'>"
+      end
+
+      private
+      attr_reader :rails_server, :asset_path
+    end
+  end
+end

data/spec/lib/spec/parsing/rails_asset.rb

@@ -0,0 +1,30 @@
+module Spec
+  module Parsing
+    class RailsAsset
+      def initialize(rails_server, asset_path)
+        @rails_server = rails_server
+        @asset_path = asset_path
+      end
+
+      def where_from
+        "Rails asset '#{asset_path}'"
+      end
+
+      def exists?
+        !! source
+      end
+
+      def source
+        @source ||= (rails_server.get("assets/#{asset_path}", :nil_on_not_found => true) || :none)
+        @source unless @source == :none
+      end
+
+      def to_s
+        "<RailsAsset '#{asset_path}'>"
+      end
+
+      private
+      attr_reader :rails_server, :asset_path
+    end
+  end
+end

data/spec/lib/spec/parsing/sprockets_asset.rb

@@ -0,0 +1,40 @@
+module Spec
+  module Parsing
+    class SprocketsAsset
+      def initialize(sprockets_env, asset_path)
+        @sprockets_env = sprockets_env
+        @asset_path = asset_path
+      end
+
+      def where_from
+        "raw Sprockets asset '#{asset_path}'"
+      end
+
+      def exists?
+        !! asset
+      end
+
+      def source
+        if asset
+          if asset.respond_to?(:source)
+            asset.source
+          else
+            asset.to_s
+          end
+        end
+      end
+
+      def to_s
+        "<SprocketsAsset '#{asset_path}'>"
+      end
+
+      private
+      attr_reader :sprockets_env, :asset_path
+
+      def asset
+        @asset ||= (sprockets_env.find_asset(asset_path) || :none)
+        @asset unless @asset == :none
+      end
+    end
+  end
+end

data/spec/rails/basic_rails_spec.rb

@@ -0,0 +1,102 @@
+describe "Parcels Rails basic support", :type => :rails do
+  uses_rails_with_template :basic_rails_spec
+
+  it "should at least have a working Rails server" do
+    expect_match("simple_css", /hello, world/)
+  end
+
+  it "should wrap a simple widget in a class" do
+    expected_class = expected_rails_asset('views/basic_rails_spec/simple_css.rb').parcels_wrapping_class
+    expect_match("simple_css", /<p class="#{Regexp.escape(expected_class)}">hello, world<\/p>/)
+  end
+
+  it "should contain the CSS in application.css due to the 'require_parcels' directive" do
+    asset = compiled_rails_asset('application.css')
+
+    asset.should_match(rails_assets do
+      asset 'views/basic_rails_spec/simple_css.rb' do
+        expect_wrapped_rule nil, 'color: green'
+      end
+      allow_additional_assets!
+    end)
+  end
+
+  it "should support both inline and alongside CSS on a .rb widget" do
+    compiled_rails_asset('application.css').should_match(rails_assets do
+      asset 'views/basic_rails_spec/alongside_and_inline.rb' do
+        expect_wrapped_rule :p, 'color: green'
+      end
+
+      asset 'views/basic_rails_spec/alongside_and_inline.pcss' do
+        expect_wrapped_rule :div, 'color: blue'
+      end
+
+      allow_additional_assets!
+    end)
+  end
+
+  it "should support both inline and alongside CSS on a .html.rb widget" do
+    compiled_rails_asset('application.css').should_match(rails_assets do
+      asset 'views/basic_rails_spec/alongside_and_inline_html.html.rb' do
+        expect_wrapped_rule :p, 'color: yellow'
+      end
+
+      asset 'views/basic_rails_spec/alongside_and_inline_html.html.pcss' do
+        expect_wrapped_rule :div, 'color: purple'
+      end
+
+      allow_additional_assets!
+    end)
+  end
+
+  it "should allow precompiling assets with 'rake'" do
+    rails_server.run_command_in_rails_root!("rake assets:precompile --trace")
+
+    asset = precompiled_rails_asset('application.css')
+    asset.should_match(rails_assets do
+      asset 'views/basic_rails_spec/simple_css.rb' do
+        expect_wrapped_rule nil, 'color: green'
+      end
+      allow_additional_assets!
+    end)
+  end
+
+  it "should not pick up alongside files if there is no corresponding widget class" do
+    compiled_rails_asset('application.css') do
+      asset_must_not_be_present('views/basic_rails_spec/no_corresponding_widget.pcss')
+      allow_additional_assets!
+    end
+  end
+
+  it "should allow using ERb in inline CSS if desired" do
+    compiled_rails_asset('application.css').should_match(rails_assets do
+      asset 'views/basic_rails_spec/inline_erb.rb' do
+        expect_wrapped_rule :p, 'background-image: url("foo-21")'
+      end
+      allow_additional_assets!
+    end)
+  end
+
+  it "should allow using ERb in alongside CSS if desired" do
+    compiled_rails_asset('application.css').should_match(rails_assets do
+      asset 'views/basic_rails_spec/alongside_erb.pcss' do
+        expect_wrapped_rule :p, 'background-image: url("foo-21")'
+      end
+      allow_additional_assets!
+    end)
+  end
+
+  it "should allow using other asset-pipeline engines (extensions) if desired" do
+    compiled_rails_asset('application.css').should_match(rails_assets do
+      asset 'views/basic_rails_spec/multiple_engines.rb' do
+        expect_wrapped_rule :p, 'background-image: url("21")'
+      end
+
+      asset 'views/basic_rails_spec/multiple_engines.pcss' do
+        expect_wrapped_rule :div, 'background-image: url("21")'
+      end
+
+      allow_additional_assets!
+    end)
+  end
+end

data/spec/rails/compression_rails_spec.rb

@@ -0,0 +1,11 @@
+describe "Parcels Rails support with compression enabled", :type => :rails do
+  uses_rails_with_template :compression_rails_spec
+
+  it "should still seem to contain our inline and alongside CSS" do
+    asset = compiled_rails_asset('application.css')
+    source = asset.source
+
+    expect(source).to match(/.parcels_class__views__compression_rails_spec__inline_and_alongside_css\s+div\{color:blue\}/i)
+    expect(source).to match(/.parcels_class__views__compression_rails_spec__inline_and_alongside_css\s+p\{color:green\}/i)
+  end
+end