rad_face 0.0.1

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake_ext'
+
+project(
+  name: "face",
+  official_name: "rad_face",
+  gem: true,
+  summary: "User Interface tools for Rad Framework",
+
+  author: "Alexey Petrushin",
+  homepage: "http://github.com/alexeypetrushin/rad_face"
+)

data/lib/components/face.rb

@@ -0,0 +1,5 @@
+rad.register :face, depends_on: [:controller, :template, :js, :web, :assets] do
+  require 'face/gems'
+  require 'face/require'
+  Rad::Face.new
+end

data/lib/components/face.yml

@@ -0,0 +1,2 @@
+themes_path: '/themes'
+available_themes: []

data/lib/components/theme.rb

@@ -0,0 +1,3 @@
+rad.register :theme, depends_on: :face, scope: :cycle do
+  Rad::Face::Theme.new
+end

data/lib/face/face.rb

@@ -0,0 +1,9 @@
+class Rad::Face    
+  attr_accessor :themes_path, :theme, :available_themes
+  require_attr :themes_path
+  def available_themes; @available_themes ||= [] end
+  
+  def availiable_layouts
+    @availiable_layouts ||= {}
+  end
+end

data/lib/face/gems.rb

@@ -0,0 +1,6 @@
+if respond_to? :fake_gem
+  fake_gem 'rad_core'
+  fake_gem 'rad_ext'
+  fake_gem 'rad_js'
+  fake_gem 'rad_assets'
+end

data/lib/face/haml_builder.rb

@@ -0,0 +1,49 @@
+class Rad::Face::HamlBuilder < BasicObject
+  def initialize template, hash = {}
+    @template = template
+    @hash = ::Rad::Face::HtmlOpenObject.initialize_from(hash)
+    @array = []
+  end
+
+  def method_missing m, value = nil, &block      
+    @hash[m] = ::Rad::Face::HamlBuilder.get_input @template, value, &block
+    nil
+  end
+
+  def add value = nil, &block      
+    @array << ::Rad::Face::HamlBuilder.get_input(@template, value, &block)
+    nil
+  end
+
+  def get_value
+    !@array.empty? ? @array : @hash
+  end
+
+  def self.get_input template, value, &block
+    value = ::Rad::Face::HtmlOpenObject.initialize_from(value) if value.is_a? ::Hash
+  
+    block_value = if block 
+      if block.arity <= 0
+        template.must_be.defined
+        template.capture &block
+      else
+        b = ::Rad::Face::HamlBuilder.new template
+        block.call b
+        b.get_value
+      end
+    else
+      nil
+    end
+  
+    if value and block_value
+      if block_value.is_a? ::Hash
+        value.merge! block_value
+      else
+        raise "Invalid usage!" if value.include? :content
+        value.content = block_value
+      end
+    end
+  
+    value || block_value
+  end    
+end

data/lib/face/html_open_object.rb

@@ -0,0 +1,54 @@
+class Rad::Face::HtmlOpenObject < OpenObject
+  HTML_ATTRIBUTES = [:id, :class]
+  
+  def merge_html_attributes hash = {}
+    # html attributes
+    result = {}
+    HTML_ATTRIBUTES.each{|k| result[k.to_s] = self[k] if include? k}
+    html_attributes.each{|k, v| result[k.to_s] = v} if html_attributes?
+    
+    # merging html attributes with hash
+    hash.each do |k, v|
+      k = k.to_s
+      if result.include?(k) and v.is_a?(String)
+        string = result[k].must_be.a Symbol, String
+        result[k] = "#{result[k]}#{v}"
+      else
+        result[k] = v
+      end
+    end
+    result
+  end
+  
+  def self.initialize_from hash, deep = false
+    unless deep
+      ::Rad::Face::HtmlOpenObject.new.update hash 
+    else
+      r = ::Rad::Face::HtmlOpenObject.new
+      hash.each do |k, v|
+        r[k] = if v.is_a? Hash
+          v.to_openobject
+        else
+          v
+        end
+      end
+      r
+    end
+  end
+  
+  protected
+    # should threat newlines as blank
+    def method_missing m, arg = nil, &block      
+      type = m[-1,1]
+      if type == '='
+        self[m[0..-2]] = arg
+      elsif type == '!'        
+        self[m[0..-2]]
+      elsif type == '?'        
+        value = self[m[0..-2]]
+        !(value.is_a?(String) ? (value =~ /\A\s*\z/) : value.blank?)
+      else
+        self[m]
+      end
+    end  
+end

data/lib/face/require.rb

