parcels 0.0.1

data/lib/parcels.rb

@@ -0,0 +1,21 @@
+require "sprockets"
+
+module Parcels
+  def self.fortitude_available?
+    @fortitude_available || false
+  end
+
+  def self.fortitude_available!
+    @fortitude_available = true
+  end
+
+  def self.is_fortitude_logical_path?(logical_path)
+    ::Parcels::FortitudeParcel.is_fortitude_logical_path?(logical_path)
+  end
+end
+
+require "parcels/version"
+require "parcels/rails/rails_loader"
+require "parcels/fortitude/fortitude_loader"
+require "parcels/sprockets"
+require "parcels/environment"

data/parcels.gemspec

@@ -0,0 +1,48 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parcels/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "parcels"
+  spec.version       = Parcels::VERSION
+  spec.authors       = ["Andrew Geweke"]
+  spec.email         = ["andrew@geweke.org"]
+  spec.summary       = %q{Views are HTML...and CSS, and Javascript. Together at last!}
+  spec.description   = %q{Allows you to package the CSS and Javascript for your view together with that view, creating self-contained parcels of view code that seamlessly work together. When used with Fortitude, automatically scopes your CSS, too. No more dueling CSS rules!}
+  spec.homepage      = "https://github.com/ageweke/parcels"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  if RUBY_VERSION =~ /^1\.8\./
+    spec.add_dependency "activesupport", "< 4.0.0"
+  else
+    spec.add_dependency "activesupport"
+  end
+
+  if (ENV['PARCELS_SPECS_SPROCKETS_VERSION'] || '').strip.length > 0
+    spec.add_dependency "sprockets", "= #{ENV['PARCELS_SPECS_SPROCKETS_VERSION']}"
+  else
+    spec.add_dependency "sprockets"
+  end
+
+  spec.add_dependency "sass"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  if RUBY_VERSION =~ /^1\.8\./
+    spec.add_development_dependency "nokogiri", "< 1.6.0"
+  else
+    spec.add_development_dependency "nokogiri"
+  end
+
+  spec.add_development_dependency "oop_rails_server", "~> 0", ">= 0.0.5"
+  spec.add_development_dependency "css_parser"
+  spec.add_development_dependency "fortitude", ">= 0.9.1"
+end

data/spec/helpers/content_in_helpers.rb

@@ -0,0 +1,21 @@
+require 'nokogiri'
+
+module ContentInHelpers
+  def classes_from(node, xpath)
+    elements = node.xpath(xpath)
+
+    if elements.length == 0
+      raise "No elements matched #{xpath.inspect} from here: #{node}"
+    elsif elements.length == 1
+      element = elements[0]
+      class_string = element['class']
+      if class_string
+        class_string.split(/\s+/)
+      else
+        [ ]
+      end
+    else
+      raise "Multiple elements matched #{xpath.inspect} from here: #{node}; they are: #{elements.inspect}"
+    end
+  end
+end

data/spec/helpers/file_structure_helpers.rb

@@ -0,0 +1,79 @@
+require 'fortitude'
+
+require 'active_support/concern'
+
+require 'spec/fixtures/file_set'
+
+module Views; end
+
+module FileStructureHelpers
+  extend ActiveSupport::Concern
+
+  included do
+    after :each do
+      unload_all_classes!
+    end
+  end
+
+  def this_example_root
+    per_example_data[:this_example_root] ||= clean_directory(this_spec_root, this_example_name)
+  end
+
+  def files(&block)
+    per_example_data[:file_set_fixture] ||= ::Spec::Fixtures::FileSet.new(this_example_root)
+    per_example_data[:file_set_fixture].instance_eval(&block)
+    per_example_data[:file_set_fixture].create!
+  end
+
+  def files_root(file_set_fixture = nil)
+    file_set_fixture ||= per_example_data[:file_set_fixture]
+    file_set_fixture.root_dir
+  end
+
+  private
+  def unload_all_classes!
+    fd = per_example_data[:file_set_fixture]
+    fd.unload_all_classes! if fd
+  end
+
+  def this_example_name
+    per_example_data[:this_example_name] ||= this_example.metadata[:full_description].strip.downcase.gsub(/[^A-Za-z0-9_]+/, '_')
+  end
+
+  def this_spec_root
+    per_example_data[:this_spec_root] ||= extant_directory(tempdir_root, this_spec_name)
+  end
+
+  def this_spec_name
+    per_example_data[:this_spec_name] ||= begin
+      name = self.class.name
+      name = $1 if name =~ /::([^:]+)$/i
+      name.strip.downcase.gsub(/[^A-Za-z0-9_]+/, '_')
+    end
+  end
+
+  def gem_root
+    per_example_data[:gem_root] ||= extant_directory(File.dirname(File.dirname(File.dirname(__FILE__))))
+  end
+
+  def tempdir_root
+    per_example_data[:tempdir_root] ||= extant_directory(gem_root, 'tmp', 'spec')
+  end
+
+  def extant_directory(*path_components)
+    out = path(*path_components)
+    FileUtils.mkdir_p(out)
+    out
+  end
+
+  def clean_directory(*path_components)
+    p = path(*path_components)
+    FileUtils.rm_rf(p)
+    FileUtils.mkdir_p(p)
+    p
+  end
+
+  def path(*path_components)
+    File.expand_path(File.join(*path_components))
+  end
+end

