einstein-enum 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8a9f734114e08c89f7b162fc923d5be76db5fb9
+  data.tar.gz: ae6349c335b99e8ac11e0dd13d0fc020412f9e3e
+SHA512:
+  metadata.gz: 225faebfed556dc7165fe79b86e90ef09c54454dc74710f3f5dbbe9373fa2d1b8289b9b8897669840dd9b28e0eaa2e78347dec3a0815d2b49b46abf7189ee494
+  data.tar.gz: 397d849c770e61564d8f83d092af2b61fdf6e5ee635e54134d4a1b24a651a6d62651a3d2e9fcd94f716e668acfd2b2ac9ccd41bd118ff96b14cd9b2da5ed45f7

data/README.md

@@ -0,0 +1,96 @@
+# Einstein-enum
+
+This is a port of Swift's Enum type.  In Swift, Enums have all sorts of great
+features, like associated values and raw values.  GENIUS.
+
+They are truly awesome, unlike generics, terrible compilation error messages,
+and the rather pedantic `init` method requirements.
+
+
+# Compatibility
+
+I wrote this for use in RubyMotion, but I wrote it in a way that it is
+compatible with all Ruby implementations (that I know of!).
+
+
+## Usage
+
+```ruby
+class Api < Enum
+  value :Status
+  value :Posts, raw_value: :posts
+  # these represent an endpoint for "user detail", either by id or username
+  value :User, Fixnum
+  value :User, String
+
+  def url
+    # inside this method, the constants "Status" and methods "User" are defined
+    # to return the appropriate enum values/matchers
+    case self
+    when Status
+      "/status"
+    when User(-1)  # one off values can be matched!
+      "/users/by_role/admin"
+    when User(Fixnum)
+      # you can access the values using array access
+      id = self[0]
+      "/users/by_id/#{id}"
+    when User(String)
+      username = self[0]
+      "/users/by_name/#{username}"
+    when Posts
+      "/posts"
+    else
+      nil
+    end
+  end
+
+end
+
+
+status_endpoint = Api.Status
+user_endpoint = Api.User(2)  # if you tried `Api.User` you would get a 'value not defined' expection
+
+
+# matching is really where it's at:
+case status_endpoint
+# simple enum values
+when Api.Status
+when Api.Posts
+# here is the cool "polymorphic" matching.  I have not seen any other Ruby Enum
+# gems offer this:
+when Api.User(Fixnum)
+when Api.User(String)
+end
+
+
+# the ability to have methods associated with the enum values is very handy, and
+# adds object-oriented ideas to the boring old 'enum' type.
+puts status_endpoint.url  # => https://api.api.com/api/v1/status
+```
+
+## Testing
+
+```
+rake spec
+```
+
+## Todo
+
+It would be neat to have "named" values, instead of just positional.
+
+```ruby
+class Api < Enum
+  value :User, id: Fixnum
+end
+
+user_endpoint = Api.User(id: 2)
+
+id = user_endpoint[:id]
+id = user_endpoint.id
+```
+
+Using Einstein-enum, I'd like to build a [Moya][]-like tool for RubyMotion
+
+
+[Moya]: https://github.com/ashfurrow/Moya

data/lib/einstein-enum.rb

@@ -0,0 +1,7 @@
+if defined?(Motion::Project::Config)
+  Motion::Project::App.setup do |app|
+    app.files << File.join(File.dirname(__FILE__), 'enum.rb')
+  end
+else
+  require File.join(File.dirname(__FILE__), 'enum.rb')
+end

data/lib/enum.rb

