cramp 0.11 → 0.12

data/lib/cramp/controller/rendering.rb

@@ -1,13 +0,0 @@
-module Cramp
-  module Controller
-    module Rendering
-
-      extend ActiveSupport::Concern
-
-      def render(body)
-        @body.call(body)
-      end
-
-    end
-  end
-end

data/lib/cramp/controller/test_case.rb

@@ -1,57 +0,0 @@
-require 'active_support'
-require 'active_support/test_case'
-
-module Cramp
-  module Controller
-    class TestCase < ::ActiveSupport::TestCase
-
-      setup :create_request
-
-      def create_request
-        @request = Rack::MockRequest.new(app)
-      end
-
-      def get(path, options = {}, headers = {}, &block)
-        callback = options.delete(:callback) || block
-        headers = headers.merge('async.callback' => callback)
-
-        EM.run { @request.get(path, headers) }
-      end
-
-      def get_body(path, options = {}, headers = {}, &block)
-        callback = options.delete(:callback) || block
-        response_callback = proc {|response| response[-1].each {|chunk| callback.call(chunk) } }
-        headers = headers.merge('async.callback' => response_callback)
-
-        EM.run { @request.get(path, headers) }
-      end
-
-      def get_body_chunks(path, options = {}, headers = {}, &block)
-        callback = options.delete(:callback) || block
-        count = options.delete(:count) || 1
-
-        stopping = false
-        chunks = []
-
-        get_body(path, options, headers) do |body_chunk|
-          chunks << body_chunk unless stopping
-
-          if chunks.count >= count
-            stopping = true
-            callback.call(chunks) if callback
-            EM.next_tick { EM.stop }
-          end
-        end
-      end
-
-      def app
-        raise "Please define a method called 'app' returning an async Rack Application"
-      end
-
-      def stop
-        EM.stop
-      end
-    end
-
-  end
-end

data/lib/cramp/controller/websocket.rb

@@ -1,63 +0,0 @@
-module Cramp
-  module Controller
-    module WebsocketExtension
-      WEBSOCKET_RECEIVE_CALLBACK = 'websocket.receive_callback'.freeze
-
-      def websocket?
-        @env['HTTP_CONNECTION'] == 'Upgrade' && @env['HTTP_UPGRADE'] == 'WebSocket'
-      end
-
-      def websocket_upgrade_data
-        location  = "ws://#{@env['HTTP_HOST']}#{@env['REQUEST_PATH']}"
-
-        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
-        upgrade << "Upgrade: WebSocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "WebSocket-Origin: #{@env['HTTP_ORIGIN']}\r\n"
-        upgrade << "WebSocket-Location: #{location}\r\n\r\n"
-
-        upgrade
-      end
-    end
-
-    class Websocket < Abstract
-      include PeriodicTimer
-
-      # TODO : Websockets shouldn't need this in an ideal world
-      include KeepConnectionAlive
-
-      class_inheritable_accessor :on_data_callbacks, :instance_reader => false
-      self.on_data_callbacks = []
-
-      class << self
-        def backend=(backend)
-          raise "Websocket backend #{backend} is unknown" unless [:thin, :rainbows].include?(backend.to_sym)
-          require "cramp/controller/websocket/#{backend}_backend.rb"
-        end
-
-        def on_data(*methods)
-          self.on_data_callbacks += methods
-        end
-      end
-
-      def process
-        @env['websocket.receive_callback'] = method(:_on_data_receive)
-        super
-      end
-
-      def render(body)
-        @body.call("\x00#{body}\xff")
-      end
-
-      def _on_data_receive(data)
-        data = data.split(/\000([^\377]*)\377/).select{|d| !d.empty? }.collect{|d| d.gsub(/^\x00|\xff$/, '') }
-        self.class.on_data_callbacks.each do |callback|
-          data.each do |message|
-            EM.next_tick { send(callback, message) }
-          end
-        end
-      end
-      
-    end
-  end
-end

data/lib/cramp/model.rb

@@ -1,40 +0,0 @@
-require 'cramp'
-require 'cramp/model/evented_mysql'
-require 'cramp/model/emysql_ext'
-
-require 'mysqlplus'
-
-require 'arel'
-require 'cramp/model/arel_monkey_patches'
-
-require 'active_model'
-
-module Cramp
-  module Model
-    autoload :Quoting, "cramp/model/quoting"
-    autoload :Engine, "cramp/model/engine"
-    autoload :Column, "cramp/model/column"
-    autoload :Relation, "cramp/model/relation"
-
-    autoload :Base, "cramp/model/base"
-    autoload :Finders, "cramp/model/finders"
-    autoload :Attribute, "cramp/model/attribute"
-    autoload :AttributeMethods, "cramp/model/attribute_methods"
-    autoload :Status, "cramp/model/status"
-    autoload :Callbacks, "cramp/model/callbacks"
-
-    def self.init(settings)
-      Arel::Table.engine = Cramp::Model::Engine.new(settings)
-    end
-
-    def self.select(query, callback = nil, &block)
-      callback ||= block
-
-      EventedMysql.select(query) do |rows|
-        callback.arity == 1 ? callback.call(rows) : callback.call if callback
-      end
-    end
-
-  end
-end
-

