cistern 2.2.3 → 2.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 271e3b4819b0195e672410246c8388ff65f88ad0
-  data.tar.gz: 8be7d35f9a52253069c3dc19a6ab969ceeeb0b7f
+  metadata.gz: 12f0361fa92430b5aab7d1b3e8934a615670369a
+  data.tar.gz: 0a09ee7dd69399efbeb59a6341cbf6b18d7e55af
 SHA512:
-  metadata.gz: d863ffdb75969540acb17e44746d4432bde8ee733ccacc48da7ec3fbe47a099a77f191f1057c216a7a1471beebb1158952102ef304136094bee9d3c14e787500
-  data.tar.gz: 7834397862a3ec7262f979dd26bc6253fa345a98188e99df373b8633c9c4cdf00a55f0744130a6d8f5e35422b715dccfae4bc5837292b2e91aba3a457e4021ec
+  metadata.gz: 03c0726e4050c3c02fa05397625a43b651516dc1d7eea53166953dad89286212474ec880d74411ca44ff1d511c8cf17809116dc695831c118a02fe01fa3d4f01
+  data.tar.gz: d5149e6a0212522f9dae85f85b73ba1e699da5a06093a48b1ee5c5aa8733c43ee5855409c57c57ea6d24e940435b487c377eb7d0cb6d875d53fb999eea967c7f

data/.travis.yml

@@ -1,16 +1,16 @@
 language: ruby
 rvm:
-- 2.1.1
-- 1.9.3
-- jruby-19mode
+- 2.2
+- 1.9
 bundler_args: "--without development"
 before_install:
-- gem install bundler -v 1.5.2
+- gem install bundler -v "~> 1.10"
 script: bundle exec rake --trace
 notifications:
   email:
     on_success: never
     on_failure: change
+sudo: false
 services:
 - redis-server
 env:

data/lib/cistern/attributes.rb

@@ -1,18 +1,18 @@
 module Cistern::Attributes
   def self.parsers
     @parsers ||= {
-      :string  => lambda { |v, _| v.to_s },
-      :time    => lambda { |v, _| v.is_a?(Time) ? v : v && Time.parse(v.to_s) },
-      :integer => lambda { |v, _| v && v.to_i },
-      :float   => lambda { |v, _| v && v.to_f },
-      :array   => lambda { |v, _| [*v] },
-      :boolean => lambda { |v, _| ['true', '1'].include?(v.to_s.downcase) }
+      string: ->(v, _) { v.to_s },
+      time: ->(v, _) { v.is_a?(Time) ? v : v && Time.parse(v.to_s) },
+      integer: ->(v, _) { v && v.to_i },
+      float: ->(v, _) { v && v.to_f },
+      array: ->(v, _) { [*v] },
+      boolean: ->(v, _) { %w(true 1).include?(v.to_s.downcase) }
     }
   end
 
   def self.transforms
     @transforms ||= {
-      :squash  => Proc.new do |k, _v, options|
+      squash: proc do |_k, _v, options|
         v      = Cistern::Hash.stringify_keys(_v)
         squash = options[:squash]
 
@@ -20,7 +20,8 @@ module Cistern::Attributes
           travel = lambda do |tree, path|
             if tree.is_a?(::Hash)
               travel.call(tree[path.shift], path)
-            else tree
+            else
+              tree
             end
           end
 
@@ -30,7 +31,7 @@ module Cistern::Attributes
 
           if v.key?(key = squash_s.to_sym)
             v[key]
-          elsif v.has_key?(squash_s)
+          elsif v.key?(squash_s)
             v[squash_s]
           else
             v
@@ -38,12 +39,12 @@ module Cistern::Attributes
         else v
         end
       end,
-      :none => lambda { |k, v, opts| v },
+      none: ->(_, v, _) { v }
     }
   end
 
   def self.default_parser
-    @default_parser ||= lambda { |v, opts| v }
+    @default_parser ||= ->(v, _opts) { v }
   end
 
   module ClassMethods