@@ -0,0 +1,18 @@
+require 'rad_ext'
+
+class Rad::Face
+end
+
+%w(
+  support
+  html_open_object
+  theme
+  haml_builder
+  themed_form_helper
+  view_builder
+  view_helper
+  face
+).each{|f| require "face/#{f}"}
+
+Rad::Template::Context.inherit Rad::Face::ViewHelper
+Rad::Controller::Abstract.inject theme: :theme

data/lib/face/support.rb

@@ -0,0 +1,42 @@
+# 
+# content_or_self
+# 
+[Hash, OpenObject].each do |aclass|
+  aclass.class_eval do 
+    def hash?; true end
+  end
+end
+
+NilClass.class_eval do
+  def content; "" end
+  def hash?; false end
+end
+
+String.class_eval do
+  def content; self end
+  def hash?; false end
+end
+
+# OpenObject
+OpenObject.class_eval do
+  def merge_html_attributes *a
+    raise "invalid usage, something wrong goin on, this method should be called only from instance of HtmlOpenObject class!"
+  end
+  alias_method :merge_html_attributes?, :merge_html_attributes
+  alias_method :merge_html_attributes!, :merge_html_attributes
+end
+
+
+# 
+# Automaticaly add content of action view to the :content content variable,
+# to eliminate need for "content_for :content do ..." stuff.
+# 
+Rad::Controller::Abstract::Render.class_eval do
+  protected
+    def render_content_with_content *a
+      content, context = render_content_without_content *a      
+      context.content_for :content, content      
+      return content, context
+    end
+    alias_method_chain :render_content, :content
+end

data/lib/face/theme.rb

@@ -0,0 +1,48 @@
+class Rad::Face::Theme      
+  def name; @name || 'default' end    
+  def name= name
+    # lots of other properties depends on :name, so we need to clean all of them if we change name
+    clear
+    @name = name.to_sym if name.present?
+  end
+  
+  attr_writer :layout
+  def layout; @layout || 'default' end            
+  
+  def layout_template
+    @layout_template || layout_definition['layout_template'] || 'default'
+  end      
+
+  def layout_template= layout_template
+    path = "#{rad.face.themes_path}/#{name}/layout_templates/#{layout_template}"      
+    @layout_template = (layout_template and rad.template.exist?(path)) ? layout_template : 'default'
+  end      
+  
+  def layout_definition
+    self.class.layout_definition(name, layout) || self.class.layout_definition(name, 'default') || {}
+  end
+
+  protected
+    def clear
+      @layout_config, @layout_template, @layout = nil
+    end
+  
+  class << self
+    def layout_definition theme, layout
+      path = "#{rad.face.themes_path}/#{theme}/layout_definitions/#{layout}.yml"
+      files = Rad::Environment::FilesHelper.find_files(path, rad.template.paths)
+      raise "multiple layout configs '#{layout}' for '#{theme}' theme!" if files.size > 1        
+      if absolute_path = files.first
+        YAML.load_file(absolute_path).tap do |definition|
+          definition.must_be.a Hash
+          definition.must.include 'layout_template'
+          definition.must.include 'slots'
+          definition['slots'].must_be.a Hash
+        end
+      else
+        nil
+      end
+    end
+    cache_method_with_params_in_production :layout_definition
+  end
+end

data/lib/face/themed_form_helper.rb

@@ -0,0 +1,74 @@
+class Rad::Face::ThemedFormHelper
+  attr_accessor :template
+
+  def initialize template
+    self.template = template
+  end
+
+  def error_messages *errors
+    errors = errors.first if errors.size == 1 and errors.first.is_a? Array
+    template.render template.themed_partial('/forms/errors'), object: errors
+  end
+
+  def form_field options, &block      
+    html_options = options.to_openobject
+    options = Rad::Face::HtmlOpenObject.new
+  
+    # prepare options
+    %w(errors label description required theme).each do |k| 
+      v = html_options.delete k
+      options[k] = v unless v.nil?
+    end
+    options.errors = options.errors.to_a
+
+    # CSS style
+    html_options.class ||= ""
+    html_options << " themed_input"
+  
+    options.content = template.capture{block.call(html_options)}
+  
+    html = template.render(template.themed_partial('/forms/field'), object: options)
+    template.concat html
+  end
+
+  def line *items
+    object = Rad::Face::HtmlOpenObject.initialize_from(items: items)
+    template.render template.themed_partial('/forms/line'), object: object
+  end    
+  
+  def self.generate_form_helper_methods methods
+    methods.each do |m|
+      define_method m do |*args|
+        options = args.extract_options!
+        template.capture do
+          form_field options do |html_options|
+            args << html_options
+            template.concat(template.send(m, *args))
+          end
+        end
+      end
+    end
+  end
+
+
+  # 
+  # Form fields
+  # 
+  methods = %w(
+    check_box_tag
+    field_set_tag
+    file_field_tag      
+    password_field_tag
+    radio_button_tag
+    select_tag
+    text_field_tag
+    text_area_tag        
+  )
+  generate_form_helper_methods methods  
+
+  %w(
+    hidden_field_tag
+    submit_tag
+  ).each{|m| delegate m, to: :template}
+
+end

