sunrise-locales 0.1.0

data/lib/generators/sunrise/locales/templates/yaml.js

@@ -0,0 +1,95 @@
+CodeMirror.defineMode("yaml", function() {
+	
+	var cons = ['true', 'false', 'on', 'off', 'yes', 'no'];
+	var keywordRegex = new RegExp("\\b(("+cons.join(")|(")+"))$", 'i');
+	
+	return {
+		token: function(stream, state) {
+			var ch = stream.peek();
+			var esc = state.escaped;
+			state.escaped = false;
+			/* comments */
+			if (ch == "#") { stream.skipToEnd(); return "comment"; }
+			if (state.literal && stream.indentation() > state.keyCol) {
+				stream.skipToEnd(); return "string";
+			} else if (state.literal) { state.literal = false; }
+			if (stream.sol()) {
+				state.keyCol = 0;
+				state.pair = false;
+				state.pairStart = false;
+				/* document start */
+				if(stream.match(/---/)) { return "def"; }
+				/* document end */
+				if (stream.match(/\.\.\./)) { return "def"; }
+				/* array list item */
+				if (stream.match(/\s*-\s+/)) { return 'meta'; }
+			}
+			/* pairs (associative arrays) -> key */
+			if (!state.pair && stream.match(/^\s*([a-z0-9\._-])+(?=\s*:)/i)) {
+				state.pair = true;
+				state.keyCol = stream.indentation();
+				return "atom";
+			}
+			if (state.pair && stream.match(/^:\s*/)) { state.pairStart = true; return 'meta'; }
+			
+			/* inline pairs/lists */
+			if (stream.match(/^(\{|\}|\[|\])/)) {
+				if (ch == '{')
+					state.inlinePairs++;
+				else if (ch == '}')
+					state.inlinePairs--;
+				else if (ch == '[')
+					state.inlineList++;
+				else
+					state.inlineList--;
+				return 'meta';
+			}
+			
+			/* list seperator */
+			if (state.inlineList > 0 && !esc && ch == ',') {
+				stream.next();
+				return 'meta';
+			}
+			/* pairs seperator */
+			if (state.inlinePairs > 0 && !esc && ch == ',') {
+				state.keyCol = 0;
+				state.pair = false;
+				state.pairStart = false;
+				stream.next();
+				return 'meta';
+			}
+			
+			/* start of value of a pair */
+			if (state.pairStart) {
+				/* block literals */
+				if (stream.match(/^\s*(\||\>)\s*/)) { state.literal = true; return 'meta'; };
+				/* references */
+				if (stream.match(/^\s*(\&|\*)[a-z0-9\._-]+\b/i)) { return 'variable-2'; }
+				/* numbers */
+				if (state.inlinePairs == 0 && stream.match(/^\s*-?[0-9\.\,]+\s?$/)) { return 'number'; }
+				if (state.inlinePairs > 0 && stream.match(/^\s*-?[0-9\.\,]+\s?(?=(,|}))/)) { return 'number'; }
+				/* keywords */
+				if (stream.match(keywordRegex)) { return 'keyword'; }
+			}
+
+			/* nothing found, continue */
+			state.pairStart = false;
+			state.escaped = (ch == '\\');
+			stream.next();
+			return null;
+		},
+		startState: function() {
+			return {
+				pair: false,
+				pairStart: false,
+				keyCol: 0,
+				inlinePairs: 0,
+				inlineList: 0,
+				literal: false,
+				escaped: false
+			};
+		}
+	};
+});
+
+CodeMirror.defineMIME("text/x-yaml", "yaml");

data/lib/sunrise-locales.rb

@@ -0,0 +1 @@
+require 'sunrise/locales'

data/lib/sunrise/locales.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Sunrise  
+  module Locales
+    # Default way to setup Sunrise.
+    def self.setup
+      yield self
+    end
+  end
+end
+
+require 'sunrise/locales/yml_locale'
+require 'sunrise/locales/version'
+require 'sunrise/locales/engine'

data/lib/sunrise/locales/engine.rb

@@ -0,0 +1,19 @@
+require 'rails'
+require 'sunrise-locales'
+
+module Sunrise
+  module Locales
+    class Engine < ::Rails::Engine
+      config.before_initialize do
+        Sunrise::Plugin.register :locales do |plugin|
+          plugin.model = 'sunrise/yml_locale'
+          plugin.menu = 'select'
+          plugin.version = Sunrise::Locales::VERSION.dup
+          plugin.klass = Sunrise::YmlLocale
+        end
+        
+        Sunrise::Plugins.activate(:locales)
+      end
+    end
+  end
+end

data/lib/sunrise/locales/version.rb