data/spec/helpers/global_helper.rb

@@ -0,0 +1,34 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'parcels'
+
+require 'spec/parsing/sprockets_asset'
+require 'spec/parsing/compiled_asset'
+require 'spec/expected/expected_asset'
+
+require 'helpers/file_structure_helpers'
+require 'helpers/content_in_helpers'
+require 'helpers/sprockets_helpers'
+require 'helpers/per_example_helpers'
+require 'helpers/parcels_rails_helpers'
+require 'helpers/new_asset_helpers'
+require 'helpers/new_rails_helpers'
+
+require 'oop_rails_server'
+
+RSpec.configure do |c|
+  c.include ContentInHelpers
+  c.include PerExampleHelpers
+  c.include FileStructureHelpers
+  c.include NewAssetHelpers, :type => :system
+  c.include NewRailsHelpers, :type => :rails
+
+  c.include SprocketsHelpers, :type => :system
+
+  c.include ::OopRailsServer::Helpers, :type => :rails
+  c.include ParcelsRailsHelpers, :type => :rails
+
+  c.before(:each) do |example|
+    set_up_per_example_data!(example)
+  end
+end

data/spec/helpers/new_asset_helpers.rb

@@ -0,0 +1,31 @@
+require 'spec/expected/expected_asset_set'
+
+module NewAssetHelpers
+  def sprockets_asset(name, the_sprockets_env = nil)
+    the_sprockets_env ||= sprockets_env
+    ::Spec::Parsing::SprocketsAsset.new(the_sprockets_env, name)
+  end
+
+  def compiled_sprockets_asset(name, the_sprockets_env = nil)
+    ::Spec::Parsing::CompiledAsset.new(sprockets_asset(name, the_sprockets_env))
+  end
+
+  def expected_file_asset(subpath, &block)
+    ::Spec::Expected::ExpectedAsset.new(files_root, subpath, &block)
+  end
+
+  def file_assets(&block)
+    ::Spec::Expected::ExpectedAssetSet.new(files_root, &block)
+  end
+
+  def render_file_asset(subpath, args = { }, options = { })
+    subpath = $1 if subpath =~ %r{^(.*?)\.rb$}i
+    full_path = File.join(files_root, subpath)
+    full_path += ".rb" unless full_path =~ /\.rb\s*$/i
+    widget_class = Fortitude::Widget.widget_class_from_file(full_path, :root_dirs => files_root)
+    html = widget_class.new(args).to_html
+    out = Nokogiri::HTML(html)
+    out = out.xpath('/html/body') if options.fetch(:extract_body_contents, true)
+    out
+  end
+end

data/spec/helpers/new_rails_helpers.rb

