rail 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a66f7d5b9a7e1436ce075bcf244d8c020b14b29
-  data.tar.gz: 0bff180762f3b1be3d8193e8a36cb810ebc39980
+  metadata.gz: ed960041649216cdcaeb74ef9689f4e95036b95b
+  data.tar.gz: 9f8d32c3ff9f03a87521958d217a0d12c9cde586
 SHA512:
-  metadata.gz: 8779ed872c394c8df542f8d15277b235e7c1de0936ead82e8b1c6e6fb129b312d6789ae7f5dd8f3a0d83d7d41de8b2f20d21c12a4d939fee8033559ebcb3dc4a
-  data.tar.gz: facff4a130a3574032a7b1e5fdd52c5210dff76929260dcd6ad7df54a12f0208d463fbce56cce13525e09960e664c5e9e03ea5a6bfba2b3877f1f9512f9cce51
+  metadata.gz: 1738d5b0b7a8725f7e9187edd6f6cc8c96815197167e9e2bf0d50245a27c8d2420807c01d211d0355bc14c98e67ddfccaf43d0dff2ccd93c20f8737cca10c759
+  data.tar.gz: 04cc3ad49ca4dbd80fd4144de9d6684b48a007c303bd1fc0e01ef3657fddb9d158871919d738ecacbf40b02129613bcdaae3c66f93ebd419252809eb951461cd

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## Rail 0.0.8 (July 29, 2014)
+
+* Automatically reload helper modules when they change.
+
 ## Rail 0.0.7 (July 15, 2014)
 
 * Added a CLI for generating project directories.

data/Guardfile

@@ -0,0 +1,10 @@
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^lib/(.+)\.rb$}) do |match|
+    file = "spec/lib/#{match[1]}_spec.rb"
+    File.exist?(file) ? file : 'spec'
+  end
+  watch(%r{^spec/.*_spec\.rb$})
+  watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+end
+
+# vim: set ft=ruby

data/README.md