@@ -52,7 +53,7 @@ module Cistern::Attributes
     end
 
     def aliases
-      @aliases ||= Hash.new { |h,k| h[k] = [] }
+      @aliases ||= Hash.new { |h, k| h[k] = [] }
     end
 
     def attributes
@@ -61,10 +62,10 @@ module Cistern::Attributes
 
     def attribute(_name, options = {})
       if defined? Cistern::Coverage
-        attribute_call = Cistern::Coverage.find_caller_before("cistern/attributes.rb")
+        attribute_call = Cistern::Coverage.find_caller_before('cistern/attributes.rb')
 
         # Only use DSL attribute calls from within a model
-        if attribute_call and attribute_call.label.start_with? "<class:"
+        if attribute_call && attribute_call.label.start_with?('<class:')
           options[:coverage_file] = attribute_call.absolute_path
           options[:coverage_line] = attribute_call.lineno
           options[:coverage_hits] = 0
@@ -73,25 +74,23 @@ module Cistern::Attributes
 
       name = _name.to_s.to_sym
 
-      self.send(:define_method, name) do
+      send(:define_method, name) do
         read_attribute(name)
-      end unless self.instance_methods.include?(name)
+      end unless instance_methods.include?(name)
 
-      if options[:type] == :boolean
-        self.send(:alias_method, "#{name}?", name)
-      end
+      send(:alias_method, "#{name}?", name) if options[:type] == :boolean
 
-      self.send(:define_method, "#{name}=") do |value|
+      send(:define_method, "#{name}=") do |value|
         write_attribute(name, value)
-      end unless self.instance_methods.include?("#{name}=".to_sym)
+      end unless instance_methods.include?("#{name}=".to_sym)
 
-      if self.attributes[name]
-        raise(ArgumentError, "#{self.name} attribute[#{_name}] specified more than once")
+      if attributes[name]
+        fail(ArgumentError, "#{self.name} attribute[#{_name}] specified more than once")
       else
         if options[:squash]
           options[:squash] = Array(options[:squash]).map(&:to_s)
         end
-        self.attributes[name] = options
+        attributes[name] = options
       end
 
       options[:aliases] = Array(options[:aliases] || options[:alias]).map { |a| a.to_s.to_sym }
@@ -103,7 +102,7 @@ module Cistern::Attributes
 
     def identity(name, options = {})
       @identity = name
-      self.attribute(name, options)
+      attribute(name, options)
     end
 
     def ignore_attributes(*args)
@@ -116,33 +115,34 @@ module Cistern::Attributes
   end
 
   module InstanceMethods
-    def _dump(level)
+    def dump
       Marshal.dump(attributes)
     end
 
     def read_attribute(name)
-      options = self.class.attributes[name] || {}
-      # record the attribute was accessed
-      self.class.attributes[name.to_s.to_sym][:coverage_hits] += 1 rescue nil
-
+      key = name.to_s.to_sym
+      options = self.class.attributes[key]
       default = options[:default]
 
-      unless default.nil?
-        default = Marshal.load(Marshal.dump(default))
+      # record the attribute was accessed
+      if defined?(Cistern::Coverage) && options[:coverage_hits]
+        options[:coverage_hits] += 1
       end
 
-      attributes.fetch(name.to_s.to_sym, default)
+      default = Marshal.load(Marshal.dump(default)) unless default.nil?
+
+      attributes.fetch(key, default)
     end
 
     def write_attribute(name, value)
       options = self.class.attributes[name] || {}
 
       transform = Cistern::Attributes.transforms[options[:squash] ? :squash : :none] ||
-        Cistern::Attributes.default_transform
+                  Cistern::Attributes.default_transform
 
       parser = Cistern::Attributes.parsers[options[:type]] ||
-        options[:parser] ||
-        Cistern::Attributes.default_parser
+               options[:parser] ||
+               Cistern::Attributes.default_parser
 
       transformed = transform.call(name, value, options)
 
