abstract-interface 0.0.3

data/Rakefile

@@ -0,0 +1,64 @@
+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"].select{|f| f !~ /\/_/}
+  t.libs = ['lib'].collect{|f| "#{File.dirname __FILE__}/#{f}"}
+end
+
+# Gem
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'fileutils'
+
+spec = Gem::Specification.new do |s|
+	s.name = "abstract-interface"
+	s.version = "0.0.3" 
+	s.summary = "Abstract Interface for the Crystal Framework"
+	s.description = "Abstract Interface for the Crystal Framework"
+	s.author = "Alexey Petrushin"
+	#	s.email = ""
+	s.homepage = "http://github.com/alexeypetrushin/abstract-interface"
+  
+	s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+	
+  s.files = (['Rakefile', 'readme.md'] + Dir.glob("{lib,spec}/**/*"))
+	
+	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("abstract-interface*.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/abstract_interface.rb

@@ -0,0 +1,64 @@
+module AbstractInterface
+  class << self
+    inject :logger => :logger, :config => :config, :environment => :environment
+    
+    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
+        
+    def theme_metadata theme
+      logger.warn "Complex calculation (AbstractInterface.theme_metadata) called in production!" if config.production?
+      
+      metadata = {}
+
+      name = "/#{Crystal::Template::DIRECTORY_NAME}/#{THEMES_DIR}/#{theme}/metadata.rb"
+      if environment.file_exist? name
+        fname = environment.find_file name
+        code = File.read fname
+        metadata = eval code
+        metadata.must_be.a Hash        
+      end
+      
+      metadata.to_openobject
+    end
+    
+    def layouts_defined?
+      !!layout_configurations_dir
+    end
+    
+    # Place definitions of your layouts into :layout_configurations_dir folder, you can have multiple such directories
+    def layout_definitions_without_cache theme
+      name = "#{layout_configurations_dir.must_be.present}/#{theme}.yml"
+      raise "File '#{name}' not exist!" unless environment.file_exist? name
+    
+      result = {}
+      environment.find_files(name).each do |fname|      
+        lds = YAML.load_file(fname)
+        validate_layout_definition!(lds, theme)
+        result.merge! lds
+      end
+      result
+    end
+    cache_method_with_params_in_production :layout_definitions
+    
+    protected
+      def validate_layout_definition! lds, theme
+        lds.must_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.must_be.a Hash
+          ld.must.include 'layout_template'
+          ld.must.include 'slots'
+          ld['slots'].must_be.a Hash
+        end
+      end
+  end
+    
+end

data/lib/abstract_interface/controller_helper.rb

@@ -0,0 +1,24 @@
+module AbstractInterface
+  module ControllerHelper
+    def current_theme
+      @current_theme ||= AbstractInterface::Theme.new
+    end
+
+    # TODO1
+    # 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/haml_builder.rb

@@ -0,0 +1,56 @@
+module AbstractInterface
+  class HamlBuilder < BasicObject
+    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.to_openobject if value.is_a? Hash
+      
+      block_value = if block 
+        if block.arity <= 0
+          template.must_be.defined
+          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/support.rb

@@ -0,0 +1,40 @@
+# 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].must_be.a [Symbol, String]
+        result[k] = "#{result[k]}#{v}"
+      else
+        result[k] = v
+      end
+    end
+    result
+  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/themed_form_helper.rb

@@ -0,0 +1,74 @@
+module AbstractInterface
+  class 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 = OpenObject.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
+      template.render template.themed_partial('forms/line'), :object => {:items => items, :delimiter => false}.to_openobject
+    end
+    
+    def line_with_delimiters *items
+      template.render template.themed_partial('forms/line'), :object => {:items => items, :delimiter => true}.to_openobject
+    end
+    
+    
+    # 
+    # Form fields
+    # 
+    %w(
+      check_box_tag
+      field_set_tag
+      file_field_tag      
+      password_field_tag
+      radio_button_tag
+      select_tag
+      text_field_tag
+      text_area_tag        
+    ).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
+    
+    %w(
+      hidden_field_tag
+      submit_tag
+    ).each{|m| delegate m, :to => :template}
+    
+  end
+end

data/lib/abstract_interface/view_builder.rb

@@ -0,0 +1,100 @@
+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
+    # 
+    %w(
+      capture
+      concat
+      content_for
+      tag
+      render
+      themed_resource        
+      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
+      
+      AbstractInterface::HamlBuilder.get_input self.template, opt, &block
+    end        
+    
+    
+    # 
+    # Forms
+    # 
+    def form_tag *args, &block
+      f = ThemedFormHelper.new(template)
+      
+      content = block ? capture{block.call(f)} : ""             
+      html = render(
+        themed_partial('forms/form'), 
+        :object => {:form_attributes => options, :content => content}.to_openobject
+      )
+      
+      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    
+  
+    private
+    
+      def render_haml_builder folder, template, *args, &block
+        opt = options *args, &block
+        
+        partial = "#{folder}/#{template}"
+
+        html = render themed_partial(partial), :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
+  end
+end

data/lib/abstract_interface/view_helper.rb

@@ -0,0 +1,42 @@
+module AbstractInterface
+  module ViewHelper
+    def b
+      @b ||= AbstractInterface::ViewBuilder.new self
+    end
+    alias_method :builder, :b
+
+    def themed_resource resource
+      "/#{AbstractInterface.plugin_name.must_not_be.blank}/#{THEMES_DIR}/#{current_theme.name}/#{resource}"
+    end
+    
+    def themed_partial partial
+      themed_partial = "/#{THEMES_DIR}/#{current_theme.name}/#{partial}"
+      if Crystal::Template.exist? themed_partial
+        themed_partial
+      else
+        "/#{THEMES_DIR}/default/#{partial}"
+      end
+    end
+    
+    def current_theme
+      controller.current_theme
+    end
+
+    # TODO1
+    # 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/readme.md

@@ -0,0 +1,3 @@
+# Abstract Interface for the Crystal Framework
+
+Tool for rapid interface creation, [add more]

data/spec/haml_builder_spec.rb

@@ -0,0 +1,121 @@
+dir = File.expand_path(File.dirname(__FILE__))
+require "#{dir}/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
+    
+    AbstractInterface::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
+    lambda{
+      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/helper.rb

@@ -0,0 +1,9 @@
+dir = File.expand_path(File.dirname(__FILE__))
+lib_dir = File.expand_path("#{dir}/../../../lib")
+$LOAD_PATH << lib_dir unless $LOAD_PATH.include? lib_dir
+
+require 'crystal/support'
+require 'abstract_interface/support'
+require "abstract_interface/haml_builder"
+
+require 'spec_ext'

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: abstract-interface
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Alexey Petrushin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-11 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: crystal
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Abstract Interface for the Crystal Framework
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- readme.md
+- lib/abstract_interface/abstract_interface.rb
+- lib/abstract_interface/controller_helper.rb
+- lib/abstract_interface/haml_builder.rb
+- lib/abstract_interface/support.rb
+- lib/abstract_interface/theme.rb
+- lib/abstract_interface/themed_form_helper.rb
+- lib/abstract_interface/view_builder.rb
+- lib/abstract_interface/view_helper.rb
+- spec/haml_builder_spec.rb
+- spec/helper.rb
+- spec/spec.opts
+has_rdoc: true
+homepage: http://github.com/alexeypetrushin/abstract-interface
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Abstract Interface for the Crystal Framework
+test_files: []
+