lightrail 0.0.1

data/bin/lightrail

@@ -0,0 +1 @@
+require "rails/cli"

data/lib/lightrail/action_controller.rb

@@ -0,0 +1,3 @@
+require 'action_controller'
+require 'active_support/concern'
+require 'lightrail/action_controller/metal'

data/lib/lightrail/action_controller/haltable.rb

@@ -0,0 +1,26 @@
+module Lightrail
+  module ActionController
+    module Haltable
+      def process_action(*)
+        opts = catch :halt do
+          return super
+        end
+
+        if opts
+          render opts
+        end
+      end
+
+      def halt(opts = nil)
+        throw :halt, opts
+      end
+    end
+  end
+end
+
+ActionController::Renderers.add :errors do |errors, opts|
+  json = { :errors => errors }.to_json(opts)
+  self.status         = 422 if status == 200
+  self.content_type ||= Mime::JSON
+  self.response_body  = json
+end

data/lib/lightrail/action_controller/metal.rb

@@ -0,0 +1,42 @@
+require 'lightrail/action_controller/haltable'
+require 'lightrail/action_controller/param'
+
+module Lightrail
+  module ActionController
+    # A configured ActionController::Metal that includes
+    # only the basic functionality.
+    class Metal < ::ActionController::Metal
+      abstract!
+
+      include ::ActionController::UrlFor
+      include ::ActionController::Head
+      include ::ActionController::Redirecting
+      include ::ActionController::Rendering
+      include ::ActionController::Renderers::All
+      include ::ActionController::ConditionalGet
+      include ::ActionController::RackDelegation
+      include ::ActionController::Caching
+      include ::ActionController::MimeResponds
+      include ::ActionController::ImplicitRender
+
+      include ::ActionController::ForceSSL if defined?(::ActionController::ForceSSL)
+      include ::ActionController::HttpAuthentication::Basic::ControllerMethods
+      include ::ActionController::HttpAuthentication::Digest::ControllerMethods
+      include ::ActionController::HttpAuthentication::Token::ControllerMethods
+
+      # Before callbacks should also be executed the earliest as possible, so
+      # also include them at the bottom.
+      include ::AbstractController::Callbacks
+
+      # The same with rescue, append it at the end to wrap as much as possible.
+      include ::ActionController::Rescue
+
+      # Add instrumentations hooks at the bottom, to ensure they instrument
+      # all the methods properly.
+      include ::ActionController::Instrumentation
+
+      include Haltable
+      include Param
+    end
+  end
+end

data/lib/lightrail/action_controller/param.rb

@@ -0,0 +1,12 @@
+module Lightrail
+  module ActionController
+    module Param
+      def param(key)
+        key.to_s.split('.').inject(params) do |param, key|
+          return unless param
+          param[key]
+        end
+      end
+    end
+  end
+end

data/lib/lightrail/core_ext/regexp.rb

@@ -0,0 +1,7 @@
+class Regexp
+  class << self
+    def email
+      /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i
+    end
+  end
+end

data/lib/lightrail/encryptor.rb

@@ -0,0 +1,62 @@
+require 'openssl'
+
+module Lightrail
+  class Encryptor
+    class InvalidMessage < StandardError; end
+    OpenSSLCipherError = OpenSSL::Cipher.const_defined?(:CipherError) ? OpenSSL::Cipher::CipherError : OpenSSL::CipherError
+
+    attr_accessor :addon_secret
+
+    def initialize(secret)
+      @addon_secret = secret
+    end
+
+    def encrypt(msg, initvec = nil)
+      msg       = msg.to_s
+      cipher    = new_cipher
+      initvec   = decode64(initvec) if initvec
+      initvec ||= cipher.random_iv
+
+      cipher.encrypt
+      cipher.key = decode64(addon_secret)
+      cipher.iv  = initvec
+
+      encrypted  = cipher.update(msg)
+      encrypted << cipher.final
+
+      [ encrypted, initvec ].
+        map { |bytes| encode64(bytes) }.
+        join("--")
+    end
+
+    def decrypt(encrypted_message)
+      cipher = new_cipher
+      encrypted_data, iv = encrypted_message.split("--").map { |v| decode64(v) }
+
+      cipher.decrypt
+      cipher.key = decode64(addon_secret)
+      cipher.iv  = iv
+
+      decrypted_data = cipher.update(encrypted_data)
+      decrypted_data << cipher.final
+
+      decrypted_data
+    rescue OpenSSLCipherError, TypeError
+      raise InvalidMessage
+    end
+
+    private
+
+    def decode64(s)
+      ActiveSupport::Base64.decode64(s)
+    end
+
+    def encode64(s)
+      ActiveSupport::Base64.encode64s(s)
+    end
+
+    def new_cipher
+      OpenSSL::Cipher::Cipher.new("AES-256-CBC")
+    end
+  end
+end