@@ -175,9 +175,7 @@ module Cistern::Attributes
     def identity
       key = self.class.instance_variable_get('@identity')
 
-      if key
-        public_send(key)
-      end
+      public_send(key) if key
     end
 
     def identity=(new_identity)
@@ -186,7 +184,7 @@ module Cistern::Attributes
       if key
         public_send("#{key}=", new_identity)
       else
-        raise ArgumentError, "Identity not specified"
+        fail ArgumentError, 'Identity not specified'
       end
     end
 
@@ -197,37 +195,40 @@ module Cistern::Attributes
       class_aliases      = self.class.aliases
 
       new_attributes.each do |_key, value|
-        string_key = _key.kind_of?(String) ? _key : _key.to_s
+        string_key = _key.is_a?(String) ? _key : _key.to_s
         symbol_key = case _key
-              when String
-                _key.to_sym
-              when Symbol
-                _key
-              else
-                string_key.to_sym
+                     when String
+                       _key.to_sym
+                     when Symbol
+                       _key
+                     else
+                       string_key.to_sym
               end
 
         # find nested paths
         value.is_a?(::Hash) && class_attributes.each do |name, options|
           if options[:squash] && options[:squash].first == string_key
-            send("#{name}=", {symbol_key => value})
+            send("#{name}=", symbol_key => value)
           end
         end
 
-        unless ignored_attributes.include?(symbol_key)
-          if class_aliases.has_key?(symbol_key)
-            class_aliases[symbol_key].each do |aliased_key|
-              send("#{aliased_key}=", value)
-            end
-          end
+        next if ignored_attributes.include?(symbol_key)
 
-          assignment_method = "#{string_key}="
-          if !protected_methods.include?(symbol_key) && self.respond_to?(assignment_method, true)
-            send(assignment_method, value)
+        if class_aliases.key?(symbol_key)
+          class_aliases[symbol_key].each do |aliased_key|
+            send("#{aliased_key}=", value)
           end
         end
+
+        assignment_method = "#{string_key}="
+
+        if !protected_methods.include?(symbol_key) && self.respond_to?(assignment_method, true)
+          send(assignment_method, value)
+        end
       end
+
       changed.clear
+
       self
     end
 
@@ -239,16 +240,16 @@ module Cistern::Attributes
     def requires(*args)
       missing = missing_attributes(args)
       if missing.length == 1
-        raise(ArgumentError, "#{missing.first} is required for this operation")
+        fail(ArgumentError, "#{missing.first} is required for this operation")
       elsif missing.any?
