crystal-ext 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*~
+.DS_Store
+.require_paths
+Thumbs.db

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+Dir.chdir File.dirname(__FILE__)	
+
+# Specs
+task :default => :spec
+
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_files = FileList["spec/**/*_spec.rb"]
+	t.libs = ["lib", "spec"]
+end
+
+# Gem
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'fileutils'
+
+spec = Gem::Specification.new do |s|
+	s.name = "crystal-ext"
+	s.version = "0.0.1" 
+	s.summary = "Crystal Ext - Extensions for the Crystal framework"
+	s.description = "Crystal Ext - Extensions for the Crystal framework"
+	s.author = "Alexey Petrushin"
+	#	s.email = ""
+	s.homepage = "http://github.com/alexeypetrushin/crystal-ext"
+  
+	s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  # s.extra_rdoc_files = ["README.rdoc"]
+	
+  # s.files = (%w{rakefile readme.md .gitignore} + Dir.glob("{app,lib,spec,.git}/**/*"))
+  s.files = (%w{Rakefile readme.md .gitignore} + Dir.glob("{lib,spec,git}/**/*"))
+	
+	s.require_paths = ["lib"]
+
+  [
+    'crystal',
+  ].each{|name| s.add_dependency(name)}
+
+end
+
+PACKAGE_DIR = "#{File.expand_path File.dirname(__FILE__)}/build"
+
+Rake::GemPackageTask.new(spec) do |p|
+	package_dir = PACKAGE_DIR
+#	FileUtils.mkdir package_dir unless File.exist? package_dir	
+	p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+	p.need_zip = true
+	p.package_dir = package_dir
+end
+
+# CLEAN.include [ 'pkg', '*.gem']
+
+task :push do
+  dir = Dir.chdir PACKAGE_DIR do
+    gem_file = Dir.glob("crystal*.gem").first
+    system "gem push #{gem_file}"
+  end
+end
+
+task :clean do
+  system "rm -r #{PACKAGE_DIR}"
+end
+
+task :release => [:gem, :push, :clean]

data/lib/abstract_interface/controller_helper.rb

@@ -0,0 +1,30 @@
+module AbstractInterface
+  module ControllerHelper
+    TEMPLATE_EXTENSIONS = ['html.haml', 'html.erb']
+
+    def themed_partial_exist? partial
+      partial = partial + "_t"
+      
+      partial_fname = if pos = partial.index('/')
+        partial.clone.insert(pos + 1, '_')
+      else
+        "_#{partial}"
+      end
+      
+      TEMPLATE_EXTENSIONS.any?{|ext| File.exist? "#{AbstractInterface.themes_dir}/#{current_theme.name}/#{partial_fname}.#{ext}"}
+    end    
+    cache_with_params! :themed_partial_exist? unless Rails.development?
+    
+    def themed_partial partial
+      if themed_partial_exist? partial
+        "/themes/#{current_theme.name}/#{partial}_t"
+      else
+        "/themes/default/#{partial}_t"
+      end
+    end
+    
+    def current_theme
+      @current_theme ||= AbstractInterface::Theme.new
+    end
+  end
+end

data/lib/abstract_interface/form_builders/abstract_form_builder.rb

@@ -0,0 +1,79 @@
+module AbstractInterface
+  module FormBuilders
+    module AbstractFormBuilder
+  
+      attr_reader :template
+  
+      def line *items
+        template.render :partial => template.themed_partial('forms/line'), :object => {:items => items, :delimiter => false}.to_openobject
+      end
+  
+      def submit *args
+        @template.submit_tag *args
+      end
+  
+      # def hidden_field_tag *args
+      #   result[:hidden_fields] << @template.hidden_field_tag(*args)
+      # end
+  
+      def line_with_delimiters *items
+        template.render :partial => template.themed_partial('forms/line'), :object => {:items => items, :delimiter => true}.to_openobject
+      end
+  
+      # text_field_tag, ... xxx_tag
+      def method_missing name, *args, &block
+        options = args.extract_options!.symbolize_keys
+        args << options
+
+        inject_styles! options, name
+
+        input = @template.send name, *args, &block
+
+        remove_styles! options
+
+        custom_helper input, options, name, options[:object], *args
+      end
+  
+      def error_messages *errors
+        if errors.size == 1 and errors.first.is_a?(Array)
+          custom_error_messages *errors
+        else
+          custom_error_messages errors
+        end
+      end
+      
+      def field_tag html, options = {}
+        custom_helper html, options, nil, options[:object]
+      end
+  
+      protected
+        def custom_helper input, options, field, object, *args
+          # Input
+          options[:input] = input
+
+          # Errors
+          errors = options[:errors] || (object ? (object.errors.on(field) || []) : [])
+          errors = [errors] unless errors.is_a?(Array)
+          options[:errors] = errors
+
+          template.render :partial => template.themed_partial('forms/field'), :object => options.to_openobject
+        end
+  
+        def custom_error_messages errors
+          errors = [errors] unless errors.is_a?(Array)
+          template.render :partial => template.themed_partial('forms/errors'), :object => errors
+        end
+  
+        def inject_styles! options, name
+          name = name.to_s.sub(/_tag$/, "")
+          options[:class] ||= "";
+          options[:class] << " themed_input #{name}_input"
+        end
+  
+        def remove_styles! options
+          options.delete :class
+          options.delete 'class' # sometimes it's a String
+        end
+    end
+  end
+end

