espresso-framework 0.3.0

data/lib/espresso/view/form_builder.rb

@@ -0,0 +1,60 @@
+require 'espresso/view'
+require 'action_view'
+require 'formtastic'
+
+module Espresso
+  module View
+    class FormBuilder < Formtastic::SemanticFormBuilder
+      def submit(value=nil, options={})
+        value, options = nil, value if value.is_a?(Hash)
+        value ||= submit_default_value
+        @template.submit_tag(value, options.reverse_merge(:id => "#{object_name}_submit"))
+      end
+
+      def inline_errors_for(method, options = nil) #:nodoc:
+        if render_inline_errors?
+          errors = Array(@object.errors[method.to_sym]) +
+            Array(@object.errors[:"#{method}_id"])
+          send(:"error_#{@@inline_errors}", [*errors]) if errors.present?
+        else
+          nil
+        end
+      end
+
+      def submit_default_value
+        model = if object.class.respond_to?(:model_name)
+                  object.class.human_name
+                else
+                  @object_name.to_s.humanize
+                end
+
+        defaults = []
+        defaults << :"helpers.submit.#{object_name}.#{form_action}"
+        defaults << :"helpers.submit.#{form_action}"
+        defaults << "#{form_action.to_s.humanize} #{model}"
+
+        I18n.t(defaults.shift, :model => model, :default => defaults)
+      end
+
+      def commit_button(*args)
+        options = args.extract_options!
+
+        button_html = options.delete(:button_html) || {}
+        button_html.merge!(:class => [button_html[:class], form_action].compact.join(' '))
+        element_class = ['commit', options.delete(:class)].compact.join(' ')
+        accesskey = (options.delete(:accesskey) || @@default_commit_button_accesskey) unless button_html.has_key?(:accesskey)
+        button_html = button_html.merge(:accesskey => accesskey) if accesskey  
+        template.content_tag(:li, self.submit(options.delete(:label), button_html), :class => element_class)
+      end
+
+    protected
+      def model_object
+        @object.respond_to?(:to_model) ? @object.to_model : @object
+      end
+
+      def form_action
+        model_object ? (model_object.new_record? ? :create : :update) : :submit
+      end
+    end
+  end
+end

data/lib/espresso/view/has_scope.rb

@@ -0,0 +1,23 @@
+require 'espresso/view'
+require 'has_scope'
+
+module Espresso::View
+  mattr_accessor :scope_filter_wrapper_class, :scope_filter_ul_class
+  self.scope_filter_wrapper_class = 'b-scope-filter'
+  self.scope_filter_ul_class = 'b-hlist b-hlist_vline'
+
+  module InstanceMethods
+    def scope_filter(scopes)
+      content_tag(:div, :class => Espresso::View.scope_filter_wrapper_class) do
+        content_tag(:ul, :class => Espresso::View.scope_filter_ul_class) do
+          scopes.inject([]) do |list, scope|
+            list << content_tag(:li, link_to_unless_current(t(".#{scope}"),
+                                           collection_path(scope => true)))
+            list
+          end.join
+        end
+      end
+    end
+
+  end
+end

data/lib/espresso/view/inherited_resources.rb