data/lib/face/view_builder.rb

@@ -0,0 +1,96 @@
+class Rad::Face::ViewBuilder
+
+#   def self.generate_view_helper_methods methods      
+#     methods.each do |folder, templates|
+#       templates.each do |template|
+#         code = %{\
+# def #{template} *args, &block
+#   render_block "#{folder}", "#{template}", *args, &block
+# end}
+# 
+#         eval code, binding, __FILE__, __LINE__
+#       end
+#     end      
+#   end    
+
+  attr_reader :template
+  def initialize template
+    @template = template
+  end
+
+
+  # 
+  # Template methods
+  # 
+  %w(
+    capture
+    concat
+    content_for
+    tag
+    render
+    themed_partial
+    controller    
+  ).each do |m|
+    delegate m, to: :template
+  end
+
+  
+  # 
+  # Builders
+  #     
+  def options *args, &block
+    opt = args.extract_options!
+    args.size.must_be.in 0..1
+    opt[:content] = args.first if args.size == 1
+  
+    Rad::Face::HamlBuilder.get_input self.template, opt, &block
+  end        
+
+
+  # 
+  # Forms
+  # 
+  def form_tag *args, &block
+    f = Rad::Face::ThemedFormHelper.new(template)    
+  
+    content = block ? capture{block.call(f)} : ""             
+    object = Rad::Face::HtmlOpenObject.initialize_from(form_attributes: args, content: content)
+    html = render(
+      themed_partial('/forms/form'), 
+      object: object
+    )
+  
+    if block
+      template.concat html
+    else
+      html
+    end
+  end
+
+  def form_for *args, &block
+    model_helper, options = template.build_form_model_helper_and_form_options *args
+        
+    form_tag options do |themed_form_helper|
+      model_helper.form_helper = themed_form_helper
+    
+      block.call model_helper if block
+    end
+  end    
+
+  def render_block template, *args, &block
+    opt = options *args, &block
+    html = render themed_partial(template), object: opt
+    block ? self.concat(html) : html
+  end
+      
+  def prepare_form! options, *args
+    buff = template.form_tag *args
+    options[:begin] = buff
+    options[:end] = '</form>'
+  end
+  
+  protected
+    def method_missing m, *args, &block
+      render_block "/#{m}", *args, &block
+    end
+end

data/lib/face/view_helper.rb

@@ -0,0 +1,36 @@
+module Rad::Face::ViewHelper
+  inject theme: :theme
+
+  def b
+    @b ||= Rad::Face::ViewBuilder.new self
+  end
+  alias_method :builder, :b
+
+  def unique_id
+    @unique_id ||= 0
+    @unique_id += 1
+  end
+
+  def themed_partial partial
+    partial.must =~ /^\//
+    themed_partial = "/#{rad.face.themes_path}/#{theme.name}#{partial}"
+    if rad.template.exist? themed_partial
+      themed_partial
+    else
+      "/#{rad.face.themes_path}/default#{partial}"
+    end
+  end
+
+  def build_layout layout = nil
+    # Configuring
+    theme.layout = layout
+
+    # Rendering
+    theme.layout_definition['slots'].each do |slot_name, slots|
+      slots = Array(slots)
+      slots.each do |partial|
+        content_for slot_name, render(partial)
+      end
+    end
+  end
+end

data/readme.md

@@ -0,0 +1,3 @@
+# Face (UI toolkit) for the Rad Framework
+
+Tool for rapid interface creation, [add more]