data/lib/cramp/model/arel_monkey_patches.rb

@@ -1,66 +0,0 @@
-class Arel::Session
-  def create(insert, &block)
-    insert.call(&block)
-  end
-
-  def read(select, &block)
-    select.call(&block)
-  end
-
-  def update(update, &block)
-    update.call(&block)
-  end
-
-  def delete(delete, &block)
-    delete.call(&block)
-  end
-
-end
-
-module Arel::Relation
-  def call(&block)
-    engine.read(self, &block)
-  end
-
-  def all(&block)
-    session.read(self) {|rows| block.call(rows) }
-  end
-
-  def first(&block)
-    session.read(self) {|rows| block.call(rows[0]) }
-  end
-
-  def each(&block)
-    session.read(self) {|rows| rows.each {|r| block.call(r) } }
-  end
-
-  def insert(record, &block)
-    session.create(Arel::Insert.new(self, record), &block)
-  end
-
-  def update(assignments, &block)
-    session.update(Arel::Update.new(self, assignments), &block)
-  end
-
-  def delete(&block)
-    session.delete(Arel::Deletion.new(self), &block)
-  end
-end
-
-class Arel::Deletion
-  def call(&block)
-    engine.delete(self, &block)
-  end
-end
-
-class Arel::Insert
-  def call(&block)
-    engine.create(self, &block)
-  end
-end
-
-class Arel::Update
-  def call(&block)
-    engine.update(self, &block)
-  end
-end

data/lib/cramp/model/attribute.rb

@@ -1,104 +0,0 @@
-# Copyright (c) 2009 Koziarski Software Ltd
-# 
-# Permission to use, copy, modify, and/or distribute this software for any
-# purpose with or without fee is hereby granted, provided that the above
-# copyright notice and this permission notice appear in all copies.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-module Cramp
-  module Model
-    class Attribute
-
-      FORMATS = {}
-      FORMATS[Date]    = /^\d{4}\/\d{2}\/\d{2}$/
-      FORMATS[Integer] = /^-?\d+$/
-      FORMATS[Float]   = /^-?\d*\.\d*$/
-      FORMATS[Time]    = /\A\s*
-                -?\d+-\d\d-\d\d
-                T
-                \d\d:\d\d:\d\d
-                (\.\d*)?
-                (Z|[+-]\d\d:\d\d)?
-                \s*\z/ix # lifted from the implementation of Time.xmlschema
-
-      CONVERTERS = {}
-      CONVERTERS[Date] = Proc.new do |str|
-        Date.strptime(str, "%Y/%m/%d")
-      end
-
-      CONVERTERS[Integer] = Proc.new do |str|
-        Integer(str)
-      end
-
-      CONVERTERS[Float] = Proc.new do |str|
-        Float(str)
-      end
-
-      CONVERTERS[Time] = Proc.new do |str|
-        Time.xmlschema(str)
-      end
-
-      attr_reader :name
-      def initialize(name, owner_class, options)
-        @name = name.to_s
-        @owner_class = owner_class
-        @options = options
-
-        # append_validations!
-        define_methods!
-      end
-
-      # I think this should live somewhere in Amo
-      def check_value!(value)
-        # Allow nil and Strings to fall back on the validations for typecasting
-        # Everything else gets checked with is_a?
-        if value.nil?
-          nil
-        elsif value.is_a?(String)
-          value
-        elsif value.is_a?(expected_type)
-          value
-        else
-          raise TypeError, "Expected #{expected_type.inspect} but got #{value.inspect}"
-        end
-      end
-
-      def expected_type
-        @options[:type] || String
-      end
-
-      def type_cast(value)
-        if value.is_a?(expected_type)
-          value
-        elsif (converter = CONVERTERS[expected_type]) && (value =~ FORMATS[expected_type])
-          converter.call(value)
-        else
-          value
-        end
-      end
-
-      def append_validations!
-        if f = FORMATS[expected_type]
-          @owner_class.validates_format_of @name, :with => f, :unless => lambda {|obj| obj.send(name).is_a? expected_type }, :allow_nil => @options[:allow_nil]
-        end
-      end
-
-      def define_methods!
-        @owner_class.define_attribute_methods(true)
-      end
-
-      def primary_key?
-        @options[:primary_key]
-      end
-
-    end
-
-  end
-end

data/lib/cramp/model/attribute_methods.rb

