perspectives 0.0.1

data/lib/perspectives/controller_additions.rb

@@ -0,0 +1,142 @@
+module Perspectives
+  module ControllerAdditions
+    def self.included(base)
+      base.before_filter :set_perspectives_version
+      base.helper_method :assets_meta_tag
+      base.class_attribute :perspectives_enabled_actions
+      delegate :perspectives_enabled_actions, to: 'self.class'
+      base.helper_method :perspective
+
+      base.class_attribute :perspectives_wrapping
+      base.perspectives_wrapping = []
+
+      base.extend(ClassMethods)
+
+      delegate 'resolve_perspective_class_name', to: 'self.class'
+    end
+
+    private
+
+    unless defined?(ActionController::Responder)
+      def respond_to(*mimes, &block)
+        return super if block_given? || mimes.many? || !mimes.first.is_a?(Perspectives::Base)
+
+        perspectives_object = mimes.first
+        perspectives_object = wrap_perspective(perspectives_object) if wrap_perspective?
+
+        super() do |format|
+          format.html { render text: perspectives_object.to_html, layout: :default }
+          format.json { render json: perspectives_object }
+        end
+      end
+    end
+
+    def perspective(name, params_or_options = {})
+      if params_or_options.key?(:context) || params_or_options.key?(:params)
+        params = params_or_options.fetch(:params, {})
+        context = params_or_options.fetch(:context, default_context)
+      else
+        context = default_context
+        params = params_or_options
+      end
+
+      resolve_perspective_class_name(name).new(context, params)
+    end
+
+    def respond_with(*resources, &block)
+      return super unless wrap_perspective? && resources.first.is_a?(Perspectives::Base)
+
+      wrapped = wrap_perspective(resources.shift)
+
+      super(*resources.unshift(wrapped), &block)
+    end
+
+    def default_context
+      {}
+    end
+
+    def assets_version
+      Rails.application.assets.index.each_file.to_a.map { |f| File.new(f).mtime }.max.to_i
+    end
+
+    def assets_meta_tag
+      view_context.content_tag(:meta, nil, :'http-equiv' => 'x-perspectives-version', content: assets_version)
+    end
+
+    def set_perspectives_version
+      response.headers['X-Perspectives-Version'] = assets_version.to_s
+    end
+
+    def perspectives_enabled_action?
+      action_enabled_by?(perspectives_enabled_actions)
+    end
+
+    def perspectives_wrapper
+      return unless perspectives_enabled_action? && (request.headers['X-Perspectives-Full-Page'].to_s == 'true' || !request.xhr?)
+
+      perspectives_wrapping.find do |_, options|
+        next unless action_enabled_by?(options)
+
+        if options[:unless].present?
+          !options[:unless].call(self)
+        elsif options[:if].present?
+          options[:if].call(self)
+        else
+          true
+        end
+      end
+    end
+    alias_method :wrap_perspective?, :perspectives_wrapper
+
+    def wrap_perspective(unwrapped_perspective)
+      perspective_klass, options = *perspectives_wrapper
+      perspective_klass.new(unwrapped_perspective.context, options[:args].call(self, unwrapped_perspective))
+    end
+
+    def action_enabled_by?(options)
+      return false if options.nil?
+
+      action = action_name.to_s
+
+      if options[:except]
+        !options[:except].include?(action)
+      elsif options[:only]
+        options[:only].include?(action)
+      else
+        true
+      end
+    end
+
+    module ClassMethods
+      def perspectives_actions(options = {})
+        self.perspectives_enabled_actions = options.slice(:only, :except).each_with_object({}) do |(k, v), h|
+          h[k] = Array(v).map(&:to_s)
+        end
+
+        respond_to :html, :json, options
+        self.responder = Perspectives::Responder
+      end
+
+      def wrapped_with(perspective, options = {})
+        perspective_klass = resolve_perspective_class_name(perspective)
+
+        options[:only] = Array(options[:only]).map(&:to_s) if options[:only]
+        options[:except] = Array(options[:except]).map(&:to_s) if options[:except]
+
+        options[:if] ||= lambda { |c| c.params[perspective_klass.id_param].present? }
+        options[:args] ||= lambda do |controller, perspective|
+          {
+            perspective_klass.active_record_klass.name.underscore => perspective_klass.active_record_klass.find(controller.params[perspective_klass.id_param]),
+            options.fetch(:as, controller_name.underscore.singularize) => perspective
+          }
+        end
+
+        self.perspectives_wrapping += [[perspective_klass, options]]
+      end
+
+      def resolve_perspective_class_name(name)
+        Perspectives.resolve_partial_class_name(controller_name.camelize, name)
+      end
+    end
+  end
+end

