sunrise-core 0.1.0

data/lib/sunrise/utils/settingslogic.rb

@@ -0,0 +1,164 @@
+# encoding: utf-8
+require "yaml"
+require "erb"
+
+module Sunrise
+  module Utils
+    # A simple settings solution using a YAML file. See README for more information.
+    class Settingslogic < Hash
+      class MissingSetting < StandardError; end
+
+      class << self
+        def name # :nodoc:
+          instance.key?("name") ? instance.name : super
+        end
+
+        # Enables Settings.get('nested.key.name') for dynamic access
+        def get(key)
+          parts = key.split('.')
+          curs = self
+          while p = parts.shift
+            curs = curs.send(p)
+          end
+          curs
+        end
+
+        def source(value = nil)
+          if value.nil?
+            @source
+          else
+            @source = value
+          end
+        end
+
+        def namespace(value = nil)
+          if value.nil?
+            @namespace
+          else
+            @namespace = value
+          end
+        end
+        
+        def [](key)
+          instance.fetch(key.to_s, nil)
+        end
+
+        def []=(key, val)
+          # Setting[:key][:key2] = 'value' for dynamic settings
+          val = new(val, source) if val.is_a? Hash
+          instance.store(key.to_s, val)
+          instance.create_accessor_for(key, val)
+        end
+
+        def load!
+          instance
+          true
+        end
+        
+        def reload!
+          @instance = nil
+          load!
+        end
+        
+        private
+          def instance
+            return @instance if @instance
+            @instance = new
+            create_accessors!
+            @instance
+          end
+          
+          def method_missing(name, *args, &block)
+            instance.send(name, *args, &block)
+          end
+
+          # It would be great to DRY this up somehow, someday, but it's difficult because
+          # of the singleton pattern.  Basically this proxies Setting.foo to Setting.instance.foo
+          def create_accessors!
+            instance.each do |key,val|
+              create_accessor_for(key)
+            end
+          end
+
+          def create_accessor_for(key)
+            return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
+            instance_eval "def #{key}; instance.send(:#{key}); end"
+          end
+
+      end
+
+      # Initializes a new settings object. You can initialize an object in any of the following ways:
+      #
+      #   Settings.new(:application) # will look for config/application.yml
+      #   Settings.new("application.yaml") # will look for application.yaml
+      #   Settings.new("/var/configs/application.yml") # will look for /var/configs/application.yml
+      #   Settings.new(:config1 => 1, :config2 => 2)
+      #
+      # Basically if you pass a symbol it will look for that file in the configs directory of your rails app,
+      # if you are using this in rails. If you pass a string it should be an absolute path to your settings file.
+      # Then you can pass a hash, and it just allows you to access the hash via methods.
+      def initialize(hash_or_file = self.class.source, section = nil)
+        #puts "new! #{hash_or_file}"
+        case hash_or_file
+        when nil
+          raise Errno::ENOENT, "No file specified as Settingslogic source"
+        when Hash
+          self.replace hash_or_file
+        else
+          hash = YAML.load(ERB.new(File.read(hash_or_file)).result).to_hash
+          hash = hash[self.class.namespace] if self.class.namespace
+          self.replace hash
+        end
+        @section = section || self.class.source  # so end of error says "in application.yml"
+        create_accessors!
+      end
+
+      # Called for dynamically-defined keys, and also the first key deferenced at the top-level, if load! is not used.
+      # Otherwise, create_accessors! (called by new) will have created actual methods for each key.
+      def method_missing(name, *args, &block)
+        key = name.to_s
+        raise MissingSetting, "Missing setting '#{key}' in #{@section}" unless has_key? key
+        value = fetch(key)
+        create_accessor_for(key)
+        value.is_a?(Hash) ? self.class.new(value, "'#{key}' section in #{@section}") : value
+      end
+
+      def [](key)
+        fetch(key.to_s, nil)
+      end
+
+      def []=(key,val)
+        # Setting[:key][:key2] = 'value' for dynamic settings
+        val = self.class.new(val, @section) if val.is_a? Hash
+        store(key.to_s, val)
+        create_accessor_for(key, val)
+      end
+
+      # This handles naming collisions with Sinatra/Vlad/Capistrano. Since these use a set()
+      # helper that defines methods in Object, ANY method_missing ANYWHERE picks up the Vlad/Sinatra
+      # settings!  So settings.deploy_to title actually calls Object.deploy_to (from set :deploy_to, "host"),
+      # rather than the app_yml['deploy_to'] hash.  Jeezus.
+      def create_accessors!
+        self.each do |key,val|
+          create_accessor_for(key)
+        end
+      end
+
+      # Use instance_eval/class_eval because they're actually more efficient than define_method{}
+      # http://stackoverflow.com/questions/185947/ruby-definemethod-vs-def
+      # http://bmorearty.wordpress.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/
+      def create_accessor_for(key, val=nil)
+        return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
+        instance_variable_set("@#{key}", val) if val
+        self.class.class_eval <<-EndEval
+          def #{key}
+            return @#{key} if @#{key}
+            raise MissingSetting, "Missing setting '#{key}' in #{@section}" unless has_key? '#{key}'
+            value = fetch('#{key}')
+            @#{key} = value.is_a?(Hash) ? self.class.new(value, "'#{key}' section in #{@section}") : value
+          end
+        EndEval
+      end
+    end
+  end
+end