@@ -0,0 +1,167 @@
+module EinsteinEnum
+
+  class Enum
+
+    class << self
+
+      def value(name, *types)
+        if self == Enum
+          raise 'Don\'t add values to Enum'
+        end
+
+        if !name.is_a?(Symbol)
+          raise '`name` must be a symbol'
+        end
+
+        opts = {}
+        if types.last.is_a?(Hash)
+          opts = types.pop
+        end
+
+        new_value = EnumValue.new
+        new_value.enum = self
+        new_value.name = name
+        new_value.types = types
+        new_value.raw_value = opts[:raw_value] || (2 ** all_values.count)
+
+        if existing_value = find(name, types)
+          raise "There is already a value (#{existing_value}) that matches #{new_value}"
+        end
+
+        if all_values.any? { |existing_value| existing_value.raw_value == new_value.raw_value }
+          raise "There is already a value (#{existing_value}) with the raw_value of `#{new_value.raw_value.inspect}`"
+        end
+
+        all_values << new_value
+
+        if !self.respond_to?(name)
+          define_singleton_method(name) do |*type_values|
+            create(name, *type_values)
+          end
+          if types.count == 0
+            self.const_set(name, new_value)
+          end
+          define_method(name) do |*type_values|
+            self.class.create(name, *type_values)
+          end
+        end
+
+        new_value
+      end
+
+      def all_values
+        if self == Enum
+          return []
+        end
+
+        @all_values ||= [] + self.superclass.all_values
+      end
+
+      def find(name, type_values)
+        all_values.find do |enum_value|
+          enum_value.name == name && types_match(enum_value.types, type_values)
+        end
+      end
+
+      def types_match(types, type_values)
+        if types.count != type_values.count
+          false
+        else
+          matches = true
+          if type_values.all? { |t| t.is_a?(Class) }
+            types.each_with_index do |t, index|
+              matches &&= type_values[index].ancestors.include?(t)
+              break if not matches
+            end
+          else
+            types.each_with_index do |t, index|
+              matches &&= type_values[index].is_a?(t)
+              break if not matches
+            end
+          end
+          matches
+        end
+      end
+
+      def create(name, *type_values)
+        enum_value = find(name, type_values)
+        if enum_value.nil?
+          raise "could not find value for #{name}(#{type_values.map{|t|t.to_s}.join(', ')})"
+        elsif !type_values.empty? && type_values.all? { |t| t.is_a?(Class) }
+          return enum_value
+        else
+          return enum_value.instance(type_values)
+        end
+      end
+
+    end
+
+    attr_accessor :enum_value
+    attr_accessor :values
+
+    def ===(value)
+      if value.is_a?(EnumValue)
+        value.raw_value == raw_value
+      elsif value.is_a?(Enum)
+        value.enum_value.name == enum_value.name && value.values.count == values.count && begin
+          matches = true
+          values.each_with_index do |v, index|
+            matches &&= v == value.values[index]
+            break if not matches
+          end
+          matches
+        end
+      else
+        false
+      end
+    end
+
+    def raw_value
+      enum_value.raw_value
+    end
+
+    def [](index)
+      values[index]
+    end
+
+    def to_s
+      "#{enum_value.name}(#{values.map{|t|t.to_s}.join(', ')})"
+    end
+
+  end
+
+
+  class EnumValue
+    attr_accessor :enum
+    attr_accessor :name
+    attr_accessor :types
+    attr_accessor :raw_value
+
+    def ===(value)
+      if value.is_a?(EnumValue)
+        value.raw_value == raw_value
+      elsif value.is_a?(Enum)
+        value.enum_value.name == name && Enum.types_match(types, value.values)
+      else
+        false
+      end
+    end
+
+    def instance(values)
+      instance = enum.new
+      instance.enum_value = self
+      instance.values = values
+      instance
+    end
+
+    def to_s
+      "#{name}(#{types.map{|t|t.to_s}.join(', ')})"
+    end
+
+  end
+end
+
+
+if !defined?(::Enum)
+  Enum = EinsteinEnum::Enum
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module EinsteinEnum
+  Version = '1.0.0'
+end

data/spec/einstein_enum_spec.rb

