merb-to-rails3 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+

data/README.markdown

@@ -0,0 +1,23 @@
+# merb-to-rails3
+
+## About
+
+**merb-to-rails3** is a gem which adds several methods from Merb's API to your Rails 3 app in order to ease updating existing Merb app to Rails.
+
+Things covered:
+
+Controller:
+
+ * redirect => redirect_to
+ * before => before_filter
+ * after => after_filter
+
+Controller/View:
+
+ * url(name) => name_path
+ * resource(...) => ....._path
+ * submit => submit_tag
+ * css_include_tag => stylesheet_link_tag
+ * js_include_tag => javascript_include_tag
+ * throw_content(name) => content_for(name)
+ * partial => render :partial

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name        = 'merb-to-rails3'
+    gem.summary     = 'Small library that will help you to port a Merb-based app to Rails3'
+    gem.email       = "tech@llp.pl"
+    gem.homepage    = "http://github.com/LunarLogicPolska/merb-to-rails3"
+    gem.authors     = ['Marcin Kulik', 'Piotr Solnica']
+
+    gem.has_rdoc    = false
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: sudo gem ' \
+       'install jeweler'
+end

data/TODO.markdown

@@ -0,0 +1,6 @@
+ * figure out why helper methods added during railtie initialization aren't visible later :)
+ * cover all controller methods
+ * cover all view helpers
+ * add spec matchers and various helper method proxies required in specs (ie "request" etc.)
+ * routes.rb generator (this should be fun!)
+ * rake task for renaming controllers (files + controller class names inside)

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:major: 0
+:minor: 1
+:patch: 0

data/lib/merb-to-rails3.rb

@@ -0,0 +1,21 @@
+dir = File.join(File.dirname(__FILE__), "merb-to-rails3")
+
+require "#{dir}/helpers"
+require "#{dir}/controller_exceptions"
+
+module MerbToRails3
+  class Railtie < Rails::Railtie
+    railtie_name :"merb-to-rails3"
+
+    initializer "merb-to-rails3.rails" do
+      class ::ActionController::Base
+        extend  MerbToRails3::Helpers::Controller
+        include MerbToRails3::ControllerExceptions
+      end
+
+      module ::ApplicationHelper
+        include MerbToRails3::Helpers::View
+      end
+    end
+  end
+end

data/lib/merb-to-rails3/controller_exceptions.rb

@@ -0,0 +1,246 @@
+class Exception
+  # Returns the action_name that will be invoked on your Exceptions controller when this
+  # exception is raised. Override this method to force a different action to be invoked.
+  #
+  # ==== Returns
+  # String:: The name of the action in the Exceptions controller which will get invoked
+  #   when this exception is raised during a request.
+  #
+  # :api: public
+  # @overridable
+  def action_name() self.class.action_name end
+
+
+  # ==== Returns
+  # Boolean:: Whether or not this exception is the same as another.
+  #
+  # :api: public
+  def same?(other)
+    self.class == other.class &&
+      self.message == other.message &&
+      self.backtrace == other.backtrace
+  end
+
+  # Returns the action_name that will be invoked on your Exceptions controller when an instance
+  # is raised during a request.
+  #
+  # ==== Returns
+  # String:: The name of the action in the Exceptions controller which will get invoked
+  #   when an instance of this Exception sub/class is raised by an action.
+  #
+  # :api: public
+  # @overridable
+  def self.action_name
+    name = self.to_s.split('::').last.underscore
+    ApplicationController.method_defined?(name) ? name : superclass.action_name
+  end
+
+  def self.status
+    500
+  end
+end
+
+module MerbToRails3
+  module ControllerExceptions
+
+    # Mapping of status code names to their numeric value.
+    STATUS_CODES = {}
+
+    class Base < StandardError #:doc:
+
+      # === Returns
+      # Integer:: The status-code of the error.
+      #
+      # @overridable
+      # :api: plugin
+      def status; self.class.status; end
+      alias :to_i :status
+
+      class << self
+
+        # Get the actual status-code for an Exception class.
+        #
+        # As usual, this can come from a constant upwards in
+        # the inheritance chain.
+        #
+        # ==== Returns
+        # Fixnum:: The status code of this exception.
+        #
+        # :api: public
+        def status
+          const_get(:STATUS) rescue 0
+        end
+        alias :to_i :status
+
+        # Set the actual status-code for an Exception class.
+        #
+        # If possible, set the STATUS constant, and update
+        # any previously registered (inherited) status-code.
+        #
+        # ==== Parameters
+        # num<~to_i>:: The status code
+        #
+        # ==== Returns
+        # (Integer, nil):: The status set on this exception, or nil if a status was already set.
+        #
+        # :api: private
+        def status=(num)
+          unless self.status?
+            register_status_code(self, num)
+            self.const_set(:STATUS, num.to_i)
+          end
+        end
+
+        # See if a status-code has been defined (on self explicitly).
+        #
+        # ==== Returns
+        # Boolean:: Whether a status code has been set
+        #
+        # :api: private
+        def status?
+          self.const_defined?(:STATUS)
+        end
+
+        # Registers any subclasses with status codes for easy lookup by
+        # set_status in Merb::Controller.
+        #
+        # Inheritance ensures this method gets inherited by any subclasses, so
+        # it goes all the way down the chain of inheritance.
+        #
+        # ==== Parameters
+        #
+        # subclass<ControllerExceptions::Base>::
+        #   The Exception class that is inheriting from ControllerExceptions::Base
+        #
+        # :api: public
+        def inherited(subclass)
+          # don't set the constant yet - any class methods will be called after self.inherited
+          # unless self.status = ... is set explicitly, the status code will be inherited
+          register_status_code(subclass, self.status) if self.status?
+        end
+
+        private
+
+        # Register the status-code for an Exception class.
+        #
+        # ==== Parameters
+        # num<~to_i>:: The status code
+        #
+        # :api: privaate
+        def register_status_code(klass, code)
+          name = self.to_s.split('::').last.underscore
+          STATUS_CODES[name.to_sym] = code.to_i
+        end
+
+      end
+    end
+
+    class Informational               < ControllerExceptions::Base; end
+
+    class Continue                    < ControllerExceptions::Informational; self.status = 100; end
+
+    class SwitchingProtocols          < ControllerExceptions::Informational; self.status = 101; end
+
+    class Successful                  < ControllerExceptions::Base; end
+
+    class OK                          < ControllerExceptions::Successful; self.status = 200; end
+
+    class Created                     < ControllerExceptions::Successful; self.status = 201; end
+
+    class Accepted                    < ControllerExceptions::Successful; self.status = 202; end
+
+    class NonAuthoritativeInformation < ControllerExceptions::Successful; self.status = 203; end
+
+    class NoContent                   < ControllerExceptions::Successful; self.status = 204; end
+
+    class ResetContent                < ControllerExceptions::Successful; self.status = 205; end
+
+    class PartialContent              < ControllerExceptions::Successful; self.status = 206; end
+
+    class Redirection                   < ControllerExceptions::Base; end
+
+    class MultipleChoices             < ControllerExceptions::Redirection; self.status = 300; end
+
+    class MovedPermanently            < ControllerExceptions::Redirection; self.status = 301; end
+
+    class MovedTemporarily            < ControllerExceptions::Redirection; self.status = 302; end
+
+    class SeeOther                    < ControllerExceptions::Redirection; self.status = 303; end
+
+    class NotModified                 < ControllerExceptions::Redirection; self.status = 304; end
+
+    class UseProxy                    < ControllerExceptions::Redirection; self.status = 305; end
+
+    class TemporaryRedirect           < ControllerExceptions::Redirection; self.status = 307; end
+
+    class ClientError                 < ControllerExceptions::Base; end
+
+    class BadRequest                  < ControllerExceptions::ClientError; self.status = 400; end
+
+    class MultiPartParseError         < ControllerExceptions::BadRequest; end
+
+    class Unauthorized                < ControllerExceptions::ClientError; self.status = 401; end
+
+    class PaymentRequired             < ControllerExceptions::ClientError; self.status = 402; end
+
+    class Forbidden                   < ControllerExceptions::ClientError; self.status = 403; end
+
+    class NotFound                    < ControllerExceptions::ClientError; self.status = 404; end
+
+    class ActionNotFound              < ControllerExceptions::NotFound; end
+
+    class TemplateNotFound            < ControllerExceptions::NotFound; end
+
+    class LayoutNotFound              < ControllerExceptions::NotFound; end
+
+    class MethodNotAllowed            < ControllerExceptions::ClientError; self.status = 405; end
+
+    class NotAcceptable               < ControllerExceptions::ClientError; self.status = 406; end
+
+    class ProxyAuthenticationRequired < ControllerExceptions::ClientError; self.status = 407; end
+
+    class RequestTimeout              < ControllerExceptions::ClientError; self.status = 408; end
+
+    class Conflict                    < ControllerExceptions::ClientError; self.status = 409; end
+
+    class Gone                        < ControllerExceptions::ClientError; self.status = 410; end
+
+    class LengthRequired              < ControllerExceptions::ClientError; self.status = 411; end
+
+    class PreconditionFailed          < ControllerExceptions::ClientError; self.status = 412; end
+
+    class RequestEntityTooLarge       < ControllerExceptions::ClientError; self.status = 413; end
+
+    class RequestURITooLarge          < ControllerExceptions::ClientError; self.status = 414; end
+
+    class UnsupportedMediaType        < ControllerExceptions::ClientError; self.status = 415; end
+
+    class RequestRangeNotSatisfiable  < ControllerExceptions::ClientError; self.status = 416; end
+
+    class ExpectationFailed           < ControllerExceptions::ClientError; self.status = 417; end
+
+    class ServerError                 < ControllerExceptions::Base; end
+
+    class InternalServerError         < ControllerExceptions::ServerError; self.status = 500; end
+
+    class NotImplemented              < ControllerExceptions::ServerError; self.status = 501; end
+
+    class BadGateway                  < ControllerExceptions::ServerError; self.status = 502; end
+
+    class ServiceUnavailable          < ControllerExceptions::ServerError; self.status = 503; end
+
+    class GatewayTimeout              < ControllerExceptions::ServerError; self.status = 504; end
+
+    class HTTPVersionNotSupported     < ControllerExceptions::ServerError; self.status = 505; end
+  end
+
+  # Required to show exceptions in the log file
+  #
+  # e<Exception>:: The exception that a message is being generated for
+  #
+  # :api: plugin
+  def self.exception(e)
+    "#{ e.message } - (#{ e.class })\n" <<
+      "#{(e.backtrace or []).join("\n")}"
+  end
+end