@@ -1,83 +0,0 @@
-# Copyright (c) 2009 Koziarski Software Ltd
-# 
-# Permission to use, copy, modify, and/or distribute this software for any
-# purpose with or without fee is hereby granted, provided that the above
-# copyright notice and this permission notice appear in all copies.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-module Cramp
-  module Model
-    module AttributeMethods
-
-      extend ActiveSupport::Concern
-      include ActiveModel::AttributeMethods
-
-      module ClassMethods
-        def attribute(name, options = {})
-          write_inheritable_hash(:model_attributes, {name => Attribute.new(name, self, options)})
-        end
-
-        def define_attribute_methods(force = false)
-          return unless model_attributes
-          undefine_attribute_methods if force
-          super(model_attributes.keys)
-        end
-      end
-  
-      included do
-        class_inheritable_hash :model_attributes
-        undef_method(:id) if method_defined?(:id)
-
-        attribute_method_suffix("", "=")
-      end
-  
-      def write_attribute(name, value)
-        if ma = self.class.model_attributes[name.to_sym]
-          value = ma.check_value!(value)
-        end
-        if(@attributes[name] != value)
-          send "#{name}_will_change!".to_sym
-          @attributes[name] = value
-        end
-      end
-
-      def read_attribute(name)
-        if ma = self.class.model_attributes[name]
-          ma.type_cast(@attributes[name])
-        else
-          @attributes[name]
-        end
-      end
-
-      def attributes=(attributes)
-        attributes.each do |(name, value)|
-          send("#{name}=", value)
-        end
-      end
-
-      protected
-
-      def attribute_method?(name)
-        @attributes.include?(name.to_sym) || model_attributes[name.to_sym]
-      end
-
-      private
-
-      def attribute(name)
-        read_attribute(name.to_sym)
-      end
-
-      def attribute=(name, value)
-        write_attribute(name.to_sym, value)
-      end
-
-    end
-  end
-end

data/lib/cramp/model/base.rb

@@ -1,119 +0,0 @@
-module Cramp
-  module Model
-    class Base
-
-      extend Finders
-      include AttributeMethods
-      include ActiveModel::Validations
-      include ActiveModel::Dirty
-      include Callbacks
-
-      class << self
-        def columns
-          @columns ||= arel_table.columns
-        end
-
-        def column_names
-          columns.map(&:name)
-        end
-
-        def primary_key
-          @primary_key ||= model_attributes.detect {|k, v| v.primary_key? }[0]
-        end
-
-        def instantiate(record)
-          object = allocate
-          object.instance_variable_set("@attributes", record.with_indifferent_access)
-          object
-        end
-      end
-
-      attr_reader :attributes
-
-      def initialize(attributes = {})
-        @new_record = true
-        @attributes = {}.with_indifferent_access
-        self.attributes = attributes
-      end
-
-      def new_record?
-        @new_record
-      end
-
-      def save(callback = nil, &block)
-        callback ||= block
-
-        if valid?
-          new_record? ? create_record(callback) : update_record(callback)
-        else
-          callback.arity == 1 ? callback.call(Status.new(self, false)) : callback.call if callback
-        end
-      end
-
-      def destroy(callback = nil, &block)
-        callback ||= block
-        
-        relation.delete do
-          status = Status.new(self, true)
-          after_destroy_callbacks status
-          callback.arity == 1 ? callback.call(status) : callback.call if callback
-        end
-      end
-
-      private
-
-      def create_record(callback = nil, &block)
-        callback ||= block
-
-        self.class.arel_table.insert(arel_attributes(true)) do |new_id|
-          if new_id.present?
-            self.id = new_id
-            saved = true
-            @new_record = false
-          else
-            saved = false
-          end
-
-          status = Status.new(self, saved)
-          after_save status
-          callback.arity == 1 ? callback.call(status) : callback.call if callback
-        end
-      end
-
-      def update_record(callback = nil, &block)
-        callback ||= block
-
-        relation.update(arel_attributes) do |updated_rows|
-          status = Status.new(self, true)
-          after_save status
-          callback.arity == 1 ? callback.call(status) : callback.call if callback
-        end
-      end
-
-      def relation
-        self.class.arel_table.where(self.class[self.class.primary_key].eq(send(self.class.primary_key)))
-      end
-
-      def after_save(status)
-        if status.success?
-          @previously_changed = changes
-          changed_attributes.clear
-        end
-        
-        after_save_callbacks status
-      end
-
-      def arel_attributes(exclude_primary_key = true, attribute_names = @attributes.keys)
-        attrs = {}
-
-        attribute_names.each do |name|
-          value = read_attribute(name)
-          attrs[self.class.arel_table[name]] = value
-        end
-
-        attrs
-      end
-
-    end
-  end
-end