@@ -0,0 +1,31 @@
+require 'spec/parsing/compiled_asset'
+require 'spec/parsing/rails_asset'
+require 'spec/parsing/precompiled_rails_asset'
+require 'spec/expected/expected_asset'
+require 'spec/expected/expected_asset_set'
+
+module NewRailsHelpers
+  def rails_asset(name, the_rails_server = nil)
+    the_rails_server ||= rails_server
+    ::Spec::Parsing::RailsAsset.new(the_rails_server, name)
+  end
+
+  def compiled_rails_asset(name, the_rails_server = nil)
+    ::Spec::Parsing::CompiledAsset.new(rails_asset(name, the_rails_server))
+  end
+
+  def precompiled_rails_asset(name, the_rails_server = nil)
+    the_rails_server ||= rails_server
+    ::Spec::Parsing::CompiledAsset.new(::Spec::Parsing::PrecompiledRailsAsset.new(the_rails_server, name))
+  end
+
+  def expected_rails_asset(subpath, the_rails_server = nil, &block)
+    the_rails_server ||= rails_server
+    ::Spec::Expected::ExpectedAsset.new("#{the_rails_server.rails_root}/app", subpath, &block)
+  end
+
+  def rails_assets(the_rails_server = nil, &block)
+    the_rails_server ||= rails_server
+    ::Spec::Expected::ExpectedAssetSet.new("#{the_rails_server.rails_root}/app", &block)
+  end
+end

data/spec/helpers/parcels_rails_helpers.rb

@@ -0,0 +1,20 @@
+module ParcelsRailsHelpers
+  def rails_server_project_root
+    @rails_server_project_root ||= File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+  end
+
+  def rails_server_additional_gemfile_lines
+    [
+      "gem 'fortitude', \">= 0.9.0\"",
+      "gem 'parcels', :path => '#{rails_server_project_root}'"
+    ]
+  end
+
+  def rails_server_implicit_template_paths
+    [ :base ]
+  end
+
+  def rails_server_default_version
+    ENV['PARCELS_SPECS_RAILS_VERSION']
+  end
+end

data/spec/helpers/per_example_helpers.rb

@@ -0,0 +1,15 @@
+module PerExampleHelpers
+  def set_up_per_example_data!(example)
+    @per_example_data = {
+      :example => example
+    }
+  end
+
+  def per_example_data
+    (@per_example_data || raise("#set_up_per_example_data! was not called!"))
+  end
+
+  def this_example
+    per_example_data[:example]
+  end
+end

data/spec/helpers/sprockets_helpers.rb

@@ -0,0 +1,23 @@
+module SprocketsHelpers
+  def new_sprockets_env(*args)
+    ::Sprockets::Environment.new(*args)
+  end
+
+  def sprockets_env(*args, &block)
+    out = if args.length > 0 || block
+      raise "Duplicate creation of sprockets_env? #{args.inspect}" if @sprockets_env
+      args = [ this_example_root ] if args.length == 0
+      per_example_data[:sprockets_env] = new_sprockets_env(*args)
+      block.call(per_example_data[:sprockets_env]) if block
+    else
+      per_example_data[:sprockets_env] ||= begin
+        out = new_sprockets_env(this_example_root)
+        out.append_path 'assets'
+        out
+      end
+    end
+
+    out.parcels.add_widget_tree!(File.join(this_example_root, 'views'))
+    out
+  end
+end

data/spec/lib/spec/expected/base_expected_asset.rb

@@ -0,0 +1,35 @@
+module Spec
+  module Expected
+    class BaseExpectedAsset
+      def initialize(root_directory, expected_subpath)
+        @root_directory = root_directory
+        @expected_subpath = expected_subpath
+      end
+
+      def to_s
+        "<#{self.class.name} at #{expected_subpath.inspect}>"
+      end
+
+      private
+      attr_reader :root_directory, :expected_subpath
+
+      def filename
+        @filename ||= begin
+          if expected_subpath.kind_of?(Symbol)
+            expected_subpath
+          else
+            File.join(root_directory, expected_subpath)
+          end
+        end
+      end
+
+      def applies_to_asset?(asset)
+        asset.filename == filename
+      end
+
+      def applicable_assets_from(remaining_assets)
+        remaining_assets.select { |a| applies_to_asset?(a) }
+      end
+    end
+  end
+end

data/spec/lib/spec/expected/expected_asset.rb