@@ -0,0 +1,72 @@
+require 'espresso/view'
+require 'inherited_resources'
+
+module Espresso
+  module View
+    module InstanceMethods
+      def link_to_new(klass=nil, path=nil)
+        klass ||= resource_class
+        klass_underscored = klass.name.underscore
+        path ||= if klass == resource_class
+                   new_resource_path
+                 else
+                   [:new, klass_underscored]
+                 end
+        link_to(t("helpers.action.#{klass_underscored}.new",
+                  :default => [:'helpers.action.new', 'Add']),
+                path,
+                :class => Espresso::View.block_classes('action', %w(new)))
+      rescue
+      end
+
+      def link_to_show(object=nil)
+        object ||= resource
+        link_to(t("helpers.action.#{object.class.name.underscore}.show",
+                  :default => [:'helpers.action.show', object.to_s]),
+                object,
+                :class => Espresso::View.block_classes('action', %w(show)))
+      rescue
+      end
+
+      def link_to_edit(object=nil, path=nil)
+        object ||= resource
+        path ||= if object == resource
+                   edit_resource_path
+                 else
+                   [:edit, object]
+                 end
+        link_to(t("helpers.action.#{object.class.name.underscore}.edit",
+                  :default => [:'helpers.action.edit', 'Edit']),
+                path,
+                :class => Espresso::View.block_classes('action', %w(edit)))
+      rescue
+      end
+
+      def link_to_destroy(object=nil, path=nil)
+        object ||= resource
+        path ||= if object == resource
+                   resource_path
+                 else
+                   object
+                 end
+        class_underscored = object.class.name.underscore
+        link_to(t("helpers.action.#{class_underscored}.edit",
+                  :default => [:'helpers.action.destroy', 'Destroy']),
+                path,
+                :class => Espresso::View.block_classes('action', %w(destroy)),
+                :method => :delete,
+                :confirm => t("helpers.action.#{class_underscored}.confirm_destroy",
+                              :default => [:'helpers.action.confirm_destroy', 'are you sure?']))
+      end
+
+      def link_to_index
+        link_to(t("helpers.action.#{controller_name.singularize}.index",
+                  :default => [:'helpers.action.index', '← Back']),
+                    collection_path,
+                    :class => 'b-action b-action_index')
+      rescue
+      end
+
+    end
+  end
+end

data/lib/espresso/view/searchlogic.rb

@@ -0,0 +1,33 @@
+require 'espresso/view'
+require 'searchlogic'
+
+module Espresso::View
+  module InstanceMethods
+    def simple_search
+      ''.tap do |form|
+        form << form_tag(url_for(:action => :index), :method => :get)
+        form << content_tag(:table, :class => 'b-search') do
+          content_tag(:tr) do
+            ''.tap do |result|
+              result << content_tag(:td,
+                                    content_tag(:div,
+                                                text_field_tag(:q,
+                                                               params[:q],
+                                                               :type => 'search'),
+                                                :class => 'b-input'),
+                                    :class => 'input')
+              result << content_tag(:td,
+                                    submit_tag(t('espresso.view.find',
+                                                 :default => 'Find!'),
+                                               :class => 'submit'),
+                                    :class => 'button')
+            end
+          end
+        end
+        form << yield if block_given?
+        form << '</form>'
+      end
+    end
+
+  end
+end

data/lib/espresso/view/will_paginate.rb

@@ -0,0 +1,35 @@
+require 'espresso/view'
+require 'will_paginate/view_helpers'
+
+module Espresso::View
+  module InstanceMethods
+    include WillPaginate::ViewHelpers
+
+    def will_paginate_with_i18n(collection, options = {})
+      will_paginate_without_i18n(collection,
+                                 options.merge({
+        :class => 'b-pagination',
+        :previous_label => t('espresso.navigation.previous', :default => '← Previous'),
+        :next_label =>     t('espresso.navigation.next', :default => 'Next →')}))
+    end
+    alias_method_chain :will_paginate, :i18n
+
+    def paginated_list(collection_name, options = {})
+      collection = options.delete(:collection) do
+        instance_variable_get("@#{collection_name}")
+      end
+      prefix = options.delete(:prefix)
+      prefix = prefix ? " b-list_#{prefix}_#{collection_name}" : nil
+      start = (collection.respond_to?(:offset) ? collection.offset : 0) + 1
+      ''.tap do |result|
+        result << content_tag(:ol,
+                              render(collection),
+                              :class => "b-list b-list_#{collection_name}#{prefix}",
+                              :start => start)
+        if collection.respond_to?(:total_pages)
+          result << (will_paginate(collection, options) || '')
+        end
+      end
+    end
+  end
+end

data/test/espresso_collection_test.rb

@@ -0,0 +1,6 @@
+require 'test_helper'
+require 'espresso/collection'
+
+class Espresso::CollectionTest < Test::Unit::TestCase
+  should_have_instance_methods(:search, :to_a) { Espresso::Collection.new(nil) }
+end

data/test/espresso_controller_test.rb

