cog 0.3.1 → 0.3.2

data/lib/cog/dsl/feature_dsl.rb

@@ -0,0 +1,59 @@
+module Cog
+  module DSL
+    
+    # DSL for defining cog features
+    class FeatureDSL
+      
+      # @api developer
+      # @return [Cog::Seed] the seed which is defined by this DSL object
+      attr_reader :feature
+      
+      # @api developer
+      def initialize(seed, name, opt={})
+        @feature = Seed::Feature.new seed, name
+      end
+
+      # Describe what this method does in one line
+      # @param value [String] a short description
+      # @return [nil]
+      def desc(value)
+        feature_eval { @desc = value }
+        nil
+      end
+      
+      # Declare this method abstract
+      # @return [nil]
+      def abstract
+        feature_eval { @abstract = true }
+        nil
+      end
+      
+      # Add a parameter to the feature
+      # @param type [Symbol] the type of the parameter
+      # @param name [String] name of the parameter
+      # @option opt [String] :desc (nil) optional description which will be used in documentation
+      # @option opt [Seed] :scope (nil) optional scope to use when rendering the variable in a qualified way
+      # @return [nil]
+      def param(type, name, opt={})
+        v = Seed::Var.new type, name, opt
+        feature_eval { @params << v }
+        nil
+      end
+      
+      # Define the return type for the method.
+      # Will be `:void` if this method is never called.
+      # @param type [Symbol] a type
+      # @return [nil]
+      def return(type)
+        feature_eval { @return_type = type }
+        nil
+      end
+      
+      private
+      
+      def feature_eval(&block)
+        @feature.instance_eval &block
+      end
+    end
+  end
+end

data/lib/cog/dsl/language_dsl.rb

@@ -48,12 +48,20 @@ module Cog
 
       # Define file extensions
       # @param values [Array<String>] list of file extensions for this language
+      # @return [nil]
       def extension(*values)
         lang_eval do
           @extensions = values.collect {|key| key.to_s.downcase}
         end  
       end
       
+      def seed_extension(ext, opt={})
+        lang_eval do
+          @seed_extension = ext.to_s.downcase
+          @seed_header = opt[:header].to_s.downcase if opt[:header]
+        end  
+      end
+      
       # Define a block to call when using a named scopes in this language
       # @yieldparam name [String] name of the scope to use
       # @yieldreturn [String] a using named scope statement in this language
@@ -106,6 +114,86 @@ module Cog
         lang_eval { @include_guard_style = lang_key.to_s.downcase }
         nil
       end
+
+      # Enumerate reserved identifiers in the language
+      # @param words [Array<String>] a list of words which must not be used as identifiers in the language
+      # @return [nil]
+      def reserved(words)
+        lang_eval { @reserved = words }
+        nil
+      end
+      
+      # Map a cog primitive type to a native type in this language
+      # @param name [Symbol] name of the cog primitive type
+      # @param ident [String] identifier of the mapped type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_primitive(name, ident, &block)
+        lang_eval do
+          @prim_ident[name.to_sym] = ident.to_s
+          @prim_to_lit[name.to_sym] = block
+        end
+        nil
+      end
+      
+      # Map the cog boolean type to a native type in this language
+      # @param ident [String] identifier of the boolean type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the boolean literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_boolean(ident, &block) ; map_primitive(:boolean, ident, &block) ; end
+
+      # Map the cog integer type to a native type in this language
+      # @param ident [String] identifier of the integer type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the integer literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_integer(ident, &block) ; map_primitive(:integer, ident, &block) ; end
+      
+      # Map the cog long type to a native type in this language
+      # @param ident [String] identifier of the long type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the long literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_long(ident, &block) ; map_primitive(:long, ident, &block) ; end
+      
+      # Map the cog float type to a native type in this language
+      # @param ident [String] identifier of the float type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the float literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_float(ident, &block) ; map_primitive(:float, ident, &block) ; end
+      
+      # Map the cog double type to a native type in this language
+      # @param ident [String] identifier of the double type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the double literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_double(ident, &block) ; map_primitive(:double, ident, &block) ; end
+      
+      # Map the cog char type to a native type in this language
+      # @param ident [String] identifier of the char type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the char literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_char(ident, &block) ; map_primitive(:char, ident, &block) ; end
+      
+      # Map the cog string type to a native type in this language
+      # @param ident [String] identifier of the string type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the string literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_string(ident, &block) ; map_primitive(:string, ident, &block) ; end
+      
+      # Map the cog null type to a native type in this language
+      # @param ident [String] identifier of the null type in this language
+      # @yieldparam obj [Object] a ruby object
+      # @yieldreturn [String,nil] the null literal representation of the given obj in this language, or +nil+ if the object can not be mapped
+      # @return [nil]
+      def map_null(ident, &block) ; map_primitive(:null, ident, &block) ; end
+      
+      def map_void(ident) ; map_primitive(:void, ident) ; end
       
       # @api developer
       # Compute the comment pattern
