map 6.6.0 → 8.0.0

data/lib/map/integrations/active_record.rb

@@ -1,140 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Map
-  module Integrations
-    module ActiveRecord
-      def self.included( klass )
-        klass.extend ClassMethods
-      end
-
-      module ClassMethods
-        def to_map( record , *args )
-          # prep
-          model         = record.class
-          map           = Map.new
-          map[ :model ] = model.name.underscore
-          map[ :id ]    = record.id
-
-          # yank out options if they are patently obvious...
-          if args.size == 2 and args.first.is_a?( Array ) and args.last.is_a?( Hash )
-            options = Map.for args.last
-            args = args.first
-          else
-            options = nil
-          end
-
-          # get base to_dao from class
-          base = column_names
-
-          # available options keys
-          opts = %w( include includes with exclude excludes without )
-
-          # proc to remove options
-          extract_options =
-            proc do |array|
-              to_return = Map.new
-              last = array.last
-              if last.is_a?( Hash )
-                last = Map.for last
-                if opts.any? { | opt | last.has_key? opt }
-                  array.pop
-                  to_return = last
-                end
-              end
-              to_return
-            end
-
-          # handle case where options are bundled in args...
-          options ||= extract_options[args]
-
-          # use base options iff none provided
-          base_options = extract_options[base]
-          if options.blank? and !base_options.blank?
-            options = base_options
-          end
-
-          # refine the args with includes iff found in options
-          include_opts = [ :include , :includes , :with ]
-          if options.any? { | option | include_opts.include? option.to_sym }
-            args.replace( base ) if args.empty?
-            args.push( options[ :include ] )  if options[ :include ]
-            args.push( options[ :includes ] ) if options[ :includes ]
-            args.push( options[ :with ] )     if options[ :with ]
-          end
-
-          # take passed in args or model defaults
-          list = args.empty? ? base : args
-          list = column_names if list.empty?
-
-          # proc to ensure we're all mapped out
-          map_nested =
-            proc do | value , *args |
-              if value.is_a?( Array )
-                value.map { | v | map_nested[ v , *args ] }
-              else
-                if value.respond_to? :to_map
-                  value.to_map *args
-                else
-                  value
-                end
-              end
-            end
-
-          # okay - go!
-          list.flatten.each do | attr |
-            if attr.is_a?( Array )
-              related , *argv = attr
-              v = record.send related
-              value = map_nested[ value , *argv ]
-              map[ related ] = value
-              next
-            end
-
-            if attr.is_a?( Hash )
-              attr.each do | related , argv |
-                v = record.send related
-                argv = !argv.is_a?( Array ) ? [ argv ] : argv
-                value = map_nested[ v , *argv ]
-                map[ related ] = value
-              end
-              next
-            end
-
-            value = record.send attr
-
-            if value.respond_to?( :to_map )
-              map[ attr ] = value.to_map
-              next
-            end
-
-            if value.is_a?( Array )
-              map[ attr ] = value.map &map_nested
-              next
-            end
-
-            map[ attr ] = value
-          end
-
-          # refine the map with excludes iff passed as options
-          exclude_opts = [ :exclude , :excludes , :without ]
-          if options.any? { | option | exclude_opts.include? option.to_sym }
-            [ options[ :exclude ] , options[ :excludes ] , options[ :without ] ].each do | paths |
-              paths = Array paths
-              next if paths.blank?
-              paths.each { | path | map.rm path }
-            end
-          end
-
-          map
-        end
-      end
-
-      def to_map( *args )
-        self.class.to_map self , *args
-      end
-    end
-  end
-end
-
-if defined?( ActiveRecord::Base )
-  ActiveRecord::Base.send :include , Map::Integrations::ActiveRecord
-end

data/lib/map/params.rb

@@ -1,79 +0,0 @@
-class Map
-  def param_for(*args, &block)
-    options = Map.options_for!(args)
-
-    prefix = options[:prefix] || 'map'
-
-    src_key = args.flatten.map{|arg| Map.alphanumeric_key_for(arg)}
-
-    dst_key = src_key.map{|k| k.is_a?(Numeric) ? 0 : k}
-
-    src = self
-    dst = Map.new
-
-    value =
-      if options.has_key?(:value)
-        options[:value]
-      else
-        src.get(src_key).to_s
-      end
-
-    dst.set(dst_key, value)
-
-    Param.param_for(dst, prefix)
-  end
-
-  def name_for(*args, &block)
-    options = Map.options_for!(args)
-    options[:value] = nil
-    args.push(options)
-    param_for(*args, &block)
-  end
-
-  def to_params
-    to_params = Array.new
-
-    depth_first_each do |key, val|
-      to_params.push(param_for(key))
-    end
-
-    to_params.join('&')
-  end
-
-  module Param
-    def param_for(value, prefix = nil)
-      case value
-        when Array
-          value.map { |v|
-            param_for(v, "#{ prefix }[]")
-          }.join("&")
-
-        when Hash
-          value.map { |k, v|
-            param_for(v, prefix ? "#{ prefix }[#{ escape(k) }]" : escape(k))
-          }.join("&")
-
-        when String
-          raise ArgumentError, "value must be a Hash" if prefix.nil?
-          "#{ prefix }=#{ escape(value) }"
-
-        else
-          prefix
-      end
-    end
-
-    if(''.respond_to?(:bytesize))
-      def bytesize(string) string.bytesize end
-    else
-      def bytesize(string) string.size end
-    end
-
-    require 'uri' unless defined?(URI)
-
-    def escape(s)
-      URI.encode_www_form_component(s)
-    end
-
-    extend(self)
-  end
-end

data/lib/map/struct.rb

@@ -1,52 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Map
-  class Struct
-    instance_methods.each { |m| undef_method m unless m =~ /^__|object_id/ }
-
-    attr :map
-
-    def initialize(map)
-      @map = map
-    end
-
-    def method_missing(method, *args, &block)
-      method = method.to_s
-      case method
-        when /=$/
-          key = method.chomp('=')
-          value = args.shift
-          @map[key] = value
-        when /\?$/
-          key = method.chomp('?')
-          value = @map.has?( key )
-        else
-          key = method
-          raise(IndexError, key) unless @map.has_key?(key)
-          value = @map[key]
-      end
-      value.is_a?(Map) ? value.struct : value
-    end
-
-    Keys = lambda{|*keys| keys.flatten!; keys.compact!; keys.map!{|key| key.to_s}} unless defined?(Keys)
-
-    delegates = %w(
-      inspect
-    )
-
-    delegates.each do |delegate|
-      module_eval <<-__, __FILE__, __LINE__
-        def #{ delegate }(*args, &block)
-          @map.#{ delegate }(*args, &block)
-        end
-      __
-    end
-  end
-
-  def struct
-    @struct ||= Struct.new(self)
-  end
-
-  def Map.struct(*args, &block)
-    new(*args, &block).struct
-  end
-end