@@ -0,0 +1,5 @@
+module Sunrise
+  module Locales
+    VERSION = "0.1.0".freeze
+  end
+end

data/lib/sunrise/locales/yml_locale.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require "yaml"
+
+module Sunrise
+  class YmlLocale
+    attr_accessor :locale
+
+    def initialize(locale)
+      @locale = locale
+    end
+    
+    def file_path
+      Rails.root.join("config/locales/#{@locale}.yml")
+    end
+    
+    def get_data
+      text = ''
+      
+      f = File.open(file_path, 'r')
+      f.each_line { |line| text += line }
+      f.close
+      
+      text
+    end
+    
+    def set_data(text)
+      if valid?(text)
+        File.open(file_path, 'w') {|f| f.write(text) }
+      else
+        false
+      end
+    end
+    
+    def valid?(text)
+      begin
+        YAML.load(text)
+        true
+      rescue Exception => e
+        false
+      end
+    end
+  end
+end

data/spec/controllers/manage/locales_controller_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Manage::LocalesController do
+  render_views
+  
+  before(:all) do
+    @locale = Sunrise.available_locales[rand(Sunrise.available_locales.length)]
+    @text = "#{@locale}:\n  title: 'Hello World'"
+    @text2 = @text + "\n  new: 'temp'"
+  end
+  
+  context "administrator" do
+    login_admin
+        
+    context "exists locale" do     
+      it "should render index action" do
+        get :index
+        assigns(:locales).should include(@locale)
+        response.should render_template('index')
+      end
+      
+      it "should render edit action" do
+        controller.should_receive :edit
+        get :edit, :id => @locale
+      end
+      
+      it "should update locale" do
+        put :update, :id => @locale, :text => @text
+        assigns(:locale).should == @locale
+        Sunrise::YmlLocale.new(@locale).get_data.should == @text
+        response.should redirect_to(manage_locales_path)
+        
+        put :update, :id => @locale, :text => @text2
+        Sunrise::YmlLocale.new(@locale).get_data.should == @text2
+      end
+    end
+  end
+  
+  context "anonymous user" do
+    user_logout
+    
+    it "should not render index action" do
+      controller.should_not_receive :index
+      get :index
+    end
+    
+    context "with exists structure" do  
+      it "should not render edit action" do
+        controller.should_not_receive :edit
+        get :edit, :id => @locale
+      end
+      
+      it "should not render update action" do
+        controller.should_not_receive :update
+        put :update, :id => @locale
+      end
+    end
+  end
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,7 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+require 'rake'
+
+Dummy::Application.load_tasks

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/helpers/manage/assets_helper.rb

@@ -0,0 +1,2 @@
+module Manage::AssetsHelper
+end

data/spec/dummy/app/helpers/manage/base_helper.rb

@@ -0,0 +1,81 @@
+module Manage::BaseHelper
+  def content_manager?
+    user_signed_in? && current_user.admin?
+  end
+        
+  def link_to_unless_current_span2(name, options = {}, html_options = {}, &block)
+    if current_page?(options)
+			if block_given?
+				block.arity <= 1 ? yield(name) : yield(name, options, html_options)
+			else
+			 content_tag(:span, content_tag(:span, name), html_options)
+			end
+		else
+			link_to(name, options, html_options)
+		end
+	end
+	
+	def options_for_ckeditor(options = {})
+	  {:width=>700, :height=>400, 
+	   :swf_params=>{:assetable_type=>current_user.class.name, :assetable_id=>current_user.id}
+	     
+	  }.update(options)
+	end
+	
+	def white_block_form(options = {}, &block)
+	  title = options[:title]
+	  
+	  concat(content_tag(:div, {:class=>"edit-white-bl"}) do
+	    concat(content_tag(:div, {:class=>"bot-bg"}) do
+	      concat(content_tag(:div, title, :class=>"wh-title")) unless title.blank?
+	      yield if block_given?
+	    end)
+	  end)
+	end
+	
+	def link_to_sort(title, options = {})
+    options.symbolize_keys!
+    
+    order_type = options[:order_type] || 'asc'
+    order_column = options[:name] || 'id'
+    class_name = options[:class] || nil
+                    
+    search_options = request.params[:search] || {}
+    search_options.update(:order_column => order_column, :order_type => order_type)
+    
+    link_to(title, :search => search_options, :class => class_name)
+  end
+  
+  def remove_child_link(name, f)
+    f.hidden_field(:_destroy) + link_to_function(name, "remove_fields(this)")
+  end
+  
+  def add_child_link(name, f, method, options={})
+    options.symbolize_keys!
+    
+    html_options = options.delete(:html) || {}
+    fields = new_child_fields(f, method, options)
+    
+    html_options[:class] ||= "new"
+    
+    content_tag(:div, 
+      link_to_function(name, h("insert_fields(this, \"#{method}\", \"#{escape_javascript(fields)}\")"), html_options),
+      :class=>"add-bl")
+  end
+  
+  def new_child_fields(form_builder, method, options = {})
+    options[:object] ||= form_builder.object.class.reflect_on_association(method).klass.new
+    options[:partial] ||= method.to_s.singularize
+    options[:form_builder_local] ||= :form
+    
+    form_builder.fields_for(method, options[:object], :child_index => "new_#{method}") do |f|
+      render(:partial => options[:partial], :locals => { options[:form_builder_local] => f })
+    end
+  end
+  
+  def cookie_content_tag(tag_name, options={}, &block)
+    key = options[:id]
+    options[:style] = "display:none;" if !cookies[key].blank? && cookies[key].to_i != 1
+    content_tag(tag_name, options, &block)
+  end
+end