data/lib/abstract_interface/form_builders/themed_form_builder.rb

@@ -0,0 +1,46 @@
+module AbstractInterface
+  module FormBuilders
+    class ThemedFormBuilder < ActionView::Helpers::FormBuilder
+      include AbstractFormBuilder
+  
+      helpers = field_helpers +
+          %w{date_select datetime_select time_select} +
+          %w{collection_select select country_select time_zone_select} -
+          %w{hidden_field fields_for submit} # Don't decorate these
+
+      helpers.each do |name|
+        define_method(name) do |field, *args|
+          options = args.extract_options!
+          args << options
+        
+          label = if object.class.respond_to? :human_attribute_name
+            object.class.try(:human_attribute_name, field)
+          else
+            object.t field
+          end
+        
+          options[:label] = label unless options.include? :label
+
+          inject_styles! options, name
+
+          input = super field, *args
+
+          remove_styles! options
+
+          custom_helper input, options, field, object, *args
+        end
+      end
+    
+      def error_messages
+        errors = object.errors.on(:base) || []
+        custom_error_messages errors
+      end
+
+      protected
+  
+      def object
+        @object ||= @template.instance_variable_get "@#{@object_name}"
+      end
+    end
+  end
+end

data/lib/abstract_interface/form_builders/themed_form_tag_builder.rb

@@ -0,0 +1,13 @@
+module AbstractInterface
+  module FormBuilders
+    class ThemedFormTagBuilder
+      include AbstractFormBuilder
+  
+      attr_reader :template
+
+      def initialize template
+        @template = template
+      end
+    end
+  end
+end

data/lib/abstract_interface/haml_builder.rb

@@ -0,0 +1,56 @@
+module AbstractInterface
+  class HamlBuilder < BlankSlate
+    def initialize template, hash = OpenObject.new
+      @template = template
+      @hash, @array = hash, []
+    end
+    
+    def method_missing m, value = nil, &block      
+      @hash[m] = HamlBuilder.get_input @template, value, &block
+      nil
+    end
+  
+    def add value = nil, &block      
+      @array << HamlBuilder.get_input(@template, value, &block)
+      nil
+    end
+    
+    # def add_item content, opt = {}, &block
+    #   opt[:content] = content
+    #   opt[:content] ||= @template.capture &block if block
+    #   add opt
+    # end
+      
+    def get_value
+      !@array.empty? ? @array : @hash
+    end
+    
+    def self.get_input template, value, &block
+      value = value.is_a?(Hash) ? value.to_openobject : value
+      
+      block_value = if block 
+        if block.arity <= 0
+          template.should_not! :be_nil
+          template.capture &block
+        else
+          b = 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 = value.merge block_value
+        else
+          raise "Invalid usage!" if value.include? :content
+          value.content = block_value
+        end
+      end
+      
+      value || block_value
+    end    
+  end
+end

data/lib/abstract_interface/model_stub.rb

@@ -0,0 +1,20 @@
+module Samples
+  class Errors < OpenObject
+    def on key
+      self[key]
+    end
+  end
+  
+  class ThemeSample < OpenObject
+
+  end
+  
+  def self.build_stub!
+    s = ThemeSample.new :name => "Some Name", :active => true, :body => "Some text"
+    s.errors = Errors.new \
+      :base => ["Base Error Description", "Base Error Description 2"],
+  	  :name => ["Name Error Description 1", "Name Error Description 2"]
+    s
+  end
+  
+end

data/lib/abstract_interface/support.rb

@@ -0,0 +1,56 @@
+# 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
+  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].should! :be_a, [Symbol, String]
+        result[k] = "#{result[k]}#{v}"
+      else
+        result[k] = v
+      end
+    end
+    result
+  end
+  
+  protected
+    def method_missing( sym, arg=nil, &blk)
+      type = sym.to_s[-1,1]
+      key = sym.to_s.sub(/[=?!]$/,'').to_sym
+      if type == '='
+        define_slot(key,arg)
+      elsif type == '!'
+        define_slot(key,arg)
+        self
+      elsif type == '?'
+        !self[key].blank?
+      else
+        self[key]
+      end
+    end
+end