@@ -0,0 +1,135 @@
+require 'spec/parsing/parsed_css_asset'
+
+require 'spec/expected/base_expected_asset'
+
+module Spec
+  module Expected
+    class ExpectedAsset < BaseExpectedAsset
+      def initialize(root_directory, expected_subpath, &block)
+        super(root_directory, expected_subpath)
+
+        @expected_rules = { }
+        @allow_extra_rules = false
+
+        instance_eval(&block) if block
+      end
+
+      def source
+        out = ""
+        expected_rules.each do |selector, rules|
+          out << "#{selector} {\n"
+          rules.each do |rule|
+            out << "  #{rule}\n"
+          end
+          out << "}\n\n"
+        end
+        out.strip
+      end
+
+      def expect_rules(selector, *rules)
+        selector = selector.to_s
+        expected_rules[selector] ||= [ ]
+        expected_rules[selector] += rules
+      end
+      alias_method :expect_rule, :expect_rules
+
+      def expect_wrapped_rules(selector, *rules)
+        wrapped_selector = wrap_selector(selector)
+        expect_rules(wrapped_selector, *rules)
+      end
+      alias_method :expect_wrapped_rule, :expect_wrapped_rules
+
+      def allow_extra_rules!
+        @allow_extra_rules = true
+      end
+
+      def should_match(remaining_assets)
+        matching_remaining_assets = applicable_assets_from(remaining_assets)
+
+        if matching_remaining_assets.length == 0
+          message = "Expected match not found:\n  #{self}\nnot found in these assets:"
+          remaining_assets.each do |remaining_asset|
+            message << "\n\n    #{remaining_asset}:\n        #{remaining_asset.source}\n"
+          end
+          raise message
+        elsif matching_remaining_assets.length == 1
+          matching_remaining_asset = matching_remaining_assets.first
+
+          unless asset_matches?(matching_remaining_asset)
+            raise "Asset mismatch for #{matching_remaining_asset.where_from}: expected\n  #{source}\ndoes not match actual\n  #{matching_remaining_asset.source}"
+          end
+
+          [ matching_remaining_asset ]
+        elsif matching_remaining_assets.length > 1
+          message = "Multiple assets match:\n  #{self}\nin:"
+          matching_remaining_assets.each do |matching_remaining_asset|
+            message << "\n\n    #{matching_remaining_asset}:\n        #{matching_remaining_asset.source}\n"
+          end
+          raise message
+        end
+      end
+
+      def parcels_wrapping_class
+        @parcels_wrapping_class ||= begin
+          out = expected_subpath.dup
+          out = $1 if out =~ /^(.*?)\.([^\/]+)$/i
+          out = out.gsub('/', '__').gsub(/[^A-Za-z0-9_]/, '_')
+          "parcels_class__#{out}"
+        end
+      end
+
+      private
+      attr_reader :expected_rules
+
+      def extra_rules_allowed?
+        !! @allow_extra_rules
+      end
+
+      def wrap_selector(selector)
+        if selector
+          ".#{parcels_wrapping_class} #{selector}"
+        else
+          ".#{parcels_wrapping_class}"
+        end
+      end
+
+      def asset_matches?(asset)
+        parsed_asset = ::Spec::Parsing::ParsedCssAsset.new(asset)
+
+        actual_rules = parsed_asset.style_rules.dup
+
+        expected_rules.each do |expected_selector, expected_rules_for_this_selector|
+          actual_rules_for_this_selector = actual_rules[expected_selector]
+          return false unless actual_rules_for_this_selector
+
+          matches = (actual_rules_for_this_selector.length == expected_rules_for_this_selector.length)
+          if matches
+            actual_rules_for_this_selector.each_with_index do |actual_rule, index|
+              expected_rule = expected_rules_for_this_selector[index]
+
+              this_matches = if expected_rule.kind_of?(String)
+                actual_rule == expected_rule
+              elsif expected_rule.kind_of?(Regexp)
+                actual_rule =~ expected_rule
+              else
+                false
+              end
+
+              matches &&= this_matches
+            end
+
+            actual_rules.delete(expected_selector)
+          end
+
+          return false unless matches
+        end
+
+        if actual_rules.length > 0 && (! extra_rules_allowed?)
+          return false
+        end
+
+        true
+      end
+    end
+  end
+end

data/spec/lib/spec/expected/expected_asset_set.rb

