state_store 0.0.1 → 0.0.2

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/state_store/binary_store.rb

@@ -14,6 +14,11 @@ module StateStore
       value_to_statuses(value)
     end
 
+    def value(humanized_array) 
+      raise ArgumentError.new("Out of range") if self.states < humanized_array.size
+      statuses_to_values(humanized_array)
+    end
+
     def has_status?(symbol,value) 
       human_array = humanize(value)
       human_array.include?(symbol)
@@ -23,6 +28,10 @@ module StateStore
       statuses[index] if state.to_s == "1"
     end
 
+    def index_by_state(state)
+      statuses[state]
+    end
+
     private
 
     def value_to_statuses(value)
@@ -35,6 +44,12 @@ module StateStore
       result
     end
 
+    def statuses_to_values(statuses_array)
+      self.statuses.map do |status|
+        statuses_array.include?(status) ? "1" : "0"
+      end.join("").to_i(2)
+    end
+
     def normalized_array(array)
       (Array.new(self.states - array.size, "0")+ array)
     end

data/lib/state_store/extension.rb

@@ -2,47 +2,66 @@ module StateStore
   module Extension
 
     module ClassMethods
-      def has_statuses *statuses
-        @state_store_options = statuses && statuses.last.is_a?(Hash) && statuses.pop || {}
-        raise ArgumentError.new("No statuses given") if statuses.empty? 
-        raise ArgumentError.new(":in is required") unless @state_store_options[:in]
-        @store = StateStore::BinaryStore.new(statuses)
-        override_method_store_in_method
+
+      def has_states *states
+        state_store_options = states && states.last.is_a?(Hash) && states.pop || {}
+        raise ArgumentError.new("No states given") if states.empty? 
+        raise ArgumentError.new(":in is required") unless state_store_options[:in]
+
+        state_store_options[:as] ||= :states
+        store = StateStore::BinaryStore.new(states)
+
+        @states_stores ||={}
+        @states_stores_options ||={}
+
+        @states_stores[state_store_options[:as]] = store
+        @states_stores_options[state_store_options[:as]] = state_store_options
+        create_methods_for_state_store(state_store_options[:as])
       end 
 
-      def state_store_store
-        @store
+      def states_stores
+        @states_stores
       end
 
-      def state_store_options
-        @state_store_options
+      def states_stores_options
+        @states_stores_options
       end
 
       private
 
-      def override_method_store_in_method
-        class_eval  <<-ALIAS,__FILE__,__LINE__+1  
-          if self.instance_methods.include?(:#{self.state_store_options[:in]})
-            alias :status_store_original_#{self.state_store_options[:in]} :#{self.state_store_options[:in]}
-          end
-        ALIAS
+      def create_methods_for_state_store(name)
 
         self.class_eval do 
-          define_method self.state_store_options[:in] do 
-            original_method_name = :"status_store_original_#{self.class.state_store_options[:in]}"
-            value = self.respond_to?(original_method_name) ? self.send(original_method_name) : super
-            self.class.state_store_store.humanize(value)
+          define_method name do 
+            method_name = self.class.states_stores_options[name][:in]
+            value = self.send(method_name)
+            self.class.states_stores[name].humanize(value)
+          end
+
+          define_method :"#{name}=" do |humanized_array|
+            method_name = self.class.states_stores_options[name][:in]
+            store = self.class.states_stores[name]
+            self.send(:"#{method_name}=",store.value(humanized_array))
           end
         end
+
       end
     end
 
     module InstanceMethods
       def self.included(base)
-
         def method_missing(method_name, *args)
-          if method_name.to_s == "has_#{self.class.state_store_options[:in]}?"
-            self.class.state_store_store.has_status?(args[0],self.send(self.class.state_store_options[:in]))
+          state_method_name = method_name.to_s.match(/^has_(\w+)\?$/)
+          state_method_name = state_method_name && state_method_name[1].to_sym
+          if state_method_name
+            options = self.class.states_stores_options.detect{|key,value| value[:in].to_sym == state_method_name}
+            options = options && options[1]
+            if options
+              instance_method_name = options && options[:in]
+              self.class.states_stores[options[:as]].has_status?(args[0],self.send(instance_method_name))
+            else
+              super
+            end
           else
             super
           end

data/spec/binary_store_spec.rb

@@ -66,4 +66,16 @@ describe StateStore::BinaryStore do
     store.index(1,"1").should eq(:two)
     store.index(1,"0").should be_nil
   end
+
+  it "should return value from statuses array" do 
+    store = klass.new([:read,:write,:execute])
+    store.value([]).should eq(0)
+    store.value([:execute]).should eq(1)
+    store.value([:write]).should eq(2)
+    store.value([:write,:execute]).should eq(3)
+    store.value([:read]).should eq(4)
+    store.value([:read,:execute]).should eq(5)
+    store.value([:read,:write]).should eq(6)
+    store.value([:read,:write,:execute]).should eq(7)
+  end
 end

data/spec/extension_spec.rb

@@ -14,26 +14,26 @@ describe StateStore::Extension do
       klass.send(:include,StateStore)
     end
 
-    it "should raise error when no statuses is given" do 
+    it "should raise error when no states is given" do 
       expect{
-        klass.has_statuses()
-      }.to raise_error(ArgumentError,"No statuses given")
+        klass.has_states()
+      }.to raise_error(ArgumentError,"No states given")
     end
 
     it "should raise error when no :in key is given" do 
       expect{
-        klass.has_statuses :read,:write
+        klass.has_states :read,:write
       }.to raise_error(ArgumentError,":in is required")
     end
 
     it "should create store with given statuses" do 
