storefront 0.2.0

data/Rakefile

@@ -0,0 +1,76 @@
+require 'rake'
+require "rake/rdoctask"
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.name              = "storefront"
+  s.authors           = ["Lance Pollard"]
+  s.version           = "0.2.0"
+  s.summary           = "Semantic HTML5 for Rails"
+  s.homepage          = "http://github.com/viatropos/storefront"
+  s.email             = "lancejpollard@gmail.com"
+  s.description       = "DRY, SEO-friendly Rails Views"
+  s.rubyforge_project = "storefront"
+  s.platform          = Gem::Platform::RUBY
+  s.files             = %w(Rakefile init.rb) + Dir["{lib,rails,test}/**/*"] - Dir["test/tmp"]
+  s.require_path      = "lib"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec    = spec
+end
+
+desc 'run unit tests'
+task :test do
+  Dir["test/**/*"].each do |file|
+    next unless File.basename(file) =~ /test_/
+    next unless File.extname(file) == ".rb"
+    system "ruby #{file}"
+  end
+end
+
+desc "Create .gemspec file (useful for github)"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", "w") do |f|
+    f.puts spec.to_ruby
+  end
+end
+
+desc "Build the gem into the current directory"
+task :gem => :gemspec do
+  `gem build #{spec.name}.gemspec`
+end
+
+desc "Publish gem to rubygems"
+task :publish => [:package] do
+  %x[gem push #{spec.name}-#{spec.version}.gem]
+end
+
+desc "Print a list of the files to be put into the gem"
+task :manifest do
+  File.open("Manifest", "w") do |f|
+    spec.files.each do |file|
+      f.puts file
+    end
+  end
+end
+
+desc "Install the gem locally"
+task :install => [:package] do
+  File.mkdir("pkg") unless File.exists?("pkg")
+  command = "gem install pkg/#{spec.name}-#{spec.version} --no-ri --no-rdoc"
+  command = "sudo #{command}" if ENV["SUDO"] == true
+  sh %{#{command}}
+end
+
+desc "Generate the rdoc"
+Rake::RDocTask.new do |rdoc|
+  files = ["README.md", "lib/**/*.rb"]
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.md"
+  rdoc.title = spec.summary
+end
+
+task :yank do
+  `gem yank #{spec.name} -v #{spec.version}`
+end

data/init.rb

@@ -0,0 +1 @@
+File.dirname(__FILE__) + "/rails/init.rb"

data/lib/storefront.rb

@@ -0,0 +1,21 @@
+
+# This takes care of the rest of functionality you need
+# for an SEO and easy to build page.
+# It includes: metadata helpers, grid helpers (e.g. for photo gallerys),
+# navigation helpers (menus and breadcrumbs),
+# better render method so you can pass a block to partials
+# http://github.com/rpheath/navigation_helper.git
+# http://github.com/justinfrench/lovely-layouts.git
+# http://github.com/ianwhite/truncate_html
+# http://github.com/dekart/breadcrumbs.git
+# http://github.com/html/once/blob/master/lib/once.rb
+# http://github.com/fnando/breadcrumbs.git
+# http://github.com/semanticart/smart-meta
+Dir["#{File.expand_path(File.dirname(__FILE__))}/storefront/railtie"]
+Dir["#{File.expand_path(File.dirname(__FILE__))}/storefront/helpers/*"].each do |path|
+  require path unless ::File.directory?(path)
+end
+# make this more explicit
+Dir["#{File.expand_path(File.dirname(__FILE__))}/storefront/**/*"].each do |path|
+  require path unless ::File.directory?(path) || path =~ /helpers/
+end

data/lib/storefront/dashboard.rb

@@ -0,0 +1,184 @@
+module Storefront  
+  class Dashboard
+    include Storefront::AttributeHelper
+    attr_reader :content, :template, :key, :report, :keys
+    
+    def initialize(template, record_or_key, hash, options = {}, &block)
+      @template         = template
+      @key              = record_key(record_or_key)
+      @section_index    = -1
+      @column_index     = -1
+      @row_index        = -1
+      @cols             = 0
+      @section_scope    = nil
+      @column_scope     = nil
+      @filter_scope     = nil
+      @model_names      = @key.to_s.camelize.constantize.ancestor_classes.map {|i| i.name.underscore}
+      @filter           = Array(options.delete(:filter)).compact
+      @report           = hash
+      options[:id]      ||= "#{record_or_key.to_s}-section"
+      @keys             = options.delete(:keys) || {}
+
+      @content = template.capture_haml do
+        template.haml_tag :article, options do
+          yield(self)
+        end
+      end
+    end
+
+    # section :when, :cols => 3
+    def section(*args, &block)
+      attributes     = args.extract_options!
+      @section_scope = args.shift
+      @section_index += 1
+      @row_index     = -1
+      @column_index  = -1
+      @cols          = attributes.delete(:cols)
+      @header        = attributes.delete(:title) != false
+      attributes[:"data-filters"] = @filter.join(",")
+      attributes[:"data-section"] = @section_scope.to_s
+      @subtitle = attributes.delete(:subtitle) || report_subtitle
+
+      merge_class! attributes, index_class(@section_index, @cols), "dashboard-widget", "#{@section_scope}-dashboard-widget"
+
+      template.capture_haml do
+        template.haml_tag :section, attributes do
+          if @header
+            template.haml_tag :header, :class => "header" do
+              template.haml_tag :h3, t!(:"#{@section_scope}.title", locale_keys.merge(:scope => :"reports.titles")), :class => "title"
+              if @subtitle.present?
+                template.haml_tag :h4, @subtitle, :class => "subtitle"
+              end
+            end
+          end
+          yield
+        end
+        @row_index = 0
+        @cols      = 0
+      end
+    end
+
+    def figure(*args, &block)
+      attributes    = args.extract_options!
+      @figure_scope = args.shift
+
+      merge_class! attributes, "figure"
+      attributes[:id] ||= "#{@figure_scope.to_s}-figure"
+
+      template.capture_haml do
+        template.haml_tag :figure, "", attributes
+      end
+    end
+
+    def locale_keys
+      hash = {}
+      keys.each do |key, value|
+        hash[key] = value.is_a?(::Symbol) ? t!(:"#{value}", :scope => :"reports.keys", :model_names => @model_names) : value
+      end
+      hash.merge(:model_names => @model_names)
+    end
+
+    def column(*args, &block)
+      attributes    = args.extract_options!
+      @column_scope = args.shift
+      @column_index += 1
+      @row_data     = []
+      @row_index    = -1
+      @rows         = attributes.delete(:rows)
+
+      keys = attributes.delete(:keys) || @locale_keys
+
+      merge_class! attributes, index_class(@column_index, @cols), "#{@column_scope}-column", "col#{@cols}", "column"
+      attributes[:"data-column"] = @column_scope.to_s
+
+      title = attributes.delete(:title) || t!(:"#{@section_scope}.#{@column_scope}.title", locale_keys.merge(:scope => :"reports.titles"))
+
+      template.capture_haml do
+        template.capture_haml(&block)
+        @rows = @row_data.length
+        template.haml_tag :section, attributes.merge("data-rows" => @rows) do
+          template.haml_tag :header, :class => "header" do
+            template.haml_tag @header ? :h4 : :h3, title, :class => "title"
+          end
+
+          template.haml_tag :dl, :class => "statistics" do
+            @row_data.map { |row_data| _row(*row_data) }
+          end
+        end
+        @row_index = -1
+        @rows = 0
+      end
+    end
+
+    def row(*args)
+      @row_data << args
+    end
+
+    # data-type='distance' (microdata for each statistic)
+    def _row(*args, &block)
+      attributes    = args.extract_options!
+      @row_scope    = args.shift
+      @row_index    += 1
+      @row_tags     = []
+
+      merge_class! attributes, index_class(@row_index, @rows)
+
+      template.haml_tag :dt, t!(:"#{@section_scope}.#{@column_scope}.#{@row_scope}", locale_keys.merge(attributes.slice(:past, :present, :future).merge(:scope => :"reports.titles"))), merge_class(attributes, "key")
+      template.haml_tag :dd, report_value, merge_class(attributes.merge(:"data-stat" => @row_scope.to_s), "value")
+    end
+
+    private
+    def report_value
+      keys = @filter + [@section_scope, @column_scope, @row_scope]
+      result = report
+      begin
+
+        keys.each { |key| result = result[key] }  
+      rescue Exception => e
+        raise keys.inspect
+      end
+
+      if result.is_a?(::Array)
+        result.compact.blank? ? I18n.t("reports.values.missing") : result
+      else
+        result.blank? ? I18n.t("reports.values.missing") : result
+      end
+    end
+
+    def report_subtitle
+      keys = @filter + [@section_scope, :subtitle]
+      result = report
+      keys.each { |key| result = result[key] }
+      result
+    end
+
+    def record_key(record_or_key)
+      if record_or_key.is_a?(String) || record_or_key.is_a?(Symbol)
+        record_or_key.to_s
+      else
+        record_or_key.class.name
+      end
+    end
+
+    def id_for(type, key, value, row_index = @row_index, column_index = @column_index)
+      [key, type, row_index, column_index].compact.map do |node|
+        node.to_s.gsub(/[\s_]/, "-")
+      end.join("-")
+    end
+
+    # reports:
+    #   titles:
+    #     what:
+    #       summary: Quick Summary
+    #       total: Total Activity
+    #     deal:
+    #       what:
+    #         summary: Quick Summary
+    #         total: Total Activity
+    #     rewards_deal:
+    #       what:
+    #         summary: Quick Summary
+    #         total: Total Activity
+
+  end
+end

data/lib/storefront/form.rb

@@ -0,0 +1,65 @@
+module Storefront
+  class Form
+    attr_reader :content, :template, :object, :parent, :tabindex, :access_keys
+    include Haml::Helpers
+    
+    # - form_for @user do |form|
+    #   = form.inputs do
+    #     = form.input :name, :as => :string
+    #     = form.input :email, :as => :email
+    #     = form.partial :name, :values
+    # novalidate
+    def initialize(template, *args, &block)
+      init_haml_helpers
+      @template              = template
+      options                = args.extract_options!
+      record_or_key          = args.shift
+      if record_or_key.is_a?(::Symbol) || record_or_key.is_a?(::String)
+        record_or_key = record_or_key.to_s.camelize.constantize.new
+      end
+      @object                = record_or_key
+      attributes             = options.delete(:html) || {}
+      attributes[:action]    = options.delete(:url)
+      attributes[:class]     = options.delete(:class) if options.has_key?(:class)
+      attributes[:id]        = options.delete(:id) if options.has_key?(:id)
+      attributes[:multipart] = options.delete(:multipart).to_s if options.has_key?(:multipart)
+      method                 = attributes.delete(:method)
+      if method.blank?
+        if record_or_key.respond_to?(:new_record?) && !record_or_key.new_record?
+          method = :put
+        else
+          method = :post
+        end
+      end
+      
+      if method == :get
+        attributes[:method] = :get
+      else
+        attributes[:method] = :post
+      end
+      #role="form" 
+      #role="search" 
+      # other roles = button, checkbox, link, menuitem, menuitemcheckbox, menuitemradio, presentation, progressbar, radio, slider, scrollbar, tab, or treeitem
+      # article, document, application, presentation or main
+      # http://www.w3.org/TR/wai-aria/roles#widget_roles
+    
+      @content = template.capture_haml do
+        template.haml_tag :form, attributes do
+          if block_given?
+            fields = Storefront::Form::Fields.new(@template, 
+              :tabindex    => 1, 
+              :access_keys => {}, 
+              :object      => @object, 
+              :keys        => [@object.class.name.underscore],
+              &block
+            )
+          end
+          
+          unless method == attributes[:method]
+            template.haml_tag :input, :type => :hidden, :name => :_method, :value => method
+          end
+        end
+      end
+    end
+  end
+end

data/lib/storefront/form/elements.rb

@@ -0,0 +1,101 @@
+module Storefront
+  class Form
+    module Elements
+      def wrapper_id(attribute, options = {})
+
+      end
+      
+      # input :name, :as => :string, :class => "string something", :label_method => x, :value_method => y
+      # disabled, readonly, accesskey, tabindex
+      # button, checkbox, color, date, datetime, datetime-local, email, file, hidden, image, month, number, password, radio, range , reset, search, submit, tel, text, time, url, week
+      def input(attribute, options = {}, &block)
+        # aria-required=true
+        
+        options[:required] = required?(attribute) unless options.has_key?(:required)
+        options[:as] ||= default_input_type(attribute, options)
+        
+        html_class = [
+          options[:required] ? "required" : "optional",
+          errors_on?(attribute, options) ? "error" : nil
+        ].compact.uniq
+        
+        # input
+        input_attributes            = {}
+        if options[:input_html].present?
+          options[:input_html].each do |key, value|
+            input_attributes[key] = value
+          end
+        end
+        input_attributes[:class]    = (html_class << (options.delete(:class) || options[:as]).to_s).compact.join(" ")
+        input_attributes[:id]       ||= input_id(attribute)
+        
+        input_attributes[:name]     ||= input_name(attribute, options)
+        input_attributes[:value]    ||= input_value(attribute, options.delete(:value))
+        input_attributes[:tabindex] = @tabindex
+        
+        @tabindex = @tabindex + 1
+        access_key = input_attributes.delete(:accesskey) || access_key_for(attribute)
+        input_attributes[:accesskey] = access_key
+        #input_attributes = {
+        #  :input_attributes => input_attributes,
+        #  :include_blank    => options.delete(:include_blank)
+        #}
+        
+        # label
+        unless options[:label] == false
+          label_attributes            = options.delete(:label_html) || {}
+          label_attributes[:for]      ||= input_attributes[:id]
+          label_attributes[:id]       ||= input_id(attribute, "label")
+          label_attributes[:class]    = "label"
+          label_attributes[:value]    = localized_string(attribute, options[:label], :label)
+          label_attributes[:value]    = humanized_attribute_name(attribute) if label_attributes[:value].blank?
+        else
+          label_attributes = false
+        end
+        
+        # wrapper
+        wrapper_attributes          = options.delete(:wrapper_attributes) || {}
+        wrapper_attributes[:class]  = (html_class << wrapper_attributes[:class]).compact.join(" ")
+        wrapper_attributes[:id]     ||= input_id(attribute, "field")
+        
+        # hint
+        #return if options[:hint].blank? or options[:hint].kind_of? Hash
+        hint_class              = options[:hint_class]# || default_hint_class
+        hint_attributes         = options.delete(:hint_html) || {}
+        hint_attributes[:class] = "hint inline-hints"
+        hint_attributes[:value] = localized_string(attribute, options[:hint], :hint)
+        
+        # error
+        error_attributes            = options.delete(:error_html) || {}
+        error_attributes[:class]    = "error"
+        
+        elements = []
+        if options[:as] == :hidden
+          elements << :input
+        else
+          if label_attributes
+            elements << :label
+          end
+          elements = elements.concat [:input, :hints, :errors]
+        end
+        
+        options[:input_attributes]  = input_attributes
+        options[:label_attributes]  = label_attributes
+        options[:hint_attributes]   = hint_attributes
+        options[:error_attributes]  = error_attributes
+
+        template.capture_haml do
+          template.haml_tag :li, wrapper_attributes do
+            result = elements.map do |element|
+              send("#{element}_for", attribute, options)
+              #if element == :input && block_given?
+              #  yield
+              #end
+            end.join
+            template.haml_concat result.gsub(/\n$/, "")
+          end
+        end
+      end
+    end
+  end
+end