data/lib/abstract_interface/theme.rb

@@ -0,0 +1,37 @@
+module AbstractInterface 
+  class Theme
+    attr_writer :name, :layout_template, :layout    
+    def name; @name || 'default' end    
+    def layout; @layout || 'default' end
+    
+    def layout_template
+      if @layout_template
+        # Check if this template exists
+        exists = layout_definitions.any?{|layout_name, ld| ld['layout_template'] == @layout_template}
+        exists ? @layout_template : 'default'
+      else
+        layout_definition['layout_template'] || 'default'
+      end
+    end
+    
+    def layout_definition      
+      layout_definitions[layout] || layout_definitions['default'] || {}
+    end
+    
+    def layout_definitions
+      if AbstractInterface.layouts_defined?
+        AbstractInterface.layout_definitions(name)
+      else
+        {}
+      end
+    end
+    
+    def available_layouts_names
+      layout_definitions.keys
+    end
+
+    def metadata
+      AbstractInterface.theme_metadata(name)
+    end
+  end
+end

data/lib/abstract_interface/view_builder.rb

@@ -0,0 +1,158 @@
+module AbstractInterface 
+  class ViewBuilder
+    
+    def self.generate_helper_methods methods
+      
+      methods.each do |folder, templates|
+        templates.each do |template|
+          code = %{\
+def #{template} *args, &block
+  render_haml_builder "#{folder}", "#{template}", *args, &block
+end}
+
+          eval code, binding, __FILE__, __LINE__
+        end
+      end
+      
+    end
+    
+    
+    attr_reader :template
+    def initialize template
+      @template = template
+    end
+
+
+    # 
+    # Template methods
+    # 
+    PROXY_METHODS = %w{
+      capture
+      concat
+      content_for
+      content_tag
+      render
+      themed_partial
+      themed_partial_exist?
+      themed_resource            
+    }
+    PROXY_METHODS.each do |m|
+      delegate m, :to => :template
+    end
+    
+      
+    # 
+    # Builders
+    #     
+    def options *args, &block
+      opt = args.extract_options!
+      args.size.should! :be_in, 0..1
+      opt[:content] = args.first if args.size == 1
+      
+      HamlBuilder.get_input self.template, opt, &block
+      # options.should! :be_a, Hash
+      # block.should! :be_a, Proc
+      # if block
+      #   b = HamlBuilder.new self.template
+      #   block.call b
+      #   options.merge b.get_value          
+      # else
+      #   options
+      # end
+    end        
+    
+    # 
+    # Forms
+    # 
+    def form *args, &block
+      b = FormBuilders::ThemedFormTagBuilder.new self.template
+    
+      options = {}.to_openobject
+      prepare_form! options, *args
+      
+      # wrap_theme 'forms/begin', true do
+        concat render(:partial => themed_partial('forms/begin'), :object => options)
+        concat capture(b, &block)
+        concat render(:partial => themed_partial('forms/end'), :object => options)
+      # end
+    end
+
+    def form_for(record_or_name_or_array, *args, &proc)
+      raise ArgumentError, "Missing block" unless block_given?
+
+      options = args.extract_options!
+
+      case record_or_name_or_array
+      when String, Symbol
+        object_name = record_or_name_or_array
+        object = instance_variable_get "@#{record_or_name_or_array}"
+      when Array
+        object = record_or_name_or_array.last
+        object_name = ActionController::RecordIdentifier.singular_class_name(object)
+        self.template.apply_form_for_options!(record_or_name_or_array, options)
+        args.unshift object
+      else
+        object = record_or_name_or_array
+        object_name = ActionController::RecordIdentifier.singular_class_name(object)
+        self.template.apply_form_for_options!([object], options)
+        args.unshift object
+      end
+
+      # Rendering Form
+      renderer_options = {}.to_openobject
+      prepare_form! renderer_options, options.delete(:url) || {}, options.delete(:html) || {}
+      
+      # wrap_theme 'forms/begin', true do
+        concat render(:partial => themed_partial('forms/begin'), :object => renderer_options)
+    
+        options[:builder] = FormBuilders::ThemedFormBuilder
+        self.template.fields_for(object_name, *(args << options), &proc)
+
+        concat render(:partial => themed_partial('forms/end'), :object => renderer_options)
+      # end
+    end
+    
+  
+    private
+      # # We need to wrap top-level default templates (for non-existing templates for current theme) inside '_d' div.
+      # def wrap_theme partial, concat = false, &block
+      #   unless themed_partial_exist? partial                    
+      #     # we don't need _theme_wrapper for dialog and popup, it should be invisible
+      #     classes = if AbstractInterface.dont_wrap_into_placeholder.include? partial
+      #       "_d"
+      #     else
+      #       "_d _theme_wrapper"
+      #     end
+      #     
+      #     if concat            
+      #       self.concat %{<div class="#{classes}">}
+      #       block.call
+      #       self.concat %{</div>}              
+      #     else
+      #       html = block.call
+      #       content_tag :div, html, :class => classes
+      #     end
+      #   else          
+      #     block.call
+      #   end
+      # end
+    
+      def render_haml_builder folder, template, *args, &block
+        opt = options *args, &block
+        
+        partial = "#{folder}/#{template}"
+
+        # html = wrap_theme partial do
+        html = render :partial => themed_partial(partial), :object => opt
+        # end
+        
+        block ? self.concat(html) : html
+      end
+          
+      def prepare_form! options, *args
+        buff = template.form_tag *args
+        options[:begin] = buff
+        options[:end] = '</form>'
+      end
+  end
+end