data/spec/haml_builder_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+# 
+# Don't use should ==, it doesn't works with OpenObject
+# 
+describe "HamlBuilder use cases" do  
+  class TemplateStub
+    def self.capture &block
+      block.call
+      self.output
+    end
+    
+    class << self
+      attr_accessor :output
+    end
+  end
+  
+  def build *args, &block
+    opt = args.extract_options!
+    args.size.must_be.in 0..1
+    opt[:content] = args.first if args.size == 1
+    
+    Rad::Face::HamlBuilder.get_input(TemplateStub, opt, &block)
+  end
+  
+  it "should accept OpenObject as input" do
+    build({a: :b}.to_openobject).should == {a: :b}
+  end
+  
+  it "hash" do
+    (build do |o|
+      o.a :b
+    end).should == {a: :b}
+  
+    build(a: :b).should == {a: :b}
+  end
+  
+  it "array" do
+    (build do |a|
+      a.add 1
+      a.add 2
+    end).should == {content: [1, 2]}
+    
+    (build do |o|
+      o.a :b
+      o.ar do |a|
+        a.add 1
+        a.add 2
+      end      
+    end).should == {a: :b, ar: [1, 2]}
+  end
+  
+  it "capture" do
+    build("value").should == {content: "value"}
+    
+    (build do
+      TemplateStub.output = "value"
+    end).should == {content: "value"}
+    
+    (build do |o|
+      o.content do
+        TemplateStub.output = "value"
+      end
+    end).should == {content: "value"}
+    
+    (build do |o|
+      o.value do
+        TemplateStub.output = "value"
+      end
+    end).should == {value: "value"}
+  end
+  
+  it "invalid usage" do
+    -> {
+      build "value" do
+        TemplateStub.output = "value"
+      end
+    }.should raise_error(/Invalid usage!/)
+  end
+  
+  it "merge" do
+    (build a: :b do
+      TemplateStub.output = "value"
+    end).should == {a: :b, content: "value"}
+    
+    (build a: :b do |o|
+      o.c :d
+    end).should == {a: :b, c: :d}
+  end
+  
+  it "nested" do
+    (build a: :b do |o|
+      o.a do |o|
+        o.b :c
+      end
+    end).should == {
+      a: {b: :c}
+    }
+  end
+  
+  it "complex" do
+    (build a: :b do |o|      
+      o.hs do |h|
+        h.c :d
+      end
+      o.ar do |a|
+        a.add 1        
+        a.add 2
+      end
+      o.html do
+        TemplateStub.output = "value"
+      end
+    end).should == {
+      a: :b,
+      hs: {c: :d},
+      ar: [1, 2],
+      html: 'value'
+    }
+  end
+end

data/spec/html_open_object_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe "HamlBuilder use cases" do
+  def build_hoo h
+    Rad::Face::HtmlOpenObject.initialize_from h
+  end
+  
+  it "should threat newlines as blank" do
+    o = build_hoo(blank_line: "\n\n  \t", line_with_content: "abc")
+    o.blank_line?.should be_false
+    o.line_with_content?.should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec_ext'
+
+require 'rad_ext'
+require 'rad/spec'
+
+rad.face

data/spec/view_builder_spec/blank_symbols.html.erb

@@ -0,0 +1,5 @@
+<% if object.content? %>
+  content present
+<% else %>
+  content blank
+<% end %>

data/spec/view_builder_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "Template" do
+  with_view_path spec_dir
+  
+  inject template: :template
+  
+  before do
+    @view_builder = Rad::Face::ViewBuilder.new rad.template
+    @view_builder.stub!(:themed_partial){|partial| partial}
+  end
+  
+  it "should threat string with newlines as a blank string" do
+    @view_builder.render_block('/blank_symbols', content: "\n").should =~ /content blank/
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: rad_face
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexey Petrushin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-04 00:00:00.000000000 +04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rad_core
+  requirement: &2956520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2956520
+- !ruby/object:Gem::Dependency
+  name: rad_ext
+  requirement: &2956210 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2956210
+- !ruby/object:Gem::Dependency
+  name: rad_js
+  requirement: &2955920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2955920
+- !ruby/object:Gem::Dependency
+  name: rad_assets
+  requirement: &2955680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2955680
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- readme.md
+- lib/components/face.rb
+- lib/components/face.yml
+- lib/components/theme.rb
+- lib/face/face.rb
+- lib/face/gems.rb
+- lib/face/haml_builder.rb
+- lib/face/html_open_object.rb
+- lib/face/require.rb
+- lib/face/support.rb
+- lib/face/theme.rb
+- lib/face/themed_form_helper.rb
+- lib/face/view_builder.rb
+- lib/face/view_helper.rb
+- spec/haml_builder_spec.rb
+- spec/html_open_object_spec.rb
+- spec/spec_helper.rb
+- spec/view_builder_spec/blank_symbols.html.erb
+- spec/view_builder_spec.rb
+has_rdoc: true
+homepage: http://github.com/alexeypetrushin/rad_face
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.5.1
+signing_key: 
+specification_version: 3
+summary: User Interface tools for Rad Framework
+test_files: []