link2 0.1.0

data/lib/link2/brain.rb

@@ -0,0 +1,253 @@
+# encoding: utf-8
+
+module Link2
+  module Brain
+
+    URL_PATH_REGEX = /\//
+    CLASS_INSTANCE_STRING = /\#\<.*\:0x.*\>/
+
+    LINK2_OPTION_KEYS = [:scope, :strong].freeze
+    LINK_TO_OPTION_KEYS = [:method, :confirm, :popup, :html_options].freeze
+    BUTTON_TO_OPTION_KEYS = [:method, :confirm, :disabled].freeze
+    IGNORED_OPTION_KEYS = (LINK2_OPTION_KEYS + LINK_TO_OPTION_KEYS + BUTTON_TO_OPTION_KEYS).uniq
+
+    POLYMORPHIC_OPTION_KEYS = [:action, :routing_type]
+
+    protected
+
+      # The Link2 helpers brain: Extracts any additional known info about
+      # based on the specified helper arguments to make smart assumptions.
+      #
+      # NOTE: This method is quite messy, but the different conditionals makes
+      # it tricky to refactor much more for now until DSL is very settled.
+      # The comments give guidelines on what assumptions is being made in each case.
+      #
+      def link_to_args(*args)
+        html_options = args.extract_options!
+        url_options = args.extract_options!
+        args.unshift(capture(&block)) if block_given?
+
+        case args.size
+        when 0
+          raise "No arguments specified. A least specify action or url."
+        when 1
+          if args.first.is_a?(String)
+            if args.first =~ URL_PATH_REGEX
+              # link 'http://example.com'  => link_to 'http://example.com', 'http://example.com'
+              label = url = args.shift
+            else
+              # link "Hello"  => link_to 'Hello', '#'
+              url = ::Link2::DEFAULT_LINK
+              label = args.shift
+            end
+          elsif args.first.is_a?(Symbol)
+            # link :new  => link_to I18n.t(:new, ...), new_{auto_detected_resource}_path
+            # link :back  => link_to I18n.t(:back, ...), (session[:return_to] || :back)
+            action = args.shift
+            label = self.localized_label(action, url_options)
+            resource = nil # TODO: auto-detect resource.
+            url = self.url_for_args(action, resource, url_options)
+          elsif args.first.is_a?(Object)
+            # link @user  => link_to I18n.t(:show, ...), user_path(@user)
+            # link [:admin, @user]  => link_to I18n.t(:show, ...), admin_user_path(@user)
+            resource = args.shift
+            label, url = self.label_and_url_for_resource(resource, url_options)
+          else
+            raise "Invalid 1st argument: #{args.inspect}"
+          end
+        when 2
+          if args.first.is_a?(String)
+            if args.second.is_a?(String)
+              # link "Hello", hello_path  => link_to "Hello", hello_path
+              label, url = args.slice!(0..1)
+            elsif self.resource_identifier_class?(args.second)
+              # link "New", :new  => link_to "New", new_{auto_detected_resource}_path
+              # link "<<", :back  => link_to "<<", (session[:return_to] || :back)
+              label, action = args.slice!(0..1)
+              resource = nil # TODO: auto-detect resource.
+              url = self.url_for_args(action, resource, url_options)
+            else
+              raise "Invalid 2nd argument: #{args.inspect}"
+            end
+          elsif args.first.is_a?(Symbol)
+            # TODO: Implement this:
+            raise ::Link2::NotImplementedYetError, "case link(:action, [...]) not yet supported. Need to refactor some stuff." if args.second.is_a?(Array)
+            # TODO: Cleanup.
+            if self.resource_identifier_class?(args.second)
+              # link :new, Post  => link_to I18n.t(:new, ...), new_post_path
+              # link :edit, @post  => link_to I18n.t(:edit, ...), edit_post_path(@post)
+              # link :show, [:admin, @user]  => link_to I18n.t(:show, ...), admin_user_path(@user)
+              # link :back, root_path  => link_to I18n.t(:back, ...), (session[:return_to] || :back)
+              action, resource = args.slice!(0..1)
+              label = self.localized_label(action, resource, url_options)
+              url = self.url_for_args(action, resource, url_options)
+            else
+              raise "Invalid 2nd argument: #{args.inspect}"
+            end
+          else
+            raise "Invalid 1st argument: #{args.inspect}"
+          end
+        when 3
+          if args.first.is_a?(String)
+            if args.second.is_a?(Symbol)
+              if self.resource_identifier_class?(args.third)
+                # link "New", :new, Post  => link_to "New", new_post_path
+                # link "Edit", :edit, @post  => link_to "Edit", edit_post_path(@post)
+                label, action, resource = args.slice!(0..2)
+                url = self.url_for_args(action, resource, url_options)
+              else
+                raise "Invalid 3rd argument: #{args.inspect}"
+              end
+            else
+              raise "Invalid 2nd argument: #{args.inspect}"
+            end
+          else
+            raise "Invalid 1st argument: #{args.inspect}"
+          end
+        else
+          raise "Invalid number of arguments: #{args.inspect}."
+        end
+        #[label, url, *((args << options) << html_options)]
+        #puts url_options.inspect
+        [label, url, *args]
+      rescue => e
+        raise ::ArgumentError, e
+      end
+
+      # Extracts a label and a url for a (polymorphic) resource.
+      # Partly based on - and accepts same options as - Rails core helper +polymorphic_url+.
+      #
+      # == Usage/Example:
+      #
+      #   @post = Post.find(1)
+      #
+      #   label_and_url_for_resource(@post)
+      #     # => t(:show, ...), '/posts/1'
+      #
+      #   label_and_url_for_resource([:admin, @post], :action => :edit)
+      #     # => t(:show, ...), '/admin/posts/1/edit'
+      #
+      #   label_and_url_for_resource(@post, :hello => 'World')
+      #     # => t(:show, :hello => 'World', ...), '/posts/1'
+      #
+      # See documentation on +polymorphic_url+ for available core options.
+      #
+      def label_and_url_for_resource(resource, options = {})
+        resource.compact! if resource.is_a?(Array)
+        last_resource = [resource].flatten.last
+        url_for_options = options.slice!(*POLYMORPHIC_OPTION_KEYS).reverse_merge(:routing_type => :path)
+        i18n_options = options
+
+        # Skip any ugly default to_s-value.
+        custom_name = last_resource.to_s =~ CLASS_INSTANCE_STRING ? last_resource.class.human_name.downcase : last_resource.to_s
+        custom_name = last_resource.class.human_name.downcase if custom_name.blank?
+
+        i18n_options.merge!(:name => custom_name)
+
+        label = self.localized_label(:show, last_resource.class, i18n_options)
+        url = polymorphic_url(resource, url_for_options)
+
+        [label, url]
+      end
+
+      # Generates a proper URL based on specified arguments.
+      # Partly based on - and accepts same options as - Rails core helper +url_for+.
+      #
+      # Note: Overrides +:controller+, +:action+, and +:id+ options.
+      #
+      # == Usage/Example:
+      #
+      #   @post = Post.find(1)
+      #
+      #   url_for_args(:new, Post)
+      #     # => '/posts/new'
+      #
+      #   url_for_args(:edit, @post)
+      #     # => '/posts/1/edit'
+      #
+      #   url_for_args(:home)
+      #     # => '/'
+      #
+      # See documentation on +url_for+ for available core options.
+      #
+      def url_for_args(*args)
+        options = args.extract_options!
+        action, resource = args
+
+        if resource.nil?
+          url = ::Link2.url_for_mapping(action, resource) rescue nil
+          if url
+            url
+          else
+            raise ::Link2::NotImplementedYetError,
+              "Resource needs to be specified for non-mapped actions; auto-detection of resource(s) not implemented yet."
+          end
+        elsif resource.is_a?(String)
+          resource
+        else
+          options[:controller] ||= self.controller_name_for_resource(resource)
+          options[:action] = action
+          options[:id] = resource.id if !resource.is_a?(Class) && self.record_class?(resource)
+
+          url_for(options.except(IGNORED_OPTION_KEYS))
+        end
+      end
+
+      # Helper for translating labels; merging any additional required translation info
+      # for the current template instance.
+      #
+      def localized_label(action, resource, options = {})
+        options.merge!(:controller => self.controller_name_for_resource(resource))
+        ::Link2::I18n.t(action, resource, options)
+      end
+
+      # Get controller name based for a specified resource.
+      #
+      # == Example/Usage:
+      #
+      #   # Rails routing:  map.resources :posts
+      #
+      #   controller_name_for_resource
+      #     # => "#{@template.controller.controller_name}"
+      #
+      #   controller_name_for_resource(:post)
+      #     # => "posts"
+      #
+      #   controller_name_for_resource(Post)
+      #     # => "posts"
+      #
+      #   controller_name_for_resource(@post)
+      #     # => "posts"
+      #
+      def controller_name_for_resource(resource = nil)
+        resource_class = ::Link2::Support.find_resource_class(resource)
+        if self.record_class?(resource_class)
+          resource_class.to_s.tableize # rescue nil
+        end || self.controller.controller_name
+      end
+
+      # Check if the specified object is a valid resource identifier class. Used
+      # for detecting current resource based on controller, action, etc.
+      #
+      def resource_identifier_class?(object)
+        object.is_a?(NilClass) || object.is_a?(Symbol) || self.record_class?(object)
+      end
+
+      # Check if a specified objec is a record class type.
+      #
+      # == Usage/Examples:
+      #
+      #   record_class?(ActiveRecord::Base)
+      #     # => true
+      #
+      #   record_class?(String)
+      #     # => false
+      #
+      def record_class?(object_or_class)
+        return false if object_or_class == NilClass || object_or_class.is_a?(NilClass)
+        object_or_class = object_or_class.new if object_or_class.is_a?(Class)
+        object_or_class.respond_to?(:new_record?)
+      end
+
+  end
+end