@@ -0,0 +1 @@
+require 'test_helper'

data/test/espresso_extensions_haml_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+require 'espresso/extensions/haml'
+require 'example_model'
+
+class Haml::BufferTest < Test::Unit::TestCase
+  context 'Haml::Buffer instance' do
+    setup { @buffer = Haml::Buffer.new }
+
+    {
+      [ExampleModel.new(1)] => {'id' => 'example_model_1', 'class' => 'b-example-model'},
+      [NonModel.new, :prefix] => {'id' => 'prefix_non_model_6', 'class' => 'prefix_non_model'},
+      [ExampleModel.new(5, true)] => {'id' => 'example_model_5', 'class' => 'b-example-model b-example-model_safe'}
+    }.each do |ref, result|
+      should "parse #{ref.inspect} ref to #{result.inspect} " do
+        assert_equal(result, @buffer.parse_object_ref(ref))
+      end
+    end
+  end
+end

data/test/espresso_model_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+require 'example_model'
+
+class ExampleModelTest < Test::Unit::TestCase
+  should_have_class_methods :make_slug
+  should_have_instance_methods :to_s
+
+  {
+    'Foo Bar' => 'foo-bar',
+    'Baz Bar Foo' => 'baz-bar-foo'
+  }.each do |name, slug|
+    context "Example instance with name '#{name}'" do
+      setup {
+        @example = ExampleModel.new
+        @example.name = name
+      }
+
+      should "represents to_s as '#{name}'" do
+        assert_equal name, @example.to_s
+      end
+      should "make slug '#{slug}'" do
+        assert_equal slug, ExampleModel.make_slug(@example)
+      end
+    end
+  end
+end

data/test/espresso_test.rb

@@ -0,0 +1,5 @@
+require 'test_helper'
+
+class EspressoTest < Test::Unit::TestCase
+  should_have_class_methods :configure, :uses, :extensions
+end

data/test/espresso_view_has_scope_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+require 'action_controller'
+require 'espresso/view/has_scope'
+
+
+class Espresso::ViewTest < Test::Unit::TestCase
+  include Espresso::View
+
+  should_have_class_methods :scope_filter_wrapper_class, :scope_filter_ul_class
+  should_have_instance_methods :scope_filter
+end

data/test/espresso_view_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+require 'espresso/view'
+
+class Espresso::ViewTest < Test::Unit::TestCase
+  include Espresso::View
+
+  should_have_class_methods :block_prefix, :block_classes
+  should_have_instance_methods :model_classes, :view_name,
+    :default_page_title, :page_title, :head_title, :navigation_list,
+    :overwrite_url, :overwrite_path, :online_stats, :body_modifiers,
+    :time, :date
+
+  {
+    'b-example' => ['example'],
+    'b-example b-example_foo' => ['example', %w(foo)],
+    'b-example b-example_foo b-example_bar' => ['example', %w(foo bar)],
+    'o-example' => ['example', [], {:type => 'o'}],
+    'y-example y-example_foo y-example_bar y-example_baz' => ['example', %w(foo bar baz), {:type => 'y'}],
+  }.each do |result, params|
+    should "build '#{result}' from #{params.inspect}" do
+      assert_equal result, Espresso::View.block_classes(*params)
+    end
+  end
+
+  class Example
+    def self.model_modifiers
+      [:foo]
+    end
+  end
+
+  class ::FooExample < Example
+    def foo?
+      true
+    end
+  end
+
+  should 'build "b-espresso-view-test-example" from Example instance' do
+    @example = Example.new
+    assert_equal 'b-espresso-view-test-example', model_classes(@example)
+  end
+
+  should 'build "b-foo-example b-foo-example_foo" from FooExample instance' do
+    @example = FooExample.new
+    assert_equal 'b-foo-example b-foo-example_foo', model_classes(@example)
+  end
+end

data/test/espresso_view_will_paginate_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'espresso/view/will_paginate'
+
+
+class Espresso::ViewTest < Test::Unit::TestCase
+  include Espresso::View
+
+  should_have_instance_methods :will_paginate, :paginated_list
+end