@@ -137,6 +225,7 @@ module Cog
       def lang_eval(&block)
         @lang.instance_eval &block
       end
+
     end
   end
 end

data/lib/cog/dsl/seed_dsl.rb

@@ -0,0 +1,51 @@
+module Cog
+  module DSL
+    
+    # DSL for defining cog seeds
+    class SeedDSL
+      
+      # @api developer
+      # @return [Cog::Seed] the seed which is defined by this DSL object
+      attr_reader :seed
+      
+      # @api developer
+      def initialize(name)
+        @seed = Cog::Seed.new name
+      end
+      
+      # Place classes generated by this seed in the given scope
+      # @param name [String] name of the scope
+      # @return [nil]
+      def in_scope(name)
+        seed_eval { @in_scope = name.to_s }
+        nil
+      end
+      
+      def constructor(&block)
+        feature :constructor, &block
+      end
+      
+      def destructor(&block)
+        feature :destructor, &block
+      end
+      
+      # Define a new feature for this seed
+      # @param name [String] name of the feature
+      # @yieldparam f [FeatureDSL] use this to further specify the feature
+      # @return [nil]
+      def feature(name, opt={}, &block)
+        dsl = FeatureDSL.new @seed, name, opt
+        block.call dsl unless block.nil?
+        f = dsl.feature
+        seed_eval { @features << f }
+        nil
+      end
+      
+      private
+      
+      def seed_eval(&block)
+        @seed.instance_eval &block
+      end
+    end
+  end
+end

data/lib/cog/embeds.rb

@@ -12,26 +12,34 @@ module Cog
       end
     end
     
+    # @param original [String] file in which to search for keep statements
+    # @param scratch [String] file to which keep bodies will be copied (used to create the {EmbedContext} objects)
+    # @return [Hash] mapping from hooks to {EmbedContext} objects
+    def gather_keeps(original, scratch)
+      keeps = {}
+      gather_from_file(original, :type => 'keep').each_pair do |hook, count|
+        c = keeps[hook] = EmbedContext.new(hook, scratch, count[original])
+        raise Errors::DuplicateKeep.new :hook => hook if c.count > 1
+        Helpers::FileScanner.scan(original, statement('keep', hook)) do |s|
+          c.keep_body = if s.match[4] == '{'
+            s.capture_until end_statement('keep')
+            s.captured_text
+          else
+            ''
+          end
+        end
+      end
+      keeps
+    end
+    
     # Copy keep bodies from the original file to the scratch file
     # @param original [String] file in which to search for keep statements. If the original does not exist, then scratch will serve as the original (we do this so that the keeps will get expanded in any case)
     # @param scratch [String] file to which keep bodies will be copied
     # @return [nil]
     def copy_keeps(original, scratch)
-      keeps = {}
       Cog.activate_language(:filename => original) do
         original = scratch unless File.exists? original
-        gather_from_file(original, :type => 'keep').each_pair do |hook, count|
-          c = keeps[hook] = EmbedContext.new(hook, scratch, count[original])
-          raise Errors::DuplicateKeep.new :hook => hook if c.count > 1
-          Helpers::FileScanner.scan(original, statement('keep', hook)) do |s|
-            c.keep_body = if s.match[4] == '{'
-              s.capture_until end_statement('keep')
-              s.captured_text
-            else
-              ''
-            end
-          end
-        end
+        keeps = gather_keeps original, scratch
         keeps.each_pair do |hook, c|
           result = update c, :type => 'keep' do |c|
             c.keep_body