data/lib/merb-to-rails3/helpers.rb

@@ -0,0 +1,110 @@
+def merb_deprec(notice=nil)
+  msg = "!!! #{caller.first[/in `(.+)'$/, 1]} IS DEPRECATED (found at #{self}:#{caller.first[/:(\d+):in/, 1]})"
+  if notice
+    msg << ": #{notice}"
+  end
+  Rails.logger.warn(msg)
+end
+
+module MerbToRails3
+  module Helpers
+    module ViewAndController
+      def url(name)
+        path = "#{name}_path"
+        merb_deprec("use #{path}")
+        send(path)
+      end
+
+      def resource(*args)
+        opts_hash = args.last.is_a?(Hash) ? args.pop : {}
+        action = args.pop if args.size > 1 && [:new, :edit, :delete].include?(args.last)
+        objects = []
+        resources = args.map do |a|
+          if a.is_a?(String) || a.is_a?(Symbol)
+            a.to_s.underscore
+          else
+            objects << a
+            a.class.to_s.underscore
+          end
+        end
+        if action
+          resources.unshift(action)
+          resources << resources.pop.to_s.singularize
+        end
+        path = "#{resources.join('_')}_path"
+        merb_deprec("use #{path}")
+        objects.empty? ? send(path, opts_hash) : send(path, *(objects << opts_hash))
+      end
+
+      def partial(name, opts={})
+        merb_deprec("use render :partial")
+        args = { :partial => name.to_s, :locals => opts }
+        if opts.key?(:with)
+          args[:object] = opts.delete(:with)
+        end
+        render args
+      end
+      
+      def message
+        merb_deprec("use flash")
+        flash
+      end
+    end
+
+    module View
+      include ViewAndController
+
+      def submit(value, options)
+        merb_deprec("use submit_tag")
+        submit_tag(value, options)
+      end
+
+      def css_include_tag(*args)
+        merb_deprec("use stylesheet_link_tag")
+        stylesheet_link_tag(*args)
+      end
+
+      def js_include_tag(*args)
+        merb_deprec("use javascript_include_tag")
+        javascript_include_tag(*args)
+      end
+
+      def throw_content(name, *args, &blk)
+        content_for(name, *args, &blk)
+      end
+    end
+
+    module Controller
+      def self.extended(base)
+        base.send(:include, InstanceMethods)
+      end
+
+      def before(*args)
+        merb_deprec("use before_filter")
+        before_filter(*args)
+      end
+
+      def after(*args)
+        merb_deprec("use after_filter")
+        after_filter(*args)
+      end
+
+      module InstanceMethods
+        include ViewAndController
+
+        def redirect(*args)
+          opts = args.dup.extract_options!
+
+          if message = opts.delete(:message)
+            message.each { |type, text| flash[type] = text }
+            merb_deprec("use flash instead of :message option in redirect")
+          end
+
+          merb_deprec("use redirect_to")
+
+          redirect_to(*args)
+        end
+      end
+    end
+  end
+end

data/merb-to-rails3.gemspec

@@ -0,0 +1,45 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{merb-to-rails3}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marcin Kulik", "Piotr Solnica"]
+  s.date = %q{2010-03-31}
+  s.email = %q{tech@llp.pl}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.markdown",
+     "Rakefile",
+     "TODO.markdown",
+     "VERSION.yml",
+     "lib/merb-to-rails3.rb",
+     "lib/merb-to-rails3/controller_exceptions.rb",
+     "lib/merb-to-rails3/helpers.rb",
+     "merb-to-rails3.gemspec"
+  ]
+  s.has_rdoc = false
+  s.homepage = %q{http://github.com/LunarLogicPolska/merb-to-rails3}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Small library that will help you to port a Merb-based app to Rails3}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: merb-to-rails3
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Marcin Kulik
+- Piotr Solnica
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-31 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: tech@llp.pl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- README.markdown
+- Rakefile
+- TODO.markdown
+- VERSION.yml
+- lib/merb-to-rails3.rb
+- lib/merb-to-rails3/controller_exceptions.rb
+- lib/merb-to-rails3/helpers.rb
+- merb-to-rails3.gemspec
+has_rdoc: false
+homepage: http://github.com/LunarLogicPolska/merb-to-rails3
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Small library that will help you to port a Merb-based app to Rails3
+test_files: []
+