shift-lang 0.1.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shift-lang.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Pradeek
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Shift::Lang
+
+Shift is a Domain-Specific Language that can be used to quickly write server-side applications
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'shift-lang'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shift-lang
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/sft

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/shift-lang'
+
+Shift::CLI.new(ARGV)

data/bin/shift

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/shift-lang'
+
+Shift::CLI.new(ARGV)

data/lib/app_engine_templates/app.yaml

@@ -0,0 +1,13 @@
+application: <%= project_name %>
+version: 1
+runtime: python27
+api_version: 1
+threadsafe: false
+
+libraries:
+- name: markupsafe
+  version: latest
+
+handlers:
+- url: /.*
+  script: <%= project_name %>.app

data/lib/app_engine_templates/pystache/__init__.py

@@ -0,0 +1,8 @@
+from pystache.template import Template
+from pystache.view import View
+from pystache.loader import Loader
+
+def render(template, context=None, **kwargs):
+    context = context and context.copy() or {}
+    context.update(kwargs)
+    return Template(template, context).render()

data/lib/app_engine_templates/pystache/loader.py

@@ -0,0 +1,47 @@
+import os
+
+class Loader(object):
+    
+    template_extension = 'mustache'
+    template_path = '.'
+    template_encoding = None
+    
+    def load_template(self, template_name, template_dirs=None, encoding=None, extension=None):
+        '''Returns the template string from a file or throws IOError if it non existent'''
+        if None == template_dirs:
+            template_dirs = self.template_path
+        
+        if encoding is not None:
+            self.template_encoding = encoding
+        
+        if extension is not None:
+            self.template_extension = extension
+        
+        file_name = template_name + '.' + self.template_extension
+
+        # Given a single directory we'll load from it
+        if isinstance(template_dirs, basestring):
+            file_path = os.path.join(template_dirs, file_name)
+
+            return self._load_template_file(file_path)
+            
+        # Given a list of directories we'll check each for our file
+        for path in template_dirs:
+            file_path = os.path.join(path, file_name)
+            if os.path.exists(file_path):
+                return self._load_template_file(file_path)
+                
+        raise IOError('"%s" not found in "%s"' % (template_name, ':'.join(template_dirs),))
+    
+    def _load_template_file(self, file_path):
+        '''Loads and returns the template file from disk'''
+        f = open(file_path, 'r')
+        
+        try:
+            template = f.read()
+            if self.template_encoding:
+                template = unicode(template, self.template_encoding)
+        finally:
+            f.close()
+        
+        return template

data/lib/app_engine_templates/pystache/template.py