data/lib/lightrail/models/errors.rb

@@ -0,0 +1,21 @@
+require 'active_model/errors'
+
+module Lightrail
+  module Models
+    module Errors
+      def errors
+        @errors ||= Lightrail::Models::Errors::Errors.new(self)
+      end
+
+      class Errors < ::ActiveModel::Errors
+        # Only show one message per error key.
+        def as_json(options=nil)
+          hash   = ActiveSupport::OrderedHash.new
+          target = @messages || self
+          target.each_key { |k| hash[k] = target[k][0] }
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/lightrail/railtie.rb

@@ -0,0 +1,34 @@
+require "lightrail/action_controller"
+require "rails/railtie"
+
+module Lightrail
+  class Railtie < Rails::Railtie
+    class Wrapper
+      def initialize(config)
+        @config = config
+      end
+
+      def remove_session_middlewares!
+        @config.app_middleware.delete "ActionDispatch::Cookies"
+        @config.app_middleware.delete "ActionDispatch::Session::CookieStore"
+        @config.app_middleware.delete "ActionDispatch::Flash"
+      end
+
+      def remove_browser_middlewares!
+        @config.app_middleware.delete "ActionDispatch::BestStandardsSupport"
+      end
+    end
+
+    config.lightrail = Wrapper.new(config)
+
+    initializer "lightrail.action_controller.set_config" do |app|
+      Lightrail::ActionController::Metal.class_eval do
+        include app.routes.url_helpers
+        self.logger      ||= Rails.logger
+        self.cache_store ||= RAILS_CACHE
+        prepend_view_path "app/views"
+        app.config.action_controller.each { |k,v| send("#{k}=", v) rescue nil }
+      end
+    end
+  end
+end

data/lib/lightrail/version.rb

@@ -0,0 +1,3 @@
+module Lightrail
+  VERSION = '0.0.1'
+end

data/lib/lightrail/wrapper.rb

@@ -0,0 +1,65 @@
+module Lightrail
+  module Wrapper
+    class Result < Hash
+      attr_reader :associations
+
+      def initialize
+        super
+        @associations = Hash.new { |h,k| h[k] = [] }
+      end
+    end
+
+    class << self
+      # Receives an object and returns its wrapper.
+      def find(model)
+        klass = model.is_a?(Class) ? model : model.class
+        ActiveSupport::Dependencies.constantize("#{klass.name}Wrapper")
+      end
+
+      # Receives an object, find its wrapper and render it.
+      # If the object is an array, loop for each element in the
+      # array and call +render_many+ (instead of +render+).
+      def render(object, scope, options={}, result={})
+        result = Result.new.merge!(result)
+
+        if object.blank?
+          handle_blank(object, result, options)
+        elsif object.respond_to?(:each)
+          object.each { |i| Lightrail::Wrapper.find(i).new(i, scope).render_many(options, result) }
+        else
+          Lightrail::Wrapper.find(object).new(object, scope).render(options, result)
+        end
+
+        result.associations.inject(result) do |final, (key, value)|
+          value.uniq!
+          render_association(value, scope, { :as => key }, final)
+        end
+      end
+
+      def render_association(value, scope, options, result)
+        if value.empty?
+          handle_blank(value, result, options)
+          result
+        else
+          wrapper = Lightrail::Wrapper.find(value.first)
+          wrapper.around_association(value, scope) do
+            value.each { |i| wrapper.new(i, scope).render_many(options, result) }
+            result
+          end
+        end
+      end
+
+      private
+
+      def handle_blank(object, result, options)
+        name   = options[:as] || options[:fallback]
+        name ||= object ? "resources" : "resource"
+        result[name] = object
+      end
+    end
+  end
+end
+
+require "lightrail/wrapper/model"
+require "lightrail/wrapper/controller"
+require "lightrail/wrapper/active_record"