data/lib/link2/helpers.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Link2
+  module Helpers
+
+    include ::Link2::Brain
+
+    def self.included(base)
+      include JavascriptLinkHelpers
+    end
+
+    # Enhanced +link_to+ helper.
+    #
+    # TODO: Documentation for this helper.
+    #
+    def link(*args, &block)
+      args = self.link_to_args(*args)
+      link_to(*args)
+    end
+    alias :link2 :link
+
+    # Enhanced +button_to+ helper.
+    #
+    # == Usage/Examples:
+    #
+    # (See +link+ - identical except for passed +button_to+-options)
+    #
+    def button(*args, &block)
+      args = self.link_to_args(*args)
+      button_to(*args)
+    end
+    alias :button2 :button
+
+    # Rails 3-deprecations - unless +prototype_legacy_helper+-plugin.
+
+    module JavascriptLinkHelpers
+      def js_link(*args)
+        raise ::Link2::NotImplementedYetError
+      end
+
+      def js_button(*args)
+        raise ::Link2::NotImplementedYetError
+      end
+
+      def ajax_link(*args)
+        raise ::Link2::NotImplementedYetError
+      end
+      alias :remote_link :ajax_link
+
+      def ajax_button(*args)
+        raise ::Link2::NotImplementedYetError
+      end
+      alias :remote_button :ajax_button
+    end
+
+  end
+end

