freeberry 0.2.5

data/lib/freeberry/railtie.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'rails'
+require 'freeberry'
+
+module Freeberry
+  class Engine < ::Rails::Engine   
+    config.before_initialize do
+      ActiveSupport::XmlMini.backend = 'Nokogiri'
+      
+      Responders::FlashResponder.flash_keys = [ :success, :failure ]
+      InheritedResources.flash_keys = [ :success, :failure ]
+        
+      config.i18n.load_path += Dir[File.join(File.dirname(__FILE__), "../../config", 'locales', '**', '*.{rb,yml}').to_s]
+      
+      I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
+      
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.send :include, Freeberry::MysqlUtils
+        ActiveRecord::Base.send :include, Freeberry::AccessibleAttributes
+      end
+    end
+    
+    config.after_initialize do
+      ActionController::Base.send :include, Freeberry::Controllers::AuthorizedSystem
+      ActionController::Base.send :include, Freeberry::Controllers::HeadOptions
+    
+      ActionView::Base.send :include, Freeberry::Controllers::HelperTools
+    end
+    
+    rake_tasks do
+      load "tasks/freeberry.rake"
+    end
+  end
+end

data/lib/freeberry/settingslogic.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+require "yaml"
+require "erb"
+
+module Freeberry
+  # 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

data/lib/freeberry/system_settings.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require 'ostruct'
+
+module Freeberry
+  class SystemSettings < Settingslogic
+    source Rails.root.join("config", "application.yml")
+    #namespace (Rails.env.to_s || 'development')
+    
+    class << self
+      def ostruct
+        instance.serialize
+      end
+      
+      def update_settings(attributes)
+        instance.update attributes
+        instance.save
+      end
+      
+      def write(hash)
+        begin
+          File.open(source, 'w') do |file|
+            file.write hash.to_yaml
+          end
+        rescue Exception => e
+          return false
+        end
+      end
+      
+      def hashes_to_openstructs(obj, memo={})
+        return obj unless Hash === obj
+        
+        memo[obj.object_id] ||= OpenStruct.new( Hash[
+            *obj.inject( [] ) { |a, (k, v)|
+              a.push k, hashes_to_openstructs( v, memo )
+            }
+          ])
+      end
+    end
+    
+    def save
+      if self.class.namespace
+        hash = YAML.load(ERB.new(File.read(self.class.source)).result).to_hash
+        hash[self.class.namespace] ||= {}
+        hash[self.class.namespace].update self
+      else
+        hash = self
+      end
+        
+      self.class.write(hash)
+      reload
+    end
+    
+    def reload
+      @instance = nil
+      @struct = nil
+      
+      return true
+    end
+    
+    def serialize
+      @struct ||= self.class.hashes_to_openstructs(self)   
+      @struct
+    end
+  end
+end

data/lib/freeberry/transliteration.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+module Freeberry
+  # 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

data/lib/freeberry/utils.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Freeberry
+  class Utils
+    class << self
+      def form_field(form_name, field_name, column, options={})
+        field = case column.type
+          when :string, :binary, :integer, :float, :decimal then 
+            options[:class] = "'text'"
+            "text_field"
+          when :boolean then "check_box"
+          when :datetime, :date, :timestamp, :time then 
+            options[:extra_html] ||= "<script type='text/javascript'>
+              $(function() {
+	              $('#_#{field_name}').datepicker({
+		              numberOfMonths: 1,
+		              dateFormat: 'dd.mm.yy'
+	              });
+              });
+            </script>"
+            'text_field'
+          when :text then 
+            options[:cols] ||= 70
+            options[:rows] ||= 5
+            "text_area"
+        end
+        
+        extra_html = options.delete(:extra_html) || ''
+        
+        options_fields = []
+        options.each { |k, v| options_fields << ":#{k}=>#{v}" }
+        
+        options_str = ", {#{options_fields.join(', ')}}" unless options_fields.empty? 
+        options_str ||= ''
+        
+        "<%= #{form_name}.#{field} #{field_name}#{options_str} %>#{extra_html}"
+      end
+    end
+  end
+end

data/lib/freeberry/version.rb

@@ -0,0 +1,11 @@
+module Freeberry
+  module Version
+    MAJOR = 0
+    MINOR = 2
+    RELEASE = 5
+
+    def self.dup
+      "#{MAJOR}.#{MINOR}.#{RELEASE}"
+    end
+  end
+end

data/lib/generators/freeberry/USAGE

@@ -0,0 +1,5 @@
+== Freeberry
+
+rails generate freeberry:base
+rails generate freeberry:models [options]
+rails generate freeberry:manage_scaffold ModelName

data/lib/generators/freeberry/base/USAGE

@@ -0,0 +1,7 @@
+Usage:
+  rails generate freeberry:base
+
+Options:
+                 
+Example:
+  rails g freeberry:base

data/lib/generators/freeberry/base/base_generator.rb

@@ -0,0 +1,63 @@
+require 'rails/generators'
+
+module Freeberry
+  class BaseGenerator < Rails::Generators::Base
+
+    def self.source_root
+      @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+    end  
+    
+    # copy images
+    def copy_images
+      directory "images/manage", "public/images/manage"
+    end
+    
+    # copy javascripts
+    def copy_javascripts
+      directory "javascripts", "public/javascripts"
+    end
+    
+    # copy stylesheets
+    def copy_stylesheets
+      directory "stylesheets", "public/stylesheets"
+    end
+    
+    # copy views
+    def copy_views
+      directory "views", "app/views"
+    end
+    
+    # copy sweepers
+    def copy_sweepers
+      directory "sweepers", "app/sweepers"
+    end
+    
+    def copy_configurations
+      copy_file('config/words', 'config/words')
+      copy_file('config/authorization_rules.rb', 'config/authorization_rules.rb')
+      copy_file('config/seeds.rb', 'db/seeds.rb')
+      copy_file('config/freeberry.rb', 'config/initializers/freeberry.rb')
+      
+      template('config/application.yml', 'config/application.yml.sample')
+      template('config/database.yml', 'config/database.yml.sample')
+      template('config/logrotate-config', 'config/logrotate-config.sample')
+      template('config/nginx-config-passenger', 'config/nginx-config-passenger.sample')
+    end
+    
+    def copy_helpers
+      directory('helpers', 'app/helpers')
+    end
+    
+    protected
+      
+      def app_name
+        @app_name ||= File.basename(Rails.root)
+        @app_name
+      end
+      
+      def app_path
+        @app_path ||= Rails.root.to_s
+        @app_path
+      end
+  end
+end