@@ -128,7 +136,7 @@ module Cog
       end
       c.body = s.captured_text
       value = block.call(c).rstrip
-      if c.once? || value != s.captured_text
+      if c.once? || value.normalize_eol != s.captured_text.rstrip.normalize_eol
         s.replace_captured_text(value + "\n", :once => c.once?)
       else
         false

data/lib/cog/errors.rb

@@ -34,6 +34,8 @@ module Cog
       end
     end
 
+    define_error :ActiveLanguageDoesNotSupportSeeds
+    
     define_error :ActionRequiresProjectGeneratorPath
     define_error :ActionRequiresProjectTemplatePath
     define_error :ActionRequiresProjectPluginPath
@@ -58,6 +60,8 @@ module Cog
     
     define_error :PluginPathIsNotADirectory
     
+    define_error :PrimitiveNotSupported
+    
     define_error :ScopeStackUnderflow do
       "scope stack underflow: this can happen if you have too many *_end calls in a template"
     end

data/lib/cog/helpers/file_scanner.rb

@@ -1,3 +1,9 @@
+class String
+  def normalize_eol
+    gsub /(\r|\n|\r\n)/, "\n"
+  end
+end
+
 module Cog
   module Helpers
 
@@ -17,6 +23,13 @@ module Cog
         @cap_begin_pos = nil
         @cap_end_pos = nil
         @match = nil # The last match object
+        @win_fudge = if RUBY_PLATFORM =~ /(mswin|mingw)/
+          x = @f.readline.end_with? '\r\n'
+          @f.seek 0
+          x ? 0 : 1
+        else
+          0
+        end
       end
       
       # @api developer
@@ -43,10 +56,14 @@ module Cog
         val
       end
 
+      def win_fudge
+        (@f.lineno - 1) * @win_fudge
+      end
+      
       # Remember this position. A later call to insert_at_mark will insert at this marked position
       # @return [nil]
       def mark!
-        @mark = @f.pos
+        @mark = @f.pos - win_fudge
         @marked_line_number = @f.lineno + 1
       end
       
@@ -91,7 +108,7 @@ module Cog
       # @option opt [Array<Regexp>, Regexp] :but_not (nil) if a line matching any of the provided patterns is found before the desired pattern :bad_pattern_found will be thrown
       # @return [Boolean] whether or not the pattern was found
       def capture_until(pattern, opt={})
-        @cap_begin_pos = @f.pos
+        @cap_begin_pos = @f.pos - win_fudge
         but_not = opt[:but_not] || []
         but_not = [but_not] unless but_not.is_a?(Array)
         while line = @f.readline
@@ -102,7 +119,7 @@ module Cog
           end
           return true if line =~ pattern
           @lines << line
-          @cap_end_pos = @f.pos
+          @cap_end_pos = @f.pos # win_fudge not needed here
         end
       rescue EOFError
         false
@@ -111,7 +128,6 @@ module Cog
       # @return [String] text captured during capture_until. The last newline is stripped
       def captured_text
         x = @lines.join('')
-        x = x.slice(0..-2) if x =~ /\n$/
         x
       end
       
@@ -121,11 +137,11 @@ module Cog
       def replace_captured_text(value, opt={})
         return false if @cap_begin_pos.nil? || @cap_end_pos.nil?
         @f.seek 0
-        tmp.write @f.read(opt[:once] ? @mark : @cap_begin_pos)
-        tmp.write value
+        tmp.write @f.read(opt[:once] ? @mark : @cap_begin_pos).normalize_eol
+        tmp.write value.normalize_eol
         @f.seek @cap_end_pos
         @f.readline if opt[:once]
-        tmp.write @f.read
+        tmp.write @f.read.normalize_eol
         tmp.close
         close
         FileUtils.mv tmp_filename, @filename
@@ -137,10 +153,10 @@ module Cog
       def insert_at_mark(value)
         return false if @mark.nil?
         @f.seek 0