data/lib/link2/i18n.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+module Link2
+  module I18n
+
+    ScopeInterpolationError = Class.new(::Link2::Error)
+
+    VALID_SCOPE_VARIABLES = [:controller, :action, :resource, :resources].freeze
+    INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
+    RESERVED_KEYS = ::I18n::Backend::Base::RESERVED_KEYS
+
+    class << self
+
+      # Helper method to lookup I18n keys based on a additionally known conditions;
+      # such as current action, model, etc.. This makes I18n translations more flexible
+      # and maintainable: Bottom-up approach; if no translation is found by first scope;
+      # try next scope, etc.
+      #
+      # == Scoped I18n lookup (default):
+      #
+      #   1. links.{{resource}}.{{action}}
+      #   2. links.{{action}}
+      #   ...
+      #
+      def translate_with_scoping(action, resource, options = {})
+        raise ArgumentError, "At least action must be specified." unless action.present?
+        resource_name = self.localized_resource_class_name(resource)
+        i18n_options = options.merge(
+          :scope => nil,
+          :default => self.substituted_scopes_for(action, resource, options),
+          :resource => resource_name,
+          :resources => resource_name.pluralize
+        )
+        key = i18n_options[:default].shift
+        i18n_options[:default] << action.to_s.humanize
+        ::I18n.t(key, i18n_options)
+      end
+      alias :translate :translate_with_scoping
+      alias :t :translate_with_scoping
+
+      protected
+
+        # Pre-processeses Link2 I18n scopes by interpolating any scoping
+        # variables.
+        #
+        # == Usage/Examples:
+        #
+        #   ::Link2.i18n_scopes = ['{{resources}}.links.{{action}}', '{{controller}}.links.{{action}}', 'links.{{action}}']
+        #
+        #   substituted_scopes_for(:new, Post.new)
+        #     # => Link2::I18n::ScopeInterpolationError
+        #
+        #   substituted_scopes_for(:new, Post.new, :controller => 'admin')
+        #     # => ['posts.links.new', 'admin.links.{new', 'links.new']
+        #
+        def substituted_scopes_for(action, resource, options = {})
+          resource_name = self.localized_resource_class_name(resource) # TODO: Should not be localized. Maybe use "model"/"models" to avoid confusion?
+          substitutions = options.merge(
+            :action => action.to_s.underscore,
+            :resource => resource_name,
+            :resources => resource_name.pluralize
+          )
+
+          scopes = ::Link2::i18n_scopes.collect do |i18n_scope|
+            i18n_key = i18n_scope.dup
+            i18n_key.gsub!(INTERPOLATION_SYNTAX_PATTERN, '%{\2}') # {{hello}} => %{hello}
+            begin
+              i18n_key = i18n_key % substitutions
+            rescue KeyError
+              raise ::Link2::I18n::ScopeInterpolationError,
+                "Contains a invalid scope-variable: #{i18n_key.inspect}. Valid scope-variables: #{VALID_SCOPE_VARIABLES.join(',')}"
+                # "key not found: #{i18n_key.inspect} where #{substitutions.collect { |k,v| "#{k}=#{v.inspect}"}.join(', ')}"
+            end
+            i18n_key.tr!('/', '.')
+            i18n_key.gsub!('..', '.')
+            i18n_key.to_sym
+          end
+          scopes
+        end
+
+        # Extracts a localized class name from a resource class/instance/identifier.
+        #
+        def localized_resource_class_name(resource)
+          resource_class = ::Link2::Support.find_resource_class(resource)
+          resource_name = resource_class.human_name rescue resource_class.to_s.humanize
+          resource_name.underscore
+        end
+
+    end
+
+  end
+end

data/lib/link2/locales/en.yml

@@ -0,0 +1,9 @@
+en:
+  links:
+    home: "Home"
+    back: "Back"
+    new: "New {{resource}}"
+    edit: "Edit {{resource}}"
+    delete: "Delete {{resource}}"
+    show: "Show {{resource}}"
+    index: "Index of {{resources}}"

data/lib/link2/support.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Link2
+  module Support
+
+    class << self
+      # Get resource class based on name, object, or class.
+      #
+      # == Example/Usage:
+      #
+      #   resource_class(:post), resource_class(@post), resource_class(Post)
+      #     # => Post, Post, Post
+      #
+      def find_resource_class(arg)
+        if arg.is_a?(Symbol)
+          resource_class_name = arg.to_s.singularize.camelize
+          resource_class_name.constantize
+        elsif arg.is_a?(Class)
+          arg
+        elsif arg.is_a?(Object)
+          arg.class
+        else
+          arg
+        end
+      rescue
+        raise "No such class: #{resource_class_name}"
+      end
+    end
+
+  end
+end

data/lib/link2/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Link2
+  VERSION = '0.1.0'.freeze
+end