data/lib/sunrise/utils/transliteration.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+module Sunrise
+  module Utils
+    # Russian transliteration 
+    #
+    module Transliteration
+      extend self
+
+      # Transliteration heavily based on rutils gem by Julian "julik" Tarkhanov and Co.
+      # <http://rutils.rubyforge.org/>
+      # Cleaned up and optimized.
+
+      LOWER_SINGLE = {
+        "і"=>"i","ґ"=>"g","ё"=>"yo","№"=>"#","є"=>"e",
+        "ї"=>"yi","а"=>"a","б"=>"b",
+        "в"=>"v","г"=>"g","д"=>"d","е"=>"e","ж"=>"zh",
+        "з"=>"z","и"=>"i","й"=>"y","к"=>"k","л"=>"l",
+        "м"=>"m","н"=>"n","о"=>"o","п"=>"p","р"=>"r",
+        "с"=>"s","т"=>"t","у"=>"u","ф"=>"f","х"=>"h",
+        "ц"=>"ts","ч"=>"ch","ш"=>"sh","щ"=>"sch","ъ"=>"'",
+        "ы"=>"y","ь"=>"","э"=>"e","ю"=>"yu","я"=>"ya",
+      }
+      LOWER_MULTI = {
+        "ье"=>"ie",
+        "ьё"=>"ie",
+      }
+
+      UPPER_SINGLE = {
+        "Ґ"=>"G","Ё"=>"YO","Є"=>"E","Ї"=>"YI","І"=>"I",
+        "А"=>"A","Б"=>"B","В"=>"V","Г"=>"G",
+        "Д"=>"D","Е"=>"E","Ж"=>"ZH","З"=>"Z","И"=>"I",
+        "Й"=>"Y","К"=>"K","Л"=>"L","М"=>"M","Н"=>"N",
+        "О"=>"O","П"=>"P","Р"=>"R","С"=>"S","Т"=>"T",
+        "У"=>"U","Ф"=>"F","Х"=>"H","Ц"=>"TS","Ч"=>"CH",
+        "Ш"=>"SH","Щ"=>"SCH","Ъ"=>"'","Ы"=>"Y","Ь"=>"",
+        "Э"=>"E","Ю"=>"YU","Я"=>"YA",
+      }
+      UPPER_MULTI = {
+        "ЬЕ"=>"IE",
+        "ЬЁ"=>"IE",
+      }
+
+      LOWER = (LOWER_SINGLE.merge(LOWER_MULTI)).freeze
+      UPPER = (UPPER_SINGLE.merge(UPPER_MULTI)).freeze
+      MULTI_KEYS = (LOWER_MULTI.merge(UPPER_MULTI)).keys.sort_by {|s| s.length}.reverse.freeze
+
+      # Transliterate a string with russian characters
+      #
+      # Возвращает строку, в которой все буквы русского алфавита заменены на похожую по звучанию латиницу
+      def transliterate(str)
+        chars = str.scan(%r{#{MULTI_KEYS.join '|'}|\w|.})
+
+        result = ""
+
+        chars.each_with_index do |char, index|
+          if UPPER.has_key?(char) && LOWER.has_key?(chars[index+1])
+            # combined case
+            result << UPPER[char].downcase.capitalize
+          elsif UPPER.has_key?(char)
+            result << UPPER[char]
+          elsif LOWER.has_key?(char)
+            result << LOWER[char]
+          else
+            result << char
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/sunrise/version.rb

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

data/lib/sunrise/views/form_builder.rb

@@ -0,0 +1,44 @@
+require 'simple_form'
+require 'sunrise/views/inputs/date_time_input'
+
+module Sunrise
+  module Views
+    class FormBuilder < ::SimpleForm::FormBuilder
+      delegate :concat, :content_tag, :link_to, :link_to_function, :to => :template
+      
+      def input(attribute_name, options = {}, &block)
+        options[:input_html] ||= {}
+        options[:input_html] = { :class => 'text' }.merge(options[:input_html])
+        
+        attribute_name = "#{attribute_name}_#{options[:locale]}" unless options[:locale].blank?
+        
+        super(attribute_name, options, &block)
+      end
+      
+      def globalize(options={}, &block)
+        locales = options[:locales] || Sunrise.available_locales
+        html = []
+        
+        html.join.html_safe
+      end
+      
+      def button(type, *args, &block)
+        options = args.extract_options!
+        url = options[:url] || [:manage, object_plural]
+        title = object.new_record? ? I18n.t('manage.create') : I18n.t('manage.update')
+        
+        content_tag(:div, :style => "padding: 20px 0px 10px 20px;", :class => "buts") do
+          concat link_to_function content_tag(:span, title), "$(this).parents('form').submit()", :class=>"gr"
+          concat link_to I18n.t('manage.cancel'), url, :class=>"erase"
+          concat super(type, {:style => "display:none"}, &block)
+        end
+      end
+      
+      protected
+      
+        def object_plural
+          object_name.to_s.pluralize
+        end
+    end
+  end
+end

data/lib/sunrise/views/helpers.rb

@@ -0,0 +1,190 @@
+module Sunrise
+  module Views
+    module Helpers
+      
+      def title(content)
+	      content_for(:title) { content } unless content.blank?
+      end
+
+      def javascript(*args)
+	      content_for(:head) { javascript_include_tag(*args) }
+      end
+
+      def stylesheet(*args)
+        content_for(:head) { stylesheet_link_tag(*args) }
+      end
+
+      def description(content)
+        content_for(:description) { tag(:meta, :content=>content, :name=>"description") } unless content.blank?
+      end
+
+      def keywords(content)
+        content_for(:keywords) { tag(:meta, :content=>content, :name=>"keywords") } unless content.blank?
+      end
+      
+      def render_title
+        @page_title || I18n.t("page.title")
+      end
+      
+      def render_keywords
+        @page_keywords || I18n.t("page.keywords")
+      end
+      
+      def render_description
+        @page_description || I18n.t("page.description")
+      end
+
+      def anchor_to(name, options={})
+        return if name.blank?
+        options[:name] = name
+        
+        content_tag(:a, '', options)
+      end
+
+      def link_by_href(name, options={})
+        link_to name, name, options
+      end
+
+      def link_to_unless_current_span(name, options = {}, html_options = {}, &block)
+        link_to_unless_span current_page?(options), name, options, html_options, &block
+      end
+
+      def link_to_unless_span(condition, name, options = {}, html_options = {}, &block)
+        if condition
+          if block_given?
+	          block.arity <= 1 ? yield(name) : yield(name, options, html_options)
+          else
+           content_tag(:span, name, html_options)
+          end
+        else
+          link_to(name, options, html_options)
+        end
+      end
+
+      def link_to_unless_current_tag(name, options = {}, html_options = {}, &block)
+        link_to_unless_tag current_page?(options), name, options, html_options, &block
+      end
+
+      def link_to_if_tag(condition, name, options = {}, html_options = {}, &block)
+        tag_name = html_options.delete(:tag) || :span
+        if condition
+          link_to(name, options, html_options)
+        else
+          if block_given?
+	          block.arity <= 1 ? yield(name) : yield(name, options, html_options)
+          else
+           content_tag(tag_name, name, html_options)
+          end
+        end
+      end	
+
+      def link_to_unless_tag(condition, name, options = {}, html_options = {}, &block)
+        tag_name = html_options.delete(:tag) || :span
+        unless condition
+          link_to(name, options, html_options)
+        else
+          if block_given?
+	          block.arity <= 1 ? yield(name) : yield(name, options, html_options)
+          else
+           content_tag(tag_name, name, html_options)
+          end
+        end
+      end	
+
+      def link_to_remote_if(condition, name, options = {}, html_options = nil)
+        return name unless condition
+        link_to_function(name, remote_function(options), html_options || options.delete(:html))
+      end
+
+      def submit_image(name, src, options={})
+        html_options = options.dup.symbolize_keys
+        
+        html_options[:name] = name
+        html_options[:src] = src
+        html_options[:type] ||= 'image'
+        
+        tag(:input, html_options)
+      end
+
+      def submit_image_to_remote(name, value, options = {})
+        options[:with] ||= 'Form.serialize(this.form)'
+        
+        html_options = options.delete(:html) || {}
+        html_options[:name] = name
+        html_options[:type] ||= 'button'
+
+        onclick = html_options.delete(:onclick) || remote_function(options)
+
+        tag(:input, html_options.merge(:value => name, :onclick => onclick))
+      end
+
+      def locale_image_tag(source, options = {})
+        source = "#{I18n.locale}/#{source}"
+        image_tag(source, options)
+      end
+
+      # swf_object
+      def swf_object(swf, id, width, height, flash_version, options = {})
+        options.symbolize_keys!
+        
+        params = options.delete(:params) || {}
+        attributes = options.delete(:attributes) || {}
+        flashvars = options.delete(:flashvars) || {}
+        
+        attributes[:classid] ||= "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
+        attributes[:id] ||= id
+        attributes[:name] ||= id
+        
+        output_buffer = ActiveSupport::SafeBuffer.new
+        
+        if options[:create_div]
+          output_buffer << content_tag(:div, 
+            "This website requires <a href='http://www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash&promoid=BIOW' target='_blank'>Flash player</a> #{flash_version} or higher.",
+            :id => id)
+        end
+        
+        js = []
+        
+        js << "var params = {#{params.to_a.map{|item| "#{item[0]}:'#{item[1]}'" }.join(',')}};"
+        js << "var attributes = {#{attributes.to_a.map{|item| "#{item[0]}:'#{item[1]}'" }.join(',')}};"
+        js << "var flashvars = {#{flashvars.to_a.map{|item| "#{item[0]}:'#{item[1]}'" }.join(',')}};"
+
+        js << "swfobject.embedSWF('#{swf}', '#{id}', '#{width}', '#{height}', '#{flash_version}', '/swf/expressInstall.swf', flashvars, params, attributes);"
+
+        output_buffer << javascript_tag(js.join)
+        
+        output_buffer
+      end
+
+      def encode_email(email_address, options = {})
+        email_address = email_address.to_s
+        string = ''
+
+        "document.write('#{email_address}');".each_byte do |c|
+           string << sprintf("%%%x", c)
+         end
+         
+        "<script type=\"#{Mime::JS}\">eval(decodeURIComponent('#{string}'))</script>"
+      end
+      
+      def record_asset_tag(record, method_name, default_image, options = {})
+        asset = record ? record.send(method_name) : nil
+        asset_type = options.has_key?(:type) ? options.delete(:type).to_sym : nil
+        extname = File.extname(default_image)
+		    image_path = asset_type.nil? ? default_image : "#{File.basename(default_image, extname)}_#{asset_type}#{extname}"
+		    image_full = default_image.gsub(File.basename(default_image), image_path)
+		
+		    path = (asset && !asset.new_record?) ? asset.url(asset_type) : image_full
+	      
+		    image_tag(path, options)
+      end
+      
+      def manage_form_for(object, *args, &block)
+        options = args.extract_options!
+        options[:builder] ||= Sunrise::Views::FormBuilder
+        
+        simple_form_for([:manage, object].flatten, *(args << options), &block)
+      end
+    end
+  end
+end

data/lib/sunrise/views/inputs/date_time_input.rb

@@ -0,0 +1,46 @@
+module SimpleForm
+  module Inputs
+    class DateTimeInput < Base
+      def input
+        #@builder.send(:"#{input_type}_select", attribute_name, input_options, input_html_options)
+        html = [@builder.text_field(attribute_name, input_html_options)]
+        
+        html << case input_type
+          when :date then
+            @builder.javascript_tag("$(function() {
+		          $('##{@builder.object_name}_#{attribute_name}').datepicker({
+			          numberOfMonths: 2,
+			          showButtonPanel: true
+		          });
+	          });")
+	        when :datetime then
+	          @builder.javascript_tag("$(function() {
+		          $('##{@builder.object_name}_#{attribute_name}').datetimepicker({
+			          numberOfMonths: 2,
+			          hourGrid: 4,
+                minuteGrid: 10
+		          });
+	          });")
+	      end
+
+	      html.join.html_safe
+      end
+
+    private
+
+      def has_required?
+        false
+      end
+
+      def label_target
+        case input_type
+        when :date, :datetime
+          "#{attribute_name}_1i"
+        when :time
+          "#{attribute_name}_4i"
+        end
+      end
+    end
+  end
+end
+

data/lib/sunrise-core.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'sunrise/core'