@@ -0,0 +1,163 @@
+require "einstein_enum"
+
+
+ROOT = "https://api.api.com/api/v1"
+
+
+class Api < Enum
+  value :Status
+  value :User, Fixnum
+  value :User, String
+  value :Posts, raw_value: :posts
+
+  def root
+    ROOT
+  end
+
+  def url
+    case self
+    when Status
+      root + "/status"
+    when User(Fixnum)
+      id = self[0]
+      root + "/users/by_id/#{id}"
+    when User(String)
+      username = self[0]
+      root + "/users/by_name/#{username}"
+    when Posts
+      root + "/posts"
+    else
+      nil
+    end
+  end
+
+end
+
+
+# extending an Enum
+class AnotherApi < Api
+  value :PostDetail, Fixnum
+
+  def url
+    case self
+    when PostDetail(Fixnum)
+      root + "/posts/#{self[0]}"
+    else
+      super
+    end
+  end
+
+end
+
+
+status = Api.Status
+user_type = Api.User(Fixnum)
+user_id = Api.User(2)
+user_name = Api.User('colinta')
+posts = Api.Posts
+post_detail = AnotherApi.PostDetail(2)
+
+
+RSpec.describe EinsteinEnum do
+
+  describe "matches" do
+    it "should match Api.Status" do
+      expect(case status
+      when Api.Status
+        true
+      when Api.User(Fixnum)
+        false
+      else
+        false
+      end).to(eq(true))
+    end
+
+    it "should match Api.Status" do
+      expect(case status
+      when Api.Status
+        true
+      when Api.User(Fixnum)
+        false
+      else
+        false
+      end).to eq(true)
+    end
+
+    it "should match Api.User(Fixnum)" do
+      expect(case user_id
+      when Api.Status
+        false
+      when Api.User(String)
+        false
+      when Api.User(Fixnum)
+        true
+      else
+        false
+      end).to eq(true)
+    end
+
+    it "should match Api.User(String)" do
+      expect(case user_name
+      when Api.Status
+        false
+      when Api.User(Fixnum)
+        false
+      when Api.User(String)
+        true
+      else
+        false
+      end).to eq(true)
+    end
+
+    it "should match Api.User(2)" do
+      expected_id = 2
+      expect(case user_id
+      when Api.Status
+        false
+      when Api.User(expected_id - 1)
+        false
+      when Api.User(expected_id)
+        true
+      else
+        false
+      end).to eq(true)
+    end
+  end
+
+  describe "raw values" do
+    it "should be unique" do
+      expect(user_type.raw_value).not_to eq(user_type.raw_value)
+      expect(user_id.raw_value).not_to eq(user_id.raw_value)
+      expect(user_name.raw_value).not_to eq(user_name.raw_value)
+      expect(posts.raw_value).not_to eq(posts.raw_value)
+    end
+
+    it "should be customizable" do
+      expect(posts.raw_value).to eq(:posts)
+    end
+  end
+
+  describe("methods") do
+    it "should create the Status url string" do
+      expect(status.url).to eq(ROOT + "/status")
+    end
+
+    it "should create the User(Fixnum) url string" do
+      expect(user_id.url).to eq(ROOT + "/users/by_id/2")
+    end
+
+    it "should create the User(String) url string" do
+      expect(user_name.url).to eq(ROOT + "/users/by_name/colinta")
+    end
+
+    it "should create the Post url string" do
+      expect(posts.url).to eq(ROOT + "/posts")
+    end
+
+    it "should create the PostDetail(Fixnum) url string" do
+      expect(post_detail.url).to eq(ROOT + "/posts/2")
+    end
+  end
+
+end
+

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: einstein-enum
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Colin T.A. Gray
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: |
+  Let's not kid ourselves: Swift didn't remove much of the tedium of iOS
+  development.  However, it introduced the best ENUM type that I've ever seen.
+email:
+- colinta@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/einstein-enum.rb
+- lib/enum.rb
+- lib/version.rb
+- spec/einstein_enum_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/colinta/einstein-enum
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Swift's Enums are genius.  Especially in a language that doesn't suck.
+test_files:
+- spec/einstein_enum_spec.rb
+- spec/spec_helper.rb