data/test/example_model.rb

@@ -0,0 +1,23 @@
+require 'espresso/model'
+
+class ExampleModel
+  include Espresso::Model
+  self.model_modifiers << :safe
+
+  attr_accessor :id, :name, :safe
+
+  def initialize(id = nil, safe = false)
+    self.id = id
+    self.safe = safe
+  end
+
+  def safe?
+    safe == true
+  end
+end
+
+class NonModel
+  def id
+    6
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'redgreen'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'espresso'
+
+require 'active_support/core_ext/string'
+module Test
+  module Unit
+    class TestCase
+      def self.should_have_class_methods(*methods)
+        get_options!(methods)
+        klass = described_type
+        methods.each do |method|
+          should "respond to class method ##{method}" do
+            assert_respond_to(klass, method, "#{klass.name} does not have class method #{method}")
+          end
+        end
+      end
+
+      def self.should_have_instance_methods(*methods)
+        get_options!(methods)
+        klass = described_type
+        instance = if block_given?
+                     # Class initializer requires some attributes,
+                     # or another custom generator used
+                     yield
+                   elsif klass.is_a?(Class)
+                     klass.new
+                   else
+                     # klass is a module
+                     metaclass = Class.new
+                     metaclass.send(:include, klass)
+                     metaclass.new
+                   end
+        methods.each do |method|
+          should "respond to instance method ##{method}" do
+            assert_respond_to(instance, method, "#{klass.name} does not have instance method #{method}")
+          end
+        end
+      end
+    end
+
+    class TestCaseTest < TestCase
+      should_have_class_methods :should_have_class_methods, :should_have_instance_methods
+    end
+  end
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: espresso-framework
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Alexander Semyonov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2010-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+- !ruby/object:Gem::Dependency
+  name: inherited_resources
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redgreen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Useful templates for controller and model functions
+email: rotuka@tokak.ru
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- espresso-framework.gemspec
+- init.rb
+- lib/espresso.rb
+- lib/espresso/collection.rb
+- lib/espresso/collection/searchlogic.rb
+- lib/espresso/collection/will_paginate.rb
+- lib/espresso/concern.rb
+- lib/espresso/controller.rb
+- lib/espresso/controller/inherited_resources.rb
+- lib/espresso/deprecated.rb
+- lib/espresso/deprecated/resources.rb
+- lib/espresso/extensions/action_controller.rb
+- lib/espresso/extensions/action_view.rb
+- lib/espresso/extensions/active_record.rb
+- lib/espresso/extensions/all.rb
+- lib/espresso/extensions/haml.rb
+- lib/espresso/extensions/has_scope.rb
+- lib/espresso/extensions/inherited_resources.rb
+- lib/espresso/extensions/searchlogic.rb
+- lib/espresso/extensions/will_paginate.rb
+- lib/espresso/model.rb
+- lib/espresso/model/inherited_resources.rb
+- lib/espresso/view.rb
+- lib/espresso/view/form_builder.rb
+- lib/espresso/view/has_scope.rb
+- lib/espresso/view/inherited_resources.rb
+- lib/espresso/view/searchlogic.rb
+- lib/espresso/view/will_paginate.rb
+- test/espresso_collection_test.rb
+- test/espresso_controller_test.rb
+- test/espresso_extensions_haml_test.rb
+- test/espresso_model_test.rb
+- test/espresso_test.rb
+- test/espresso_view_has_scope_test.rb
+- test/espresso_view_test.rb
+- test/espresso_view_will_paginate_test.rb
+- test/example_model.rb
+- test/test_helper.rb
+homepage: http://github.com/krasivotokak/espresso
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 3
+summary: Rails extender to simplify rails development
+test_files:
+- test/espresso_extensions_haml_test.rb
+- test/example_model.rb
+- test/espresso_collection_test.rb
+- test/espresso_model_test.rb
+- test/espresso_view_test.rb
+- test/espresso_test.rb
+- test/test_helper.rb
+- test/espresso_controller_test.rb
+- test/espresso_view_has_scope_test.rb
+- test/espresso_view_will_paginate_test.rb