data/spec/dummy/app/helpers/manage/pages_helper.rb

@@ -0,0 +1,2 @@
+module Manage::PagesHelper
+end

data/spec/dummy/app/helpers/manage/settings_helper.rb

@@ -0,0 +1,2 @@
+module Manage::SettingsHelper
+end

data/spec/dummy/app/helpers/manage/structures_helper.rb

@@ -0,0 +1,12 @@
+module Manage::StructuresHelper
+
+  def edit_structure_record_path(structure)                   
+    case structure.structure_type
+      when StructureType.page then edit_manage_structure_page_path(:structure_id=>structure.id)      
+      when StructureType.posts then manage_structure_posts_path(:structure_id => structure.id)
+      when StructureType.main then '#'
+      when StructureType.redirect then structure.slug
+      when StructureType.group then '#'
+    end
+  end
+end

data/spec/dummy/app/helpers/manage/users_helper.rb

@@ -0,0 +1,6 @@
+module Manage::UsersHelper
+  def manage_user_avatar_tag(record, options={})
+	  options.symbolize_keys!
+	  record_asset_tag(record, :avatar, "manage/user_pic.gif", options.merge(:title => record.try(:name)))
+	end
+end

data/spec/dummy/app/models/defaults/ability.rb

@@ -0,0 +1,39 @@
+class Ability
+  include CanCanNamespace::Ability
+  
+  attr_accessor :context, :user
+
+  def initialize(user, context = nil)
+    alias_action :delete, :to => :destroy
+
+    @user = (user || User.new) # guest user (not logged in)
+    @context = context
+    
+    case @user.role_type_id
+      when RoleType.default.id then default
+      when RoleType.redactor.id then redactor
+      when RoleType.moderator.id then moderator
+      when RoleType.admin.id then admin
+    end
+  end
+  
+  def default
+    # TODO
+  end
+  
+  def redactor
+    # TODO
+  end
+  
+  def moderator
+    # TODO
+  end
+  
+  def admin
+    can :manage, :all
+    can :manage, :all, :context => :manage
+    
+    # User cannot destroy self account
+    cannot :destroy, User, :id => @user.id, :context => :manage
+  end
+end

data/spec/dummy/app/models/defaults/asset.rb

@@ -0,0 +1,9 @@
+class Asset < ActiveRecord::Base
+  include Sunrise::Models::Asset
+  
+  attr_accessible :data
+  
+  validates_presence_of :data
+
+	default_scope order("#{quoted_table_name}.sort_order")
+end

data/spec/dummy/app/models/defaults/attachment_file.rb

@@ -0,0 +1,31 @@
+# == Schema Information
+#
+# Table name: assets
+#
+#  id                :integer(4)      not null, primary key
+#  data_file_name    :string(255)     not null
+#  data_content_type :string(255)
+#  data_file_size    :integer(4)
+#  assetable_id      :integer(4)      not null
+#  assetable_type    :string(25)      not null
+#  type              :string(25)
+#  guid              :string(10)
+#  locale            :integer(1)      default(0)
+#  user_id           :integer(4)
+#  created_at        :datetime
+#  updated_at        :datetime
+#  duration          :float           default(0.0)
+#  resolution_id     :integer(1)      default(0)
+#
+# Indexes
+#
+#  index_assets_on_assetable_type_and_type_and_assetable_id  (assetable_type,type,assetable_id)
+#  index_assets_on_assetable_type_and_assetable_id           (assetable_type,assetable_id)
+#  index_assets_on_user_id                                   (user_id)
+#
+
+class AttachmentFile < Asset
+  sunrise_uploader AttachmentFileUploader
+  
+  validates_filesize_of :data, :maximum => 100.megabytes.to_i
+end