data/lib/abstract_interface/view_helper.rb

@@ -0,0 +1,31 @@
+module AbstractInterface
+  module ViewHelper
+    # 
+    # Basic
+    # 
+    def b
+      @b ||= AbstractInterface::ViewBuilder.new self
+    end
+    alias_method :builder, :b
+
+    def themed_resource resource
+      "/#{AbstractInterface.plugin_name.should_not_be!(:blank)}/themes/#{current_theme.name}/#{resource}"
+    end
+    
+    def build_layout layout = nil
+      # Configuring
+      current_theme.layout = layout
+
+      #  Rendering
+      current_theme.layout_definition['slots'].each do |slot_name, slots|
+        slots = Array(slots)
+        slots.each do |partial|
+          content_for slot_name do
+            render :partial => partial
+          end
+        end
+      end
+    end  
+      
+  end
+end

data/lib/abstract_interface.rb

@@ -0,0 +1,78 @@
+require 'abstract_interface/haml_builder'
+require 'abstract_interface/model_stub'
+require 'abstract_interface/view_helper'
+require 'abstract_interface/support'
+
+ActionController::Base.class_eval do
+  include AbstractInterface::ControllerHelper
+  helper AbstractInterface::ViewHelper
+  
+  helper_method :themed_partial_exist?, :themed_partial, :current_theme
+end
+
+ActionView::Base.field_error_proc = lambda do |html_tag, instance|
+  html_tag
+end
+
+module AbstractInterface
+  class << self
+    attr_accessor :plugin_name
+    attr_accessor :layout_configurations_dir
+    
+    def generate_helper_methods *args
+      AbstractInterface::ViewBuilder.generate_helper_methods *args
+    end
+    
+    def available_themes; @available_themes ||= [] end
+    
+    # Templates that should be wrapped if it doesn't defined for current theme
+    # def dont_wrap_into_placeholder; @dont_wrap_into_placeholder ||= Set.new end
+    
+    # TODO 3 don't cache it becouse there's a lots of text data that will be reside in memory.
+    def theme_metadata theme
+      metadata = {}
+      fname = "#{AbstractInterface.themes_dir}/#{theme}/metadata.rb"
+      if File.exist? fname
+        code = File.read fname
+        metadata = eval code
+        metadata.should! :be_a, Hash        
+      end
+      metadata.to_openobject
+    end
+    cache_with_params! :theme_metadata unless Rails.development?
+    
+    def themes_dir
+      "#{RAILS_ROOT}/vendor/plugins/#{AbstractInterface.plugin_name.should_not_be!(:blank)}/app/views/themes"
+    end
+    
+    def layouts_defined?
+      !!layout_configurations_dir
+    end
+    
+    def layout_definitions theme
+      fname = "#{layout_configurations_dir.should_not_be!(:empty)}/#{theme}.yml"
+      File.should! :exist?, fname
+      lds = YAML.load_file(fname)
+      validate_layout_definition!(lds, theme)
+      lds
+    end
+    cache_with_params! :layout_definitions unless Rails.development?
+    
+    protected
+      def validate_layout_definition! lds, theme
+        lds.should! :be_a, Hash
+        unless lds.include?('default')
+          raise "No 'default' layout definition for '#{theme}' Theme (there always should be definition for 'default' layout)!"
+        end
+        lds.each do |theme_name, ld|
+          ld.should! :be_a, Hash
+          ld.should! :include, 'layout_template'
+          ld.should! :include, 'slots'
+          ld['slots'].should! :be_a, Hash
+        end
+      end
+  end
+    
+end
+
+Rails.development{RailsExt.create_public_symlinks!} # rails_ext.css, rails_ext.js in development mode