loyal_core 0.0.1

data/lib/loyal_core/config.rb

@@ -0,0 +1,116 @@
+# -*- encoding : utf-8 -*-
+module LoyalCore
+  DEFAULT_CLAZZ_ALIAS = ::LoyalCore::DataUtil.new(
+    :like_track   => 'LoyalCore::LikeTrack',
+    :rating_track => 'LoyalCore::RatingTrack'
+  )
+
+
+  SANITIZED_CONFIGS = {
+    :relaxed => {        # 宽松的
+      :elements => %w[
+          a abbr b bdo blockquote br caption cite code col colgroup dd del dfn dl
+          dt em figcaption figure h1 h2 h3 h4 h5 h6 hgroup i img ins kbd li mark
+          ol p pre q rp rt ruby s samp small strike strong sub sup table tbody td
+          tfoot th thead time tr u ul var wbr span code
+      ],
+
+      :attributes => {
+        :all         => ['dir', 'lang', 'title', 'style', 'name', 'id'],
+        'a'          => ['href', 'target', 'name', 'title'],
+        'blockquote' => ['cite'],
+        'col'        => ['span', 'width'],
+        'colgroup'   => ['span', 'width'],
+        'del'        => ['cite', 'datetime'],
+        'img'        => ['align', 'alt', 'height', 'src', 'width', 'title'],
+        'ins'        => ['cite', 'datetime'],
+        'ol'         => ['start', 'reversed', 'type'],
+        'q'          => ['cite'],
+        'table'      => ['summary', 'width', 'border', 'bordercolor'],
+        'td'         => ['abbr', 'axis', 'colspan', 'rowspan', 'width'],
+        'th'         => ['abbr', 'axis', 'colspan', 'rowspan', 'scope', 'width'],
+        'time'       => ['datetime', 'pubdate'],
+        'ul'         => ['type'],
+        'pre'        => ['class', 'lang'],
+        'code'       => ['class']
+      },
+
+      :protocols => {
+        'a'          => {'href' => ['ftp', 'http', 'https', 'mailto', :relative]},
+        'blockquote' => {'cite' => ['http', 'https', :relative]},
+        'del'        => {'cite' => ['http', 'https', :relative]},
+        'img'        => {'src'  => ['http', 'https', :relative]},
+        'ins'        => {'cite' => ['http', 'https', :relative]},
+        'q'          => {'cite' => ['http', 'https', :relative]}
+      }
+    },
+
+    :restricted => {
+      :elements => %w[b em i strong u]
+    },
+
+    :basic => {
+      :elements => %w[
+          a abbr b blockquote br cite code dd dfn dl dt em i kbd li mark ol p pre
+          q s samp small strike strong sub sup time u ul var
+      ],
+
+        :attributes => {
+        'a'          => ['href', 'target'],
+        'abbr'       => ['title'],
+        'blockquote' => ['cite'],
+        'dfn'        => ['title'],
+        'q'          => ['cite'],
+        'time'       => ['datetime', 'pubdate']
+      },
+
+      :add_attributes => {
+        'a' => {'rel' => 'nofollow'}
+      },
+
+      :protocols => {
+        'a'          => {'href' => ['ftp', 'http', 'https', 'mailto', :relative]},
+        'blockquote' => {'cite' => ['http', 'https', :relative]},
+        'q'          => {'cite' => ['http', 'https', :relative]}
+      }
+    },
+    :text => {
+
+    }
+  }.freeze
+
+
+  class << self
+    attr_accessor :config
+    def configure
+      yield self.config ||= Config.new
+    end
+  end
+
+  class Config
+    # 头像的server
+    def avatar_server= server=''
+      @avatar_server ||= server
+    end
+
+    def avatar_server
+      @avatar_server ||= ''
+    end
+
+    def clazz_alias= ali={}
+      @clazz_alias ||= (
+        DEFAULT_CLAZZ_ALIAS.deep_merge(
+          ali
+        )
+      )
+    end
+
+    def clazz_alias
+      @clazz_alias ||= DEFAULT_CLAZZ_ALIAS
+    end
+
+    def sanitize_config
+      SANITIZED_CONFIGS
+    end
+  end
+end