-        tmp.write @f.read(@mark)
-        tmp.write value
+        tmp.write @f.read(@mark).normalize_eol
+        tmp.write value.normalize_eol
         @f.readline # discard original
-        tmp.write @f.read
+        tmp.write @f.read.normalize_eol
         tmp.close
         close
         FileUtils.mv tmp_filename, @filename

data/lib/cog/language.rb

@@ -5,7 +5,10 @@ module Cog
 
     # @return [Array<String>] list of file extensions
     attr_reader :extensions
-      
+
+    attr_reader :seed_extension
+    attr_reader :seed_header
+    
     # @return [String] unique lower case identifier
     attr_reader :key
 
@@ -35,6 +38,9 @@ module Cog
       @named_scope_end_block = identibitch
       @include_guard_begin_block = identibitch
       @include_guard_end_block = identibitch
+      @reserved = []
+      @prim_ident = {} # :name => 'ident'
+      @prim_to_lit = {} # :name => to_literal_block
     end
       
     # @param nested_pattern [String] regular expression pattern (as a string) to embed in the regular expression which matches one line comments in this language
@@ -101,7 +107,7 @@ module Cog
       w ||= @name.length
       "#{@name.ljust w} -> #{@extensions.collect {|x| x.to_s}.sort.join ', '}"
     end
-
+    
     # Sort by name
     def <=>(other)
       @name <=> other.name
@@ -136,5 +142,75 @@ module Cog
     def include_guard_end(name)
       @include_guard_end_block.call name
     end
+    
+    # @param name [String] a potential identifier name
+    # @return [String] an escaped version of the identifier, if it conflicted with a reserved word in the language
+    def to_ident(name)
+      if @reserved.member? name.to_s
+        "#{name}_"
+      else
+        name.to_s
+      end
+    end
+    
+    # @param name [Symbol] name of a primitive cog type
+    # @return [String] the representation of a primitive cog type in the native language
+    # @example
+    #   # For Objective-C
+    #   lang.to_prim :boolean # => 'BOOL'
+    def to_prim(name)
+      ident = @prim_ident[name.to_sym]
+      raise Errors::PrimitiveNotSupported.new :type => name, :language => @name unless ident
+      ident
+    end
+
+    # @param obj [Object] a ruby object
+    # @return [String] boolean literal representation of the object in this language
+    def to_boolean(obj) ; try_to_lit(:boolean, obj) ; end
+
+    # @param obj [Object] a ruby object
+    # @return [String] integer literal representation of the object in this language
+    def to_integer(obj) ; try_to_lit(:integer, obj) ; end
+
+    # @param obj [Object] a ruby object
+    # @return [String] long literal representation of the object in this language
+    def to_long(obj) ; try_to_lit(:long, obj) ; end
+
+    # @param obj [Object] a ruby object
+    # @return [String] float literal representation of the object in this language
+    def to_float(obj) ; try_to_lit(:float, obj) ; end
+
+    # @param obj [Object] a ruby object
+    # @return [String] double literal representation of the object in this language
+    def to_double(obj) ; try_to_lit(:double, obj) ; end
+
+    # @param obj [Object] a ruby object
+    # @return [String] char literal representation of the object in this language
+    def to_char(obj) ; try_to_lit(:char, obj) ; end
+
+    # @param obj [Object] a ruby object
+    # @return [String] string literal representation of the object in this language
+    def to_string(obj) ; try_to_lit(:string, obj) ; end
+
+    # @param obj [Object] a ruby object
+    # @return [String] null literal representation of the object in this language
+    def to_null(obj) ; try_to_lit(:null, obj) ; end
+
+    # @param obj [Object] a ruby object
+    # @return [String] literal representation of the object in this language
+    def to_lit(obj)
+      return obj.to_lit if obj.respond_to?(:to_lit)
+      raise Errors::PrimitiveNotSupported.new :object => obj
+    end
+
+    private    
+    
+    # @api developer
+    def try_to_lit(name, obj)
+      to_lit_block = @prim_to_lit[name]
+      raise Errors::PrimitiveNotSupported.new :type => name, :language => @name unless to_lit_block
+      to_lit_block.call obj if to_lit_block
+    end
+    
   end
 end