data/lib/perspectives/forms/base.rb

@@ -0,0 +1,5 @@
+class Perspectives::Forms::Base < Perspectives::Base
+  def self.template_path
+    File.expand_path('../../../../vendor/assets/javascripts', __FILE__)
+  end
+end

data/lib/perspectives/forms/text_field.rb

@@ -0,0 +1,15 @@
+module Perspectives::Forms
+  class TextField < Base
+    param :object, :field
+
+    property(:param_key) { object.class.model_name.param_key }
+    property(:human_name) { object.class.name.humanize }
+    property(:field_id) { "#{param_key}_#{field}" }
+    property(:field_param) do
+      "#{param_key}[#{field.sub(/\?$/, '')}]"
+    end
+
+    property(:name) { object.class.human_attribute_name(field) }
+    property(:value) { object.__send__(field) }
+  end
+end

data/lib/perspectives/forms.rb

@@ -0,0 +1,7 @@
+module Perspectives
+  module Forms
+  end
+end
+
+require 'perspectives/forms/base'
+require 'perspectives/forms/text_field'

data/lib/perspectives/memoization.rb

@@ -0,0 +1,30 @@
+module Perspectives
+  module Memoization
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def property(name, *names, &block)
+        super.tap { memoize_property(name) if names.empty? }
+      end
+
+      def memoize_property(prop_name)
+        raise ArgumentError, "No method #{prop_name}" unless method_defined?(prop_name)
+
+        original_property_method = "_unmemoized_#{prop_name}"
+        raise ArgumentError, "Already memoized property #{prop_name.inspect}" if method_defined?(original_property_method)
+
+        ivar = "@_memoized_#{prop_name.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')}"
+        alias_method original_property_method, prop_name
+
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{prop_name}                              # def name
+            return #{ivar} if defined?(#{ivar})         # return @_memoized_name if defined?(@_memoized_name)
+            #{ivar} = #{original_property_method}      # @_memoized_name = _unmemoized_name
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/perspectives/mustache_compiler.rb

@@ -0,0 +1,33 @@
+# somewhat ganked from https://github.com/railsware/smt_rails/blob/7d63a3d5c838881690d365f41f45b9082c2611c8/lib/smt_rails/tilt.rb
+
+require 'tilt'
+
+module Perspectives
+  class MustacheCompiler < Tilt::Template
+    self.default_mime_type = 'application/javascript'
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      namespace = "this.#{Perspectives.template_namespace}"
+
+      <<-MustacheTemplate
+        (function() {
+        #{namespace} || (#{namespace} = {});
+        #{namespace}.views || (#{namespace}.views = {})
+
+        var data = #{data.inspect}
+
+        Mustache.parse(data)
+
+        #{namespace}.views[#{scope.logical_path.inspect}] = function(object) {
+          if (!object){ object = {}; }
+          return Mustache.render(data, object)
+        };
+
+        }).call(this);
+      MustacheTemplate
+    end
+  end
+end

data/lib/perspectives/params.rb

@@ -0,0 +1,48 @@
+module Perspectives
+  module Params
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+
+        class_attribute :_required_params, :_optional_params
+        self._required_params = []
+        self._optional_params = []
+        attr_reader :_params, :context
+      end
+    end
+
+    def initialize(context = {}, params = {})
+      raise ArgumentError, "Params is not a hash!" unless params.is_a?(Hash)
+      @_params = params.symbolize_keys
+      @context = context
+      assert_valid_params!
+    end
+
+    private
+
+    def assert_valid_params!
+      missing = _required_params.select { |l| !_params.key?(l) }
+      unknown = _params.keys - (_required_params + _optional_params)
+
+      if missing.any?
+        raise ArgumentError, "Missing #{missing.join(', ').inspect} while initializing #{self.class}!"
+      elsif unknown.any?
+        raise ArgumentError, "Unrecognized params #{unknown.join(', ').inspect} while initializing #{self.class}!"
+      end
+    end
+
+    module ClassMethods
+      def param(*param_names)
+        options = param_names.extract_options!
+
+        if options[:allow_nil]
+          self._optional_params += param_names
+        else
+          self._required_params += param_names
+        end
+
+        param_names.each { |n| define_method(n) { _params[n] } }
+      end
+    end
+  end
+end

data/lib/perspectives/properties.rb