@@ -8,7 +8,9 @@ assets, and it includes the following components:
 * [Haml](http://haml.info/) for HTML, and
 * [Sass](http://sass-lang.com/) for CSS.
 
-## Straightforward Installation
+## Installation
+
+### Straightforward
 
 Install the gem:
 
@@ -42,18 +44,14 @@ current directory called `my_project` and initializes a basic Rail project
 inside that folder. In this case, `MyProject` is used as the class name of
 the project. Feel free to replace `my_project` with the name of your project.
 
-## Manual Installation
+### Manual
 
-Include the gem in your `Gemfile`:
+Create a `Gemfile`:
 
 ```ruby
 source 'https://rubygems.org'
 
-gem 'rail', '~> 0.0.7'
-
-# The rest is optional
-gem 'redcarpet', '~> 3.1.2' # your favorit complement to Haml
-gem 'thin', '~> 1.6.2'      # your favorit Web server
+gem 'rail'
 ```
 
 Run [Bundler](http://bundler.io/):
@@ -122,15 +120,15 @@ As with Rails, Rail is configured inside `config/application.rb`:
 ```ruby
 module MyProject
   class Application < Rail::Application
-    # Import assets from other gems:
-    config.gems << 'turbolinks'
+    # Gems to look for additional assets
+    config.gems << 'googleplus-reader'
 
-    # Precompile assets using `rake assets`:
+    # Assets to precompile when running `rake assets`
     config.precompile << 'application.css'
     config.precompile << 'application.js'
     config.precompile << 'index.html'
 
-    # Compress assets:
+    # Compress assets when serving and precompiling
     config.compress = true
   end
 end

data/Rakefile

@@ -1,10 +1,7 @@
 require 'bundler/gem_tasks'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new do |test|
-  test.libs.push('lib')
-  test.test_files = FileList[ 'spec/*_spec.rb' ]
-  test.verbose = true
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task :default => :test
+task :default => :spec
+task :test => :spec

data/bin/rail

@@ -10,7 +10,7 @@ unless ARGV.length == 2 && ARGV[0] == 'new'
 end
 
 begin
-  Rail::Generator.new(root_dir: ARGV[1]).run
+  Rail::Generator.new(destination: ARGV[1]).run
 rescue Rail::Generator::Error => e
   puts e
   exit 1

data/lib/rail.rb

@@ -1,29 +1,30 @@
-require 'ostruct'
 require 'forwardable'
-
 require 'rack'
-
 require 'coffee-script'
 require 'haml'
 require 'sass'
-
 require 'uglifier'
 
+require_relative 'support/inflector'
+require_relative 'support/loader'
+require_relative 'support/query_string'
+require_relative 'support/query_struct'
+
 require_relative 'rail/application'
 require_relative 'rail/browser'
 require_relative 'rail/context'
 require_relative 'rail/pipeline'
+require_relative 'rail/precompiler'
 require_relative 'rail/processor'
 require_relative 'rail/request'
 require_relative 'rail/server'
-require_relative 'rail/support'
 require_relative 'rail/version'
 
 module Rail
   NotFoundError = Class.new(StandardError)
 
   def self.env
-    @env ||= build_env
+    @env ||= Support::QueryString.new(ENV['RAIL_ENV'] || 'development')
   end
 
   def self.applications
@@ -31,19 +32,4 @@ module Rail
       klass < Application
     end
   end
-
-  private
-
-  def self.build_env
-    string = ENV['RAIL_ENV'] ? ENV['RAIL_ENV'].dup : 'development'
-
-    string.singleton_class.class_eval do
-      define_method(:method_missing) do |name, *arguments, &block|
-        super unless name.to_s =~ /^(?<name>.+)\?$/
-        self == Regexp.last_match(:name)
-      end
-    end
-
-    string
-  end
 end

data/lib/rail/application.rb

@@ -1,16 +1,11 @@
 module Rail
   class Application
-    extend Forwardable
-
-    attr_reader :browser, :pipeline
-    def_delegators :config, :root, :gems, :compress?
+    attr_reader :config, :browser, :pipeline
 
     def initialize
-      # config.ru
-      config.root ||= self.class.find_root
-
-      @browser = Browser.new(self)
-      @pipeline = Pipeline.new(self)
+      @config = self.class.config
+      @browser = Browser.new(config)
+      @pipeline = Pipeline.new(config)
     end
 
     def call(env)
@@ -18,95 +13,28 @@ module Rail
       (browser.accept?(request) ? browser : pipeline).process(request)
     end
 
-    def helpers
-      @helpers ||= load_helpers
+    def precompile
+      Precompiler.new(pipeline).process(config.precompile)
     end
 
-    def config
-      self.class.config
+    def self.inherited(klass)
+      klass.config.root = File.expand_path('../..', caller[0].sub(/:.*/, ''))
     end
 
     def self.config
-      @config ||= build_config
+      @config ||= Support::QueryStruct.new(default_options)
     end
 
     def self.load_tasks
-      # Rakefile
-      config.root ||= find_root
-
       Dir[File.join(File.dirname(__FILE__), 'tasks/*.rake')].each do |path|
         Rake::load_rakefile(path)
       end
     end
 
-    def self.precompile
-      if config.precompile.empty?
-        puts 'Nothing to precompile.'
-        return
-      end
-
-      application = self.new
-
-      puts 'Precompiling assets...'
-      puts
-
-      config.precompile.each do |path|
-        file = File.join('public', path)
-        unless File.exist?(File.dirname(file))
-          FileUtils.mkdir_p(File.dirname(file))
-        end
-
-        puts "#{ path } -> #{ file }"
-
-        request = Request.new('REQUEST_METHOD' => 'GET', 'PATH_INFO' => path)
-        _, _, source = application.pipeline.process(request)
-
-        File.open(file, 'w') do |file|
-          source.each { |chunk| file.write(chunk) }
-        end
-      end
-
-      puts
-      puts 'Done.'
-    end
-
-    def self.find_root
-      File.expand_path('..', caller[1].sub(/:.*/, ''))
-    end
-
     private
 
-    def load_helpers
-      Dir[File.join(root, 'app/helpers/*.rb')].map do |file|
-        require file
-        Support.constantize(File.basename(file, '.rb'))
-      end
-    end
-
     def self.default_options
-      {
-        gems: [],
-        precompile: [],
-        compress: Rail.env.production?
-      }
+      { gems: [], precompile: [], compress: Rail.env.production?  }
     end
-
-    def self.build_config
-      struct = OpenStruct.new
-
-      struct.singleton_class.class_eval do
-        define_method(:method_missing) do |name, *arguments, &block|
-          !!super(name.to_s.sub(/\?$/, '').to_sym, *arguments, &block)
-        end
-      end
-
-      default_options.each do |name, value|
-        struct.send("#{ name }=", value)
-      end
-
-      struct
-    end
-
-    private_class_method :default_options, :build_config
   end
 end

data/lib/rail/browser.rb

@@ -2,23 +2,19 @@ require 'rack'
 
 module Rail
   class Browser
-    extend Forwardable
+    attr_reader :root
 
-    def_delegator :@host, :root
-    def_delegator :@directory, :call
-
-    def initialize(host)
-      @host = host
-      @directory ||= Rack::Directory.new(File.join(root, 'public'))
+    def initialize(config)
+      @root = File.join(config.root, 'public')
+      @directory = Rack::Directory.new(root)
     end
 
     def process(request)
-      call(request.env)
+      @directory.call(request.env)
     end
 
     def accept?(request)
-      path = request.path
-      !path.empty? && File.exist?(File.join(root, 'public', path))
+      File.exist?(File.join(root, request.path))
     end
   end
 end

data/lib/rail/generator.rb

@@ -1,9 +1,8 @@
-require 'generator'
+require 'support/generator'
+require 'support/inflector'
 
 module Rail
-  class Generator < ::Generator
-    Error = Class.new(StandardError)
-
+  class Generator < Support::Generator
     FILES = [
       'app/assets/javascripts/application.js.coffee',
       'app/assets/stylesheets/application.css.scss',
@@ -17,31 +16,25 @@ module Rail
     ]
 
     def initialize(options)
-      root_dir = options.fetch(:root_dir)
-      template_dir = File.expand_path('../templates', __FILE__)
-
-      project_name = (root_dir.split('/').last || '')
-        .gsub(/^[^a-zA-Z]*/, '')
-        .gsub(/[^\w]/, '')
-        .gsub(/^\w|_\w/, &:upcase)
-        .gsub(/_+/, ' ')
+      destination = options.fetch(:destination)
+      source = File.expand_path('../templates', __FILE__)
 
+      directory = destination.split('/').last || ''
+      project_name = Support::Inflector.titelize(directory)
       class_name = project_name.gsub(' ', '')
 
       @locals = { class_name: class_name, project_name: project_name }
 
-      raise Error, 'The project name is invalid.' if class_name.empty?
+      raise ArgumentError, 'The project name is invalid.' if class_name.empty?
 
-      super(root_dir: root_dir, template_dir: template_dir)
+      super(destination: destination, source: source)
     end
 
     def run
-      raise Error, 'The directory already exists.' if File.directory?(root_dir)
-      super(FILES, @locals)
-    end
-
-    def report(message)
-      puts "Creating '#{ message }'..."
+      if File.directory?(destination)
+        raise ArgumentError, 'The directory already exists.'
+      end
+      process(FILES, @locals)
     end
   end
 end

data/lib/rail/pipeline.rb

@@ -2,14 +2,16 @@ module Rail
   class Pipeline
     extend Forwardable
 
-    def_delegators :@host, :root, :gems, :helpers, :compress?
+    attr_reader :config
+    def_delegators :config, :root, :gems, :compress?
 
-    def initialize(host)
-      @host = host
+    def initialize(config)
+      @config = config
+      @loader = Support::Loader.new(File.join(root, 'app/helpers/*.rb'))
     end
 
     def process(request)
-      context = Context.new(locals: { request: request }, mixins: helpers)
+      context = Context.new(locals: { request: request }, mixins: loader.find)
 
       asset = rewrite(request.path)
       klass = Processor.find(asset) or raise NotFoundError
@@ -21,9 +23,9 @@ module Rail
 
       headers = { 'Content-Type' => klass.mime_type }
 
-      [ 200, headers, Array(body) ]
+      [200, headers, Array(body)]
     rescue NotFoundError
-      [ 404, {}, [] ]
+      [404, {}, []]
     end
 
     def find(asset)
@@ -36,14 +38,12 @@ module Rail
 
     private
 
+    attr_reader :loader
+
     def rewrite(path)
-      if [ '', 'index.html' ].include?(path)
-        'layouts/application.html'
-      elsif File.extname(path).empty?
-        "#{ path }.html"
-      else
-        path
-      end
+      path = path.sub(/^\//, '')
+      path = 'layouts/application.html' if path == 'index.html'
+      path
     end
 
     def paths

data/lib/rail/precompiler.rb

@@ -0,0 +1,58 @@
+module Rail
+  class Precompiler
+    class Storage
+      attr_reader :root
+
+      def initialize(root = 'public')
+        @root = root
+      end
+
+      def write(file, stream)
+        file = File.join(root, file)
+
+        unless File.exist?(File.dirname(file))
+          FileUtils.mkdir_p(File.dirname(file))
+        end
+
+        File.open(file, 'w') do |file|
+          stream.each { |chunk| file.write(chunk) }
+        end
+      end
+    end
+
+    def initialize(pipeline, storage = nil)
+      @pipeline = pipeline
+      @storage = storage || Storage.new
+    end
+
+    def process(paths)
+      if paths.empty?
+        report('Nothing to precompile.')
+        return
+      end
+
+      report('Precompiling assets...')
+
+      paths.each_with_index do |path, i|
+        report('%4d. %s' % [i + 1, path])
+        storage.write(path, read(path))
+      end
+
+      report('Done.')
+    end
+
+    private
+
+    attr_reader :pipeline, :storage
+
+    def read(path)
+      request = Request.new('REQUEST_METHOD' => 'GET', 'PATH_INFO' => path)
+      _, _, source = pipeline.process(request)
+      source
+    end
+
+    def report(message)
+      puts message
+    end
+  end
+end