@@ -0,0 +1,177 @@
+import re
+import cgi
+import collections
+import os
+import copy
+
+try:
+    import markupsafe
+    escape = markupsafe.escape
+    literal = markupsafe.Markup
+
+except ImportError:
+    escape = lambda x: cgi.escape(unicode(x))
+    literal = unicode
+
+
+class Modifiers(dict):
+    """Dictionary with a decorator for assigning functions to keys."""
+
+    def set(self, key):
+        """
+        Decorator function to set the given key to the decorated function.
+
+            >>> modifiers = {}
+            >>> @modifiers.set('P')
+            ... def render_tongue(self, tag_name=None, context=None):
+            ...     return ":P %s" % tag_name
+            >>> modifiers
+            {'P': <function render_tongue at 0x...>}
+        """
+
+        def setter(func):
+            self[key] = func
+            return func
+        return setter
+
+
+class Template(object):
+
+    tag_re = None
+
+    otag = '{{'
+
+    ctag = '}}'
+
+    modifiers = Modifiers()
+
+    def __init__(self, template=None, context=None, **kwargs):
+        from view import View
+
+        self.template = template
+
+        if kwargs:
+            context.update(kwargs)
+
+        self.view = context if isinstance(context, View) else View(context=context)
+        self._compile_regexps()
+
+    def _compile_regexps(self):
+        tags = {
+            'otag': re.escape(self.otag),
+            'ctag': re.escape(self.ctag)
+        }
+
+        section = r"%(otag)s[\#|^]([^\}]*)%(ctag)s\s*(.+?\s*)%(otag)s/\1%(ctag)s"
+        self.section_re = re.compile(section % tags, re.M|re.S)
+
+        tag = r"%(otag)s(#|=|&|!|>|\{)?(.+?)\1?%(ctag)s+"
+        self.tag_re = re.compile(tag % tags)
+
+    def _render_sections(self, template, view):
+        while True:
+            match = self.section_re.search(template)
+            if match is None:
+                break
+
+            section, section_name, inner = match.group(0, 1, 2)
+            section_name = section_name.strip()
+            it = self.view.get(section_name, None)
+            replacer = ''
+
+            # Callable
+            if it and isinstance(it, collections.Callable):
+                replacer = it(inner)
+            # Dictionary
+            elif it and hasattr(it, 'keys') and hasattr(it, '__getitem__'):
+                if section[2] != '^':
+                    replacer = self._render_dictionary(inner, it)
+            # Lists
+            elif it and hasattr(it, '__iter__'):
+                if section[2] != '^':
+                    replacer = self._render_list(inner, it)
+            # Other objects
+            elif it and isinstance(it, object):
+                if section[2] != '^':
+                    replacer = self._render_dictionary(inner, it)
+            # Falsey and Negated or Truthy and Not Negated
+            elif (not it and section[2] == '^') or (it and section[2] != '^'):
+                replacer = self._render_dictionary(inner, it)
+
+            template = literal(template.replace(section, replacer))
+
+        return template
+
+    def _render_tags(self, template):
+        while True:
+            match = self.tag_re.search(template)
+            if match is None:
+                break
+
+            tag, tag_type, tag_name = match.group(0, 1, 2)
+            tag_name = tag_name.strip()
+            func = self.modifiers[tag_type]
+            replacement = func(self, tag_name)
+            template = template.replace(tag, replacement)
+
+        return template
+
+    def _render_dictionary(self, template, context):
+        self.view.context_list.insert(0, context)
+        template = Template(template, self.view)
+        out = template.render()
+        self.view.context_list.pop(0)
+        return out
+
+    def _render_list(self, template, listing):
+        insides = []
+        for item in listing:
+            insides.append(self._render_dictionary(template, item))
+
+        return ''.join(insides)
+
+    @modifiers.set(None)
+    def _render_tag(self, tag_name):
+        raw = self.view.get(tag_name, '')
+
+        # For methods with no return value
+        if not raw and raw is not 0:
+            if tag_name == '.':
+                raw = self.view.context_list[0]
+            else:
+                return ''
+
+        return escape(raw)
+
+    @modifiers.set('!')
+    def _render_comment(self, tag_name):
+        return ''
+
+    @modifiers.set('>')
+    def _render_partial(self, template_name):
+        from pystache import Loader
+        markup = Loader().load_template(template_name, self.view.template_path, encoding=self.view.template_encoding)
+        template = Template(markup, self.view)
+        return template.render()
+
+    @modifiers.set('=')
+    def _change_delimiter(self, tag_name):
+        """Changes the Mustache delimiter."""
+        self.otag, self.ctag = tag_name.split(' ')
+        self._compile_regexps()
+        return ''
+
+    @modifiers.set('{')
+    @modifiers.set('&')
+    def render_unescaped(self, tag_name):
+        """Render a tag without escaping it."""
+        return literal(self.view.get(tag_name, ''))
+
+    def render(self, encoding=None):
+        template = self._render_sections(self.template, self.view)
+        result = self._render_tags(template)
+
+        if encoding is not None:
+            result = result.encode(encoding)
+
+        return result

data/lib/app_engine_templates/pystache/view.py

@@ -0,0 +1,94 @@
+from pystache import Template
+import os.path
+import re
+from types import *
+
+def get_or_attr(context_list, name, default=None):
+    if not context_list:
+        return default
+
+    for obj in context_list:
+        try:
+            return obj[name]
+        except KeyError:
+            pass
+        except:
+            try:
+                return getattr(obj, name)
+            except AttributeError:
+                pass
+    return default
+
+class View(object):
+    
+    template_name = None
+    template_path = None
+    template = None
+    template_encoding = None
+    template_extension = 'mustache'
+    
+    def __init__(self, template=None, context=None, **kwargs):
+        self.template = template
+        context = context or {}
+        context.update(**kwargs)
+
+        self.context_list = [context]
+        
+    def get(self, attr, default=None):
+        attr = get_or_attr(self.context_list, attr, getattr(self, attr, default))
+        if hasattr(attr, '__call__') and type(attr) is UnboundMethodType:
+            return attr()
+        else:
+            return attr
+    
+    def get_template(self, template_name):
+        if not self.template:
+            from pystache import Loader
+            template_name = self._get_template_name(template_name)
+            self.template = Loader().load_template(template_name, self.template_path, encoding=self.template_encoding, extension=self.template_extension)
+        
+        return self.template
+
+    def _get_template_name(self, template_name=None):
+        """TemplatePartial => template_partial
+        Takes a string but defaults to using the current class' name or
+        the `template_name` attribute
+        """
+        if template_name:
+            return template_name
+
+        template_name = self.__class__.__name__
+
+        def repl(match):
+            return '_' + match.group(0).lower()
+
+        return re.sub('[A-Z]', repl, template_name)[1:]
+
+    def _get_context(self):
+        context = {}
+        for item in self.context_list:
+            if hasattr(item, 'keys') and hasattr(item, '__getitem__'):
+                context.update(item)
+        return context
+
+    def render(self, encoding=None):
+        return Template(self.get_template(self.template_name), self).render(encoding=encoding)
+
+    def __contains__(self, needle):
+        return needle in self.context or hasattr(self, needle)
+
+    def __getitem__(self, attr):
+        val = self.get(attr, None)
+
+        if not val and val is not 0:
+            raise KeyError("Key '%s' does not exist in View" % attr)
+        return val
+
+    def __getattr__(self, attr):
+        if attr == 'context':
+            return self._get_context()
+
+        raise AttributeError("Attribute '%s' does not exist in View" % attr)
+
+    def __str__(self):
+        return self.render()