@@ -0,0 +1,130 @@
+module Perspectives
+  module Properties
+    CantUseLambdas = Class.new(StandardError)
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        class_attribute :_properties, :_nested_perspectives
+
+        self._properties = []
+        self._nested_perspectives = []
+      end
+    end
+
+    private
+
+    def _property_map
+      _properties.each_with_object({}) do |p, h|
+        h[p] = __send__(p)
+
+        if h[p].is_a?(Proc)
+          raise CantUseLambdas, "You cannot use the lambda mustache behavior if you want to render on the client...it's not portable!"
+        end
+      end
+    end
+
+    def _resolve_partial_class_name(name)
+      Perspectives.resolve_partial_class_name(self.class.to_s.split('::').first, name)
+    end
+
+    module ClassMethods
+      def property(name, *names, &block)
+        unless names.empty?
+          raise ArgumentError, "Can't define multiple properties and pass a block" if block_given?
+          return names.push(name).each(&public_method(:property))
+        end
+
+        self._properties += [name]
+
+        unless method_defined?(name)
+          raise ArgumentError, "No method #{name} and no block given" unless block_given?
+
+          define_method(name, &block)
+        end
+      end
+
+      def nested(name, args = {}, &block)
+        locals, options = args, {}
+
+        if args[:locals]
+          locals = args[:locals]
+          options = args.except(:locals)
+        end
+
+        _setup_nested(name, locals, options, &block)
+      end
+
+      def nested_collection(name, *args, &block)
+        options = args.extract_options!
+        collection = options.fetch(:collection, args.first)
+        raise ArgumentError, "You must either pass in a collection, or pass a collection option" unless collection
+
+        _setup_nested(name, options.fetch(:locals, {}), options.merge!(:collection => collection), &block)
+      end
+
+      def delegate_property(*props)
+        delegate *props
+        opts = props.pop
+
+        prop_names = props
+
+        if opts[:prefix]
+          prefix = opts[:prefix] == true ? opts[:to] : opts[:prefix]
+          prop_names = prop_names.map { |n| "#{prefix}_#{n}" }
+        end
+
+        prop_names.each(&public_method(:property))
+      end
+
+      private
+
+      def _setup_nested(name, locals, options, &block)
+        name_str, name_sym = name.to_s, name.to_sym
+
+        prop_name = options.fetch(:property, _default_property_name(name_str, options)).to_sym
+
+        unless block_given? || method_defined?(prop_name)
+          local_procs = locals.each_with_object({}) { |(k, v), h| h[k.to_sym] = v.respond_to?(:to_proc) ? v.to_proc : proc { v } }
+          nested_klass_ivar = :"@_#{name_str.underscore.gsub('/', '__')}_klass"
+
+          define_method(prop_name) do
+            klass =
+              if self.class.instance_variable_defined?(nested_klass_ivar)
+                self.class.instance_variable_get(nested_klass_ivar)
+              else
+                self.class.instance_variable_set(nested_klass_ivar, _resolve_partial_class_name(name))
+              end
+
+            if options[:unless]
+              return if instance_exec(self, &options[:unless])
+            elsif options[:if]
+              return unless instance_exec(self, &options[:if])
+            end
+
+            realized_locals = local_procs.each_with_object({}) { |(k, v), h| h[k] = instance_exec(self, &v) }
+
+            if options.key?(:collection)
+              collection = instance_exec(self, &options[:collection])
+              return unless collection.present?
+
+              as = options.fetch(:as, collection.first.class.base_class.name.downcase).to_sym
+              Collection.new(collection.map { |o| klass.new(context, realized_locals.merge(as => o)) })
+            else
+              klass.new(context, realized_locals)
+            end
+          end
+        end
+
+        property(prop_name, &block)
+        self._nested_perspectives += [prop_name]
+      end
+
+      def _default_property_name(name_str, options)
+        name = name_str.split('/').last
+        name = name.pluralize if options.key?(:collection)
+        name
+      end
+    end
+  end
+end

data/lib/perspectives/railtie.rb

