intermodal 0.0.1 → 0.4.0

data/lib/intermodal/concerns/models/has_parent_resource.rb

@@ -0,0 +1,45 @@
+module Intermodal
+  module Models
+    module HasParentResource
+      extend ActiveSupport::Concern
+
+      included do
+        include Intermodal::Models::Presentation
+      end
+
+      module ClassMethods
+        include Models::Accountability::Get
+
+        def parent_resource(resource, options = {})
+          parent_resource_scope = "by_#{resource}_id"
+          parent_table_name = options[:parent_table_name] || resource.to_s.pluralize
+
+          instance_eval do
+            if options[:class_name]
+              belongs_to resource, :class_name => options[:class_name]
+            else
+              belongs_to resource
+            end
+
+            validates_presence_of resource
+
+            scope parent_resource_scope, lambda { |id| where("#{resource}_id" => id) }
+            scope "by_#{resource}", lambda { |parent| send(parent_resource_scope, parent.id) }
+            scope "by_parent_id", lambda { |id| send(parent_resource_scope, id) }
+            scope :by_parent, lambda { |parent| by_parent_id(parent.id) }
+
+            scope :by_account_id, lambda { |a_id| joins(resource).where( parent_table_name => { :account_id => a_id } ) }
+            scope :by_account, lambda { |a| by_account_id(a.id) }
+          end
+        end
+
+        def build_get_query(_query, opts)
+          _query = super(_query, opts)
+          _query = _query.by_parent(opts[:parent]) if opts[:parent]
+          _query = _query.by_parent_id(opts[:parent_id]) if opts[:parent_id]
+          return _query
+        end
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/models/presentation.rb

@@ -0,0 +1,25 @@
+module Intermodal
+  module Models
+    module Presentation
+      extend ActiveSupport::Concern
+
+      def as_json(opts = {})
+        return presentation(opts) if opts && (opts[:presenter] || opts[:api])
+        super(opts)
+      end
+
+      def to_xml(opts = {})
+        return presentation(opts.except(:root)).to_xml(opts) if opts && (opts[:presenter] || opts[:api])
+        super(opts)
+      end
+
+      def presenter(opts)
+        opts[:presenter] || opts[:api].presenter_for(self.class)
+      end
+
+      def presentation(opts)
+        presenter(opts).call(self, opts)
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/models/redis_access_token.rb

@@ -0,0 +1,60 @@
+module Intermodal
+  module Models
+    module RedisAccessToken
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :account_id, :token
+        cattr_accessor :redis
+
+        EXPIRATION_PERIOD = 24 unless defined?(EXPIRATION_PERIOD)# hours
+        TOKEN_SIZE = 32        unless defined?(TOKEN_SIZE)
+        REDIS = Redis.new      unless defined?(REDIS)
+
+        def self.establish_connection!(address = 'localhost:6379')
+          host, port = address.split(':')
+
+          host ||= 'localhost'
+          port = (port || 6379).to_i
+
+          self.redis = Redis.new(:host => host, :port => port)
+        end
+
+        def self.authenticate!(token)
+          return nil unless account_id = self.redis.get("auth:#{token.to_s}")
+          ::Account.where(:id => account_id).first
+        end
+
+        def self.generate!(account)
+          token = new(:account_id => account.id)
+          begin
+            token.token = SecureRandom.hex(TOKEN_SIZE)
+          end until token.valid?
+          return token if token.save
+        end
+
+        def self.count
+          redis.keys('auth:*').size
+        end
+
+        def initialize(opts)
+          @account_id = opts[:account_id]
+        end
+
+        def redis_key
+          "auth:#{self.token.to_s}"
+        end
+
+        def valid?
+          !redis.get(redis_key)
+        end
+
+        def save
+          redis.setex(redis_key, EXPIRATION_PERIOD.hours, account_id)
+        end
+
+        def to_s; self.token; end
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/models/resource_linking.rb

@@ -0,0 +1,126 @@
+module Intermodal
+  module Models
+    module ResourceLinking
+      extend ActiveSupport::Concern
+
+      included do
+        include Intermodal::Models::HasParentResource
+        extend ClassMethods
+      end
+
+      module ClassMethods
+        include HasParentResource::ClassMethods
+
+        def links_resource(_parent, options = {})
+          raise "Must supply :to" unless options[:to]
+
+          _target_resource = options[:to]
+          _target_resource_class_name = options[:class_name]
+          _target_table_name = options[:target_table_name] || _target_resource.to_s.pluralize
+          _parent_resource_class_name = options[:parent_class_name]
+          _parent_table_name = options[:parent_table_name] || _parent.to_s.pluralize
+
+          instance_eval do
+            parent_resource(_parent, :class_name => _parent_resource_class_name)
+
+            # Associations
+            if _target_resource_class_name
+              belongs_to _target_resource, :class_name => _target_resource_class_name
+            else
+              belongs_to _target_resource
+            end
+
+            # Scopes
+            scope "by_#{_target_resource}_id", lambda { |_id| where("#{target_resource_name}_id" => _id) }
+            scope :by_target_id, lambda { |_id| send("by_#{target_resource_name}_id", _id) }
+            #scope :by_target_account_id, lambda { |a_id| 
+            #    joins(_target_resource).
+            #    where(_target_table_name => { :account_id => a_id })}
+            #scope :by_target_account, lambda { |a| by_target_account_id(a.id) }
+            #scope :_by_target_account_id, lambda { |a_id| where(_target_table_name => { :account_id => a_id})}
+
+            # Transformations
+            def self.to_target_ids
+              select("#{target_resource_name}_id").map(&"#{target_resource_name}_id".to_sym)
+            end
+
+            # Links parent resource and target resource
+            class_attribute :target_resource_name, :target_resource_class_name, :parent_resource_name, :parent_resource_class_name
+
+            def self.parent_model
+              (parent_resource_class_name || parent_resource_name.to_s.camelize).constantize
+            end
+
+            def self.target_model
+              (target_resource_class_name || target_resource_name.to_s.camelize).constantize
+            end
+
+            singleton_class.instance_eval do
+              define_method "to_#{_target_resource}_ids" do
+                to_target_ids
+              end
+            end
+          end
+
+          # Set class inheritable variables
+          self.target_resource_name = _target_resource
+          self.target_resource_class_name = _target_resource_class_name
+          self.parent_resource_name = _parent
+          self.parent_resource_class_name = _parent_resource_class_name
+        end
+
+        def build_get_query(_query, opts)
+          _query = super(_query, opts)
+          #_query.build_arel
+          #_query = _query.by_target_account(opts[:account]) if opts[:account]
+          #_query = _query.by_target_account_id(opts[:account_id]) if opts[:account_id]
+          # HACK:
+          # Workaround for Arel bug
+          #_query = _query._by_target_account_id(opts[:account_id]) if opts[:account_id]
+          return _query
+        end
+
+        # Standard Methods for all linking resources
+
+        # .replace
+        #  - replaces existing resources with new resource ids
+        #  - existing resources gets deleted
+        def replace(parent_id, resource_ids, options = {})
+          transaction do
+            parent = parent_model.get(parent_id, options.except(:parent, :parent_id))
+            return nil unless parent
+
+            targets = target_model.get(:all, options).where(:id => resource_ids)
+            parent.send("#{target_resource_name.to_s.pluralize}=", targets)
+            by_parent_id(parent_id).to_target_ids
+          end
+        end
+
+        # .append
+        #  - adds new resources into the list
+        #  - does not add redundent resources
+        def append(parent_id, resource_ids, options = {})
+          transaction do
+            parent = parent_model.get(parent_id, options.except(:parent, :parent_id))
+            return nil unless parent
+
+            resource_ids = resource_ids - by_parent_id(parent_id).by_target_id(resource_ids).to_target_ids
+            parent.send("#{target_resource_name.to_s.pluralize}") << target_model.get(:all, options).where(:id => resource_ids)
+          end
+        end
+
+        # .remove
+        #  - removes specified lists
+        def remove(parent_id, resource_ids, options = {})
+          transaction do
+            parent = parent_model.get(parent_id, options.except(:parent, :parent_id))
+            return nil unless parent
+
+            by_parent_id(parent_id).by_target_id(resource_ids).delete_all
+            by_parent_id(parent_id).to_target_ids
+          end
+        end
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/models/sanitize_html.rb

@@ -0,0 +1,35 @@
+require 'rails-html-sanitizer'
+
+module Intermodal
+  module Models
+    module SanitizeHTML
+      extend ActiveSupport::Concern
+
+      included do
+        # Whitelist sanitizer
+        # sanitize_html :description
+        # sanitize_html :description, tags: %w(table tr td), attributes: %w(id class style)
+        def self.sanitize_html(field, options={})
+          before_save do
+            # Only sanitize if there is something to sanitize
+            if self.send(field) and self.send("#{field}_changed?")
+              self.send("#{field}=", Rails::Html::WhiteListSanitizer.new.sanitize(self.send(field), options))
+            end
+          end
+        end
+
+        # Completely strips out all HTML tags
+        # strip_html :title
+        def self.strip_html(field)
+          before_save do
+            # Only strip if there is something to sanitize
+            if self.send(field) and self.send("#{field}_changed?")
+              self.send("#{field}=", Rails::Html::FullSanitizer.new.sanitize(self.send(field)))
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/presenters/named_resource.rb

@@ -0,0 +1,12 @@
+module Intermodal
+  module Presenters
+    module NamedResource
+      extend ActiveSupport::Concern
+
+      included do
+        include Intermodal::Presenters::Resource
+        presents :name
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/presenters/resource.rb

@@ -0,0 +1,14 @@
+module Intermodal
+  module Presenters
+    module Resource
+      extend ActiveSupport::Concern
+
+      included do
+        presents :id
+
+        presents :created_at
+        presents :updated_at
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/rails/rails_3_stack.rb

@@ -0,0 +1,42 @@
+require 'intermodal/rack/rescue'
+
+module Intermodal
+  module Concerns
+    module Rails
+      module Rails3Stack
+        extend ActiveSupport::Concern
+        # Override the middleware stack to something more streamlined
+
+        included do
+          def default_middleware_stack
+            ActionDispatch::MiddlewareStack.new.tap do |middleware|
+              #middleware.use ::Rack::Lock unless config.allow_concurrency
+              middleware.use ::Rack::Runtime
+              middleware.use ::Intermodal::Rack::Rescue
+              middleware.use ::Rails::Rack::Logger
+              middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
+              middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
+              middleware.use ::ActionDispatch::Callbacks #, !config.cache_classes
+
+              if config.session_store
+                middleware.use config.session_store, config.session_options
+                middleware.use ::ActionDispatch::Flash
+              end
+
+              middleware.use ::ActionDispatch::ParamsParser
+              middleware.use ::Rack::MethodOverride
+              middleware.use ::ActionDispatch::Head
+            end
+          end
+
+          # Query caching doesn't work well with what we are doing
+          # Maybe this has changed since Rails 4.
+          initializer 'intermodal_example.hack_active_record', :after => 'eager_load!' do
+            config.middleware.delete ActiveRecord::QueryCache
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/rails/rails_4_stack.rb

@@ -0,0 +1,17 @@
+module Intermodal
+  module Concerns
+    module Rails
+      module Rails4Stack
+        extend ActiveSupport::Concern
+
+        # Delete extraneous middleware
+
+        included do
+          config.middleware.delete 'ActiveRecord::QueryCache'
+          config.middleware.delete 'ActionDispatch::Cookies'
+          config.middleware.delete 'ActionDispatch::Session::CookieStore'
+        end
+      end
+    end
+  end
+end

data/lib/intermodal/concerns/rails/use_warden.rb

@@ -0,0 +1,21 @@
+require 'intermodal/rack/auth'
+
+# Use this to configure Warden to use X_AUTH_TOKEN strategy
+module Intermodal
+  module Concerns
+    module Rails
+      module UseWarden
+        extend ActiveSupport::Concern
+
+        included do
+          config.middleware.use Warden::Manager do |manager|
+            manager.default_strategies :x_auth_token #, :basic
+            manager.failure_app = proc do
+              Intermodal::Rack::Auth::UNAUTHORIZED
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/intermodal/config.rb

@@ -0,0 +1,15 @@
+module Intermodal
+  @max_per_page = 100
+  @default_per_page = 10
+
+  #TODO: Refactor to create a config DSL for modules
+  def self.max_per_page(value = nil)
+    return @max_per_page unless value
+    @max_per_page = value
+  end
+
+  def self.default_per_page(value = nil)
+    return @default_per_page unless value
+    @default_per_page = value
+  end
+end

data/lib/intermodal/configuration.rb

@@ -0,0 +1,11 @@
+module Intermodal
+  class Configuration < ::Rails::Engine::Configuration
+    attr_accessor :allow_concurrency
+
+    def initialize(*)
+      super
+      self.encoding = 'utf-8'
+      @allow_concurrency           = false
+    end
+  end
+end

data/lib/intermodal/controllers/api_controller.rb

@@ -0,0 +1,26 @@
+require 'responders'
+
+module Intermodal
+  class APIController < ActionController::Metal
+
+    include AbstractController::Rendering
+    include ActionController::Rendering
+    include ActionController::Renderers
+    include ActionController::RackDelegation
+    include ActionController::Head
+    include ActionController::MimeResponds
+
+    include ActionController::Instrumentation
+    include AbstractController::Callbacks
+    include ActionController::Rescue
+
+    include ActionController::RespondWith
+    include Intermodal::Controllers::Presentation
+
+    use_renderers :json, :xml
+
+    self.responder = Intermodal::ResourceResponder
+
+    ActiveSupport.run_load_hooks(:intermodal_api_controller, self)
+  end
+end