data/lib/heroku_templates/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+gem 'sinatra', '1.3.2'
+gem 'data_mapper'
+gem 'pg'
+gem 'dm-postgres-adapter'
+gem 'mustache'

data/lib/heroku_templates/Procfile

@@ -0,0 +1 @@
+web: bundle exec ruby app.rb -p $PORT

data/lib/shift-lang/builder/db_model.rb

@@ -0,0 +1,20 @@
+module Shift
+	module Builder
+		class DBModel
+			attr_accessor :name, :attributes
+
+			def initialize(name)
+				@name = name.to_s
+				@attributes = []
+			end
+
+			def add_attribute(name, type)
+				attribute = {
+					:name => name.to_s,
+					:type => type.to_s
+				}
+				@attributes.push attribute
+			end
+		end
+	end
+end

data/lib/shift-lang/builder/url_handler.rb

@@ -0,0 +1,17 @@
+module Shift
+	module Builder
+		class UrlHandler
+			attr_accessor :url, :method, :handler
+
+			def initialize(url, method)
+				@url = url
+				@method = method
+				@handler = []
+			end
+
+			def add_statement(statement)
+				handler.push statement
+			end
+		end
+	end
+end

data/lib/shift-lang/builder.rb

@@ -0,0 +1,103 @@
+require_relative 'builder/db_model'
+require_relative 'builder/url_handler'
+
+require_relative 'parser'
+
+module Shift
+	class ShiftBuilder
+		attr_accessor :models, :handlers, :clean
+
+		def initialize()
+			@models = []
+			@handlers = []
+			@clean = true
+		end
+
+		def get_data_from_file(file_name)
+			parser = Shift::ShiftParser.new
+
+			model = nil
+
+			url_handler = nil
+
+			last_statement = ""
+			this_statement = ""
+
+			url = ""
+
+			line_number = 0
+
+			File.open(file_name) do |file|
+				while line = file.gets
+					parts = line.split("\t")
+					num_tabs = parts.length - 1
+					line = line.strip
+					line_number += 1
+					if line != ""
+						begin
+						statement = parser.parse(line)
+
+						this_statement = statement.keys[0]
+
+						case this_statement
+
+						when :model_definition_statement
+							model = Builder::DBModel.new(statement[:model_definition_statement][:model_name])
+
+						when :model_attribute_definition_statement
+							model_attribute = statement[:model_attribute_definition_statement]
+							model.add_attribute(model_attribute[:attribute_name], model_attribute[:attribute_type])
+
+						when :url
+							if (last_statement == :model_attribute_definition_statement)
+								add_model model
+							end
+
+							url = statement[:url]
+						when :url_method
+							if url_handler
+								add_handler url_handler
+							end
+
+							url_handler = Builder::UrlHandler.new(url, statement[:url_method].to_s)
+						else
+							stmt = {
+								:statement => statement, 
+								:num_tabs => num_tabs
+							}
+							if !url_handler 
+								url_handler = Builder::UrlHandler.new("", "")
+							end	
+							url_handler.add_statement stmt
+						end			
+
+						last_statement = this_statement
+
+						rescue Parslet::ParseFailed => parse_error
+							error = parse_error.to_s
+							error =  error.split(" ")
+							puts "Error at line #{line_number} character #{error[error.length - 1]} : #{line}"
+							@clean = false
+						end
+					end
+				end
+			end
+
+			if (last_statement == :model_attribute_definition_statement)
+				add_model model
+			else
+				add_handler url_handler
+			end
+
+			self
+		end
+
+		def add_model(model)
+			@models.push model
+		end
+
+		def add_handler(handler)
+			@handlers.push handler
+		end
+	end 
+end