@@ -0,0 +1,45 @@
+require 'spec/expected/expected_asset'
+require 'spec/expected/must_not_be_present_asset'
+
+module Spec
+  module Expected
+    class ExpectedAssetSet
+      def initialize(root_directory, &block)
+        @root_directory = root_directory
+        @expected_assets = [ ]
+        @allows_additional = false
+
+        instance_eval(&block) if block
+      end
+
+      def asset(subpath, &block)
+        expected_asset = Spec::Expected::ExpectedAsset.new(root_directory, subpath, &block)
+        @expected_assets << expected_asset
+      end
+
+      def asset_must_not_be_present(subpath)
+        expected_asset = Spec::Expected::MustNotBePresentAsset.new(root_directory, subpath)
+        @expected_assets << expected_asset
+      end
+
+      def expected_assets
+        @expected_assets
+      end
+
+      def allow_additional_assets!
+        @allows_additional = true
+      end
+
+      def allows_additional?
+        !! @allows_additional
+      end
+
+      def to_s
+        "<ExpectedAssetSet: #{@expected_assets.length} assets:\n  #{@expected_assets.join("\n  ")}>"
+      end
+
+      private
+      attr_reader :root_directory
+    end
+  end
+end

data/spec/lib/spec/expected/must_not_be_present_asset.rb

@@ -0,0 +1,17 @@
+require 'spec/expected/base_expected_asset'
+
+module Spec
+  module Expected
+    class MustNotBePresentAsset < BaseExpectedAsset
+      def should_match(remaining_assets)
+        matching = applicable_assets_from(remaining_assets)
+
+        if matching.length > 0
+          raise "Assets found that must not be present:\n  #{matching.join("\n  ")}"
+        end
+
+        [ ]
+      end
+    end
+  end
+end

data/spec/lib/spec/fixtures/file_set.rb

@@ -0,0 +1,80 @@
+require 'spec/fixtures/widget_base'
+require 'spec/fixtures/widget_file'
+
+module Spec
+  module Fixtures
+    class FileSet
+      attr_reader :root_dir
+
+      def initialize(root_dir)
+        @root_dir = root_dir
+        @files = { }
+        @widgets = { }
+      end
+
+      def file(subpath, contents = nil)
+        contents = $2 if contents =~ /\A(\s*\n)*(.*?)(\s\n)*\Z/mi
+        files[subpath] = contents
+      end
+
+      def widget(subpath, options = { }, &block)
+        class_name = options[:class_name]
+        class_name ||= begin
+          out = subpath
+          out = $1 if out =~ /^(.*)(\.[A-Z0-9_]+)+$/i
+          out = out.camelize
+          out
+        end
+        superclass = options[:superclass] || ::Spec::Fixtures::WidgetBase
+        superclass = superclass.name if superclass.kind_of?(Class)
+        subpath += ".rb" unless subpath =~ /\.rb$/i
+
+        widget_definition = ::Spec::Fixtures::WidgetFile.new(class_name, superclass, root_dir)
+        widget_definition.instance_eval(&block) if block
+
+        @widgets[subpath] = widget_definition
+      end
+
+      def create!
+        files.each do |subpath, contents|
+          full_path = File.join(root_dir, subpath)
+          FileUtils.mkdir_p(File.dirname(full_path))
+          File.open(full_path, 'w') { |f| f << contents }
+        end
+
+        widgets.each do |subpath, definition|
+          full_path = File.join(root_dir, subpath)
+          FileUtils.mkdir_p(File.dirname(full_path))
+          File.open(full_path, 'w') { |f| f << definition.source_text }
+        end
+      end
+
+      def unload_all_classes!
+        subpaths = files.keys | widgets.keys
+
+        subpaths.each do |subpath|
+          next unless subpath =~ /\.rb$/i
+          full_path = File.join(root_dir, subpath)
+          widget_class = ::Fortitude::Widget.widget_class_from_file(full_path, :root_dirs => root_dir) rescue nil
+
+          if widget_class
+            parent = constant_name = nil
+
+            if widget_class.name =~ /^(.*)::([^:]+)$/i
+              parent = $1.constantize
+              constant_name = $2.to_sym
+            else
+              parent = ::Object
+              constant_name = widget_class.name.to_sym
+            end
+
+            parent.send(:remove_const, constant_name)
+          end
+        end
+      end
+
+      private
+      attr_reader :files, :widgets
+    end
+  end
+end

data/spec/lib/spec/fixtures/widget_base.rb

@@ -0,0 +1,13 @@
+module Spec
+  module Fixtures
+    class WidgetBase < ::Fortitude::Widget
+      doctype :html5
+
+      enable_parcels!
+
+      def content
+        p "spec_widget #{self.class.name} contents!"
+      end
+    end
+  end
+end