data/lib/loyal_core/core_ext/singleton_class.rb

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+module Kernel
+  # Returns the object's singleton class.
+  def singleton_class
+    class << self
+      self
+    end
+  end unless respond_to?(:singleton_class) # exists in 1.9.2
+end

data/lib/loyal_core/engine.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+module LoyalCore
+  class Engine < ::Rails::Engine
+    isolate_namespace LoyalCore
+
+    config.generators do |g|
+      g.test_framework :rspec, :view_specs => true
+    end
+
+  end
+end

data/lib/loyal_core/memoist.rb

@@ -0,0 +1,204 @@
+# -*- encoding : utf-8 -*-
+#
+# extend  ::LoyalCore::Memoist
+# memoize :helloworld
+#
+require "#{File.dirname(__FILE__)}/core_ext/singleton_class"
+
+module LoyalCore
+  module Memoist
+
+    def self.memoized_ivar_for(method_name, identifier=nil)
+      ["@#{memoized_prefix(identifier)}", escape_punctuation(method_name.to_s)].join("_")
+    end
+
+    def self.unmemoized_method_for(method_name, identifier=nil)
+      [unmemoized_prefix(identifier), method_name].join("_").to_sym
+    end
+
+    def self.memoized_prefix(identifier=nil)
+      ["_memoized", identifier].compact.join("_")
+    end
+
+    def self.unmemoized_prefix(identifier=nil)
+      ["_unmemoized", identifier].compact.join("_")
+    end
+
+    def self.escape_punctuation(string)
+      string.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')
+    end
+
+    def self.memoist_eval(klass, *args, &block)
+      if klass.respond_to?(:class_eval)
+        klass.class_eval(*args, &block)
+      else
+        klass.singleton_class.class_eval(*args, &block)
+      end
+    end
+
+    def self.extract_reload!(method, args)
+      if args.length == method.arity + 1 && (args.last == true || args.last == :reload)
+        reload = args.pop
+      end
+      reload
+    end
+
+    module InstanceMethods
+      def memoize_all
+        prime_cache
+      end
+
+      def unmemoize_all
+        flush_cache
+      end
+
+      def prime_cache(*method_names)
+        if method_names.empty?
+          prefix = Memoist.unmemoized_prefix+"_"
+          method_names = methods.collect do |method_name|
+            if method_name.to_s.start_with?(prefix)
+              method_name[prefix.length..-1]
+            end
+          end.compact
+        end
+
+        method_names.each do |method_name|
+          if method(Memoist.unmemoized_method_for(method_name)).arity == 0
+            __send__(method_name)
+          else
+            ivar = Memoist.memoized_ivar_for(method_name)
+            instance_variable_set(ivar, {})
+          end
+        end
+      end
+
+      def flush_cache(*method_names)
+        if method_names.empty?
+          prefix = Memoist.unmemoized_prefix+"_"
+          method_names = (methods + private_methods + protected_methods).collect do |method_name|
+            if method_name.to_s.start_with?(prefix)
+              method_name[prefix.length..-1]
+            end
+          end.compact
+        end
+
+        method_names.each do |method_name|
+          ivar = Memoist.memoized_ivar_for(method_name)
+          instance_variable_get(ivar).clear if instance_variable_defined?(ivar)
+        end
+      end
+    end
+
+    def memoize(*method_names)
+      if method_names.last.is_a?(Hash)
+        identifier = method_names.pop[:identifier]
+      end
+
+      method_names.each do |method_name|
+        unmemoized_method = Memoist.unmemoized_method_for(method_name, identifier)
+        memoized_ivar = Memoist.memoized_ivar_for(method_name, identifier)
+
+        Memoist.memoist_eval(self) do
+          include InstanceMethods
+
+          if method_defined?(unmemoized_method)
+            raise "Already memoized #{method_name}"
+          end
+          alias_method unmemoized_method, method_name
+
+          if instance_method(method_name).arity == 0
+
+            # define a method like this;
+
+            # def mime_type(reload=true)
+            #   skip_cache = reload || !memoized?(:abc)
+            #   set_cache = skip_cache && !frozen?
+            #
+            #   if skip_cache
+            #     value = _unmemoized_mime_type
+            #   else
+            #     value = @_memoized_mime_type[0]
+            #   end
+            #
+            #   if set_cache
+            #     @_memoized_mime_type = [value]
+            #   end
+            #
+            #   value
+            # end
+
+            module_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{method_name}(reload = false)
+              skip_cache = reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?
+              set_cache = skip_cache && !frozen?
+
+              if skip_cache
+                value = #{unmemoized_method}
+              else
+                value = #{memoized_ivar}[0]
+              end
+
+              if set_cache
+                #{memoized_ivar} = [value]
+              end
+
+              value
+            end
+                EOS
+          else
+
+            # define a method like this;
+
+            # def mime_type(*args)
+            #   reload = Memoist.extract_reload!(method(:_unmemoized_mime_type), args)
+            #
+            #   skip_cache = reload || !memoized_with_args?(:mime_type, args)
+            #   set_cache = skip_cache && !frozen
+            #
+            #   if skip_cache
+            #     value = _unmemoized_mime_type(*args)
+            #   else
+            #     value = @_memoized_mime_type[args]
+            #   end
+            #
+            #   if set_cache
+            #     @_memoized_mime_type ||= {}
+            #     @_memoized_mime_type[args] = value
+            #   end
+            #
+            #   value
+            # end
+
+            module_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{method_name}(*args)
+              reload = Memoist.extract_reload!(method(#{unmemoized_method.inspect}), args)
+
+              skip_cache = reload || !(defined?(#{memoized_ivar}) && #{memoized_ivar} && #{memoized_ivar}.has_key?(args))
+              set_cache = skip_cache && !frozen?
+
+              if skip_cache
+                value = #{unmemoized_method}(*args)
+              else
+                value = #{memoized_ivar}[args]
+              end
+
+              if set_cache
+            #{memoized_ivar} ||= {}
+            #{memoized_ivar}[args] = value
+              end
+
+              value
+            end
+            EOS
+          end
+
+          if private_method_defined?(unmemoized_method)
+            private method_name
+          elsif protected_method_defined?(unmemoized_method)
+            protected method_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/loyal_core/utils/array_util.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module LoyalCore
+  class ArrayUtil
+    def self.extract_options!(arr)
+      if arr.last.is_a?(Hash)
+        arr.pop
+      else
+        {}
+      end
+    end
+
+    def self.init args
+      args.is_a?(Array) ? args : (args.nil? ? [] : [args])
+    end
+  end
+end

data/lib/loyal_core/utils/config_util.rb

@@ -0,0 +1,186 @@
+# -*- encoding : utf-8 -*-
+module LoyalCore
+  class ConfigUtil
+    attr_reader :config_values_map, :pure_values, :select_options,
+      :default_item
+
+    # config*
+    #   [
+    #     {
+    #       :key => :name, :value => 1, :desc => 'Hello World'
+    #     },
+    #     {
+    #       :key => :age, :value => 2, :desc => 'Good'
+    #     },
+    #     {
+    #       :desc => '地址',
+    #       :group => [
+    #
+    #       ]
+    #     }
+    #   ]
+    def initialize *args
+      # options = args.extract_options!
+
+      @config_values_map = {}
+      @config_keys_map   = {}
+      @select_options = impl_collect_select_options args
+      @default_item = nil
+
+      impl_collect_item args
+
+      @config_values_map.freeze
+      @config_keys_map.freeze
+      @select_options.freeze
+      @default_item.freeze
+
+      self.freeze
+    end
+
+    def at(key)
+      @config_keys_map[key]
+    end
+
+    def item(value)
+      @config_values_map[value]
+    end
+
+    def to_select_options
+      @select_options.dup
+    end
+
+    private
+
+    def impl_collect_select_options item
+      if item.is_a?(Hash)
+        if item[:group].is_a?(Array)
+          [item[:desc]] + [
+            impl_collect_select_options(item[:group])
+          ]
+        elsif item.key?(:key) && item.key?(:value)
+          [item[:desc], item[:value]]
+        end
+      elsif item.is_a?(Array)
+        item.map do |itm|
+          impl_collect_select_options itm
+        end
+      end
+    end
+
+    def impl_collect_item item
+      if item.is_a? Hash
+        if item[:group].is_a?(Array)
+          impl_collect_item item[:group]
+        else
+          if item.key?(:key) && item.key?(:value)
+            util_item = ConfigUtilItem.new item
+            @config_values_map[item[:value]] = util_item
+            @config_keys_map[item[:key]]   = util_item
+
+            if item[:default]
+              @default_item = util_item
+            end
+          end
+        end
+      elsif item.is_a? Array
+        item.each do |itm|
+          impl_collect_item itm
+        end
+      end
+    end
+  end
+
+  class ConfigUtilItem
+    def initialize(item={})
+      @item = item || {}
+    end
+
+    def [] key
+      @item[key]
+    end
+
+    def method_missing(method_name, *args, &block)
+      @item[method_name.to_sym]
+    end
+
+  end
+end
+
+#  module LoyalCore
+#    # 配置工具类
+#    class ConfigUtil < ::Hash
+#      attr_reader :config_values_map, :pure_values
+#  
+#      # 
+#      # configs:
+#      #   {
+#      #     :john    => { :value => 1, :desc => '约翰' },
+#      #     :liming =>  { :value => 2, :desc => '黎明' },
+#      #     :have => {
+#      #       :book => {
+#      #         :value => 3， ：desc => ''
+#      #       }
+#      #     }
+#      #     ...
+#      #   }
+#      def initialize(*args)
+#        configs = args.extract_options!
+#        @default_key = args.first
+#        @config_values_map = {}
+#  
+#        configs.each do |key, item|
+#          self[key] = ConfigUtilItem.new(item.merge(:key => key))
+#          @config_values_map[self[key].value] = self[key]
+#        end
+#  
+#        @config_values_map.freeze
+#        @pure_values = @config_values_map.keys.freeze
+#  
+#        @select_options = (
+#          self.values.map do |item|
+#            [item.desc, item.value]
+#          end
+#        ).freeze
+#  
+#        self.freeze
+#      end
+#  
+#      def at(key)
+#        self[key]
+#      end
+#  
+#      def item(value)
+#        @config_values_map[value] || ( self[@default_key] unless @default_key.nil? )
+#      end
+#  
+#      # options:
+#      #   - include_blank:
+#      def select_options options={}
+#        result = @select_options.dup
+#  
+#        if options.key?(:include_blank)
+#          if options[:include_blank].is_a?(::Hash)
+#            result.insert(0, [options[:include_blank][:desc] || '- - 请选择 - -', options[:include_blank][:value].to_i])
+#          elsif options[:include_blank]
+#            result.insert(0, ['- - 请选择 - -', 0])
+#          end
+#        end
+#  
+#        result
+#      end
+#    end
+#  
+#    class ConfigUtilItem
+#      def initialize(item={})
+#        @item = item || {}
+#      end
+#  
+#      def [] key
+#        @item[key]
+#      end
+#  
+#      def method_missing(method_name, *args, &block)
+#        @item[method_name.to_sym]
+#      end
+#    end
+#  end