data/lib/lightrail/wrapper/active_record.rb

@@ -0,0 +1,15 @@
+module Lightrail
+  module Wrapper
+    module ActiveRecord
+      def slice(*attrs)
+        attrs.map! { |a| a.to_s }
+        attributes.slice(*attrs)
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include Lightrail::Wrapper::ActiveRecord
+end
+

data/lib/lightrail/wrapper/associations.rb

@@ -0,0 +1,49 @@
+module Lightrail
+  module Wrapper
+    module Associations
+      # +association+ returns the name of the association in the wrapped object.
+      # +key+ returns the JSON key  to store the +association+ id.
+      # +as+ is the name of the +association+ in the flat JSON.
+      # +includes+ is the name expected on the include.
+      class AssociationConfig
+        attr_reader :name, :as, :key, :includes
+
+        def initialize(name, options)
+          @name = name.to_sym
+        end
+
+        # Receives a view and update it accordingly with the given object id
+        # and the association cardinality.
+        def update(view, object)
+          raise NotImplementedError
+        end
+      end
+
+      class HasOneConfig < AssociationConfig
+        def initialize(name, options)
+          super
+          @as          = options[:as] || name.to_s.pluralize.to_sym
+          @key         = options[:key] || :"#{name}_id"
+          @includes    = options[:includes] || name.to_s.pluralize
+        end
+
+        def update(view, object)
+          view[@key] = object && object.id
+        end
+      end
+
+      class HasManyConfig < AssociationConfig
+        def initialize(name, options)
+          super
+          @as          = options[:as] || name.to_sym
+          @key         = options[:key] || name.to_sym
+          @includes    = options[:includes] || name.to_s
+        end
+
+        def update(view, object)
+          view[@key] = object.map(&:id)
+        end
+      end
+    end
+  end
+end

data/lib/lightrail/wrapper/controller.rb

@@ -0,0 +1,55 @@
+module Lightrail
+  module Wrapper
+    module Controller
+      extend ActiveSupport::Concern
+
+      private
+
+      # Receives an object and render it as JSON considering its respective wrapper.
+      def json(object, options={})
+        json = Lightrail::Wrapper.render(object, wrapper_scope,
+          :include => wrapper_includes, :fallback => controller_name, :as => options.delete(:as))
+        render options.merge(:json => json)
+      end
+
+      def errors(object)
+        render :errors => { object.class.model_name.underscore => object.errors }
+      end
+
+      # Receives a relation and add the appropriate includes and configuration.
+      # Useful when wrapping up arrays to avoid N+1 queries in the database.
+      def wrap_array(array)
+        array = array.to_a
+        return array if array.empty?
+
+        klass = array[0].class
+        valid = Lightrail::Wrapper.find(klass).valid_includes(wrapper_includes)
+        return array if valid.empty?
+
+        klass.send(:preload_associations, array, valid)
+        array
+      end
+
+      # Returns a wrapper around the given object.
+      def wrapper(object, scope=wrapper_scope)
+        Lightrail::Wrapper.find(object).new(object, scope)
+      end
+
+      # Returns given includes as a nested hash.
+      def wrapper_includes
+        @wrapper_includes ||= params[:include].to_s.split(",")
+      end
+
+      # Pass the relevant scope to the wrapper object.
+      def wrapper_scope
+        raise NotImplementedError, "wrapper_scope needs to be implemented according to your application"
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_controller) do
+  include Lightrail::Wrapper::Controller
+end
+
+Lightrail::ActionController::Metal.send :include, Lightrail::Wrapper::Controller

data/lib/lightrail/wrapper/model.rb

@@ -0,0 +1,114 @@
+require "lightrail/wrapper/associations"
+
+module Lightrail
+  module Wrapper
+    class Model
+      class_attribute :associations
+      self.associations = []
+
+      class << self
+        def inherited(base)
+          base.class_eval do
+            alias_method wrapped_class.model_name.underscore, :resource
+          end
+        end
+
+        def around_association(collection, scope)
+          yield
+        end
+
+        # Declares that this object is associated to the given association
+        # with cardinality 1..1.
+        def has_one(*associations)
+          options = associations.extract_options!
+          self.associations += associations.map { |a| Associations::HasOneConfig.new(a, options) }
+          define_association_methods(associations)
+        end
+
+        # Declares that this object is associated to the given association
+        # with cardinality 1..*.
+        def has_many(*associations)
+          options = associations.extract_options!
+          self.associations += associations.map { |a| Associations::HasManyConfig.new(a, options) }
+          define_association_methods(associations)
+        end
+
+        # Based on the declared associations and the given parameters,
+        # generate an includes clause that can be passed down to the relation
+        # object to avoid doing N+1 queries.
+        def valid_includes(includes)
+          result = []
+          includes.each do |i|
+            if association = associations.find { |a| a.includes == i }
+              result << association.name
+            end
+          end
+          result
+        end
+
+        # Returns the original class wrapped by this wrapper.
+        def wrapped_class
+          @wrapped_class ||= name.sub(/Wrapper$/, "").constantize
+        end
+
+        private
+
+        def define_association_methods(associations)
+          associations.each do |association|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{association}
+                @resource.#{association}
+              end
+            RUBY
+          end
+        end
+      end
+
+      attr_reader :resource, :scope
+
+      def initialize(resource, scope)
+        @resource = resource
+        @scope    = scope
+      end
+
+      def view
+        raise NotImplementedError, "No view implemented for #{self}"
+      end
+
+      # Gets the view and render the associated object.
+      def render(options={}, result=Result.new)
+        name         = options[:as] || wrapped_model_name.underscore
+        result[name] = view = self.view
+        _include_associations(result, view, options[:include])
+      end
+
+      # Gets the view and render the associated considering it is part of a collection.
+      def render_many(options={}, result=Result.new)
+        name     = options[:as] || wrapped_model_name.plural
+        view     = self.view
+        array    = (result[name] ||= []) << view
+        _include_associations(result, view, options[:include])
+      end
+
+      private
+
+      def _include_associations(result, view, includes)
+        return result if includes.blank?
+        associations = result.associations
+
+        self.class.associations.each do |config|
+          next unless includes.include?(config.includes)
+          object = send(config.name)
+          config.update(view, object)
+          associations[config.as].concat Array.wrap(object)
+        end
+
+        result
+      end
+
+      def wrapped_model_name
+        self.class.wrapped_class.model_name
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: lightrail
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Carl Lerche
+- José Valim
+- Tony Arcieri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: &70316991038220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70316991038220
+description: Lightrail slims Rails down to the bare essentials great JSON web services
+  crave
+email:
+- me@carllerche.com
+- jose.valim@gmail.com
+- tony.arcieri@gmail.com
+executables:
+- lightrail
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lightrail/action_controller/haltable.rb
+- lib/lightrail/action_controller/metal.rb
+- lib/lightrail/action_controller/param.rb
+- lib/lightrail/action_controller.rb
+- lib/lightrail/core_ext/regexp.rb
+- lib/lightrail/encryptor.rb
+- lib/lightrail/models/errors.rb
+- lib/lightrail/railtie.rb
+- lib/lightrail/version.rb
+- lib/lightrail/wrapper/active_record.rb
+- lib/lightrail/wrapper/associations.rb
+- lib/lightrail/wrapper/controller.rb
+- lib/lightrail/wrapper/model.rb
+- lib/lightrail/wrapper.rb
+- bin/lightrail
+homepage: http://github.com/tarcieri/lightrail
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Slim Rails stack for JSON services
+test_files: []
+has_rdoc: