lux-fw 0.1.17 → 0.1.35

data/lib/overload/hash_wia.rb

@@ -1,282 +0,0 @@
-# exrtacted from Rails
-
-class HashWithIndifferentAccess < Hash
-  # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
-  # this class.
-  def extractable_options?
-    true
-  end
-
-  def with_indifferent_access
-    dup
-  end
-
-  def initialize(constructor = {})
-    if constructor.respond_to?(:to_hash)
-      super()
-      update(constructor)
-
-      hash = constructor.to_hash
-      self.default = hash.default if hash.default
-      self.default_proc = hash.default_proc if hash.default_proc
-    else
-      super(constructor)
-    end
-  end
-
-  def default(*args)
-    arg_key = args.first
-
-    if include?(key = convert_key(arg_key))
-      self[key]
-    else
-      super
-    end
-  end
-
-  def self.[](*args)
-    new.merge!(Hash[*args])
-  end
-
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-  # Assigns a new value to the hash:
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new
-  #   hash[:key] = 'value'
-  #
-  # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
-  def []=(key, value)
-    regular_writer(convert_key(key), convert_value(value, for: :assignment))
-  end
-
-  alias_method :store, :[]=
-
-  # Updates the receiver in-place, merging in the hash passed as argument:
-  #
-  #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
-  #   hash_1[:key] = 'value'
-  #
-  #   hash_2 = ActiveSupport::HashWithIndifferentAccess.new
-  #   hash_2[:key] = 'New Value!'
-  #
-  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-  #
-  # The argument can be either an
-  # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
-  # In either case the merge respects the semantics of indifferent access.
-  #
-  # If the argument is a regular hash with keys +:key+ and +"key"+ only one
-  # of the values end up in the receiver, but which one is unspecified.
-  #
-  # When given a block, the value for duplicated keys will be determined
-  # by the result of invoking the block with the duplicated key, the value
-  # in the receiver, and the value in +other_hash+. The rules for duplicated
-  # keys follow the semantics of indifferent access:
-  #
-  #   hash_1[:key] = 10
-  #   hash_2['key'] = 12
-  #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
-  def update(other_hash)
-    if other_hash.is_a? HashWithIndifferentAccess
-      super(other_hash)
-    else
-      other_hash.to_hash.each_pair do |key, value|
-        if block_given? && key?(key)
-          value = yield(convert_key(key), self[key], value)
-        end
-        regular_writer(convert_key(key), convert_value(value))
-      end
-      self
-    end
-  end
-
-  alias_method :merge!, :update
-
-  # Checks the hash for a key matching the argument passed in:
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new
-  #   hash['key'] = 'value'
-  #   hash.key?(:key)  # => true
-  #   hash.key?('key') # => true
-  def key?(key)
-    super(convert_key(key))
-  end
-
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?, :key?
-
-  # Same as <tt>Hash#[]</tt> where the key passed as argument can be
-  # either a string or a symbol:
-  #
-  #   counters = ActiveSupport::HashWithIndifferentAccess.new
-  #   counters[:foo] = 1
-  #
-  #   counters['foo'] # => 1
-  #   counters[:foo]  # => 1
-  #   counters[:zoo]  # => nil
-  def [](key)
-    super(convert_key(key))
-  end
-
-  # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
-  # either a string or a symbol:
-  #
-  #   counters = ActiveSupport::HashWithIndifferentAccess.new
-  #   counters[:foo] = 1
-  #
-  #   counters.fetch('foo')          # => 1
-  #   counters.fetch(:bar, 0)        # => 0
-  #   counters.fetch(:bar) { |key| 0 } # => 0
-  #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
-  def fetch(key, *extras)
-    super(convert_key(key), *extras)
-  end
-
-  # Returns an array of the values at the specified indices:
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new
-  #   hash[:a] = 'x'
-  #   hash[:b] = 'y'
-  #   hash.values_at('a', 'b') # => ["x", "y"]
-  def values_at(*indices)
-    indices.collect { |key| self[convert_key(key)] }
-  end
-
-  # Returns an array of the values at the specified indices, but also
-  # raises an exception when one of the keys can't be found.
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new
-  #   hash[:a] = 'x'
-  #   hash[:b] = 'y'
-  #   hash.fetch_values('a', 'b') # => ["x", "y"]
-  #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
-  #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
-  def fetch_values(*indices, &block)
-    indices.collect { |key| fetch(key, &block) }
-  end if Hash.method_defined?(:fetch_values)
-
-  # Returns a shallow copy of the hash.
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new({ a: { b: 'b' } })
-  #   dup  = hash.dup
-  #   dup[:a][:c] = 'c'
-  #
-  #   hash[:a][:c] # => nil
-  #   dup[:a][:c]  # => "c"
-  def dup
-    self.class.new(self).tap do |new_hash|
-      set_defaults(new_hash)
-    end
-  end
-
-  # This method has the same semantics of +update+, except it does not
-  # modify the receiver but rather returns a new hash with indifferent
-  # access with the result of the merge.
-  def merge(hash, &block)
-    dup.update(hash, &block)
-  end
-
-  # Like +merge+ but the other way around: Merges the receiver into the
-  # argument and returns a new hash with indifferent access as result:
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new
-  #   hash['a'] = nil
-  #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
-  def reverse_merge(other_hash)
-    super(self.class.new(other_hash))
-  end
-  alias_method :with_defaults, :reverse_merge
-
-  # Same semantics as +reverse_merge+ but modifies the receiver in-place.
-  def reverse_merge!(other_hash)
-    replace(reverse_merge(other_hash))
-  end
-  alias_method :with_defaults!, :reverse_merge!
-
-  # Replaces the contents of this hash with other_hash.
-  #
-  #   h = { "a" => 100, "b" => 200 }
-  #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
-  def replace(other_hash)
-    super(self.class.new(other_hash))
-  end
-
-  # Removes the specified key from the hash.
-  def delete(key)
-    super(convert_key(key))
-  end
-
-  def stringify_keys!; self end
-  def deep_stringify_keys!; self end
-  def stringify_keys; dup end
-  def deep_stringify_keys; dup end
-  # undef :symbolize_keys!
-  # undef :deep_symbolize_keys!
-  def symbolize_keys; to_hash.symbolize_keys! end
-  def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
-  def to_options!; self end
-
-  def select(*args, &block)
-    return to_enum(:select) unless block_given?
-    dup.tap { |hash| hash.select!(*args, &block) }
-  end
-
-  def reject(*args, &block)
-    return to_enum(:reject) unless block_given?
-    dup.tap { |hash| hash.reject!(*args, &block) }
-  end
-
-  def transform_values(*args, &block)
-    return to_enum(:transform_values) unless block_given?
-    dup.tap { |hash| hash.transform_values!(*args, &block) }
-  end
-
-  def compact
-    dup.tap(&:compact!)
-  end
-
-  # Convert to a regular hash with string keys.
-  def to_hash
-    _new_hash = Hash.new
-    set_defaults(_new_hash)
-
-    each do |key, value|
-      _new_hash[key] = convert_value(value, for: :to_hash)
-    end
-    _new_hash
-  end
-
-  private
-    def convert_key(key) # :doc:
-      key.kind_of?(Symbol) ? key.to_s : key
-    end
-
-    def convert_value(value, options = {}) # :doc:
-      if value.is_a? Hash
-        if options[:for] == :to_hash
-          value.to_hash
-        else
-          value.class == Hash ? HashWithIndifferentAccess.new(value) : value
-        end
-      elsif value.is_a?(Array)
-        if options[:for] != :assignment || value.frozen?
-          value = value.dup
-        end
-        value.map! { |e| convert_value(e, options) }
-      else
-        value
-      end
-    end
-
-    def set_defaults(target) # :doc:
-      if default_proc
-        target.default_proc = default_proc.dup
-      else
-        target.default = default
-      end
-    end
-end
-

data/lib/overload/inflections.rb

@@ -1,199 +0,0 @@
-# # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
-
-# class String
-#   def pluralize(locale = :en)
-#     word = self
-#     apply_inflections(word, inflections(locale).plurals)
-#   end
-
-#   def singularize(locale = :en)
-#     word = self
-#     apply_inflections(word, inflections(locale).singulars)
-#   end
-
-#   def camelize(uppercase_first_letter = true)
-#     term = self
-#     string = term.to_s
-#     if uppercase_first_letter
-#       string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
-#     else
-#       string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
-#     end
-#     string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-#     string.gsub!("/".freeze, "::".freeze)
-#     string
-#   end
-
-#   def underscore
-#     camel_cased_word = self
-#     return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
-#     word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
-#     word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
-#     word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
-#     word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
-#     word.tr!("-".freeze, "_".freeze)
-#     word.downcase!
-#     word
-#   end
-
-#   def humanize(options = {})
-#     result = self.to_s.dup
-
-#     inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
-
-#     result.sub!(/\A_+/, "".freeze)
-#     result.sub!(/_id\z/, "".freeze)
-#     result.tr!("_".freeze, " ".freeze)
-
-#     result.gsub!(/([a-z\d]*)/i) do |match|
-#       "#{inflections.acronyms[match] || match.downcase}"
-#     end
-
-#     if options.fetch(:capitalize, true)
-#       result.sub!(/\A\w/) { |match| match.upcase }
-#     end
-
-#     result
-#   end
-
-#   def upcase_first
-#     string = self
-#     string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
-#   end
-
-#   def titleize
-#     word = self
-#     humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { |match| match.capitalize }
-#   end
-
-#   def tableize
-#     class_name = self
-#     pluralize(underscore(class_name))
-#   end
-
-#   def classify
-#     table_name = self.dup
-#     table_name.to_s.sub(/.*\./, "").freeze.singularize.camelize
-#   end
-
-#   def dasherize
-#     underscored_word = self
-#     underscored_word.tr("_".freeze, "-".freeze)
-#   end
-
-#   def demodulize()
-#     path = self.to_s
-#     if i = path.rindex("::")
-#       path[(i + 2)..-1]
-#     else
-#       path
-#     end
-#   end
-
-#   def deconstantize
-#     path = self.to_s
-#     path.to_s[0, path.rindex("::") || 0] # implementation based on the one in facets' Module#spacename
-#   end
-
-#   def foreign_key(separate_class_name_and_id_with_underscore = true)
-#     class_name = self
-#     underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
-#   end
-
-#   def constantize
-#     camel_cased_word = self
-#     names = camel_cased_word.split("::".freeze)
-
-#     # Trigger a built-in NameError exception including the ill-formed constant in the message.
-#     Object.const_get(camel_cased_word) if names.blank?
-
-#     # Remove the first blank element in case of '::ClassName' notation.
-#     names.shift if names.size > 1 && names.first.blank?
-
-#     names.inject(Object) do |constant, name|
-#       if constant == Object
-#         constant.const_get(name)
-#       else
-#         candidate = constant.const_get(name)
-#         next candidate if constant.const_defined?(name, false)
-#         next candidate unless Object.const_defined?(name)
-
-#         # Go down the ancestors to check if it is owned directly. The check
-#         # stops when we reach Object or the end of ancestors tree.
-#         constant = constant.ancestors.inject do |const, ancestor|
-#           break const    if ancestor == Object
-#           break ancestor if ancestor.const_defined?(name, false)
-#           const
-#         end
-
-#         # owner is in Object, so raise
-#         constant.const_get(name, false)
-#       end
-#     end
-#   end
-
-#   def safe_constantize
-#     camel_cased_word = self
-#     constantize(camel_cased_word)
-#   rescue NameError => e
-#     raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
-#       e.name.to_s == camel_cased_word.to_s)
-#   rescue ArgumentError => e
-#     raise unless /not missing constant #{const_regexp(camel_cased_word)}!$/.match?(e.message)
-#   end
-
-#   def ordinal
-#     number = self
-#     abs_number = number.to_i.abs
-
-#     if (11..13).include?(abs_number % 100)
-#       "th"
-#     else
-#       case abs_number % 10
-#       when 1; "st"
-#       when 2; "nd"
-#       when 3; "rd"
-#         else    "th"
-#       end
-#     end
-#   end
-
-#   def ordinalize
-#     number = self
-#     "#{number}#{ordinal(number)}"
-#   end
-
-#   private
-
-#     # Mounts a regular expression, returned as a string to ease interpolation,
-#     # that will match part by part the given constant.
-#     #
-#     #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
-#     #   const_regexp("::")            # => "::"
-#     def const_regexp(camel_cased_word) #:nodoc:
-#       parts = camel_cased_word.split("::".freeze)
-
-#       return Regexp.escape(camel_cased_word) if parts.blank?
-
-#       last = parts.pop
-
-#       parts.reverse.inject(last) do |acc, part|
-#         part.blank? ? acc : "#{part}(::#{acc})?"
-#       end
-#     end
-
-#     # Applies inflection rules for +singularize+ and +pluralize+.
-#     #
-#     #  apply_inflections('post', inflections.plurals)    # => "posts"
-#     #  apply_inflections('posts', inflections.singulars) # => "post"
-#     def apply_inflections(word, rules)
-#       result = word.to_s.dup
-
-#       if word.blank? || inflections.uncountables.uncountable?(result)
-#         result
-#       else
-#         rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
-#         result
-#       end
-#     end
-# end

data/lib/vendor/mini_assets/mini_asset/base.rb

@@ -1,167 +0,0 @@
-class MiniAsset::Base
-  attr_reader :error
-
-  def initialize source, opts={}
-    @source       = source
-    @opts         = opts
-
-    raise 'Bad source: %s' % source unless File.exist?(local_file)
-  end
-
-  def run! what
-    puts what.yellow
-
-    stdin, stdout, stderr, wait_thread = Open3.popen3(what)
-
-    error = stderr.gets
-    while line = stderr.gets do
-      error += line
-    end
-
-    # node-sass prints to stderror on complete
-    error = nil if error && error.index('Rendering Complete, saving .css file...')
-
-    if error
-      File.unlink(cache_file) if File.exists?(cache_file)
-      @error = error
-    end
-  end
-
-  def production?
-    !!@opts[:production]
-  end
-
-  def create file, opts=nil
-    MiniAsset.create file, opts || @opts
-  end
-
-  def content
-    File.read local_file
-  end
-
-  def ext
-    @source.split('.').last.to_sym
-  end
-
-  def asset_join_string
-    "\n"
-  end
-
-  def local_file
-    'app/assets/%s' % @source
-  end
-
-  def production_file
-    file = MiniAsset.manifest['files'][@source] || raise('Production file not found')
-
-    'public%s' % file
-  end
-
-  def cache_file
-    'tmp/assets/%s' % @source.gsub('/', '-')
-  end
-
-  def base_dir
-    list = @source.split('/')
-    list.pop
-    'app/assets/' + list.join('/')
-  end
-
-  def resolve_file files
-    files = files.sub(/^\.\//,'')
-    files += '/*' unless files.include?('*')
-
-    path = '%s/%s' % [base_dir, files]
-    @files += Dir[path].sort.map{ |f| f.split('app/assets/', 2).last }
-  end
-
-  def files
-    return @files if @files
-
-    @files = []
-
-    for line in content.split($/)
-      test = line.split(/^[\/\/#]=\s*req\w*\s+/)
-      resolve_file test[1] if test[1]
-    end
-
-    @files.push @source
-    @files
-  end
-
-  def path_for_comment
-    '/* Source: %s */' % @source
-  end
-
-  def do_compile?
-    return true unless File.exists?(cache_file)
-    return true if File.mtime(cache_file).to_i <= File.mtime(local_file).to_i
-    false
-  end
-
-  # compiles all the files, allways for production
-  def compile args=[]
-    data = []
-
-    for file in files
-      asset = create file, production: true
-      data.push asset.path_for_comment
-      data.push asset.compiled_data
-    end
-
-    data  = data.join(asset_join_string)
-    pfile = update_manifest(data)
-
-    unless File.exists? pfile
-      File.write(pfile, data)
-      minify!
-    end
-
-    if args.include?('gzip')
-      gzip!
-    else
-      gzip_file = '%s.gz' % pfile
-      File.unlink gzip_file if File.exists?(gzip_file)
-    end
-
-    fix_created_times!
-
-    pfile
-  end
-
-  # compiles single current file
-  def compiled_data
-    content
-  end
-
-  def minify!
-    true
-  end
-
-  def gzip!
-    f =  production_file
-    run! "gzip -f -c -1 '%{f}' > '%{f}.gz'" % { f: f } unless File.exists?('%s.gz' % f)
-  end
-
-  def fix_created_times!
-    touch_file = 'public/touch.ref'
-    `touch '#{touch_file}'` unless File.exists?(touch_file)
-
-    # touch and fix reference
-    `touch -r '#{touch_file}' #{production_file}`
-    `touch -r '#{touch_file}' #{production_file}.gz` if File.exists?("#{production_file}.gz")
-  end
-
-  def update_manifest data
-    digest = Digest::SHA1.hexdigest(data.to_s)
-    json = MiniAsset.manifest
-
-    pfile = cache_file.sub('tmp/assets/', 'public/assets/')
-    pfile = pfile.sub(/\.(\w+)/, "-#{digest}.\\1")
-
-    json['files'][@source] = pfile.sub('public/', '/')
-    MiniAsset.manifest json
-    pfile
-  end
-
-end

data/lib/vendor/mini_assets/mini_asset/css.rb

@@ -1,38 +0,0 @@
-class MiniAsset::Css < MiniAsset::Base
-
-  def content_type
-    'text/css'
-  end
-
-  def cache_file
-    super.sub(/\.(\w+)/, "#{production? ? '-p' : ''}.\\1").sub('.scss', '.css')
-  end
-
-  def update_cache
-    node_sass = './node_modules/node-sass/bin/node-sass'
-    node_opts = production? ? '--output-style compressed' : '--source-comments'
-    run! "#{node_sass} #{node_opts} '#{local_file}' '#{cache_file}'"
-  end
-
-  def compiled_data
-    if do_compile?
-      update_cache
-    else
-      # extract linked files from css cache and compile if needed
-      data = File.read cache_file
-      files = []
-      data.gsub(%r{(app/assets/[\w\-\./]+)}) { files.push($1) unless files.include?($1) }
-
-      final_check = false
-      cache_time  = File.mtime(cache_file).to_i
-      for file in files
-        final_check ||= true if cache_time <= File.mtime(file).to_i
-      end
-
-      update_cache if final_check
-    end
-
-    File.read cache_file
-  end
-
-end