-        raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
+        fail(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
       end
     end
 
     def requires_one(*args)
       missing = missing_attributes(args)
       if missing.length == args.length
-        raise(ArgumentError, "#{missing[0...-1].join(", ")} or #{missing[-1]} are required for this operation")
+        fail(ArgumentError, "#{missing[0...-1].join(', ')} or #{missing[-1]} are required for this operation")
       end
     end
 
@@ -257,7 +258,7 @@ module Cistern::Attributes
     end
 
     def dirty_attributes
-      changed.inject({}) { |r,(k,(_,v))| r.merge(k => v) }
+      changed.inject({}) { |r, (k, (_, v))| r.merge(k => v) }
     end
 
     def changed

data/lib/cistern/client.rb

@@ -1,5 +1,4 @@
 module Cistern::Client
-
   module Collections
     def collections
       service.collections
@@ -11,7 +10,7 @@ module Cistern::Client
   end
 
   # custom include
-  def self.with(options={})
+  def self.with(options = {})
     client_module = Module.new
 
     custom_include = <<-EOS
@@ -29,22 +28,22 @@ module Cistern::Client
 
   # vanilla include
   def self.included(klass)
-    self.setup(klass)
+    setup(klass)
 
     super
   end
 
-  def self.setup(klass, options={})
-    request_class    = options[:request]    || "Request"
-    collection_class = options[:collection] || "Collection"
-    model_class      = options[:model]      || "Model"
-    singular_class   = options[:singular]   || "Singular"
+  def self.setup(klass, options = {})
+    request_class    = options[:request] || 'Request'
+    collection_class = options[:collection] || 'Collection'
+    model_class      = options[:model] || 'Model'
+    singular_class   = options[:singular] || 'Singular'
 
     interface = options[:interface] || :class
     interface_callback = (:class == interface) ? :inherited : :included
 
     unless klass.name
-      raise ArgumentError, "can't turn anonymous class into a Cistern service"
+      fail ArgumentError, "can't turn anonymous class into a Cistern service"
     end
 
     klass.class_eval <<-EOS, __FILE__, __LINE__
@@ -156,10 +155,17 @@ module Cistern::Client
   end
 
   module ClassMethods
+    def mock!
+      @mocking = true
+    end
 
-    def mock!;    @mocking = true; end
-    def mocking?; @mocking; end
-    def unmock!;  @mocking = false; end
+    def mocking?
+      @mocking
+    end
+
+    def unmock!
+      @mocking = false
+    end
 
     def collections
       @collections ||= []
@@ -186,26 +192,26 @@ module Cistern::Client
     end
 
     def requires(*args)
-      self.required_arguments.concat(args)
+      required_arguments.concat(args)
     end
 
     def recognizes(*args)
-      self.recognized_arguments.concat(args)
+      recognized_arguments.concat(args)
     end
 
-    def validate_options(options={})
+    def validate_options(options = {})
       required_options = Cistern::Hash.slice(options, *required_arguments)
 
       missing_required_options = required_arguments - required_options.keys
 
       unless missing_required_options.empty?
-        raise "Missing required options: #{missing_required_options.inspect}"
+        fail "Missing required options: #{missing_required_options.inspect}"
       end
 
       unrecognized_options = options.keys - (required_arguments + recognized_arguments)
 
       unless unrecognized_options.empty?
-        raise "Unrecognized options: #{unrecognized_options.inspect}"
+        fail "Unrecognized options: #{unrecognized_options.inspect}"
       end
     end
 
@@ -214,28 +220,28 @@ module Cistern::Client
 
       requests.each do |klass|
         name = klass.service_method ||
-          Cistern::String.camelize(Cistern::String.demodulize(klass.name))
+               Cistern::String.camelize(Cistern::String.demodulize(klass.name))
 
         Cistern::Request.service_request(self, klass, name)
       end
 
       collections.each do |klass|
         name = klass.service_method ||
-          Cistern::String.underscore(klass.name.gsub("#{self.name}::", "").gsub("::", ""))
+               Cistern::String.underscore(klass.name.gsub("#{self.name}::", '').gsub('::', ''))
 
         Cistern::Collection.service_collection(self, klass, name)
       end
 
       models.each do |klass|
         name = klass.service_method ||
-          Cistern::String.underscore(klass.name.gsub("#{self.name}::", "").gsub("::", ""))
+               Cistern::String.underscore(klass.name.gsub("#{self.name}::", '').gsub('::', ''))
 
         Cistern::Model.service_model(self, klass, name)
       end
 
       singularities.each do |klass|
         name = klass.service_method ||
-          Cistern::String.underscore(klass.name.gsub("#{self.name}::", "").gsub("::", ""))
+               Cistern::String.underscore(klass.name.gsub("#{self.name}::", '').gsub('::', ''))
 
         Cistern::Singular.service_singular(self, klass, name)
       end
@@ -243,15 +249,15 @@ module Cistern::Client
       @_setup = true
     end
 
-    def new(options={})
+    def new(options = {})
       setup
       validate_options(options)
 
-      self.const_get(self.mocking? ? :Mock : :Real).new(options)
+      const_get(self.mocking? ? :Mock : :Real).new(options)
     end
 
     def reset!
-      self.const_get(:Mock).reset!
+      const_get(:Mock).reset!
     end
   end
 end