rafters 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 20c5adf484fe6dee7a436bf120a01abc45262768
+  data.tar.gz: 492d4021eb8760ea3d0a1da556c31a0b9bd3c2ef
+SHA512:
+  metadata.gz: d55783f2ff80d38f75990f1a82b3a04d48d8a18f1c0026cb7dbd5adcded1afdc7c4218dd58a936a5aac9ab0cf0e2d033a865eab6071eba75549930ecdada9cd3
+  data.tar.gz: 16d62a56843a39b954b94438b7e6c29d0cc7c051b932d55507468daea22442440a743fbb5f0d8644b5d2befb8b9b3e4c0e6c4123729e7986498ce80049a13ee6

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/dummy/.sass-cache
+spec/dummy/db/*.sqlite3
+spec/dummy/db/*.sqlite3-journal
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/reports
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.rvmrc

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 2.0.0" > .rvmrc
+environment_id="ruby-2.0.0-p0@rafters"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.19.1 (master)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  for __hook in "${rvm_path:-$HOME/.rvm}/hooks/after_use"*
+  do
+    if [[ -f "${__hook}" && -x "${__hook}" && -s "${__hook}" ]]
+    then \. "${__hook}" || true
+    fi
+  done
+  unset __hook
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,18 @@
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in rafters.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# jquery-rails is used by the dummy application
+gem "jquery-rails"
+gem "sqlite3"
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Andrew Hite
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,168 @@
+# Rafters
+
+!!! STILL UNDER ACTIVE DEVELOPMENT. USE AT YOUR OWN RISK !!!
+
+Rafters lets you think about each page of your application as a collection of small pieces instead of monolithic, difficult to maintain
+views.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rafters'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install rafters
+```
+
+## Usage
+
+After you install the Rafters gem, you need to run the following generator:
+
+```sh
+$ rails generate rafters:install
+```
+  
+This generator will create an `app/rafters` directory in your application, a `config/initializers/rafters.rb` initializer with some basic configuration, and add the `require_components` directive to your application.css and application.js files.
+
+### Creating a component
+
+When you build out a page using Rafters you're effectively breaking it down into small, easy to digest chunks of code / markup that can optimally be configured and re-used on other pages as well. These bite-sized "views" are called Components, and you can think of them as partials on steroids (with their own "controllers" and templates).
+
+To begin creating a new component, run the following generator:
+
+```sh
+$ rails generate rafters:component [name]
+```
+  
+This generator will create the following files:
+
+```
+app/rafters/[name]
+app/rafters/[name]/[name]_component.rb
+app/rafters/[name]/assets/stylesheets/[name]_component.scss
+app/rafters/[name]/assets/javascripts/[name]_component.js.coffee
+app/rafters/[name]/views/[name]_component.html.erb
+```
+  
+The two most important files generated above are `app/rafters/[name]/[name]_component.rb` and `app/rafters/[name]/views/[name]_component.html.erb`, which are (respectively) our component controller and view.
+
+### Rendering a component
+
+You can render components anywhere - in your view, in your controller, in another component, etc. - but the most common place will (obviously) be in your views. To render a component, call `render_component [symbolized, underscored name]` in one of your app views. For example:
+
+```erb
+...
+<div class="main">
+  <%= render_component :heading %>
+</div>
+...
+```
+
+### Adding an attribute to a component
+
+Each component exposes attributes to it's view using `Rafters::Component#attributes`, which are available in the view under the local variable `attributes`. The `attributes` are simply a collection of methods that you explicitly declare as such in your component, using the `Rafters::Component.attribute` method.
+
+For instance, let's say we have a HeadingComponent that exposes a title attribute:
+
+```ruby
+class HeadingComponent
+  include Rafters::Component
+  
+  attribute :title
+  
+  private
+  
+  def title
+    "Lorem Ipsum"
+  end
+end
+```
+  
+Since we won't be accessing the `HeadingComponent#title` method directly from within our view, it's recommended to make it a private method. The interface that our component exposes is taken care of behind the scenes.
+
+You can access the attribute in your component view using the `attributes` object:
+
+```erb
+<div class="heading">
+  <h1><%= attributes.title %></h1>  
+</div>
+```
+  
+### Adding a setting to a component
+
+In order to build components in a way that allows for re-use, you'll want to define settings that allow individual instances of the component to be configured. These settings will likely be used throughout your component view and controller for any number of purposes, like values in query conditions, section titles, turning on or off specific features of a component, etc.
+
+Adding a setting is very similar to adding an attribute, except they don't point at methods:
+
+```ruby
+class PostsComponent
+  include Rafters::Component
+
+  setting :published
+end
+```
+  
+Setting values are specified when rendering a component:
+
+```erb
+...
+<div class="main">
+  <%= render_component :posts, published: true %>
+</div>
+...
+```
+  
+And can be accessed via the `settings` object in your component view:
+
+```erb
+<div class="posts">
+  <% if settings.published? %>
+    ...
+  <% else %>
+    ...
+  <% end %>
+</div>
+```
+  
+Or your component controller:
+
+```ruby
+class PostsComponent
+  ...
+
+  def posts
+    Post.where(published: settings.published)
+  end
+end
+```
+  
+Default values can be provided for settings using the `default` option:
+    
+```ruby
+setting :type, default: "Comment"
+```
+  
+Required settings can be specified using the `required` option:
+
+```ruby
+setting :user_id, required: true
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,32 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rafters'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/generators/rafters/component/component_generator.rb

@@ -0,0 +1,33 @@
+class Rafters::ComponentGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path("../templates", __FILE__)
+
+  def create_directories
+    empty_directory "#{base_directory}"
+    empty_directory "#{base_directory}/assets"
+    empty_directory "#{base_directory}/assets/javascripts"
+    empty_directory "#{base_directory}/assets/stylesheets"
+    empty_directory "#{base_directory}/assets/images"
+    empty_directory "#{base_directory}/views"
+  end
+
+  def create_gitkeeps
+    create_file "#{base_directory}/assets/images/.gitkeep"
+  end
+
+  def create_files
+    template "component.rb.erb", "#{base_directory}/#{file_name}_component.rb"
+    template "assets/javascripts/component.js.erb", "#{base_directory}/assets/javascripts/#{file_name}_component.js"
+    template "assets/stylesheets/component.scss.erb", "#{base_directory}/assets/stylesheets/#{file_name}_component.scss"
+    template "views/component.html.erb", "#{base_directory}/views/#{file_name}_component.html.erb"
+  end
+
+  private
+
+  def app_root
+    Rails.root
+  end
+
+  def base_directory
+    "app/components/#{file_name}"
+  end
+end

data/lib/generators/rafters/component/templates/component.rb.erb

@@ -0,0 +1,4 @@
+class <%= class_name %>Component
+  include Rafters::Component
+
+end

data/lib/generators/rafters/install/install_generator.rb

@@ -0,0 +1,23 @@
+class Rafters::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path("../templates", __FILE__)
+
+  def create_initializer
+    copy_file "initializer.rb", "config/initializers/rafters.rb"
+  end
+
+  def create_directories
+    empty_directory "app/components"
+  end
+
+  def add_asset_requires
+    inject_into_file "app/assets/stylesheets/application.css", after: "*= require_tree .\n" do <<-'RUBY'
+ *= require_components`
+    RUBY
+    end
+
+    inject_into_file "app/assets/javascripts/application.js", after: "//= require_tree .\n" do <<-'RUBY'
+//= require_components
+    RUBY
+    end
+  end
+end

data/lib/generators/rafters/install/templates/initializer.rb

@@ -0,0 +1,2 @@
+Rafters.setup do |config|
+end

data/lib/rafters/component.rb

@@ -0,0 +1,70 @@
+module Rafters::Component
+  extend ActiveSupport::Concern
+
+  attr_writer :controller
+
+  def initialize(settings = {})
+    @settings = settings
+  end
+
+  def template_name
+    return @_template_name if @_template_name
+
+    _template_name = self.class._template_name
+    _underscored_name = self.class.name.underscore
+    
+    if _template_name.is_a?(Proc)
+      _template_name = _template_name.call(self)
+    end
+
+    @_template_name = (_template_name || _underscored_name)
+  end
+
+  def attributes
+    @_attributes ||= Hashie::Mash.new.tap do |_attributes|
+      self.class._attributes.each do |name, options|
+        _attributes[name] = send(name)
+      end
+    end
+  end
+
+  def settings
+    @_settings ||= Hashie::Mash.new.tap do |_settings|
+      self.class._settings.each do |name, options|
+        _settings[name] = (@settings[name] || options[:default] || nil)
+        raise SettingRequired if options[:required] && _settings[name].nil?
+      end
+    end
+  end
+
+  def current(variable_or_method_name)
+    if @controller.instance_variable_defined?("@#{variable_or_method_name}")
+      @controller.instance_variable_get("@#{variable_or_method_name}")
+    elsif @controller.respond_to?(variable_or_method_name)
+      @controller.send(variable_or_method_name)
+    else
+      raise CurrentVariableOrMethodNameMissing
+    end
+  end
+
+  module ClassMethods
+    attr_accessor :_attributes, :_settings, :_template_name
+
+    def attribute(name, options = {})
+      self._attributes ||= {}
+      self._attributes[name.to_sym] = options
+    end
+
+    def setting(name, options = {})
+      self._settings ||= {}
+      self._settings[name.to_sym] = options
+    end
+
+    def template_name(name)
+      self._template_name = name.to_s
+    end
+  end
+
+  class CurrentVariableOrMethodNameMissing < StandardError; end
+  class SettingRequired < StandardError; end
+end

data/lib/rafters/component_context.rb

@@ -0,0 +1,19 @@
+module Rafters::ComponentContext
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :render_component
+  end
+
+  def render_component(name, settings = {}, template_name = nil)
+    component_klass = "#{name}_component".classify.constantize
+    component = component_klass.new(settings)
+    component_renderer.render(component, template_name)
+  end
+
+  private
+
+  def component_renderer
+    @_component_renderer ||= Rafters::ComponentRenderer.new(self)
+  end
+end

data/lib/rafters/component_renderer.rb

@@ -0,0 +1,20 @@
+class Rafters::ComponentRenderer
+  def initialize(controller)
+    @controller = controller
+
+    Rafters.view_paths.each do |view_path|
+      @controller.prepend_view_path(view_path)
+    end
+  end
+
+  def render(component, template_name = nil)
+    component.controller = @controller
+
+    template_name = (template_name || component.template_name)
+
+    @controller.view_context.render(file: "/#{template_name}", locals: {
+      settings: component.settings,
+      attributes: component.attributes
+    })
+  end
+end

data/lib/rafters/directive_processor.rb

@@ -0,0 +1,9 @@
+class Rafters::DirectiveProcessor < Sprockets::DirectiveProcessor
+  def process_require_components_directive
+    Rafters.asset_paths.sort.each do |asset_path|
+      each_entry(asset_path) do |pathname|
+        context.require_asset(pathname) if context.asset_requirable?(pathname)
+      end
+    end
+  end
+end

data/lib/rafters/engine.rb

@@ -0,0 +1,33 @@
+class Rafters::Engine < Rails::Engine
+  isolate_namespace Rafters
+
+  config.generators do |g|
+    g.test_framework :rspec
+    g.assets false
+    g.helper false
+  end
+
+  initializer "rafters.load_view_paths" do |app|
+    Rafters.view_paths = Dir[app.root.join("app", "components", "*", "views")]
+  end
+
+  initializer "rafters.load_asset_paths" do |app|
+    Rafters.asset_paths = Dir[app.root.join("app", "components", "*", "assets", "*")]
+  end
+
+  initializer "rafters.set_asset_paths", :after => "rafters.load_asset_paths" do |app|
+    app.config.assets.paths += Rafters.asset_paths
+  end
+
+  initializer "rafters.set_autoload_paths", :before => :set_autoload_paths do |app|
+    app.config.autoload_paths += Dir[app.root.join("app", "components", "*/")]
+  end
+
+  config.after_initialize do |app|
+    app.assets.unregister_preprocessor('text/css', Sprockets::DirectiveProcessor)
+    app.assets.register_preprocessor('text/css', Rafters::DirectiveProcessor)
+
+    app.assets.unregister_preprocessor('application/javascript', Sprockets::DirectiveProcessor)
+    app.assets.register_preprocessor('application/javascript', Rafters::DirectiveProcessor)
+  end
+end

data/lib/rafters/version.rb

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

data/lib/rafters.rb

@@ -0,0 +1,27 @@
+require 'active_support'
+require 'hashie'
+
+require 'rafters/engine'
+
+module Rafters
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :Component
+    autoload :ComponentContext
+    autoload :ComponentRenderer
+    autoload :DirectiveProcessor
+  end
+
+  def self.setup
+    yield self
+  end
+
+  mattr_accessor :view_paths
+  @@view_paths = nil
+
+  mattr_accessor :asset_paths
+  @@asset_paths = nil
+end
+
+ActionController::Base.send(:include, Rafters::ComponentContext)

data/lib/tasks/rafters_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rafters do
+#   # Task goes here
+# end

data/rafters.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rafters/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rafters"
+  spec.version       = Rafters::VERSION
+  spec.authors       = ["Andrew Hite"]
+  spec.email         = ["andrew@andrew-hite.com"]
+  spec.description   = %q{Rafters lets you think about each page of your application as a collection of small pieces instead of monolithic, difficult to maintain views.}
+  spec.summary       = %q{Rafters lets you think about each page of your application as a collection of small pieces instead of monolithic, difficult to maintain views.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "debugger", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.1"
+  spec.add_development_dependency "rspec-rails", "~> 2.14"
+
+  spec.add_dependency "rails", "~> 4.0.0"
+  spec.add_dependency "hashie", "~> 2.0.5"
+end