tanuki 0.3.1 → 0.4.0

data/lib/tanuki/meta_model.rb

@@ -0,0 +1,176 @@
+module Tanuki
+
+  # Tanuki::MetaModel contains all methods for the meta-model.
+  class MetaModel
+
+    include Tanuki::BaseBehavior
+
+    # Creates new meta-model +name+ in +namespace+.
+    # Model schema is passed as +data+.
+    # Stucture +models+ contains all models being generated.
+    def initialize(namespace, name, data, models)
+      @namespace = namespace
+      @name = name
+      @data = data
+      @models = models
+    end
+
+    # Returns class name for a given class type.
+    def class_name_for(class_type)
+      case class_type
+      when :model, :model_base then "#{@namespace}::Model::#{@name}"
+      when :manager, :manager_base then "#{@namespace}::Manager::#{@name}"
+      end
+    end
+
+    # Returns an array of code for alias-column name pair.
+    def key
+      @key.inspect
+    end
+
+    # Prepares data for template generation.
+    # Processes own keys, fields, etc.
+    def process
+      process_source
+      process_key
+      process_joins
+      process_filter
+      process_order
+    end
+
+    # Extracts the model firts-source information form the YAML @data
+    # and performs
+    def process_source
+      guess_table = @name.pluralize
+      @data ||= {}
+      @source = @data['source'] || guess_table
+      @source = {'table' => @source} if @source.is_a? String
+      @first_source = (@source['table'] || guess_table).downcase.to_sym
+    end
+
+    def process_key
+      if @source.include? 'key' && @source['key'].nil?
+        @key = []
+      else
+        @key = @source['key'] || 'id'
+      end
+      @key = [@key] if @key.is_a? String
+      raise 'invalid key' unless @key.is_a? Array
+      @key.map! do |k|
+        parts = k.split('.').map {|p| p.to_sym }
+        raise "invalid key field #{k}" if parts.count > 2
+        if parts.count == 2
+          if parts[0] != @first_source.to_s
+            raise 'all key fields should belong to the first-source'
+          end
+          parts
+        else
+          [@first_source, parts[0]]
+        end
+      end
+    end
+
+    def process_joins
+      @joins = {}
+      @joins[@first_source] = nil
+      joins = @source['joins'] || {}
+      joins = [joins] if joins.is_a? String
+      if joins.is_a? Array
+        joins = Hash[*joins.collect {|v| [v, nil] }.flatten]
+      end
+      if joins.is_a? Hash
+        joins.each_pair do |table_alias, join|
+          table_alias = table_alias.to_sym
+          if @joins.include? table_alias
+            raise "#{table_alias} is already in use"
+          end
+          if join && (join['on'].is_a? Hash)
+            table_name = join['table'] || table_alias
+            on = join['on']
+            join_type = (join['type'] || 'inner').to_sym
+          else
+            on = join
+            table_name = table_alias
+            join_type = :inner
+          end
+          if on
+            on.map! do |lhs, rhs|
+              [
+                [lhs, table_alias],
+                [rhs, @first_source]
+              ].map do |side, table_alias|
+                if side.is_a? String
+                  if m = side.match(/^\(('|")(.*)\1\)$/)
+                    m[2]
+                  else
+                    parts = side.split('.').map {|x| x.to_sym }
+                    case parts.count
+                    when 1
+                      [table_alias, parts[0]]
+                    when 2
+                      unless @joins.include? parts[0]
+                        raise "unknown alias #{parts[0]}"
+                      end
+                      parts
+                    else
+                      raise "invalid column specification #{lhs}"
+                    end # case
+                  end # if match
+                else
+                  side
+                end # if
+              end # map
+            end # map!
+            on = Hash[*on.flatten]
+          else
+            on = {}
+            @key.each do |k|
+              on[[
+                table_alias,
+                (@first_source.to_s.singularize << '_' << k[1].to_s).to_sym
+              ]] = k
+            end # each
+          end # if
+          @joins[table_alias] = {
+            :type => join_type,
+            :table => table_name,
+            :alias => table_alias,
+            :on => on
+          }
+        end # each_pair
+      else
+        raise "`joins' should be either nil or string or array or hash"
+      end # if
+    end
+
+    # Prepares data for building a Sequel +where+ clause.
+    def process_filter
+      # TODO
+    end
+
+    # Prepares data for building a Sequel +order+ clause.
+    def process_order
+      # TODO
+    end
+
+    # Prepares data for template generation.
+    # Processes foreign keys, fields, etc.
+    def process_relations
+      # TODO
+    end
+
+    # Returns code for alias-column name pair for field +field_name+.
+    def qualified_name(field_name)
+      parts = field_name.split('.')
+      if parts.length == 1
+        "%w{:#{@first_source} :#{field_name}}"
+      elsif parts.length == 2
+        "%w{:#{parts[0]} :#{parts[1]}}"
+      else
+        raise "field name for model #{@namespace}.#{@name} is invalid"
+      end
+    end
+
+  end # MetaModel
+
+end # Tanuki

data/lib/tanuki/{behavior/model_behavior.rb → model_behavior.rb}

@@ -22,7 +22,9 @@ module Tanuki
       @_errors ||= {}
       @_original ||= {}
       begin
-        @_original[attribute] = self[attribute] unless @_original.include? attribute
+        unless @_original.include? attribute
+          @_original[attribute] = self[attribute]
+        end
         self.class[attribute].set(@_data, value)
         @_errors.delete(attribute)
       rescue
@@ -79,11 +81,13 @@ module Tanuki
       # Creates new model, or returns existing one.
       def get(data, ctx, lazy=false) # IDENTITY TRACKING AND LAZY LOADING
         entity_key = extract_key(data)
-        key = [self, entity_key] # extract_key is generated ad hoc by model compiler!
+        key = [self, entity_key]
+        # extract_key is generated ad-hoc by model compiler!
         if cached = ctx.entity_cache[key]
           cached
         else
-          ctx.entity_cache[key] = get(*entity_key) # get is generated Ad Hoc by model compiler
+          ctx.entity_cache[key] = get(*entity_key)
+          # get is generated ad-hoc by model compiler
         end
       end
 

data/lib/tanuki/model_generator.rb

@@ -3,14 +3,16 @@ module Tanuki
   # Tanuki::ModelGenerator is used for, well, generating models
   class ModelGenerator
 
-    # A collection of all model definitions represented as hash of hashes where
-    # the first nesting level represents namespaces
-    # and the second one contains named model bodies +Hash+.
+    # A collection of all model definitions represented as hash of hashes
+    # where the first nesting level represents namespaces
+    # and the second one contains named model bodies hash.
     attr_reader :models
 
-    # +Hash+ for collecting the template render-time info for models.
-    # Keys in this hash are full qualified names of models (+namespace_model_name+).
-    # Values are hashes in the form of +{:generated => [], :failed => [], :skipped => []}+
+    # Hash for collecting the template render-time info for models.
+    # Keys in this hash are full qualified names of models
+    # (+namespace_model_name+). Base models are marked with +(base)+ suffix.
+    # Values are hashes in the form of
+    # +{:generated => [], :failed => [], :skipped => []}+
     # where all subentries correspond to template generation statuses.
     attr_reader :tried
 
@@ -24,26 +26,41 @@ module Tanuki
     # Loads all models into memory from a given +schema_root+ and prepares
     # their own properties to be rendered in class templates.
     def read_models(schema_root)
-      Dir.entries(schema_root).reject {|path| path =~ /\A\.{1,2}\Z/ }.each do |namespace_path|
-        namespace_name = namespace_path.split('_').map {|s| s.capitalize }.join
+      paths = Dir.entries(schema_root).reject {|path| path =~ /\A\..*\Z/ }
+      paths.each do |namespace_path|
+        namespace_name = namespace_path.camelize
         namespace = @models[namespace_name] = {}
-        Dir.glob(File.join(schema_root, namespace_path, 'models', '*.yml')) do |file_path|
-          model_name = File.basename(file_path, '.yml').split('_').map {|s| s.capitalize }.join
+        schema_glob = "#{schema_root}/#{namespace_path}/models/*.yml"
+        p schema_glob
+        Dir.glob(schema_glob) do |file_path|
+
+          # Create meta model for namespace and model name from schema
+          model_name = File.basename(file_path, '.yml').camelize
           meta_model = namespace[model_name] = Tanuki::MetaModel.new(
             namespace_name,
             model_name,
             YAML.load_file(file_path),
             @models
           )
-          meta_model.process!
-          if @tried.include? namespace_model_name = "#{namespace_name}.#{model_name}"
-            next
-          else
-            @tried[namespace_model_name] = {:generated => [], :failed => [], :skipped => []}
-            @tried["#{namespace_model_name} (base)"] = {:generated => [], :failed => [], :skipped => []}
-          end
-        end
-      end
+          meta_model.process
+          namespace_model_name = "#{namespace_name}.#{model_name}"
+
+          # TODO is this necessary?
+          next if @tried.include? namespace_model_name
+
+          # Register namespace and model name
+          @tried[namespace_model_name] = {
+            :generated => [],
+            :failed    => [],
+            :skipped   => []
+          }
+          @tried["#{namespace_model_name} (base)"] = {
+            :generated => [],
+            :failed    => [],
+            :skipped   => []
+          }
+        end # glob
+      end # each
     end
 
     # Generates all models that were read from a given +schema_root+.
@@ -57,19 +74,21 @@ module Tanuki
     # Renders a model class by applying +class_type+ template
     # to a given +meta_model+. Classes are splitted in two parts:
     # * user-extendable part (+base=false+), which resides in +ctx.app_root+,
-    # * other part with framework-specific code (+base=true+), which resides in +ctx.gen_root+.
+    # * other part with framework-specific code (+base=true+),
+    # which resides in +ctx.gen_root+.
     # +namespace_model_name+ is used as a label for error report collection
     # in Tanuki::ModelGenerator#tried hash.
     def generate_class(meta_model, namespace_model_name, class_type, base)
       class_name = meta_model.class_name_for class_type
       namespace_model_name += ' (base)' if base
-      path = Tanuki::Loader.class_path(class_name, base ? @ctx.gen_root : @ctx.app_root)
+      root = base ? @ctx.gen_root : @ctx.app_root
+      path = Tanuki::Loader.class_path(class_name, root)
       if base || !(File.exists? path)
         begin
           dirname = File.dirname(path)
           FileUtils.mkdir_p dirname unless File.directory? dirname
-          File.open path, 'w' do |file|
-            writer = proc {|out| file.print out.to_s }
+          File.open(path, 'w') do |file|
+            writer = proc {|out| file << out.to_s }
             Loader.run_template({}, meta_model, class_type).call(writer, @ctx)
           end
           @tried[namespace_model_name][:generated] << class_name
@@ -88,9 +107,9 @@ module Tanuki
         namespace.each do |model_name, meta_model|
           namespace_model_name = "#{namespace_name}.#{model_name}"
           {
-            :model => false,
-            :model_base => true,
-            :manager => false,
+            :model        => false,
+            :model_base   => true,
+            :manager      => false,
             :manager_base => true
           }.each do |class_type, base|
             generate_class meta_model, namespace_model_name, class_type, base
@@ -99,12 +118,13 @@ module Tanuki
       end
     end
 
-    # Iterates over all loaded model definitions, giving them a chance to meet each other
-    # and make any cross-model assumptions (like names for foreign keys).
+    # Iterates over all loaded model definitions, giving them a chance
+    # to meet each other and make any cross-model assumptions
+    # (like names for foreign keys).
     def process_models
       @models.each do |namespace_name, namespace |
         namespace.each do |model_name, meta_model|
-          meta_model.process_relations!
+          meta_model.process_relations
         end
       end
     end

data/lib/tanuki/template_compiler.rb

@@ -8,36 +8,45 @@ module Tanuki
   # The following tags are recognized:
   #
   #   <% Ruby code -- output to stdout %>
+  #   <%~ Ruby code -- output to stdout %>
   #   <%= Ruby expression -- replace with result %>
   #   <%# comment -- ignored -- useful in testing %>
-  #   % a line of Ruby code -- treated as <% line %>
-  #   %% replaced with % if first thing on a line
   #   <%% or %%> -- replace with <% or %> respectively
   #   <%! Ruby expression -- must return a template %> -- renders a template
   #   <%_visitor Ruby code %> -- see Tanuki::Application::visitor for details
   #   <l10n><en>English text</en> ... -- other localizations </l10n>
+  #
+  # All of these tags, except +l10n+, have a single line syntax:
+  #
+  #   % a line of Ruby code -- treated as <% line -%>
+  #   %~ a line of Ruby code -- treated as <% line -%>
+  #   %= Ruby expression -- treated as <%= line -%>
+  #   %# comment -- ignored -- treated as <%# line -%>
+  #   %% -- replace with % if first thing on a line
+  #   %! Ruby expression that returns a template -- treated as <%! line -%>
+  #   %_visitor Ruby code -- treated as <%_visitor line -%>
   class TemplateCompiler
 
     class << self
 
-      # Compiles a template from a given +src+ string to +ios+ for method +sym+ in class +klass+.
-      def compile_template(ios, src, klass, sym)
-        ios << "# encoding: #{src.encoding}\nclass #{klass}\n" << TEMPLATE_HEADER % sym
-        compile(ios, src, true)
-        ios << TEMPLATE_FOOTER % sym << "\nend"
-      end
-
-      # Compiles a wikified template from a given +src+ string to method +sym+ for a given object +obj+.
-      def compile_wiki(src, obj, sym)
-        code = StringIO.new
-        code << TEMPLATE_HEADER % sym
-        parse_wiki src
-        compile(code, src, true)
-        code << TEMPLATE_FOOTER % sym
-        obj.instance_eval code
+      # Compiles a template from a given +src+ string to +ios+
+      # for method +sym+ in class +klass+.
+      # If +development+ is false, then no encoding and class declarations,
+      # as well as runtime template checks are generated.
+      def compile_template(ios, src, klass, sym, development=true)
+        ios << TEMPLATE_HEADERS[:class] % [src.encoding, klass] if development
+        ios << TEMPLATE_HEADERS[:method] % sym
+        ios << TEMPLATE_HEADERS[:dev] % sym if development
+        ios << TEMPLATE_HEADERS[:context] % [klass, sym]
+        compile(ios, parse_wiki(src.chomp), true)
+        ios << TEMPLATE_FOOTERS[:dev] % sym if development
+        ios << TEMPLATE_FOOTERS[:method]
+        ios << TEMPLATE_FOOTERS[:class] if development
       end
 
-      # Replaces all wiki inserts like +[[controller?attribute:link#template]]+ with corresponding code in template tags +<%! %>+.
+      # Replaces all wiki inserts like
+      # +[[controller?attribute:link#template]]+
+      # with corresponding code in template tags +<%! %>+.
       def parse_wiki(s)
         s.gsub WIKI_SYNTAX do
           code = '<%! self'
@@ -52,12 +61,15 @@ module Tanuki
             end
           }.join
 
-          code << ".model#{$~[:model].split('.').map {|attr| "[:#{attr}]"}.join}" if $~[:model]
+          if $~[:model]
+            attrs = $~[:model].split('.').map {|attr| "[:#{attr}]"}.join
+            code << ".model#{attrs}"
+          end
           code << ".link_to(:#{$~[:link]})" if $~[:link]
 
           # Template
           code << case $~[:template]
-          when '' then '.default_view'
+          when '' then '.view'
           when nil then '.link_view'
           else ".#{$~[:template]}_view"
           end
@@ -76,7 +88,8 @@ module Tanuki
         begin
 
           # Find out state for expected pattern
-          if new_index = src[index..-1].index(pattern = expect_pattern(state))
+          pattern = expect_pattern(state)
+          if new_index = src[index..-1].index(pattern)
             new_index += index
             match = src[index..-1].match(pattern)[0]
             new_state = next_state(state, match)
@@ -105,7 +118,8 @@ module Tanuki
           if new_index
             unless state != :outer && new_state == :code_skip
               if new_state == :outer
-                process_code_state(ios, code_buf << src[index...new_index], state)
+                code_buf << src[index...new_index]
+                process_code_state(ios, code_buf, state)
                 code_buf = ''
               end
               index = new_index + match.length
@@ -119,20 +133,32 @@ module Tanuki
           end
 
         end until new_index.nil?
-        ios << "\n_.('',ctx)" if ensure_output && !(PRINT_STATES.include? last_state)
+
+        if ensure_output && !(PRINT_STATES.include? last_state)
+          ios << "\n_.('',ctx)"
+        end
         last_state
       end
 
       private
 
       # Scanner states that output the evaluated result.
-      PRINT_STATES = [:outer, :code_print]
+      PRINT_STATES = [:outer, :code_print].freeze
 
       # Template header code. Sent to output before compilation.
-      TEMPLATE_HEADER = "def %1$s_view(*args,&block)\nproc do|_,ctx|\nif _has_tpl ctx,self.class,:%1$s\nctx=_ctx(ctx)"
+      TEMPLATE_HEADERS = {
+        :class => "# encoding: %s\nclass %s\n",
+        :method => "def %s_view(*args,&block)\nproc do|_,ctx|\n",
+        :dev => "if _has_tpl ctx,self.class,:%s\n",
+        :context => %{ctx=_ctx(ctx,"%s#%s")}
+      }.freeze
 
       # Template footer code. Sent to output after compilation.
-      TEMPLATE_FOOTER = "\nelse\n(_run_tpl ctx,self,:%s,*args,&block).(_,ctx)\nend\nend\nend"
+      TEMPLATE_FOOTERS = {
+        :dev => "\nelse\n(_run_tpl ctx,self,:%s,*args,&block).(_,ctx)\nend\n",
+        :method => "end\nend\n",
+        :class => "end\n"
+      }.freeze
 
       # Wiki insert syntax
       WIKI_SYNTAX = %r{
@@ -142,22 +168,23 @@ module Tanuki
           (?::(?<link>[a-z_]+))?
           (?:\#(?<template>[a-z_]*))?
         \]\]
-      }x
+      }x.freeze
 
-      # Generates code for Ruby template bits from a given +src+ to +ios+ for a given +state+.
+      # Generates code for Ruby template bits from a given +src+ to +ios+
+      # for a given +state+.
       def process_code_state(ios, src, state)
         src.strip!
         src.gsub!(/^[ \t]+/, '')
         case state
-        when :code_line, :code_span then
+        when /code_(?:line_)?span/ then
           ios << "\n#{src}"
-        when :code_print then
+        when /code_(?:line_)?print/ then
           ios << "\n_.((#{src}),ctx)"
-        when :code_template then
+        when /code_(?:line_)?template/ then
           ios << "\n(#{src}).(_,ctx)"
-        when :code_visitor
-          inner_m = src.match(/^([^ \(]+)?(\([^\)]*\))?\s*(.*)$/)
-          ios << "\n#{inner_m[1]}_result=(#{inner_m[3]}).(#{inner_m[1]}_visitor#{inner_m[2]},ctx)"
+        when /code_(?:line_)?visitor/
+          m = src.match(/^([^ \(]+)?(\([^\)]*\))?\s*(.*)$/)
+          ios << "\n#{m[1]}_result=(#{m[3]}).(#{m[1]}_visitor#{m[2]},ctx)"
         when :l10n then
           localize(ios, src)
         end
@@ -166,9 +193,9 @@ module Tanuki
       # Returns the next expected pattern for a given +state+.
       def expect_pattern(state)
         case state
-        when :outer then %r{^\s*%%?|<%[=!_#%]?|<l10n>}
-        when :code_line then %r{\n|\Z}
-        when :code_span, :code_print, :code_template, :code_visitor, :code_comment then %r{[-%]?%>}
+        when :outer then %r{(?:^\s*|<)%[~=!_#%]?|<l10n>}
+        when /\Acode_line/ then %r{\n|\Z}
+        when /\Acode_(?:span|print|template|visitor|comment)/ then %r{[-%]?%>}
         when :l10n then %r{<\/l10n>}
         end
       end
@@ -178,8 +205,6 @@ module Tanuki
         case state
         when :outer then
           case match
-          when /\A\s*%\Z/ then :code_line
-          when /\A\s*%%\Z/ then :code_skip
           when '<%' then :code_span
           when '<%=' then :code_print
           when '<%!' then :code_template
@@ -187,9 +212,15 @@ module Tanuki
           when '<%#' then :code_comment
           when '<%%' then :code_skip
           when '<l10n>' then :l10n
+          when /\A\s*%~?\Z/ then :code_line_span
+          when /\A\s*%=\Z/ then :code_line_print
+          when /\A\s*%!\Z/ then :code_line_template
+          when /\A\s*%_\Z/ then :code_line_visitor
+          when /\A\s*%#\Z/ then :code_line_comment
+          when /\A\s*%%\Z/ then :code_skip
           end
-        when :code_line then :outer
-        when :code_span, :code_print, :code_template, :code_visitor, :code_comment then
+        when /\Acode_line/ then :outer
+        when /\Acode_(?:span|print|template|visitor|comment)/ then
           case match
           when '%%>' then :code_skip
           else :outer