@@ -0,0 +1,42 @@
+require 'perspectives/controller_additions'
+require 'perspectives/responder'
+require 'perspectives/active_record'
+require 'generators/perspectives/install.rb'
+require 'generators/perspectives/scaffold/scaffold_generator.rb'
+
+module Perspectives
+  class Railtie < Rails::Railtie
+    if ::Rails.version.to_s >= "3.1"
+      config.app_generators.template_engine :perspectives
+      config.app_generators.templates << File.expand_path('../../generators/perspectives/templates', __FILE__)
+    else
+      config.generators.template_engine :perspectives
+      config.generators.templates << File.expand_path('../../generators/perspectives/templates', __FILE__)
+    end
+
+    initializer 'perspectives.railtie' do |app|
+      app.config.autoload_paths += ['app/perspectives']
+      app.config.watchable_dirs['app/mustaches'] = [:mustache]
+
+      app.config.assets.paths << File.expand_path('../../../vendor/assets/javascripts', __FILE__)
+
+      Perspectives::Base.class_eval do
+        include ActionView::Helpers
+        include app.routes.url_helpers
+        include ERB::Util
+        include Perspectives::ActiveRecord
+      end
+
+      Perspectives.configure do |c|
+        c.template_path = app.root.join('app', 'mustaches')
+      end
+
+      app.assets.register_engine '.mustache', Perspectives::MustacheCompiler
+      app.config.assets.paths << Perspectives.template_path
+
+      # TODO: probably bail if we're not in rails3/sprockets land...
+      # TODO: probably cache asset version in prod?
+      ActionController::Base.send(:include, Perspectives::ControllerAdditions)
+    end
+  end
+end

data/lib/perspectives/rendering.rb

@@ -0,0 +1,15 @@
+module Perspectives
+  module Rendering
+    def as_json(options = {})
+      _property_map.merge(_template_key: _template_key)
+    end
+
+    def render_html
+      _mustache.render(_property_map).html_safe
+    end
+
+    def render; render_html; end
+    def to_html; render_html; end
+    def to_s; render_html; end
+  end
+end

data/lib/perspectives/responder.rb

@@ -0,0 +1,15 @@
+module Perspectives
+  class Responder < ActionController::Responder
+    def to_html
+      return super unless controller.__send__(:perspectives_enabled_action?)
+
+      render text: resource.to_html, layout: :default
+    end
+
+    def to_json
+      return super unless controller.__send__(:perspectives_enabled_action?)
+
+      render json: resource
+    end
+  end
+end

data/lib/perspectives/templating.rb

@@ -0,0 +1,39 @@
+module Perspectives
+  module Templating
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+
+        delegate :_mustache, :_template_key, to: 'self.class'
+      end
+    end
+
+    module ClassMethods
+      def raise_on_context_miss?
+        Perspectives.raise_on_context_miss?
+      end
+
+      def template_path
+        Perspectives.template_path
+      end
+
+      def _mustache
+        return @_mustache if defined?(@_mustache)
+
+        klass = self
+        @_mustache = Class.new(Mustache) do
+          self.template_name = klass.to_s.underscore
+          self.raise_on_context_miss = klass.raise_on_context_miss?
+          self.template_path = klass.template_path
+        end
+      end
+
+      def _template_key
+        @_template_key ||=
+          _mustache.template_file.
+            sub(/^#{Regexp.escape(_mustache.template_path)}\//, '').
+            chomp(".#{_mustache.template_extension}")
+      end
+    end
+  end
+end

data/lib/perspectives/version.rb

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

data/lib/perspectives.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+require 'mustache'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/class/attribute'
+require 'perspectives/collection'
+require 'perspectives/base'
+require 'perspectives/forms'
+require 'perspectives/configuration'
+require 'perspectives/mustache_compiler'
+require 'perspectives/railtie' if defined?(Rails) # TODO: older rails support!
+
+module Perspectives
+  class << self
+    def template_namespace
+      'Perspectives'
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    delegate :cache, :caching?, :template_path, :raise_on_context_miss?, to: :configuration
+    delegate :expand_cache_key, to: 'ActiveSupport::Cache'
+
+    def resolve_partial_class_name(top_level_view_namespace, name)
+      return name if name.is_a?(Class) && name < Perspectives::Base
+
+      camelized = name.to_s.camelize
+
+      [top_level_view_namespace, camelized].join('::').constantize
+    rescue NameError
+      camelized.constantize
+    end
+
+    private
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+
+  configure do |c|
+    c.raise_on_context_miss = true
+  end
+end

data/lib/rails/projections.json

@@ -0,0 +1,12 @@
+{
+  "config/projections.json": {"command": "projections"},
+  "config/application.rb": {"command": "application"},
+  "app/perspectives/*.rb": {
+    "command": "perspective",
+    "alternate": "app/mustaches/%s.mustache"
+  },
+  "app/mustaches/*.mustache": {
+    "command": "mview",
+    "alternate": "app/perspectives/%s.rb"
+  }
+}

data/lib/tasks/perspectives_tasks.rake

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

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end