rhyhann-merb_stathyc_slice 0.1

data/LICENSE

@@ -0,0 +1,21 @@
+(The MIT/X11 License)
+
+Copyright (c) <2008> <Othmane Benkirane>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,106 @@
+/!\ My version numbers mean that they are stable when they are pair (2,4,6,8…) and
+    nearly bugfree when they finish with a 0 (10,20,30) so if you see version 1, just know
+    that it's not meant for production now!
+
+StaticSlice
+===========
+
+A slice for the Merb framework that provides the core static pages functionnalities.
+Just see the views for edit.
+
+To see all available tasks for StaticSlice run:
+    rake -T slices:static_slice
+
+CUD Customization
+-----------------
+
+If you want to protect the CUD actions, you must know that: ALL of them are located in
+a content named *for_cud*. simple.
+If you want to change the look of the CUD operations, it's stored in a partial named *_cud*.
+But _please see the default one first_.
+
+Sidebar
+-------
+
+A partial called *_sidebar* may help you with Sidebar customization.
+
+Installation
+============
+
+* dependency (config/init.rb)
+
+    \# add the slice as a regular dependency
+    dependency 'static_slice'
+
+* router
+
+    \# example: /static_slice/:controller/:action/:id
+    add_slice(:StaticSlice)
+    \# example: /foo/:controller/:action/:id
+    add_slice(:StaticSlice, 'foo') # same as :path => 'foo'
+    \# example: /:lang/:controller/:action/:id
+    add_slice(:StaticSlice, :path => ':lang')
+    \# example: /:controller/:action/:id
+    slice(:StaticSlice)
+
+* rake
+
+    rake slices:static_slice:install
+
+Uses
+====
+
+You can put your overrides here:
+    host-app/slices/static_slice/app - controllers, models, views ...
+
+Templates are located in this order:
+1. host-app/slices/static_slice/app/views/*
+2. gems/static_slice/app/views/*
+3. host-app/app/views/*
+
+You can use the host application's layout by configuring the
+static_slice slice in a before_app_loads block:
+
+    Merb::Slices.config[:static_slice] = { :layout => :application }
+
+By default :static_slice is used. If you need to override
+stylesheets or javascripts, just specify your own files in your layout
+instead/in addition to the ones supplied (if any) in 
+host-app/public/slices/static_slice.
+
+In any case don't edit those files directly as they may be clobbered any time
+rake static_slice:install is run.
+
+About Slices
+============
+
+Merb-Slices is a Merb plugin for using and creating application 'slices' which
+help you modularize your application. Usually these are reuseable extractions
+from your main app. In effect, a Slice is just like a regular Merb MVC
+application, both in functionality as well as in structure.
+
+When you generate a Slice stub structure, a module is setup to serve as a
+namespace for your controller, models, helpers etc. This ensures maximum
+encapsulation. You could say a Slice is a mixture between a Merb plugin (a
+Gem) and a Merb application, reaping the benefits of both.
+
+A host application can 'mount' a Slice inside the router, which means you have
+full over control how it integrates. By default a Slice's routes are prefixed
+by its name (a router :namespace), but you can easily provide your own prefix
+or leave it out, mounting it at the root of your url-schema. You can even
+mount a Slice multiple times and give extra parameters to customize an
+instance's behaviour.
+
+A Slice's Application controller uses controller_for_slice to setup slice
+specific behaviour, which mainly affects cascaded view handling. Additionaly,
+this method is available to any kind of controller, so it can be used for
+Merb Mailer too for example.
+
+There are many ways which let you customize a Slice's functionality and
+appearance without ever touching the Gem-level code itself. It's not only easy
+to add template/layout overrides, you can also add/modify controllers, models
+and other runtime code from within the host application.
+
+To create your own Slice run this (somewhere outside of your merb app):
+
+    merb-gen slice <your-lowercase-slice-name>

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+require 'merb-core'
+require 'merb-core/tasks/merb'
+
+GEM_NAME = "merb_stathyc_slice"
+AUTHOR = "Othmane Benkirane (rhyhann)"
+EMAIL = "eo-in-rhyhann-net"
+HOMEPAGE = "http://github.com/rhyhann/merb-stathyc_slice"
+SUMMARY = "Merb Slice that provides core static pages functionnalities"
+GEM_VERSION = "0.1"
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = 'merb'
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.markdown", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('merb-slices', '>= 1.0')
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.markdown Rakefile TODO) + Dir.glob("{lib,spec,app,public,stubs}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install the gem"
+task :install do
+  Merb::RakeHelper.install(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Uninstall the gem"
+task :uninstall do
+  Merb::RakeHelper.uninstall(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+require 'spec/rake/spectask'
+require 'merb-core/test/tasks/spectasks'
+desc 'Default: run spec examples'
+task :default => 'spec'

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+
+- Specs
+- CUD partial
+

data/app/controllers/application.rb

@@ -0,0 +1,3 @@
+class StaticSlice::Application < Merb::Controller
+  controller_for_slice
+end

data/app/controllers/pages.rb

@@ -0,0 +1,62 @@
+class StaticSlice::Pages < StaticSlice::Application
+  # provides :xml, :yaml, :js
+  def index
+    @pages = Page.all
+    display @pages
+  end
+
+  def show(id)
+    @page = Page.get(id)
+    raise NotFound unless @page
+    display @page
+  end
+
+  def new
+    only_provides :html
+    @page = Page.new
+    display @page
+  end
+
+  def edit(id)
+    only_provides :html
+    @page = Page.get(id)
+    raise NotFound unless @page
+    display @page
+  end
+
+  def create(page)
+    @page = Page.new(page)
+    if @page.save
+      redirect resource(@page), :message => {:notice => "Page was successfully created"}
+    else
+      message[:error] = "Page failed to be created"
+      render :new
+    end
+  end
+
+  def update(id, page)
+    @page = Page.get(id)
+    raise NotFound unless @page
+    if @page.update_attributes(page)
+       redirect resource(@page)
+    else
+      display @page, :edit
+    end
+  end
+
+  def delete(id)
+    @page = Page.get(id)
+    raise NotFound unless @page
+    display @page
+  end
+  def destroy(id)
+    @page = Page.get(id)
+    raise NotFound unless @page
+    if @page.destroy
+      redirect resource(:pages)
+    else
+      raise InternalServerError
+    end
+  end
+
+end # Pages

data/app/helpers/application_helper.rb

@@ -0,0 +1,136 @@
+module Merb
+  module StaticSlice
+    module ApplicationHelper
+      
+      # @param *segments<Array[#to_s]> Path segments to append.
+      #
+      # @return <String> 
+      #  A path relative to the public directory, with added segments.
+      def image_path(*segments)
+        public_path_for(:image, *segments)
+      end
+      
+      # @param *segments<Array[#to_s]> Path segments to append.
+      #
+      # @return <String> 
+      #  A path relative to the public directory, with added segments.
+      def javascript_path(*segments)
+        public_path_for(:javascript, *segments)
+      end
+      
+      # @param *segments<Array[#to_s]> Path segments to append.
+      #
+      # @return <String> 
+      #  A path relative to the public directory, with added segments.
+      def stylesheet_path(*segments)
+        public_path_for(:stylesheet, *segments)
+      end
+      
+      # Construct a path relative to the public directory
+      # 
+      # @param <Symbol> The type of component.
+      # @param *segments<Array[#to_s]> Path segments to append.
+      #
+      # @return <String> 
+      #  A path relative to the public directory, with added segments.
+      def public_path_for(type, *segments)
+        ::StaticSlice.public_path_for(type, *segments)
+      end
+      
+      # Construct an app-level path.
+      # 
+      # @param <Symbol> The type of component.
+      # @param *segments<Array[#to_s]> Path segments to append.
+      #
+      # @return <String> 
+      #  A path within the host application, with added segments.
+      def app_path_for(type, *segments)
+        ::StaticSlice.app_path_for(type, *segments)
+      end
+      
+      # Construct a slice-level path.
+      # 
+      # @param <Symbol> The type of component.
+      # @param *segments<Array[#to_s]> Path segments to append.
+      #
+      # @return <String> 
+      #  A path within the slice source (Gem), with added segments.
+      def slice_path_for(type, *segments)
+        ::StaticSlice.slice_path_for(type, *segments)
+      end
+
+
+
+      # This function takes the Model.sexhy hash and guesses the untyped variables, sorts it
+      # and then returns the incredible formù!
+      def sexify(object, f_d = {:properties => {}})
+        f = ''
+        f_d = object_labels(object, object_types(object))
+        f_d[:properties].delete_if {|k,v| [:id,:created_at,:updated_at].include?(k)}
+        f_d[:properties].to_a.sort_by {|a|a[1][:order]}.each do |element|
+          type, options = element[0], element[1]
+          # TODO: default hashes
+          html = object.class.sexhy[:html]
+          f << nl(open_tag(:div))
+          f << nl(html[:label][:tag],
+                  options[:label],
+                  html[:label][:attributes].merge(
+                      {:for => "#{object.class.to_s.downcase}_#{type.to_s}"}
+                    )
+                 )
+          eval "f << nl(html[:input][:tag],
+                        (#{options[:input]}(:#{type})).to_s,
+                        html[:input][:attributes]
+                       )"
+          f << nl(close_tag(:div))
+        end
+        f
+      end
+      def order(hash)
+        n = 0
+        hash[:properties].each do |k,v|
+          n+=1
+          hash[:properties][k][:order] = n if hash[:properties][k][:order].nil?
+        end
+        hash
+      end
+      # This function returns the list of the inputs.
+      # It will first try to merge it to the given hash, then to the model's hash
+      # then to nothing.
+      def object_types(o, c_d = {:properties => {}})
+        c_d = o.class.sexhy if c_d == {:properties => {}} && o.class.methods.include?('sexhy')
+        c_d = order c_d
+        properties = {}
+        o.class.properties.each do |pr|
+          t = DataMapper::Types
+          properties[pr.name] = {}
+          properties[pr.name][:input] = if pr.type.is_a?(t::Boolean) ||
+              pr.type.is_a?(TrueClass); 'check_box'
+          elsif [String, Float, Fixnum,
+              Integer, BigDecimal,
+              ].include?(pr.type);      'text_field'
+          elsif pr.type == t::Text;     'text_area'
+          elsif pr.type.is_a?(Date);    'date'
+          end
+        end
+        c_d[:properties].each {|k,v|
+          properties[k].merge!(v)}
+        {:properties => properties}
+      end
+      def object_labels(o, c_d = {:properties => {}})
+        c_d = o.class.sexhy if c_d == {} && o.class.methods.include?('sexhy')
+        properties = {}
+        o.class.properties.each do |pr|
+          properties[pr.name] = {}
+          properties[pr.name][:label] = pr.name.to_s.capitalize
+        end
+        c_d[:properties].each {|k,v| properties[k].merge!(v)}
+        {:properties => properties}
+      end
+      # This function returns its arguments with new lines
+      def nl(*arg)
+        arg[0].is_a?(Symbol) ? nl(tag(*arg)) : "    \n    #{arg[0]}"
+      end
+    end
+  end
+end

data/app/helpers/pages_helper.rb

@@ -0,0 +1,49 @@
+module Merb
+  module PagesHelper
+    def sexify(object, form_definition = {})
+      f = "\n"
+      object.class.properties.each do |pr|
+        t = DataMapper::Types
+        if pr.type.is_a?(t::Boolean) || pr.type.is_a?(TrueClass)
+          f << nl(label(:"#{pr.name}"))
+          f << nl(check_box(:"#{pr.name}"))
+        elsif [String, Float, Fixnum, Integer, BigDecimal].include?(pr.type)
+          f << nl(label(:"#{pr.name}"))
+          f << nl(text_field(:"#{pr.name}"))
+        elsif pr.type == t::Text
+          f << nl(label( :"#{pr.name}" ))
+          f << nl(text_area(:"#{pr.name}"))
+        elsif pr.type.is_a?(Date)
+          dater = "\n"
+          f << tag(:label, :class => :date) do
+            yearc = (Time.now.year-100..Time.now.year)
+            dater << select(:"#{pr.name}_month", :collection => (1..12).to_a); dater << " / "
+            dater << select(:"#{pr.name}_day" , :collection => (1..31).to_a);  dater << " / "
+            dater << select(:"#{pr.name}_year" , :collection => (yearc).to_a); dater << " / "
+            dater
+          end
+        end
+      end
+      f
+    end
+    def hy_guess_type(object)
+      object.class.properties.each do |pr|
+        t = DataMapper::Types
+        inputs = {}
+        inputs[:"#{pr.name}"] = if pr.type.is_a?(t::Boolean) ||
+            pr.type.is_a?(TrueClass); :check_box
+        elsif [String, Float, Fixnum,
+            Integer, BigDecimal,
+            ].include?(pr.type);      :text_field
+        elsif pr.type == t::Text;     :text_area
+        elsif pr.type.is_a?(Date);    :date
+        end
+        inputs
+      end
+    end
+    # This function returns its arguments with new lines
+    def nl(arg)
+      tag(:div, "\n  #{arg}\n")
+    end
+  end
+end # Merb