-      klass.has_statuses :read,:write, :in => :status
-      klass.state_store_store.statuses.should eq([:read,:write])
+      klass.has_states :read,:write, :in => :status
+      klass.states_stores[:states].statuses.should eq([:read,:write])
     end
 
     it "should store given options in #state_store_options" do 
-      klass.has_statuses :read,:write, :in => :status 
-      klass.state_store_options.should eq({:in => :status})
+      klass.has_states :read,:write, :in => :status 
+      klass.states_stores_options[:states].should eq({:in => :status, :as => :states})
     end
   end
 
@@ -42,14 +42,14 @@ describe StateStore::Extension do
     before(:each){
       klass.class_eval do 
         def status_name
-          5
+          @status_name || 5
         end
       end
       klass.send(:include,StateStore)
     }
 
     it "should call store #has_status? when #has_status_name? is called on klass instance" do 
-      klass.has_statuses :read,:write,:execute, :in => :status_name
+      klass.has_states :read,:write,:execute, :in => :status_name
       klass.any_instance.stub(:status_name).and_return(5)
       
       object.has_status_name?(:read).should be_true
@@ -57,12 +57,19 @@ describe StateStore::Extension do
     end
 
     it "should call store #humanize when [status_name] is called on instance of class" do 
-      klass.has_statuses :read,:write,:execute, :in => :status_name
-      object.status_name.should eq([:read,:execute])
+      klass.has_states :read,:write,:execute, :in => :status_name
+      object.states.should eq([:read,:execute])
     end 
 
-    it "should call super if base class not respond to method" do 
-
+    it "should assign value from array to status method" do 
+      klass.has_states :read, :write, :execute, :in => :status_name
+      klass.class_eval do 
+        def status_name=(value)
+          @status_name = value
+        end
+      end
+      object.states= [:read,:write]
+      object.status_name.should eq(6)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: state_store
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &18782820 !ruby/object:Gem::Requirement
+  requirement: &19920720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.12'
   type: :development
   prerelease: false
-  version_requirements: *18782820
+  version_requirements: *19920720
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &18781480 !ruby/object:Gem::Requirement
+  requirement: &19919080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *18781480
+  version_requirements: *19919080
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &18799320 !ruby/object:Gem::Requirement
+  requirement: &19936760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +43,7 @@ dependencies:
         version: 1.8.3
   type: :development
   prerelease: false
-  version_requirements: *18799320
+  version_requirements: *19936760
 description: Create numeric value to Array of states.
 email: arturs.meisters@gmail.com
 executables: []
@@ -83,7 +83,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2956134080418210540
+      hash: -2977312246934280863
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: