espresso 0.1.12 → 0.2.1

data/lib/espresso/controller/inherited_resources.rb

@@ -0,0 +1,110 @@
+require 'espresso/controller'
+require 'inherited_resources'
+require 'active_support/core_ext/class/inheritable_attributes'
+
+module Espresso
+  module Controller
+    mattr_accessor :default_resources_options
+    self.default_resources_options = {
+      :enhance => true
+    }
+
+    included do
+      helper_method :resource?, :collection?
+    end
+
+    module ClassMethods
+      # Includes default CRUD actions in ActionController::Base using InheritedResources, enhance
+      # @param [Hash] options options of resources
+      # @option options :enhance (true) whether to enhance resource controller with Espresso-provided helpers or not
+      def resources(options = {})
+        options.reverse_merge!(Espresso::Controller.default_resources_options)
+
+        ::InheritedResources::Base.inherit_resources(self)
+        initialize_resources_class_accessors!
+        create_resources_url_helpers!
+
+        if options[:enhance]
+          include Espresso::Controller::InheritedResourcesModifications
+        end
+      end
+    end
+
+    module InstanceMethods
+      # Does the action or view have a resource
+      # @return [Boolean] having a resource
+      def resource?
+        resource
+      rescue
+        false
+      end
+
+      # Does the action or view have a collection of objects
+      # @return [Boolean] Having a collection
+      def collection?
+        collection
+      rescue
+        false
+      end
+    end
+
+    module InheritedResourcesModifications
+      extend Espresso::Concern
+
+      module ClassMethods
+        # Adds ability to build feeds for resource’s collections.
+        # By default adds Atom feed
+        # @example Add Atom feed for #index
+        #   has_feed :atom
+        # @example Add Atom and RSS feed for #index
+        #   has_feed :atom, :rss
+        # @example Add Atom, Rss, and ITunes feed for #index, #list and #archive
+        #   has_feed :atom, :rss, :itunesfeed, :only => [:index, :list, :archive]
+        def has_feed(*args)
+          require 'has_scope'
+
+          options = args.extract_options!
+          if options.empty?
+            options[:only] = :index
+          end
+
+          class_inheritable_accessor(:feed_formats) unless respond_to?(:feed_formats)
+          self.feed_formats = (args.empty? ? [:atom] : args).map(&:to_s)
+
+          self.feed_formats.each do |format|
+            respond_to format, options
+          end
+
+          include FeedScope
+          has_scope(:for_feed, options.merge(:default => true,
+                                             :type => :boolean,
+                                             :if => :feed_scope_applicable?))
+        end
+      end
+
+      module InstanceMethods
+        # Find collection of resources, wrapped with Espresso::Collection
+        # @return [Espresso::Collection] collection of resources
+        def collection
+          get_collection_ivar || set_collection_ivar(end_of_association_chain.collection(params))
+        end
+
+        # Build interpolation options for flash messages
+        # @return [Hash, nil] hash of interpolation options if current action has a resource, nil otherwise
+        def interpolation_options
+          if resource?
+            { :resource_title => resource.to_s }
+          end
+        end
+      end
+
+      module FeedScope
+        # Does scope #for_feed applicable to current action?
+        # @return [Boolean] if applicable
+        def feed_scope_applicable?
+          params[:format] && self.class.feed_formats.include?(params[:format].to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/espresso/deprecated.rb

@@ -0,0 +1,19 @@
+require 'espresso'
+require 'espresso/model'
+
+module Espresso
+  ActionView = View
+  autoload :Resources, 'espresso/deprecated/resources'
+  module Model
+    module ClassMethods
+      # @deprecated Use model_modifiers instead
+      def model_attrs=(attrs)
+        model_modifiers=attrs
+      end
+
+      def search_results(page = nil, query = {}, simple_query = nil)
+        collection(:page => page, :search => query)
+      end
+    end
+  end
+end

data/lib/espresso/deprecated/resources.rb

@@ -0,0 +1,11 @@
+require 'espresso/extensions/inherited_resources'
+
+module Espresso
+  module Resources
+    extend Espresso::Concern
+
+    included do
+      resources
+    end
+  end
+end

data/lib/espresso/extensions/action_controller.rb

@@ -0,0 +1,6 @@
+require 'action_controller'
+require 'espresso/controller'
+
+class ActionController::Base
+  include Espresso::Controller
+end

data/lib/espresso/extensions/action_view.rb

@@ -0,0 +1,6 @@
+require 'action_view'
+require 'espresso/view'
+
+class ActionView::Base
+  include Espresso::View
+end

data/lib/espresso/extensions/active_record.rb

@@ -0,0 +1,6 @@
+require 'active_record'
+require 'espresso/model'
+
+class ActiveRecord::Base
+  include Espresso::Model
+end

data/lib/espresso/extensions/all.rb

@@ -0,0 +1,6 @@
+require 'espresso'
+
+Espresso.uses :inherited_resources
+Espresso.uses :will_paginate
+Espresso.uses :searchlogic
+Espresso.uses :has_scope

data/lib/espresso/{haml.rb → extensions/haml.rb}

@@ -1,7 +1,9 @@
 require 'haml'
 require 'haml/buffer'
+require 'espresso/view'
 
 class Haml::Buffer
+  include Espresso::View
   # Takes an array of objects and uses the class and id of the first
   # one to create an attributes hash.
   # The second object, if present, is used as a prefix,
@@ -14,8 +16,8 @@ class Haml::Buffer
     class_name = underscore(ref.class)
     id = "#{class_name}_#{ref.id || 'new'}"
 
-    if ref.respond_to?(:model_class)
-      class_name = ref.model_class
+    if ref.respond_to?(:model_modifiers)
+      class_name = model_classes(ref)
     elsif prefix
       class_name = "#{prefix}_#{class_name}"
       id = "#{prefix}_#{id}"

data/lib/espresso/extensions/has_scope.rb

@@ -0,0 +1,13 @@
+require 'espresso'
+
+begin
+  require 'has_scope'
+rescue LoadError
+  raise <<-END
+  Espresso require has_scope gem to use HasScope extension.
+  Please install it by:
+  $ gem install has_scope -v 0.4.2
+  END
+end
+
+require 'espresso/view/has_scope'

data/lib/espresso/extensions/inherited_resources.rb

@@ -0,0 +1,15 @@
+require 'espresso'
+
+begin
+  require 'inherited_resources'
+rescue LoadError
+  raise <<-END
+  Espresso require inherited_resources gem to use InheritedResources extension.
+  Please install it by:
+  $ gem install inherited_resources -v 1.0.5
+  END
+end
+
+require 'espresso/model/inherited_resources'
+require 'espresso/view/inherited_resources'
+require 'espresso/controller/inherited_resources'

data/lib/espresso/extensions/searchlogic.rb

@@ -0,0 +1,14 @@
+require 'espresso'
+
+begin
+  require 'searchlogic'
+rescue LoadError
+  raise <<-END
+  Espresso require searchlogic gem to use Searchlogic extension.
+  Please install it by:
+  $ gem install searchlogic -v 2.4.12
+  END
+end
+
+require 'espresso/collection/searchlogic'
+require 'espresso/view/searchlogic'

data/lib/espresso/extensions/will_paginate.rb

@@ -0,0 +1,14 @@
+require 'espresso'
+
+begin
+  require 'will_paginate'
+rescue LoadError
+  raise <<-END
+  Espresso require will_paginate gem to use WillPaginate extension.
+  Please install it by:
+  $ gem install will_paginate -v 2.3.12
+  END
+end
+
+require 'espresso/collection/will_paginate'
+require 'espresso/view/will_paginate'

data/lib/espresso/model.rb

@@ -1,80 +1,36 @@
-require 'searchlogic'
-require 'will_paginate'
+require 'espresso'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/string'
 
 module Espresso
-  # @author Alexander Semyonov
   module Model
-    def self.included(model)
-      super
-      model.class_eval do
-        extend ClassMethods
+    extend Espresso::Concern
 
-        class_inheritable_accessor :model_attrs, :name_field, :per_page
+    included do
+      class_inheritable_accessor :name_field, :model_modifiers
 
-        self.model_attrs = []
-        self.name_field = :name
-        self.per_page = 10
-
-        named_scope :for_index, :conditions => '1 = 1'
-        named_scope :for_feed, :order => 'created_at DESC'
-        named_scope :for_show, :conditions => '1 = 1'
-        named_scope :recent, lambda {
-          {:limit => per_page}
-        }
-      end
-    end
-
-    # String representation of model, based on Model’s name_field
-    def to_s
-      send(self.class.name_field).to_s
-    end
-
-    # Model’s classes, based on Model.model_attrs
-    def model_class
-      main_class = "#{::Espresso::MODEL_PREFIX}-#{self.class.name.underscore}"
-      classes = [main_class] +
-      self.class.model_attrs.inject([]) do |collection, attribute|
-                     if send("#{attribute}?")
-                       collection << " #{main_class}_#{attribute}"
-                     end
-                     collection
-                   end
-      classes.join(' ')
+      self.name_field = :name
+      self.model_modifiers = []
     end
 
     module ClassMethods
-      # Paginates search results
-      #
-      # @param [Integer] page number of results’ page
-      # @param [Hash] query searchlogic fields (proc’ed named scopes’ names with values)
-      # @param [String] simple_query params for simple «LIKE '%something%'» searches (e.g. /people?q=Alexander)
-      # @return [Array] searchlogic object and collection of results
-      #
-      # @todo Add an options to paginating
-      def paginate_found(page = nil, query = {}, simple_query = nil)
-        query ||= {}
-        query.merge!(self.parse_simple_query(simple_query)) if simple_query
-        searchlogic = search(query)
-        results = searchlogic.paginate(:page => page)
-        [searchlogic, results]
-      end
-      alias_method :search_results, :paginate_found
-
-      # Make searchlogic query from simple query option
-      # Needed to be reimplemented in subclasses
-      #
-      # @param [String] simple query string
-      # @return [Hash] searchlogic query
-      def parse_simple_query(query)
-        {:"#{name_field}_like" => query}
+      # Make a slug from object‘s #name_field
+      # @param [ActiveRecord::Base] model object, which slug is making
+      # @return [String] slug made from model’s #name_field
+      def make_slug(model)
+        model.send(name_field).parameterize
       end
+    end
 
-      # Make a slug from object’s NameField
-      # @param [ActiveRecord::Base] object, which slug is making
-      # @return [String] slug
-      def make_slug(object)
-        object.send(name_field).parameterize
+    module InstanceMethods
+      # String representation of model, based on Model’s #name_field
+      def to_s
+        send(self.class.name_field)
       end
     end
   end
 end
+
+if defined?(InheritedResources)
+  require 'espresso/model/inherited_resources'
+end

data/lib/espresso/model/inherited_resources.rb

@@ -0,0 +1,20 @@
+require 'espresso/model'
+require 'espresso/collection'
+
+module Espresso
+  module Model
+    included do
+      named_scope :for_collection, :conditions => '1 = 1'
+      named_scope :for_feed, :order => 'created_at DESC'
+    end
+
+    module ClassMethods
+      # Collection of resources, found by params
+      # @param [Hash] options options for ActiveRecord::Base#find
+      # @return [Espresso::Collection, Array] collection of resources
+      def collection(options = {})
+        Espresso::Collection.new(self.for_collection, options)
+      end
+    end
+  end
+end

data/lib/espresso/view.rb

@@ -0,0 +1,261 @@
+require 'espresso'
+require 'active_support/core_ext/module'
+
+module Espresso
+  module View
+    extend Espresso::Concern
+
+    autoload :FormBuilder, 'espresso/view/form_builder'
+
+    mattr_accessor :block_prefix
+    self.block_prefix = 'b'
+
+    # Generic espresso block classes
+    # @param [String, Symbol] main_class main block class
+    # @param [Array] modifiers array of modifiers for main block class
+    # @param [Hash] options another options
+    # @option options [String] :type (Espresso::View.block_prefix) type of the block
+    def self.block_classes(main_class, modifiers = [], options = {})
+      options ||= {}
+      options[:type] ||= Espresso::View.block_prefix
+
+      main_class = "#{options[:type]}-#{main_class}"
+      [main_class].tap do |classes|
+        modifiers.each do |modifier|
+          classes << "#{main_class}_#{modifier}"
+        end
+      end.join(' ')
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      VIEW_PLACEHOLDERS = {
+        'create' => 'new',
+        'update' => 'edit'
+      }
+
+      # Overwrites current url.
+      # By default uses full path (with host), if it is not overwrited in options
+      # @param [Hash] overwrites hash of params to overwrite
+      # @param [Hash] options hash of options to url_for
+      # @return [String] overwrited url
+      def overwrite_url(overwrites, options = {})
+        overwrites ||= {}
+        options ||= {}
+        options[:only_path] = false unless options.key?(:only_path)
+        url_for({:overwrite_params => (overwrites || {})}.merge(options))
+      end
+
+      # Overwrites current path.
+      # By default uses relative path (started with /), if it is not overwrited in options
+      # @param [Hash] overwrites hash of params to overwrite
+      # @param [Hash] options hash of options to url_for
+      # @return [String] overwrited path
+      def overwrite_path(overwrites, options = {})
+        options ||= {}
+        options[:only_path] = true unless options.key?(:only_path)
+        overwrite_url(overwrites, options)
+      end
+
+      # Helper to write time in human- and machine-readable format
+      # @param [Time, DateTime] time time to represent
+      # @return [String] <time> tag with time representation
+      def time(time, options = {})
+        format = options.delete(:format) { :long }
+        content_tag(:time,
+                    l(time, :format => format),
+                    options.merge(:time => time.xmlschema))
+      end
+
+      # Helper to write date in human- and machine-readable format
+      # @param [Time, DateTime, Date] time_or_date time or date to represent
+      # @return [String] <time> tag with time or date to represent
+      def date(time_or_date, options = {})
+        time(time_or_date.to_date, options)
+      end
+
+
+
+      # Model‘s classes, based on Model.model_modifiers
+      # @param [ActiveRecord::Base] model model to build classes from
+      def model_classes(model)
+        klass = model.class
+        main_class = klass.name.underscore.gsub(/(_|\/)/, '-')
+        modifiers = if klass.respond_to?(:model_modifiers)
+                      klass.model_modifiers.find_all do |modifier|
+                        method = "#{modifier}?"
+                        model.respond_to?(method) && model.send(method)
+                      end
+                    else
+                      []
+                    end
+        Espresso::View.block_classes(main_class,
+                                          modifiers)
+      end
+
+      # Finds apropriate view name
+      # @return [String] current view name
+      def view_name
+        unless @view_name
+          action_name = controller.action_name
+          @view_name = VIEW_PLACEHOLDERS[action_name] || action_name
+        end
+        @view_name
+      end
+
+      # Makes default page title, based on controller and action
+      # @return [String] default page title
+      def default_page_title
+        text = case view_name
+               when 'index'
+                 if collection?
+                   resource_class.name
+                 else
+                   controller_name.camelize
+                 end
+               when 'new'
+                 "#{t('espresso.navigation.new', :default => 'New')} #{(resource? ? resource_class : controller_name.classify.constantize).human_name}"
+               when 'edit'
+                 "#{t('espresso.navigation.edit', :default => 'Edit')} #{(resource? ? resource_class : controller_name.classify.constantize).human_name}"
+               else
+                 t("navigation.#{controller_name}.#{view_name}")
+               end
+        %(<span class="translation_missing">#{text}</span>)
+      end
+
+      def page_title(title = nil, strip = false)
+        @page_title = if title
+                        title
+                      elsif @page_title
+                        @page_title
+                      else
+                        default = if !Rails.env.development?
+                                    default_page_title
+                                  else
+                                    nil
+                                  end
+
+                        rsrc = if resource?
+                                 if resource.new_record?
+                                   resource_class.human_name
+                                 else
+                                   link_to(resource, resource_path)
+                                 end
+                               else
+                                 nil
+                               end
+
+                        t("navigation.#{controller_name}.#{view_name}",
+                          :default => default,
+                          :resource => rsrc
+                         )
+                      end
+        if strip
+          strip_tags(@page_title)
+        else
+          @page_title
+        end
+      end
+
+      def head_title(default = false, separator = ' | ')
+        default ||= t('application.meta.title')
+        [page_title(nil, true), default].compact.join(separator)
+      end
+
+      # Draws navigation list, using <li> with <a>
+      # @param [Array<Symbol, String>] menu list of menu items (paths without /)
+      # @return [String] Resulting menu without <ul> or <ol>
+      def navigation_list(menu)
+        ''.tap do |result|
+          menu.each do |item|
+            path = "/#{item}"
+            uri = request.request_uri
+            title = t("navigation.#{item}.index", :default => item.to_s.camelize)
+            result << content_tag(:li, :class => uri.starts_with?(path) ? 'selected' : nil) do
+              link_to_unless_current(title, path) {
+                content_tag(:strong, title)
+              }
+            end
+          end
+        end
+      end
+
+      # Set online statistics trackers
+      # @param [Hash] options online statistics keys
+      # @option options [Hash] :piwik Piwik code: id. site
+      # @option options [String, Numeric] :metrika Yandex.Metrika code
+      # @option options [String] :analytics, 
+      def online_stats(options = {})
+        static_includes = []
+        dynamic_includes = ''
+        noscript_includes = []
+        initializers = []
+
+        if piwik = options.delete(:piwik)
+          static_includes   << "//#{piwik[:site]}/piwik.js"
+          initializers      << "var piwikTracker=Piwik.getTracker('//#{piwik[:site]}/piwik.php',#{piwik[:id]});piwikTracker.trackPageView();piwikTracker.enableLinkTracking();"
+          noscript_includes << "//#{piwik[:site]}/piwik.php?idsite=#{piwik[:id]}"
+        end
+
+        if metrika = options.delete(:metrika)
+          static_includes   << '//mc.yandex.ru/resource/watch.js'
+          initializers      << "var yaCounter#{metrika}=new Ya.Metrika(#{metrika});"
+          noscript_includes << "//mc.yandex.ru/watch/#{metrika}"
+        end
+
+        if analytics = options.delete(:analytics)
+          dynamic_includes << 'var gaJsHost=("https:"==document.location.protocol)?"https://ssl.":"http://www.";'
+          dynamic_includes << 'document.write(unescape("%3Cscript src=\'"+gaJsHost+"google-analytics.com/ga.js\' type=\'text/javascript\'%3E%3C/script%3Ei"));'
+          initializers     << "var pageTracker=_gat._getTracker('#{analytics}');pageTracker._trackPageview();"
+        end
+
+        ''.tap do |result|
+          unless dynamic_includes.empty?
+            result << javascript_tag(dynamic_includes)
+          end
+          result << javascript_include_tag(static_includes) unless static_includes.empty?
+          unless initializers.empty?
+            initializers = initializers.collect do |initializer|
+                                                                                                                                            "try {#{initializer}} catch(e) {}"
+            end.join("\n")
+            result << javascript_tag(initializers)
+          end
+
+          unless noscript_includes.empty?
+            includes = noscript_includes.collect do |noscript|
+                                                                                                                                                      %(<img src="#{noscript}" style="border:0" alt="" />)
+            end.join("\n")
+            result << content_tag(:noscript,
+                                  content_tag(:div,
+                                              includes,
+                                              :style => 'position: absolute'))
+          end
+        end
+      end
+
+      # Make body’s modifiers, based on controller_name and action_name
+      def body_modifiers
+        {:class => "m-#{controller_name} m-#{controller_name}_#{action_name}"}
+      end
+
+    end
+  end
+end
+
+if defined?(WillPaginate)
+  require 'espresso/view/will_paginate'
+end
+
+if defined?(InheritedResources)
+  require 'espresso/view/inherited_resources'
+end
+
+if defined?(HasScope)
+  require 'espresso/view/has_scope'
+end
+
+if defined?(Searchlogic)
+  require 'espresso/view/form_builder'
+end